我如何拆分一个IEnumerable <String>到IEnumerable的组<string>

Question

我有一个IEnumerable<string>我想分成三组，所以如果我输入了6个项目，我会得到一个IEnumerable<IEnumerable<string>>与每一个两个项目返回的结果包含我的字符串内容的IEnumerable<string>。

我正在寻找如何做到这一点的LINQ，而不是一个简单的for循环

感谢

Answer 1

var result = sequence.Select((s, i) => new { Value = s, Index = i }) 
        .GroupBy(item => item.Index/3, item => item.Value); 

注意这将返回一个IEnumerable<IGrouping<int,string>>这将是功能上类似于你想要什么。但是，如果严格需要将其类型为IEnumerable<IEnumerable<string>>（传递给需要它的方法C＃3.0不支持泛型方差），你应该使用Enumerable.Cast：

var result = sequence.Select((s, i) => new { Value = s, Index = i }) 
        .GroupBy(item => item.Index/3, item => item.Value) 
        .Cast<IEnumerable<string>>(); 

Answer 2

我想出了一个不同做法。它使用了一个while迭代器，但结果像常规LINQ一样缓存在内存中，直到需要为止。
这是代码。

public IEnumerable<IEnumerable<T>> Paginate<T>(this IEnumerable<T> source, int pageSize) 
{ 
    List<IEnumerable<T>> pages = new List<IEnumerable<T>>(); 
    int skipCount = 0; 

    while (skipCount * pageSize < source.Count) { 
     pages.Add(source.Skip(skipCount * pageSize).Take(pageSize)); 
     skipCount += 1; 
    } 

    return pages; 
} 

Answer 3

我知道这已经回答了，但如果你打算采取IEnumerables切片的时候，那么我建议做一个通用的扩展方法是这样的：

public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int chunkSize) 
{ 
    return source.Where((x,i) => i % chunkSize == 0).Select((x,i) => source.Skip(i * chunkSize).Take(chunkSize)); 
} 

然后你可以使用sequence.Split(3)来得到你想要的。 （如果你不喜欢这个，你可以命名为'slice'或'chunk'，'split'已经被定义为字符串，'Split'就是我碰巧称为我的）。

Answer 4

启发通过@ dicegiuy30的实现，我想创建一个只迭代源的版本，并且不会在内存中构建整个结果集来进行补偿。最好的我想出的是这样的：

public static IEnumerable<IEnumerable<T>> Split2<T>(this IEnumerable<T> source, int chunkSize) { 
    var chunk = new List<T>(chunkSize); 
    foreach(var x in source) { 
     chunk.Add(x); 
     if(chunk.Count <= chunkSize) { 
      continue; 
     } 
     yield return chunk; 
     chunk = new List<T>(chunkSize); 
    } 
    if(chunk.Any()) { 
     yield return chunk; 
    } 
} 

这样我就建立每个块的需求。我希望我也应该避开List<T>，并且只是传播那个，但还没有弄清楚。

Answer 5

使用Microsoft.Reactive你可以很简单地做到这一点，你将只遍历源代码一次。

IEnumerable<string> source = new List<string>{"1", "2", "3", "4", "5", "6"}; 

IEnumerable<IEnumerable<string>> splited = source.ToObservable().Buffer(3).ToEnumerable(); 

Answer 6

我们可以改进@ Afshari的解决方案来做真正的懒惰评估。我们使用GroupAdjacentBy方法能产生连续的元素组具有相同的键：

sequence 
.Select((x, i) => new { Value = x, Index = i }) 
.GroupAdjacentBy(x=>x.Index/3) 
.Select(g=>g.Select(x=>x.Value)) 

由于基团，得到一个接一个，该解决方案的工作原理有效地与长或无限序列。

Answer 7

这是一个迟到的回复此线程，但这里是不使用任何临时存储的方法：

public static class EnumerableExt 
{ 
    public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> input, int blockSize) 
    { 
     var enumerator = input.GetEnumerator(); 

     while (enumerator.MoveNext()) 
     { 
      yield return nextPartition(enumerator, blockSize); 
     } 
    } 

    private static IEnumerable<T> nextPartition<T>(IEnumerator<T> enumerator, int blockSize) 
    { 
     do 
     { 
      yield return enumerator.Current; 
     } 
     while (--blockSize > 0 && enumerator.MoveNext()); 
    } 
} 

和一些测试代码：

class Program 
{ 
    static void Main(string[] args) 
    { 
     var someNumbers = Enumerable.Range(0, 10000); 

     foreach (var block in someNumbers.Partition(100)) 
     { 
      Console.WriteLine("\nStart of block."); 

      foreach (int number in block) 
      { 
       Console.Write(number); 
       Console.Write(" "); 
      } 
     } 

     Console.WriteLine("\nDone."); 
     Console.ReadLine(); 
    } 
} 

Answer 8

迈赫达德Afshari的答案是优秀。这里是一个封装它的扩展方法：

using System.Collections.Generic; 
using System.Linq; 

public static class EnumerableExtensions 
{ 
    public static IEnumerable<IEnumerable<T>> GroupsOf<T>(this IEnumerable<T> enumerable, int size) 
    { 
     return enumerable.Select((v, i) => new {v, i}).GroupBy(x => x.i/size, x => x.v); 
    } 
}