我如何拆分一個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); 
    } 
}