Utilice linq para dividir la lista <t> en muchos de la lista <t> de n longitud?

Question

Duplicar posible:
How can I split an IEnumerable<String> into groups of IEnumerable<string>

tengo una lista que me gustaría entrar en grupos de 10.

Si tengo un objeto

List<Person> allPendingPersons 

que es de longitud m.

¿Hay una forma elegante en LINQ de dividir todas lasPendingPersons en uno o más objetos List que tengan hasta 10 personas?

Answer 1

var groups = allPendingPersons.Select((p, index) => new {p,index}) 
           .GroupBy(a =>a.index/10); 

si desea procesar IGrouping<,>. Si usted está buscando Lista> Atrás podría intentar

var listOfLists = allPendingPersons.Select((p, index) => new {p, index}) 
    .GroupBy(a => a.index/10) 
    .Select((grp => grp.Select(g => g.p).ToList())) 
    .ToList(); 

Answer 2

Usted puede escribir su propio método de extensión:

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> sequence, int size) { 
    List<T> partition = new List<T>(size); 
    foreach(var item in sequence) { 
     partition.Add(item); 
     if (partition.Count == size) { 
      yield return partition; 
      partition = new List<T>(size); 
     } 
    } 
    if (partition.Count > 0) 
     yield return partition; 
} 

I explored this in more depth en mi blog.

Answer 3

No es la técnica más eficaz, pero esto va a producir una secuencia de IEnumerable<IEnumerable<Person>>, con cada secuencia interna que contiene diez elementos:

var query = allPendingPersons.Select((x, i) => new { Value = x, Group = i/10 }) 
          .GroupBy(x => x.Group, 
             (k, g) => g.Select(x => x.Value)); 

y si el resultado realmente no tiene por qué ser una lista-de-listas en lugar de una simple secuencia a continuación, se puede crear un List<List<Person>> no por la adición de un par de llamadas ToList:

var query = allPendingPersons.Select((x, i) => new { Value = x, Group = i/10 }) 
          .GroupBy(x => x.Group, 
             (k, g) => g.Select(x => x.Value).ToList()) 
          .ToList(); 

Answer 4

probar un bloque de iterador:

public static IEnumerable<List<Person>> AsGroups(this List<Person> persons) 
{ 
    var buf = new List<Person>(10); 
    for (int i = 0; i<persons.Count i++;) 
    { 
     buf.Add(persons[i]); 
     if (i%10 == 0 && buf.Count > 0) 
     { 
      yield return buf; 
      buf = new List<Person>(10); 
     } 
    } 
    yield return buf; 
} 

Answer 5

El Reactive Extensions for .NET (Rx) tiene un método de extensión que hace exactamente lo que quiere:

var buffered = allPendingPersons.BufferWithCount(10); 

Si desea hacerlo utilizando LINQ usted puede hacer esto:

var buffered = 
    allPendingPersons 
     .Select((p, i) => new { Group = i/10, Person = p }) 
     .GroupBy(x => x.Group, x => x.Person) 
     .Select(g => g.ToArray()); 

Answer 6

Esto debería ser de alguna ayuda.

How can I split an IEnumerable<String> into groups of IEnumerable<string>
Divide a large IEnumerable into smaller IEnumerable of a fix amount of item
Can I improve these Pagination extension methods?
Get groups of 4 elements from name value list using LINQ in C#
LINQ: Get min and max values of sequence of numbers divided into subsequences
LINQ Partition List into Lists of 8 members

Una respuesta muy popular es de revisar MoreLinq, en particular, la función de Jon Skeet Batch, que no sólo hace lo que está preguntando, pero también te permite especificar un selector de devolución.

Answer 7

¿Hay una manera elegante en LINQ

El elegant way no es de buen calidad. Aquí es una forma más performante ...

public static List<List<T>> Chunk<T>(
     this List<T> theList, 
     int chunkSize 
    ) 
    { 
     if (!theList.Any()) 
     { 
      return new List<List<T>>(); 
     } 

     List<List<T>> result = new List<List<T>>(); 
     List<T> currentList = new List<T>(); 
     result.Add(currentList); 

     int i = 0; 
     foreach(T item in theList) 
     { 
      if (i >= chunkSize) 
      { 
       i = 0; 
       currentList = new List<T>(); 
       result.Add(currentList); 
      } 
      i += 1; 
      currentList.Add(item); 
     } 
     return result; 
    }