Список разделов LINQ на списки из 8 членов

Используйте следующий метод расширения, чтобы разбить ввод на подмножества

public static class IEnumerableExtensions
{
    public static IEnumerable<List<T>> InSetsOf<T>(this IEnumerable<T> source, int max)
    {
        List<T> 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;
        }
    }
}

У нас есть такой метод в MoreLINQ как Пакетный метод:

// As IEnumerable<IEnumerable<T>>
var items = list.Batch(8);

or

// As IEnumerable<List<T>>
var items = list.Batch(8, seq => seq.ToList());

Вам лучше использовать такую ​​библиотеку, как MoreLinq, но если вам действительно нужно было сделать это с помощью " простой LINQ ", вы можете использовать GroupBy:

var sequence = new[] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};

var result = sequence.Select((x, i) => new {Group = i/8, Value = x})
                     .GroupBy(item => item.Group, g => g.Value)
                     .Select(g => g.Where(x => true));

// result is: { {1,2,3,4,5,6,7,8}, {9,10,11,12,13,14,15,16} }

В основном мы используем версию Select(), которая предоставляет индекс для потребляемого значения, мы делим индекс на 8, чтобы определить, к какой группе принадлежит каждое значение. Затем мы группируем последовательность по этому ключу группировки. Последний Select просто уменьшает IGrouping<> до IEnumerable<IEnumerable<T>> (и не является строго необходимым, поскольку IGrouping - это IEnumerable).

Достаточно легко превратить это в метод многократного использования, факторизовав нашу константу 8 в примере и заменив ее указанным параметром. Это не обязательно самое элегантное решение, и это уже не ленивое потоковое решение ... но оно действительно работает.

Вы также можете написать свой собственный метод расширения, используя блоки итераторов (yield return), которые могут дать вам лучшую производительность и использовать меньше памяти, чем GroupBy. Это то, что Batch() метод MoreLinq делает IIRC.

Это совсем не то, что имели в виду оригинальные дизайнеры Linq, но посмотрите на это неправильное использование GroupBy:

public static IEnumerable<IEnumerable<T>> BatchBy<T>(this IEnumerable<T> items, int batchSize)
{
    var count = 0;
    return items.GroupBy(x => (count++ / batchSize)).ToList();
}

[TestMethod]
public void BatchBy_breaks_a_list_into_chunks()
{
    var values = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    var batches = values.BatchBy(3);
    batches.Count().ShouldEqual(4);
    batches.First().Count().ShouldEqual(3);
    batches.Last().Count().ShouldEqual(1);
}

Я думаю, что в этом вопросе он выиграет приз "гольф". ToList очень важен, так как вы хотите убедиться, что группировка действительно была выполнена, прежде чем пытаться что-либо сделать с выводом. Если вы удалите ToList, вы получите странные побочные эффекты.

Take не будет очень эффективным, потому что он не удаляет сделанные записи.

почему бы не использовать простой цикл:

public IEnumerable<IList<T>> Partition<T>(this/* <-- see extension methods*/ IEnumerable<T> src,int num)  
{  
    IEnumerator<T> enu=src.getEnumerator();  
    while(true)  
    {  
        List<T> result=new List<T>(num);  
        for(int i=0;i<num;i++)  
        {  
            if(!enu.MoveNext())  
            {  
                if(i>0)yield return result;  
                yield break;  
            }  
            result.Add(enu.Current);  
        }  
        yield return result;  
    }  
}

Простейшее решение дает Мел:

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, 
                                                       int partitionSize)
{
    int i = 0;
    return items.GroupBy(x => i++ / partitionSize).ToArray();
}

Лаконично, но медленнее. Вышеупомянутый метод разбивает IEnumerable на фрагменты желаемого фиксированного размера, при этом общее количество фрагментов не имеет значения. Чтобы разделить IEnumerable на N частей равного или почти равного размера, вы можете сделать:

public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> items, 
                                                   int numOfParts)
{
    int i = 0;
    return items.GroupBy(x => i++ % numOfParts);
}

Чтобы ускорить процесс, подойдет простой подход:

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, 
                                                       int partitionSize)
{
    if (partitionSize <= 0)
        throw new ArgumentOutOfRangeException("partitionSize");

    int innerListCounter = 0;
    int numberOfPackets = 0;
    foreach (var item in items)
    {
        innerListCounter++;
        if (innerListCounter == partitionSize)
        {
            yield return items.Skip(numberOfPackets * partitionSize).Take(partitionSize);
            innerListCounter = 0;
            numberOfPackets++;
        }
    }

    if (innerListCounter > 0)
        yield return items.Skip(numberOfPackets * partitionSize);
}

Это быстрее, чем что-либо в настоящее время на планете :) Эквивалентные методы для Split операции здесь