我有一个对象集合,需要批量处理100个对象,并对它们进行一些处理,直到没有剩余的对象处理为止。LINQ:从一个集合中获取一系列元素
而不是循环通过每个项目,抓住100个元素,然后下一百等有没有更好的方式与linq做呢?
非常感谢
我有一个对象集合,需要批量处理100个对象,并对它们进行一些处理,直到没有剩余的对象处理为止。LINQ:从一个集合中获取一系列元素
而不是循环通过每个项目,抓住100个元素,然后下一百等有没有更好的方式与linq做呢?
非常感谢
static void test(IEnumerable<object> objects)
{
while (objects.Any())
{
foreach (object o in objects.Take(100))
{
}
objects = objects.Skip(100);
}
}
:)
如果在Entity Framework中使用此方法,请小心。它生成的SQL在每次迭代中都会有一个额外的子查询。如果批次超过50个,则查询失败。 – 2013-10-07 11:31:16
int batchSize = 100;
var batched = yourCollection.Select((x, i) => new { Val = x, Idx = i })
.GroupBy(x => x.Idx/batchSize,
(k, g) => g.Select(x => x.Val));
// and then to demonstrate...
foreach (var batch in batched)
{
Console.WriteLine("Processing batch...");
foreach (var item in batch)
{
Console.WriteLine("Processing item: " + item);
}
}
我不认为LINQ是真正适合这种处理的 - 这是用于对整个序列的操作,而不是分裂主要是有用的或修改它们。我会通过访问底层的IEnumerator<T>
来做到这一点,因为任何使用Take
和Skip
的方法都会非常低效。
public static void Batch<T>(this IEnumerable<T> items, int batchSize, Action<IEnumerable<T>> batchAction)
{
if (batchSize < 1) throw new ArgumentException();
List<T> buffer = new List<T>();
using (var enumerator = (items ?? Enumerable.Empty<T>()).GetEnumerator())
{
while (enumerator.MoveNext())
{
buffer.Add(enumerator.Current);
if (buffer.Count == batchSize)
{
batchAction(buffer);
buffer.Clear();
}
}
//execute for remaining items
if (buffer.Count > 0)
{
batchAction(buffer);
}
}
}
这会将列表分割成您指定的很多项目的列表列表。
public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> source, int size)
{
int i = 0;
List<T> list = new List<T>(size);
foreach (T item in source)
{
list.Add(item);
if (++i == size)
{
yield return list;
list = new List<T>(size);
i = 0;
}
}
if (list.Count > 0)
yield return list;
}
var batchSize = 100;
for (var i = 0; i < Math.Ceiling(yourCollection.Count()/(decimal)batchSize); i++)
{
var batch = yourCollection
.Skip(i*batchSize)
.Take(batchSize);
// Do something with batch
}
LukeH的答案是好多了,请接受并使用它。 – Andrey 2010-10-06 13:22:08