C# 从列表中选择每1000项并将其传递给方法

我有一个列表，目前我们正在将一个项目一次传递给另一个方法

foreach (var contact in tracker.Parse())

基本上，我们正在从Azure Blob存储中选择联系人并将其导入Dynamics CRM

tracker.Parse（）返回的是联系人列表

我想选择每1000个，然后等待，直到他们在另一个方法中完成之前，我通过了下一个1000

需要关于如何做到这一点的指导

感谢您的帮助
 也许是这样的

static void Main()
{
    const int batchSize = 1000;

    // Populate array with 5841 items of data
    var lotsOfItems = new List<int>();
    for (int i = 0; i < 5841; i++)
    {
        lotsOfItems.Add(i);
    }

    // Process items in batches, waiting for each batch to complete before the next
    int indexOfLastItemTaken = 0;
    while (indexOfLastItemTaken < lotsOfItems.Count - 1)
    {
        var itemsTaken = lotsOfItems.Skip(indexOfLastItemTaken).Take(batchSize).ToList();
        ProcessItems(itemsTaken);
        indexOfLastItemTaken += itemsTaken.Count();
    }

    Console.Write("Done. Press any key to quit...");
    Console.ReadKey();
}

static void ProcessItems(IEnumerable<int> input)
{
    // do something with input
    Console.WriteLine(new string('-', 15));
    Console.WriteLine($"Processing a new batch of {input.Count()} items:");
    Console.WriteLine(string.Join(",", input));
}

static void Main（）
{
常量int batchSize=1000；
//用5841项数据填充数组
var lotsOfItems=新列表（）；
对于（int i=0；i<5841；i++）
{
增加（i）项；
}
//分批处理项目，等待每批在下一批之前完成
int indexoflastitemtake=0；
while（indexoflastitemtake
将数据源中的数据分组为所需的组大小，并对其进行处理

使用Linq可以通过
Select
和
GroupBy
扩展来实现

int groupSize = 1000;

//Batch the data
var batches = tracker.Parse()
  .Select((contact, index) => new { contact, index })
  .GroupBy(_ => _.index / groupSize, _ => _.contact);

//Process the batches.
foreach (var batch in batches) {
    //Each batch would be IEnumerable<TContact>
    ProcessBatch(batch);
}

int-groupSize=1000；
//批处理数据
var batches=tracker.Parse（）
.选择（（联系人，索引）=>new{contact，index}）
.GroupBy（=>.index/groupSize，=>.contact）；
//处理批次。
foreach（批量var）{
//每一批都是数不清的
ProcessBatch（批处理）；
}

如果需要，可以将其转换为可重用的泛型方法

public static void ProcessInBatches<TItem>(this IEnumerble<TItem> items, int batchSize, Action<IEnumerable<TItem>> processBatch) {

    //Batch the data
    var batches = items
      .Select((item, index) => new { item, index })
      .GroupBy(_ => _.index / batchSize, _ => _.item);

    //Process the batches.
    foreach (var batch in batches) {
        //Each batch would be IEnumerable<TItem>
        processBatch(batch);
    }
}

publicstaticvoidprocessinbatches（此IEnumerble项、int-batchSize、actionprocessbatch）{
//批处理数据
var批次=项目
.Select（（项，索引）=>new{item，index}）
.GroupBy（=>.index/batchSize，=>.item）；
//处理批次。
foreach（批量var）{
//每一批都是数不清的
processBatch（批处理）；
}
}
向我们展示您已经拥有的代码（然后谷歌
Take（）
和
Skip（）
），如果没有更多的上下文，这几乎是不可能回答的。什么是tracker.Parse（）？示例的可能副本既不显示
列表
，也不向方法传递单个项。你应该用一个简单的例子来说明这个问题。你说
tracker
是一个列表，但是
list
没有
Parse（）
方法，所以有点混乱。大概
Parse
返回一个
列表
？