Divida un IEnumerable grande en IEnumerable menor de un monto fijo del elemento

Question

Para admitir una API que solo acepta una cantidad específica de elementos (5 elementos), quiero transformar un resultado LINQ en grupos más pequeños de elementos que siempre contienen esa cantidad establecida de artículos.

Suponiendo que la lista {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}

quiero conseguir tres listas más pequeñas de un máximo de 5 elementos cada

{1, 2, 3, 4, 5}

{6, 7, 8, 9, 10}

{11, 12, 13, 14, 15}

{16, 17, 18}

¿Cómo puedo hacer eso con LINQ? Supongo que implica Group o Aggregate, pero tengo problemas para entender cómo escribir eso.

Answer 1

intentar algo como esto:

var result = items.Select((value, index) => new { Index = index, Value = value}) 
        .GroupBy(x => x.Index/5) 
        .Select(g => g.Select(x => x.Value).ToList()) 
        .ToList(); 

Funciona mediante la partición de los elementos en grupos en función de su índice en la lista original.

Answer 2

Una posibilidad sencilla es utilizar los métodos Enumerable.Skip y Enumerable.Take, por ejemplo:

List<int> nums = new List<int>(){1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}; 

var list1 = nums.Take(5); 
var list2 = nums.Skip(5).Take(5); 
var list3 = nums.Skip(10).Take(5); 
var list4 = nums.Skip(15).Take(5); 

Como Jon menciona en los comentarios, sin embargo, un enfoque sencillo como éste volverá a evaluar nums (en este ejemplo) cada vez, lo que afectará el rendimiento (según el tamaño de la colección).

Answer 3

Tenemos un método Batch en MoreLINQ. Debe tener cuidado de cómo lo usa, ya que el lote que se pasa al selector cada vez es una referencia a la misma matriz, pero funciona.

Usted puede utilizar GroupBy, pero eso no puede ser perezoso - tiene que acumular todos los resultados antes de que pueda devolver nada. Eso puede estar bien para ti, pero vale la pena ser consciente de ello.

Answer 4

que acababa de hacer algo como esto:

public static IEnumerable<IEnumerable<T>> TakeChunks<T>(this IEnumerable<T> source, int size) 
{ 
    // Typically you'd put argument validation in the method call and then 
    // implement it using a private method... I'll leave that to your 
    // imagination. 

    var list = new List<T>(size); 

    foreach (T item in source) 
    { 
     list.Add(item); 
     if (list.Count == size) 
     { 
      List<T> chunk = list; 
      list = new List<T>(size); 
      yield return chunk; 
     } 
    } 

    if (list.Count > 0) 
    { 
     yield return list; 
    } 
} 

Uso:

var list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 

foreach (var chunk in list.TakeChunks(3)) 
{ 
    Console.WriteLine(string.Join(", ", chunk)); 
} 

Salida:

 
1, 2, 3 
4, 5, 6 
7, 8, 9 
10 

Justificación:

En comparación con otros métodos tales múltiple llama t O Skip y Take o una consulta LINQ gran lujo, lo anterior es:

• más eficiente
• más evidente en la función (en mi opinión)
• más legible en la ejecución (de nuevo, en mi opinión)

Answer 5

var list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; 
var result = new List<List<int>>(); 
while (list.Count != 0) { 
    result.Add(list.TakeWhile(x => x++ <= 5).ToList()); 
    list.RemoveRange(0, list.Count < 5 ? list.Count : 5); 
}