用LINQ将列表拆分为子列表

试试下面的代码。

public static List<List<T>> Split<T>(IList<T> source)
{
return  source
.Select((x, i) => new { Index = i, Value = x })
.GroupBy(x => x.Index / 3)
.Select(x => x.Select(v => v.Value).ToList())
.ToList();
}

其思想是首先根据索引对元素进行分组。除以3的效果是把它们分成3组。然后将每个组转换为一个列表，并将List的IEnumerable转换为List的List

下面是我几个月前写的一个列表拆分例程:

public static List<List<T>> Chunk<T>(
List<T> theList,
int chunkSize
)
{
List<List<T>> result = theList
.Select((x, i) => new {
data = x,
indexgroup = i / chunkSize
})
.GroupBy(x => x.indexgroup, x => x.data)
.Select(g => new List<T>(g))
.ToList();


return result;
}

我们发现David B的解决方案效果最好。但我们把它改成了一个更普遍的解决方案:

list.GroupBy(item => item.SomeProperty)
.Select(group => new List<T>(group))
.ToArray();

我刚刚写了这个，我认为它比其他提出的解决方案更优雅一点:

/// <summary>
/// Break a list of items into chunks of a specific size
/// </summary>
public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunksize)
{
while (source.Any())
{
yield return source.Take(chunksize);
source = source.Skip(chunksize);
}
}

一般来说，CaseyB所建议的方法工作得很好，事实上，如果你传入一个List<T>，很难对它进行错误判断，也许我会将其更改为:

public static IEnumerable<IEnumerable<T>> ChunkTrivialBetter<T>(this IEnumerable<T> source, int chunksize)
{
var pos = 0;
while (source.Skip(pos).Any())
{
yield return source.Skip(pos).Take(chunksize);
pos += chunksize;
}
}

这将避免大量的呼叫链。然而，这种方法有一个普遍的缺陷。它实现了每个块的两个枚举，以突出问题，尝试运行:

foreach (var item in Enumerable.Range(1, int.MaxValue).Chunk(8).Skip(100000).First())
{
Console.WriteLine(item);
}
// wait forever

为了克服这个问题，我们可以尝试卡梅隆的方法，它出色地通过了上面的测试，因为它只遍历了一次枚举。

问题是，它有一个不同的缺陷，它将每个块中的每个项具体化，这种方法的问题是，你会占用大量内存。

为了说明尝试运行:

foreach (var item in Enumerable.Range(1, int.MaxValue)
.Select(x => x + new string('x', 100000))
.Clump(10000).Skip(100).First())
{
Console.Write('.');
}
// OutOfMemoryException

最后，任何实现都应该能够处理块的乱序迭代，例如:

Enumerable.Range(1,3).Chunk(2).Reverse().ToArray()
// should return [3],[1,2]

许多高度优化的解决方案，如我的第一个修订的这个答案失败了。同样的问题可以在casperOne的优化 answer中看到。

要解决所有这些问题，您可以使用以下方法:

namespace ChunkedEnumerator
{
public static class Extensions
{
class ChunkedEnumerable<T> : IEnumerable<T>
{
class ChildEnumerator : IEnumerator<T>
{
ChunkedEnumerable<T> parent;
int position;
bool done = false;
T current;




public ChildEnumerator(ChunkedEnumerable<T> parent)
{
this.parent = parent;
position = -1;
parent.wrapper.AddRef();
}


public T Current
{
get
{
if (position == -1 || done)
{
throw new InvalidOperationException();
}
return current;


}
}


public void Dispose()
{
if (!done)
{
done = true;
parent.wrapper.RemoveRef();
}
}


object System.Collections.IEnumerator.Current
{
get { return Current; }
}


public bool MoveNext()
{
position++;


if (position + 1 > parent.chunkSize)
{
done = true;
}


if (!done)
{
done = !parent.wrapper.Get(position + parent.start, out current);
}


return !done;


}


public void Reset()
{
// per http://msdn.microsoft.com/en-us/library/system.collections.ienumerator.reset.aspx
throw new NotSupportedException();
}
}


EnumeratorWrapper<T> wrapper;
int chunkSize;
int start;


public ChunkedEnumerable(EnumeratorWrapper<T> wrapper, int chunkSize, int start)
{
this.wrapper = wrapper;
this.chunkSize = chunkSize;
this.start = start;
}


public IEnumerator<T> GetEnumerator()
{
return new ChildEnumerator(this);
}


System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}


}


class EnumeratorWrapper<T>
{
public EnumeratorWrapper (IEnumerable<T> source)
{
SourceEumerable = source;
}
IEnumerable<T> SourceEumerable {get; set;}


Enumeration currentEnumeration;


class Enumeration
{
public IEnumerator<T> Source { get; set; }
public int Position { get; set; }
public bool AtEnd { get; set; }
}


public bool Get(int pos, out T item)
{


if (currentEnumeration != null && currentEnumeration.Position > pos)
{
currentEnumeration.Source.Dispose();
currentEnumeration = null;
}


if (currentEnumeration == null)
{
currentEnumeration = new Enumeration { Position = -1, Source = SourceEumerable.GetEnumerator(), AtEnd = false };
}


item = default(T);
if (currentEnumeration.AtEnd)
{
return false;
}


while(currentEnumeration.Position < pos)
{
currentEnumeration.AtEnd = !currentEnumeration.Source.MoveNext();
currentEnumeration.Position++;


if (currentEnumeration.AtEnd)
{
return false;
}


}


item = currentEnumeration.Source.Current;


return true;
}


int refs = 0;


// needed for dispose semantics
public void AddRef()
{
refs++;
}


public void RemoveRef()
{
refs--;
if (refs == 0 && currentEnumeration != null)
{
var copy = currentEnumeration;
currentEnumeration = null;
copy.Source.Dispose();
}
}
}


public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunksize)
{
if (chunksize < 1) throw new InvalidOperationException();


var wrapper =  new EnumeratorWrapper<T>(source);


int currentPos = 0;
T ignore;
try
{
wrapper.AddRef();
while (wrapper.Get(currentPos, out ignore))
{
yield return new ChunkedEnumerable<T>(wrapper, chunksize, currentPos);
currentPos += chunksize;
}
}
finally
{
wrapper.RemoveRef();
}
}
}


class Program
{
static void Main(string[] args)
{
int i = 10;
foreach (var group in Enumerable.Range(1, int.MaxValue).Skip(10000000).Chunk(3))
{
foreach (var n in group)
{
Console.Write(n);
Console.Write(" ");
}
Console.WriteLine();
if (i-- == 0) break;
}




var stuffs = Enumerable.Range(1, 10).Chunk(2).ToArray();


foreach (var idx in new [] {3,2,1})
{
Console.Write("idx " + idx + " ");
foreach (var n in stuffs[idx])
{
Console.Write(n);
Console.Write(" ");
}
Console.WriteLine();
}


/*


10000001 10000002 10000003
10000004 10000005 10000006
10000007 10000008 10000009
10000010 10000011 10000012
10000013 10000014 10000015
10000016 10000017 10000018
10000019 10000020 10000021
10000022 10000023 10000024
10000025 10000026 10000027
10000028 10000029 10000030
10000031 10000032 10000033
idx 3 7 8
idx 2 5 6
idx 1 3 4
*/


Console.ReadKey();




}


}
}

对于块的无序迭代，您还可以引入一轮优化，这超出了本文的范围。

至于你应该选择哪种方法呢?这完全取决于你要解决的问题。如果你不关心第一个缺陷，那么简单的答案是非常有吸引力的。

请注意和大多数方法一样，这对多线程来说是不安全的，如果你想让它线程安全，你需要修改EnumeratorWrapper。

系统。互动为此目的提供了Buffer()。一些快速测试显示性能与Sam的解决方案类似。

几年前我写了一个集群扩展方法。工作得很好，是这里最快的实现。: P

/// <summary>
/// Clumps items into same size lots.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">The source list of items.</param>
/// <param name="size">The maximum size of the clumps to make.</param>
/// <returns>A list of list of items, where each list of items is no bigger than the size given.</returns>
public static IEnumerable<IEnumerable<T>> Clump<T>(this IEnumerable<T> source, int size)
{
if (source == null)
throw new ArgumentNullException("source");
if (size < 1)
throw new ArgumentOutOfRangeException("size", "size must be greater than 0");


return ClumpIterator<T>(source, size);
}


private static IEnumerable<IEnumerable<T>> ClumpIterator<T>(IEnumerable<T> source, int size)
{
Debug.Assert(source != null, "source is null.");


T[] items = new T[size];
int count = 0;
foreach (var item in source)
{
items[count] = item;
count++;


if (count == size)
{
yield return items;
items = new T[size];
count = 0;
}
}
if (count > 0)
{
if (count == size)
yield return items;
else
{
T[] tempItems = new T[count];
Array.Copy(items, tempItems, count);
yield return tempItems;
}
}
}

我们可以改进@JaredPar的解决方案来做真正的惰性求值。我们使用GroupAdjacentBy方法生成一组具有相同键的连续元素:

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

因为基团是一个接一个地产生的，所以这个解决方案对长序列或无限序列有效。

使用模块化分区:

public IEnumerable<IEnumerable<string>> Split(IEnumerable<string> input, int chunkSize)
{
var chunks = (int)Math.Ceiling((double)input.Count() / (double)chunkSize);
return Enumerable.Range(0, chunks).Select(id => input.Where(s => s.GetHashCode() % chunks == id));
}

这个怎么样?

var input = new List<string> { "a", "g", "e", "w", "p", "s", "q", "f", "x", "y", "i", "m", "c" };
var k = 3


var res = Enumerable.Range(0, (input.Count - 1) / k + 1)
.Select(i => input.GetRange(i * k, Math.Min(k, input.Count - i * k)))
.ToList();

据我所知，GetRange ()与所取的条目数量是线性的。所以这应该表现得很好。

好吧，以下是我的看法:

• 完全懒惰:工作在无限枚举上
• 没有中间复制/缓冲
• O(n)执行时间
• 当内部序列仅被部分消耗时也适用

public static IEnumerable<IEnumerable<T>> Chunks<T>(this IEnumerable<T> enumerable,
int chunkSize)
{
if (chunkSize < 1) throw new ArgumentException("chunkSize must be positive");


using (var e = enumerable.GetEnumerator())
while (e.MoveNext())
{
var remaining = chunkSize;    // elements remaining in the current chunk
var innerMoveNext = new Func<bool>(() => --remaining > 0 && e.MoveNext());


yield return e.GetChunk(innerMoveNext);
while (innerMoveNext()) {/* discard elements skipped by inner iterator */}
}
}


private static IEnumerable<T> GetChunk<T>(this IEnumerator<T> e,
Func<bool> innerMoveNext)
{
do yield return e.Current;
while (innerMoveNext());
}

示例使用

var src = new [] {1, 2, 3, 4, 5, 6};


var c3 = src.Chunks(3);      // \{\{1, 2, 3}, {4, 5, 6}};
var c4 = src.Chunks(4);      // \{\{1, 2, 3, 4}, {5, 6}};


var sum   = c3.Select(c => c.Sum());    // {6, 15}
var count = c3.Count();                 // 2
var take2 = c3.Select(c => c.Take(2));  // \{\{1, 2}, {4, 5}}

解释

该代码通过嵌套两个基于yield的迭代器来工作。

注意: 答案已经更新，以解决@aolszowka指出的缺点。

这是一个老问题，但这是我最后得出的结论;它只枚举可枚举对象一次，但是为每个分区创建列表。当调用ToArray()时，它不会像某些实现那样遭受意外行为:

    public static IEnumerable<IEnumerable<T>> Partition<T>(IEnumerable<T> source, int chunkSize)
{
if (source == null)
{
throw new ArgumentNullException("source");
}


if (chunkSize < 1)
{
throw new ArgumentException("Invalid chunkSize: " + chunkSize);
}


using (IEnumerator<T> sourceEnumerator = source.GetEnumerator())
{
IList<T> currentChunk = new List<T>();
while (sourceEnumerator.MoveNext())
{
currentChunk.Add(sourceEnumerator.Current);
if (currentChunk.Count == chunkSize)
{
yield return currentChunk;
currentChunk = new List<T>();
}
}


if (currentChunk.Any())
{
yield return currentChunk;
}
}
}

我认为下面的建议是最快的。为了能够使用数组，我牺牲了源Enumerable的惰性。复制和提前知道每个子列表的长度。

public static IEnumerable<T[]> Chunk<T>(this IEnumerable<T> items, int size)
{
T[] array = items as T[] ?? items.ToArray();
for (int i = 0; i < array.Length; i+=size)
{
T[] chunk = new T[Math.Min(size, array.Length - i)];
Array.Copy(array, i, chunk, 0, chunk.Length);
yield return chunk;
}
}

下面这个解是我能想到的最紧凑的解是O(n)

public static IEnumerable<T[]> Chunk<T>(IEnumerable<T> source, int chunksize)
{
var list = source as IList<T> ?? source.ToList();
for (int start = 0; start < list.Count; start += chunksize)
{
T[] chunk = new T[Math.Min(chunksize, list.Count - start)];
for (int i = 0; i < chunk.Length; i++)
chunk[i] = list[start + i];


yield return chunk;
}
}

插一句我的意见…

通过使用列表类型对源代码进行分块，我找到了另一个非常紧凑的解决方案:

public static IEnumerable<IEnumerable<TSource>> Chunk<TSource>(this IEnumerable<TSource> source, int chunkSize)
{
// copy the source into a list
var chunkList = source.ToList();


// return chunks of 'chunkSize' items
while (chunkList.Count > chunkSize)
{
yield return chunkList.GetRange(0, chunkSize);
chunkList.RemoveRange(0, chunkSize);
}


// return the rest
yield return chunkList;
}

完全懒惰的，没有计数或复制的:

public static class EnumerableExtensions
{


public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int len)
{
if (len == 0)
throw new ArgumentNullException();


var enumer = source.GetEnumerator();
while (enumer.MoveNext())
{
yield return Take(enumer.Current, enumer, len);
}
}


private static IEnumerable<T> Take<T>(T head, IEnumerator<T> tail, int len)
{
while (true)
{
yield return head;
if (--len == 0)
break;
if (tail.MoveNext())
head = tail.Current;
else
break;
}
}
}

旧代码，但这是我一直在使用的:

    public static IEnumerable<List<T>> InSetsOf<T>(this IEnumerable<T> source, int max)
{
var toReturn = new List<T>(max);
foreach (var item in source)
{
toReturn.Add(item);
if (toReturn.Count == max)
{
yield return toReturn;
toReturn = new List<T>(max);
}
}
if (toReturn.Any())
{
yield return toReturn;
}
}

我发现这个小片段做得很好。

public static IEnumerable<List<T>> Chunked<T>(this List<T> source, int chunkSize)
{
var offset = 0;


while (offset < source.Count)
{
yield return source.GetRange(offset, Math.Min(source.Count - offset, chunkSize));
offset += chunkSize;
}
}

这是一个古老的解决方案，但我有一个不同的方法。我使用Skip移动到所需的偏移量，使用Take提取所需的元素数量:

public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source,
int chunkSize)
{
if (chunkSize <= 0)
throw new ArgumentOutOfRangeException($"{nameof(chunkSize)} should be > 0");


var nbChunks = (int)Math.Ceiling((double)source.Count()/chunkSize);


return Enumerable.Range(0, nbChunks)
.Select(chunkNb => source.Skip(chunkNb*chunkSize)
.Take(chunkSize));
}

只是说说我的意见。如果你想要“桶”列表(从左到右可视化)，你可以做以下事情:

 public static List<List<T>> Buckets<T>(this List<T> source, int numberOfBuckets)
{
List<List<T>> result = new List<List<T>>();
for (int i = 0; i < numberOfBuckets; i++)
{
result.Add(new List<T>());
}


int count = 0;
while (count < source.Count())
{
var mod = count % numberOfBuckets;
result[mod].Add(source[count]);
count++;
}
return result;
}

我将主要答案设置为IOC容器，以确定在哪里进行分割。(在阅读这篇文章的同时寻找答案时，谁真的只在3个项目上寻找答案?)

这种方法允许人们根据需要对任何类型的项目进行拆分。

public static List<List<T>> SplitOn<T>(List<T> main, Func<T, bool> splitOn)
{
int groupIndex = 0;


return main.Select( item => new
{
Group = (splitOn.Invoke(item) ? ++groupIndex : groupIndex),
Value = item
})
.GroupBy( it2 => it2.Group)
.Select(x => x.Select(v => v.Value).ToList())
.ToList();
}

所以OP的代码是

var it = new List<string>()
{ "a", "g", "e", "w", "p", "s", "q", "f", "x", "y", "i", "m", "c" };


int index = 0;
var result = SplitOn(it, (itm) => (index++ % 3) == 0 );

像山姆藏红花的方法一样具有执行性。

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> source, int size)
{
if (source == null) throw new ArgumentNullException(nameof(source));
if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size), "Size must be greater than zero.");


return BatchImpl(source, size).TakeWhile(x => x.Any());
}


static IEnumerable<IEnumerable<T>> BatchImpl<T>(this IEnumerable<T> source, int size)
{
var values = new List<T>();
var group = 1;
var disposed = false;
var e = source.GetEnumerator();


try
{
while (!disposed)
{
yield return GetBatch(e, values, group, size, () => { e.Dispose(); disposed = true; });
group++;
}
}
finally
{
if (!disposed)
e.Dispose();
}
}


static IEnumerable<T> GetBatch<T>(IEnumerator<T> e, List<T> values, int group, int size, Action dispose)
{
var min = (group - 1) * size + 1;
var max = group * size;
var hasValue = false;


while (values.Count < min && e.MoveNext())
{
values.Add(e.Current);
}


for (var i = min; i <= max; i++)
{
if (i <= values.Count)
{
hasValue = true;
}
else if (hasValue = e.MoveNext())
{
values.Add(e.Current);
}
else
{
dispose();
}


if (hasValue)
yield return values[i - 1];
else
yield break;
}
}

｝

可与无限发电机工作:

a.Zip(a.Skip(1), (x, y) => Enumerable.Repeat(x, 1).Concat(Enumerable.Repeat(y, 1)))
.Zip(a.Skip(2), (xy, z) => xy.Concat(Enumerable.Repeat(z, 1)))
.Where((x, i) => i % 3 == 0)

演示代码:https://ideone.com/GKmL7M

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


public class Test
{
private static void DoIt(IEnumerable<int> a)
{
Console.WriteLine(String.Join(" ", a));


foreach (var x in a.Zip(a.Skip(1), (x, y) => Enumerable.Repeat(x, 1).Concat(Enumerable.Repeat(y, 1))).Zip(a.Skip(2), (xy, z) => xy.Concat(Enumerable.Repeat(z, 1))).Where((x, i) => i % 3 == 0))
Console.WriteLine(String.Join(" ", x));


Console.WriteLine();
}


public static void Main()
{
DoIt(new int[] {1});
DoIt(new int[] {1, 2});
DoIt(new int[] {1, 2, 3});
DoIt(new int[] {1, 2, 3, 4});
DoIt(new int[] {1, 2, 3, 4, 5});
DoIt(new int[] {1, 2, 3, 4, 5, 6});
}
}

1


1 2


1 2 3
1 2 3


1 2 3 4
1 2 3


1 2 3 4 5
1 2 3


1 2 3 4 5 6
1 2 3
4 5 6

但实际上我更喜欢写相应的方法没有linq。

对于任何对打包/维护解决方案感兴趣的人来说，MoreLINQ库提供了Batch扩展方法，该方法与您请求的行为匹配:

IEnumerable<char> source = "Example string";
IEnumerable<IEnumerable<char>> chunksOfThreeChars = source.Batch(3);

Batch实现类似于卡梅隆·麦克法兰的回答是，增加了一个重载，用于在返回之前转换块/批，并且性能相当好。

另一种方法是使用处方 缓冲算子

//using System.Linq;
//using System.Reactive.Linq;
//using System.Reactive.Threading.Tasks;


var observableBatches = anAnumerable.ToObservable().Buffer(size);


var batches = aList.ToObservable().Buffer(size).ToList().ToTask().GetAwaiter().GetResult();

看看这个!我有一个序列计数器和日期的元素列表。每次序列重新启动时，我都想创建一个新列表。

例:消息列表。

 List<dynamic> messages = new List<dynamic>
{
new { FcntUp = 101, CommTimestamp = "2019-01-01 00:00:01" },
new { FcntUp = 102, CommTimestamp = "2019-01-01 00:00:02" },
new { FcntUp = 103, CommTimestamp = "2019-01-01 00:00:03" },


//restart of sequence
new { FcntUp = 1, CommTimestamp = "2019-01-01 00:00:04" },
new { FcntUp = 2, CommTimestamp = "2019-01-01 00:00:05" },
new { FcntUp = 3, CommTimestamp = "2019-01-01 00:00:06" },


//restart of sequence
new { FcntUp = 1, CommTimestamp = "2019-01-01 00:00:07" },
new { FcntUp = 2, CommTimestamp = "2019-01-01 00:00:08" },
new { FcntUp = 3, CommTimestamp = "2019-01-01 00:00:09" }
};

我想在计数器重新启动时将列表拆分为单独的列表。代码如下:

var arraylist = new List<List<dynamic>>();


List<dynamic> messages = new List<dynamic>
{
new { FcntUp = 101, CommTimestamp = "2019-01-01 00:00:01" },
new { FcntUp = 102, CommTimestamp = "2019-01-01 00:00:02" },
new { FcntUp = 103, CommTimestamp = "2019-01-01 00:00:03" },


//restart of sequence
new { FcntUp = 1, CommTimestamp = "2019-01-01 00:00:04" },
new { FcntUp = 2, CommTimestamp = "2019-01-01 00:00:05" },
new { FcntUp = 3, CommTimestamp = "2019-01-01 00:00:06" },


//restart of sequence
new { FcntUp = 1, CommTimestamp = "2019-01-01 00:00:07" },
new { FcntUp = 2, CommTimestamp = "2019-01-01 00:00:08" },
new { FcntUp = 3, CommTimestamp = "2019-01-01 00:00:09" }
};


//group by FcntUp and CommTimestamp
var query = messages.GroupBy(x => new { x.FcntUp, x.CommTimestamp });


//declare the current item
dynamic currentItem = null;


//declare the list of ranges
List<dynamic> range = null;


//loop through the sorted list
foreach (var item in query)
{
//check if start of new range
if (currentItem == null || item.Key.FcntUp < currentItem.Key.FcntUp)
{
//create a new list if the FcntUp starts on a new range
range = new List<dynamic>();


//add the list to the parent list
arraylist.Add(range);
}


//add the item to the sublist
range.Add(item);


//set the current item
currentItem = item;
}

public static List<List<T>> GetSplitItemsList<T>(List<T> originalItemsList, short number)
{
var listGroup = new List<List<T>>();
int j = number;
for (int i = 0; i < originalItemsList.Count; i += number)
{
var cList = originalItemsList.Take(j).Skip(i).ToList();
j += number;
listGroup.Add(cList);
}
return listGroup;
}

如果源集合实现了IList <T比;(通过索引随机访问)我们可以使用下面的方法。它只在真正访问元素时获取元素，因此这对于延迟求值的集合特别有用。类似于无界的IEnumerable<T >， but for IList<T祝辞。

    public static IEnumerable<IEnumerable<T>> Chunkify<T>(this IList<T> src, int chunkSize)
{
if (src == null) throw new ArgumentNullException(nameof(src));
if (chunkSize < 1) throw new ArgumentOutOfRangeException(nameof(chunkSize), $"must be > 0, got {chunkSize}");


for(var ci = 0; ci <= src.Count/chunkSize; ci++){
yield return Window(src, ci*chunkSize, Math.Min((ci+1)*chunkSize, src.Count)-1);
}
}


private static IEnumerable<T> Window<T>(IList<T> src, int startIdx, int endIdx)
{
Console.WriteLine($"window {startIdx} - {endIdx}");
while(startIdx <= endIdx){
yield return src[startIdx++];
}
}

public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunkSize)
{
// Some implementation
}

那么下面的使用方式就有问题了:

var myList = new List<int>()
{
1,2,3,4
};
var myChunks = myList.Chunk(2);
myList.RemoveAt(0);
var firstChunk = myChunks.First();
Console.WriteLine("First chunk:" + String.Join(',', firstChunk));
myList.RemoveAt(0);
var secondChunk = myChunks.Skip(1).First();
Console.WriteLine("Second chunk:" + String.Join(',', secondChunk));
// What outputs do we see for first and second chunk? Probably not what you would expect...

根据具体的实现，代码将失败并产生运行时错误或产生不直观的结果。

所以，至少有一个属性需要减弱。如果你想要一个无懈无击的惰性解决方案，你需要将输入类型限制为不可变类型，即使这样也不能直接覆盖所有用例。但是，如果您可以控制使用，您仍然可以选择最通用的解决方案，只要您确保以一种有效的方式使用它。否则，你可能会放弃懒惰，接受一定数量的复制。

最后，这完全取决于您的用例和需求，哪种解决方案最适合您。

问题是如何“用LINQ将列表拆分为子列表"”，但有时你可能希望这些子列表是原始列表的引用，而不是副本。这允许您从子列表中修改原始列表。在这种情况下，这可能对你有用。

public static IEnumerable<Memory<T>> RefChunkBy<T>(this T[] array, int size)
{
if (size < 1 || array is null)
{
throw new ArgumentException("chunkSize must be positive");
}


var index = 0;
var counter = 0;


for (int i = 0; i < array.Length; i++)
{
if (counter == size)
{
yield return new Memory<T>(array, index, size);
index = i;
counter = 0;
}
counter++;


if (i + 1 == array.Length)
{
yield return new Memory<T>(array, index, array.Length - index);
}
}
}

用法:

var src = new[] { 1, 2, 3, 4, 5, 6 };


var c3 = RefChunkBy(src, 3);      // \{\{1, 2, 3}, {4, 5, 6}};
var c4 = RefChunkBy(src, 4);      // \{\{1, 2, 3, 4}, {5, 6}};


// as extension method
var c3 = src.RefChunkBy(3);      // \{\{1, 2, 3}, {4, 5, 6}};
var c4 = src.RefChunkBy(4);      // \{\{1, 2, 3, 4}, {5, 6}};


var sum = c3.Select(c => c.Span.ToArray().Sum());    // {6, 15}
var count = c3.Count();                 // 2
var take2 = c3.Select(c => c.Span.ToArray().Take(2));  // \{\{1, 2}, {4, 5}}

请随意修改代码。

更新。net 6.0

. net 6.0向系统中添加了一个新的本机块方法。Linq命名空间:

public static System.Collections.Generic.IEnumerable<TSource[]> Chunk<TSource> (
this System.Collections.Generic.IEnumerable<TSource> source, int size);

使用这个新方法，除最后一个块外，每个块的大小都是size。最后一个块将包含剩余的元素，大小可能较小。

这里有一个例子:

var list = Enumerable.Range(1, 100);
var chunkSize = 10;


foreach(var chunk in list.Chunk(chunkSize)) //Returns a chunk with the correct size.
{
Parallel.ForEach(chunk, (item) =>
{
//Do something Parallel here.
Console.WriteLine(item);
});
}

你可能会想，为什么不使用Skip and Take呢?这是真的，我认为这更简洁，让事情更有可读性。

从。net 6开始，你现在可以使用原生的Chunk()方法，适用于IEnumerable<T>和IQueryable<T>。

更多信息(和链接)在这里:https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/partitioning-data