使用 linq 分解列表；分成很多列表 n 长度？

Question

可能的重复：
如何拆分 IEnumerable分成 IEnumerable 组

我有一个列表，我想将其分成 10 组。

如果我有一个

List<Person> allPendingPersons 

长度为 m 的对象。

LINQ 中是否有一种优雅的方法可以将 allPendingPersons 分解为一个或多个最多包含 10 名人员的 List 对象？

Answer 1

您可以编写自己的扩展方法：

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> sequence, int size) {
    List<T> partition = new List<T>(size);
    foreach(var item in sequence) {
        partition.Add(item);
        if (partition.Count == size) {
            yield return partition;
            partition = new List<T>(size);
        }
    }
    if (partition.Count > 0)
        yield return partition;
}

我更深入地探索了这一点< /a> 在我的博客中。

Answer 2

 var groups = allPendingPersons.Select((p, index) => new {p,index})
                               .GroupBy(a =>a.index/10 );

如果您想处理IGrouping<,>。如果您正在寻找列表>回来你可以尝试

var listOfLists = allPendingPersons.Select((p, index) => new {p, index})
    .GroupBy(a => a.index/10)
    .Select((grp => grp.Select(g => g.p).ToList()))
    .ToList();

Answer 3

.NET (Rx) 反应式扩展 有一个扩展方法这正是你想要的：

var buffered = allPendingPersons.BufferWithCount(10);

如果你想使用 LINQ 来做到这一点，你可以这样做：

var buffered =
    allPendingPersons
        .Select((p, i) => new { Group = i / 10, Person = p })
        .GroupBy(x => x.Group, x => x.Person)
        .Select(g => g.ToArray());

Answer 4

这些应该有一定的帮助。

如何拆分 IEnumerable分成 IEnumerable 组
将大的 IEnumerable 分成更小的IEnumerable 固定数量的项目
我可以改进这些分页扩展方法吗？
获取 4 个元素的组在 C# 中使用 LINQ 的名称值列表
LINQ：获取最小值和最大值分为子序列的数字序列的值
LINQ 将列表分区为 8 个成员的列表

一个非常受欢迎的答案是查看 Jon Skeet 的 MoreLinq，特别是 Batch 函数，它不仅可以满足您的要求，还可以让您指定返回选择器！

Answer 5

这不是最有效的技术，但这将产生一个 IEnumerable> 序列，每个内部序列包含十个元素：

var query = allPendingPersons.Select((x, i) => new { Value = x, Group = i / 10 })
                             .GroupBy(x => x.Group,
                                      (k, g) => g.Select(x => x.Value));

并且如果结果确实需要是一个列表-lists 而不是简单的序列，那么您可以通过添加几个 ToList 调用来创建 List> ：

var query = allPendingPersons.Select((x, i) => new { Value = x, Group = i / 10 })
                             .GroupBy(x => x.Group,
                                      (k, g) => g.Select(x => x.Value).ToList())
                             .ToList();

Answer 6

尝试迭代器块：

public static IEnumerable<List<Person>> AsGroups(this List<Person> persons)
{
    var buf = new List<Person>(10);
    for (int i = 0; i<persons.Count i++;)
    {
        buf.Add(persons[i]);
        if (i%10 == 0 && buf.Count > 0)
        {
           yield return buf;
           buf = new List<Person>(10);
        }
    }
    yield return buf;
 }

Answer 7

LINQ中有没有一种优雅的方式

优雅的方式 性能不是很好。这是一种更高效的方法...

    public static List<List<T>> Chunk<T>(
      this List<T> theList,
      int chunkSize
    )
    {
        if (!theList.Any())
        {
            return new List<List<T>>();
        }

        List<List<T>> result = new List<List<T>>();
        List<T> currentList = new List<T>();
        result.Add(currentList);

        int i = 0;
        foreach(T item in theList)
        {
            if (i >= chunkSize)
            {
                i = 0;
                currentList = new List<T>();
                result.Add(currentList);
            }
            i += 1;
            currentList.Add(item);
        }
        return result;
    }