Question

可能重复：
  LINQ Partition List into Lists of 8 members
  how do I chunk an enumerable?

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

我可以使用LINQ从大列表中拉出N个元素，并一次将它们传递给Method，N吗？我确信有一种优雅的方式来实现这一目标，而不必制作“int i = 0;”变量

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

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

这可能是一些集团电话。

Answer 1

您可以将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;
}

Answer 2

这将为您提供列表列表，其中每个列表最多包含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();

Answer 3

这对我有用

    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();

使用Linq处理列表中的项目组

3 个答案: