C# LINQ能支持这个简单的算法吗？

我一直在尝试学习LINQ，我想知道LINQ是否有办法执行以下操作：

我有一个对象列表，这些对象以串行方式使用数组中的数据。我尝试用一个循环做两件事：

使用输入数组以数据顺序填充对象，其中每个对象使用不同数量的数据

跟踪“索引”，它告诉我已经消耗了多少数据

下面是一个代码示例：

class MyBase {
    virtual int ReadData(int[] array, int StartingIndex) { }
}

class Derived1 : MyBase {
    int a;

    public override int ReadData(int[] array, int StartIndex) {
       a = array[StartingIndex];
       return StartingIndex + 1;
    }
}

class Derived2 : MyBase {
    int a, b;

    public override int ReadData(int[] array, int StartIndex) {
        a = array[StartingIndex];
        b = array[StartingIndex + 1];
        return StartingIndex + 2;
    }
}

class Program {
    public static void Main() {
        MyBase[] array = new MyBase[] {
           new Derived1(),
           new Derived2(),
           new Derived1()
        }

        int[] input = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };          
        int Index = 0 
        for (int i = 0; i < input.Length; i++) {
            Index = array[i].ReadData(input, Index);
        }
    }
}

类MyBase{
虚拟int ReadData（int[]数组，int StartingIndex）{}
}
类Derived1:MyBase{
INTA；
公共重写int ReadData（int[]数组，int StartIndex）{
a=数组[起始索引]；
返回起始索引+1；
}
}
类Derived2:MyBase{
INTA，b；
公共重写int ReadData（int[]数组，int StartIndex）{
a=数组[起始索引]；
b=数组[StartingIndex+1]；
返回起始索引+2；
}
}
班级计划{
公共静态void Main（）{
MyBase[]数组=新的MyBase[]{
新的Derived1（），
新派生的2（），
新衍生1（）
}
int[]input=newint[]{1,2,3,4,5,6,7,8,9}；
整数索引=0
for（int i=0；i

最终结果是这些对象具有以下值：

对象0的值为1

对象1具有val 2和val 3

对象2的值为4

但是我不知道如何使用LINQ实现这一点。

实现这一点的LINQish方法（而不仅仅是为循环编写

的LINQish方法）是将数组传递给每个方法，让它获取所需内容并返回其余内容。您手中不会有最终索引，但会有剩余索引：

MyBase[]array=new MyBase[]{new Derived1（），new Derived2（），new Derived1（）}
int[]输入=新的int[]{1,2,3,4,5,6,7,8,9}；
IEnumerable unusedInputs=输入；
foreach（数组中的MyBase实体）
{
unusedInputs=实体.ReadData（unusedInputs）；
}

您的ReadData代码如下所示：

public override IEnumerable<int> ReadData( IEnumerable<int> data) 
{
    a = data.Take(1).Single();
    return Data.Skip(1);
}

public override IEnumerable<int> ReadData( IEnumerable<int> data) 
{
    var dataRead = data.Take(2);
    a = dataRead.First();
    b = dataRead.Skip(1).First();
    return data.Skip(2);
}        

public重写IEnumerable可读数据（IEnumerable数据）
{
a=data.Take（1.Single（）；
返回数据。跳过（1）；
}
公共重写IEnumerable ReadData（IEnumerable数据）
{
var dataRead=data.Take（2）；
a=dataRead.First（）；
b=dataRead.Skip（1.First（）；
返回数据。跳过（2）；
}        
您调用的方法实际上有副作用，虽然您可以使用LINQ表示，但不应该这样做。
public override IEnumerable<int> ReadData( IEnumerable<int> data) 
{
    a = data.Take(1).Single();
    return Data.Skip(1);
}

public override IEnumerable<int> ReadData( IEnumerable<int> data) 
{
    var dataRead = data.Take(2);
    a = dataRead.First();
    b = dataRead.Skip(1).First();
    return data.Skip(2);
}