如何将IEnumerable <String>拆分为IEnumerable <string>组
我有一个IEnumerable<string >，我想分成三个组，如果我的input有6个项目，我会得到一个IEnumerable<IEnumerable<string>>返回两个项目，其中每个将包含一个IEnumerable<string>哪我的string内容在里面。
我正在寻找如何使用Linq而不是简单的for循环
谢谢
var result = sequence.Select((s, i) => new { Value = s, Index = i }) .GroupBy(item => item.Index / 3, item => item.Value);
请注意，这将返回一个IEnumerable<IGrouping<int,string>> ，它的function类似于你想要的。 但是，如果您严格按照IEnumerable<IEnumerable<string>> （要传递给不支持generics差异的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>>();
这是对这个线程的延迟回复，但是这里是一个不使用任何临时存储的方法：
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()); } }
还有一些testing代码：
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(); } }
我知道这已经被回答了，但是如果你打算经常使用IEnumerables的片断，那么我build议使用这样的通用扩展方法：
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'已经被定义为string，'Split'就是我刚才所说的。
启发由@ dicegiuy30的实现，我想创build一个版本，只遍历源一次，并不build立在内存中的整个结果集来弥补。 最好的我想出来的是这样的：
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; } }
这样我就可以按需build立每个块。 我希望我也应该避开List<T> ，并且只是把这个stream传下去，但还没有弄清楚。
使用Microsoft.Reactive你可以很简单地做到这一点，你只会遍历源代码一次。
IEnumerable<string> source = new List<string>{"1", "2", "3", "4", "5", "6"}; IEnumerable<IEnumerable<string>> splited = source.ToObservable().Buffer(3).ToEnumerable();
我们可以改进@ Afshari的解决scheme来做真正的懒惰评估。 我们使用一个GroupAdjacentBy方法来产生具有相同键的连续元素组：
sequence .Select((x, i) => new { Value = x, Index = i }) .GroupAdjacentBy(x=>x.Index/3) .Select(g=>g.Select(x=>x.Value))
因为这些组是一个接一个地产生的，所以这个解决scheme可以有效地处理长序列或无限序列。
我想出了一个不同的方法。 它使用了一个while迭代器，但结果像常规的LINQ一样caching在内存中直到需要。
这是代码。
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; }
Mehrdad 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 => xi/size, x => xv); } }
