1

可能重复：
LINQ 分区列表到 8 个成员的列表中
我如何分块一个可枚举的？

我有一个包含许多项目的列表，以及一个适用于这些相同项目的较短列表的方法。

我可以使用 LINQ 从大列表中提取 N 个元素，然后一次将它们传递给方法 N 吗？我确信有一种优雅的方法可以做到这一点，而不必制作“int i=0;” 多变的。

让我说清楚，我知道 foo.Take(10) 会让我从列表中删除 10 项。但我需要继续处理下一组 10 个，然后是下一组 10 个，依此类推。伪代码应该是这样的：

var shortList = BigList.NiceMethod(10);
foreach (shorty in shortlist)
{
  Method(shorty);
}

这可能是一些群呼。

4

3 回答 3

3

您可以将 an 传递IEnumerable<T>给您的方法并使用Enumerable.Take.

var part = items.Take(10);
method(part);

对于下一部分，您可以使用Skip+ Take：

var part = items.Skip(10).Take(10);
method(part);

另一种选择：Enumerable.GroupBy与余数运算符%一起使用 n 个数据包：

int groupCount = 5;
var parts = items.GroupBy(i => i % groupCount);
foreach (var p in parts)
    method(p);

编辑：如果您需要将序列划分为具有相同大小的较小序列，您可以使用此扩展：

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>(batchSize);
        }
    }
    if (nextbatch.Count > 0)
        yield return nextbatch;
}
于 2012-11-01T18:49:26.217 回答
3

这将为您提供一个列表列表，其中每个列表最多包含 N 个元素。

int N = 3;
List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

var ListOfLists = list.Select((x, inx) => new { Item = x, Group = inx / N })
                        .GroupBy(g => g.Group, g => g.Item)
                        .Select(x => x.ToList())
                        .ToList();

您也可以使用 Morelinq 的Batch方法

var ListOfLists2 = list.Batch(3).Select(x => x.ToList()).ToList();
于 2012-11-01T18:53:07.633 回答
0

这对我有用

    var l = Enumerable.Range(0, 1000).ToList<int>();
        int size = 11;
        var result = Enumerable.Range(0, l.Count / size + 1)
            .Select(p => l.Skip(p * size).Take(Math.Min(size, l.Count - size * p)).ToList())
            .Where(p=>p.Count > 0).ToList();
于 2012-11-01T19:10:25.273 回答