c# - 如何批量循环遍历IEnumerable

Question

我正在开发一个 C# 程序，它有一个“IEnumerable 用户”，它存储了 400 万用户的 id。我需要遍历 IEnumerable 并每次提取一批 1000 个 id 以在另一种方法中执行一些操作。

如何从 IEnumerable 开始一次提取 1000 个 id，做其他事情，然后获取下一批 1000 等等？

这可能吗？

Answer 1

您可以使用MoreLINQ 的 Batch 运算符（可从 NuGet 获得）：

foreach(IEnumerable<User> batch in users.Batch(1000))
   // use batch

---

如果不能选择简单地使用库，则可以重用实现：

public static IEnumerable<IEnumerable<T>> Batch<T>(
        this IEnumerable<T> source, int size)
{
    T[] bucket = null;
    var count = 0;

    foreach (var item in source)
    {
       if (bucket == null)
           bucket = new T[size];

       bucket[count++] = item;

       if (count != size)                
          continue;

       yield return bucket.Select(x => x);

       bucket = null;
       count = 0;
    }

    // Return the last bucket with all remaining elements
    if (bucket != null && count > 0)
    {
        Array.Resize(ref bucket, count);
        yield return bucket.Select(x => x);
    }
}

顺便说一句，为了性能，您可以简单地返回存储桶而不调用Select(x => x). Select 针对数组进行了优化，但仍会在每个项目上调用选择器委托。所以，在你的情况下，最好使用

yield return bucket;

Answer 2

听起来您需要使用对象的 Skip 和 Take 方法。例子：

users.Skip(1000).Take(1000)

这将跳过前 1000 个并取接下来的 1000 个。您只需要增加每次调用跳过的数量

您可以将整数变量与 Skip 参数一起使用，您可以调整跳过的数量。然后，您可以在方法中调用它。

public IEnumerable<user> GetBatch(int pageNumber)
{
    return users.Skip(pageNumber * 1000).Take(1000);
}

Answer 3

最简单的方法可能就是使用GroupByLINQ 中的方法：

var batches = myEnumerable
    .Select((x, i) => new { x, i })
    .GroupBy(p => (p.i / 1000), (p, i) => p.x);

但是对于更复杂的解决方案，请参阅这篇博客文章，了解如何创建自己的扩展方法来执行此操作。为后代复制这里：

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> collection, int batchSize)
{
    List<T> nextbatch = new List<T>(batchSize);
    foreach (T item in collection)
    {
        nextbatch.Add(item);
        if (nextbatch.Count == batchSize)
        {
            yield return nextbatch;
            nextbatch = new List<T>(); 
            // or nextbatch.Clear(); but see Servy's comment below
        }
    }

    if (nextbatch.Count > 0)
        yield return nextbatch;
}

Answer 4

怎么样

int batchsize = 5;
List<string> colection = new List<string> { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"};
for (int x = 0; x < Math.Ceiling((decimal)colection.Count / batchsize); x++)
{
    var t = colection.Skip(x * batchsize).Take(batchsize);
}

Answer 5

尝试使用这个：

  public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(
        this IEnumerable<TSource> source,
        int batchSize)
    {
        var batch = new List<TSource>();
        foreach (var item in source)
        {
            batch.Add(item);
            if (batch.Count == batchSize)
            {
                 yield return batch;
                 batch = new List<TSource>();
            }
        }

        if (batch.Any()) yield return batch;
    }

并使用上述功能：

foreach (var list in Users.Batch(1000))
{

}

Answer 6

您可以使用 Take and Skip Enumerable 扩展方法来实现。有关使用检查linq 101的更多信息

Answer 7

像这样的东西会起作用：

List<MyClass> batch = new List<MyClass>();
foreach (MyClass item in items)
{
    batch.Add(item);

    if (batch.Count == 1000)
    {
        // Perform operation on batch
        batch.Clear();
    }
}

// Process last batch
if (batch.Any())
{
    // Perform operation on batch
}

您可以将其概括为通用方法，如下所示：

static void PerformBatchedOperation<T>(IEnumerable<T> items, 
                                       Action<IEnumerable<T>> operation, 
                                       int batchSize)
{
    List<T> batch = new List<T>();
    foreach (T item in items)
    {
        batch.Add(item);

        if (batch.Count == batchSize)
        {
            operation(batch);
            batch.Clear();
        }
    }

    // Process last batch
    if (batch.Any())
    {
        operation(batch);
    }
}

Answer 8

您可以使用Take operator linq

链接：http: //msdn.microsoft.com/fr-fr/library/vstudio/bb503062.aspx

Answer 9

在流式上下文中，枚举器可能在批处理中间被阻塞，仅仅是因为尚未生成值（yield），因此有一个超时方法很有用，以便在给定时间后生成最后一批。例如，我用它来跟踪 MongoDB 中的游标。这有点复杂，因为枚举必须在另一个线程中完成。

    public static IEnumerable<List<T>> TimedBatch<T>(this IEnumerable<T> collection, double timeoutMilliseconds, long maxItems)
    {
        object _lock = new object();
        List<T> batch = new List<T>();
        AutoResetEvent yieldEventTriggered = new AutoResetEvent(false);
        AutoResetEvent yieldEventFinished = new AutoResetEvent(false);
        bool yieldEventTriggering = false; 

        var task = Task.Run(delegate
        {
            foreach (T item in collection)
            {
                lock (_lock)
                {
                    batch.Add(item);

                    if (batch.Count == maxItems)
                    {
                        yieldEventTriggering = true;
                        yieldEventTriggered.Set();
                    }
                }

                if (yieldEventTriggering)
                {
                    yieldEventFinished.WaitOne(); //wait for the yield to finish, and batch to be cleaned 
                    yieldEventTriggering = false;
                }
            }
        });

        while (!task.IsCompleted)
        {
            //Wait for the event to be triggered, or the timeout to finish
            yieldEventTriggered.WaitOne(TimeSpan.FromMilliseconds(timeoutMilliseconds));
            lock (_lock)
            {
                if (batch.Count > 0) //yield return only if the batch accumulated something
                {
                    yield return batch;
                    batch.Clear();
                    yieldEventFinished.Set();
                }
            }
        }
        task.Wait();
    }