C# 将列表细分为多个列表时System.Linq的性能问题
我编写了一个方法，使用C# 将列表细分为多个列表时System.Linq的性能问题,c#,linq,iteration,C#,Linq,Iteration,我编写了一个方法，使用System.Linq将项目列表细分为多个列表。 当我对50000个简单整数运行此方法时，大约需要59.862秒 Stopwatch watchresult0 = new Stopwatch(); watchresult0.Start(); var result0 = SubDivideListLinq(Enumerable.Range(0, 50000), 100).ToList(); watchresult0.Stop(); long elapsedresult0 =
System.LinqStopwatch watchresult0 = new Stopwatch();
watchresult0.Start();
var result0 = SubDivideListLinq(Enumerable.Range(0, 50000), 100).ToList();
watchresult0.Stop();
long elapsedresult0 = watchresult0.ElapsedMilliseconds;
Stopwatch watchresult1 = new Stopwatch();
watchresult1.Start();
var result1 = SubDivideList(Enumerable.Range(0, 50000), 100).ToList();
watchresult1.Stop();
long elapsedresult1 = watchresult1.ElapsedMilliseconds;
private static IEnumerable<List<T>> SubDivideListLinq<T>(IEnumerable<T> enumerable, int count)
{
while (enumerable.Any())
{
yield return enumerable.Take(count).ToList();
enumerable = enumerable.Skip(count);
}
}
而且：正如你所看到的，我知道如何分割列表，所以这是相关问题的重复。我想知道linq和我的实现之间的性能。如果有人带着同样的问题来到这里，不知道如何拆分列表： 所以最后我做了更多的研究，发现System.Linq的多重枚举是性能的原因： 当我将其枚举到数组中时，为了避免多次枚举，性能会更好（14 ms/50k项）： 不过，我不会使用linq方法，因为它比较慢。 相反，我编写了一个扩展方法来细分我的列表，50k个项目需要3毫秒：
T[] allItems = enumerable as T[] ?? enumerable.ToArray();
while (allItems.Any())
{
yield return allItems.Take(count);
allItems = allItems.Skip(count).ToArray();
}
public static class EnumerableExtensions
{
public static IEnumerable<List<T>> Subdivide<T>(this IEnumerable<T> enumerable, int count)
{
List<T> items = new List<T>(count);
int index = 0;
foreach (T item in enumerable)
{
items.Add(item);
index++;
if (index != count) continue;
yield return items;
items = new List<T>(count);
index = 0;
}
if (index != 0 && items.Any())
yield return items;
}
}
公共静态类EnumerableExtensions
{
公共静态IEnumerable细分（此IEnumerable可枚举，int计数）
{
列表项=新列表（计数）；
int指数=0；
foreach（可枚举中的T项）
{
项目。添加（项目）；
索引++；
如果（索引！=计数）继续；
收益回报项目；
项目=新列表（计数）；
指数=0；
}
if（index！=0&&items.Any（））
收益回报项目；
}
}
与@Andreasniedermir已经编写的一样，它也包含在
MoreLinqBatchprivate static IEnumerable<List<T>> SubDivideListLinq<T>(IEnumerable<T> enumerable, int count)
{
int index = 0;
return enumerable.GroupBy(l => index++/count).Select(l => l.ToList());
}
private静态IEnumerable subdivisidelistlinq（IEnumerable enumerable，int count）
{
int指数=0；
返回enumerable.GroupBy（l=>index++/count）；
}
private static IEnumerable<List<T>> SubDivideListLinq<T>(IEnumerable<T> enumerable, int count)
{
int index = 0;
return from l in enumerable
group l by index++/count
into l select l.ToList();
}
private static IEnumerable<List<T>> SubDivideListLinq<T>(IEnumerable<T> enumerable, int count)
{
int index = 0;
return enumerable.GroupBy(l => index++/count,
item => item,
(key,result) => result.ToList());
}
private静态IEnumerable subdivisidelistlinq（IEnumerable enumerable，int count）
{
int指数=0；
从可枚举中的l返回
按索引++/计数的l组
选择l.ToList（）；
}
private static IEnumerable<List<T>> SubDivideListLinq<T>(IEnumerable<T> enumerable, int count)
{
int index = 0;
return from l in enumerable
group l by index++/count
into l select l.ToList();
}
private static IEnumerable<List<T>> SubDivideListLinq<T>(IEnumerable<T> enumerable, int count)
{
int index = 0;
return enumerable.GroupBy(l => index++/count,
item => item,
(key,result) => result.ToList());
}
private静态IEnumerable subdivisidelistlinq（IEnumerable enumerable，int count）
{
int指数=0；
返回可枚举的.GroupBy（l=>index++/count，
项目=>项目，
（key，result）=>result.ToList（））；
}
linq 0.006秒非linq 0.002秒作为建议，不要用微优化代码折磨自己。显然，没有人会感觉到几毫秒的差异，所以请编写一段代码，稍后您和其他人可以轻松理解。LINQ版本将在每次迭代中执行两次查询。它也将有空循环，总是要找到最后的位置，而您的优化方法可以继续处理。它还将使用正确的大小初始化列表，而LINQ每次都必须调整内部数组的大小。另外，不要使用
while（enumerable.Any（））foreachMoveNextCurrent