Cómo puedo dividir un IEnumerable <String> en grupos de IEnumerable <string>

Question

tengo una IEnumerable<string> que me gustaría que se dividan en grupos de tres, así que si mi entrada tenía 6 elementos que se pueden conseguir una IEnumerable<IEnumerable<string>> volvió con dos elementos cada uno de los cuales contiene un IEnumerable<string> que contiene el contenido de mi cadena.

Busco la manera de hacer esto con LINQ en lugar de un simple bucle for

Gracias

Answer 1

var result = sequence.Select((s, i) => new { Value = s, Index = i }) 
        .GroupBy(item => item.Index/3, item => item.Value); 

Tenga en cuenta que este devolverá un IEnumerable<IGrouping<int,string>> que será funcionalmente similar a lo que desea. Sin embargo, si estrictamente necesario que escriba como IEnumerable<IEnumerable<string>> (para pasar a un método que espera que en C# 3.0, que no es compatible con los genéricos varianza,) se debe utilizar Enumerable.Cast:

var result = sequence.Select((s, i) => new { Value = s, Index = i }) 
        .GroupBy(item => item.Index/3, item => item.Value) 
        .Cast<IEnumerable<string>>(); 

Answer 2

me ocurrió con un diferente enfoque. Utiliza un iterador while bien pero los resultados se guardan en la memoria como un LINQ regular hasta que sea necesario.
Aquí está el código.

public IEnumerable<IEnumerable<T>> Paginate<T>(this IEnumerable<T> source, int pageSize) 
{ 
    List<IEnumerable<T>> pages = new List<IEnumerable<T>>(); 
    int skipCount = 0; 

    while (skipCount * pageSize < source.Count) { 
     pages.Add(source.Skip(skipCount * pageSize).Take(pageSize)); 
     skipCount += 1; 
    } 

    return pages; 
} 

Answer 3

Sé que esto ya ha sido contestada, pero si usted planea tomar rebanadas de IEnumerables menudo, entonces te recomiendo hacer un método de extensión genérica como esto:

public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int chunkSize) 
{ 
    return source.Where((x,i) => i % chunkSize == 0).Select((x,i) => source.Skip(i * chunkSize).Take(chunkSize)); 
} 

continuación, puede utilizar sequence.Split(3) a consigue lo que quieres

(puede ponerle otro nombre como 'slice', o 'chunk' si no le gusta que 'split' ya se haya definido para cadenas. 'Split' es justo lo que llamé mina).

Answer 4

Inspirado por la implementación de @ dicegiuy30, quería crear una versión que solo itere sobre la fuente una vez y no construya todo el conjunto de resultados en la memoria para compensar. Lo mejor que se me ocurre es esto:

public static IEnumerable<IEnumerable<T>> Split2<T>(this IEnumerable<T> source, int chunkSize) { 
    var chunk = new List<T>(chunkSize); 
    foreach(var x in source) { 
     chunk.Add(x); 
     if(chunk.Count <= chunkSize) { 
      continue; 
     } 
     yield return chunk; 
     chunk = new List<T>(chunkSize); 
    } 
    if(chunk.Any()) { 
     yield return chunk; 
    } 
} 

De esta manera construyo cada porción a pedido. También me gustaría evitar el List<T> y simplemente transmitir ese contenido también, pero aún no lo he descifrado.

Answer 5

usando Microsoft.Reactive puedes hacer esto bastante simple e iterarás solo una vez a través de la fuente.

IEnumerable<string> source = new List<string>{"1", "2", "3", "4", "5", "6"}; 

IEnumerable<IEnumerable<string>> splited = source.ToObservable().Buffer(3).ToEnumerable(); 

Answer 6

Podemos mejorar la solución @ Afshari para hacer una verdadera evaluación perezosa. Utilizamos un método GroupAdjacentBy que produce grupos de elementos consecutivos con la misma clave:

sequence 
.Select((x, i) => new { Value = x, Index = i }) 
.GroupAdjacentBy(x=>x.Index/3) 
.Select(g=>g.Select(x=>x.Value)) 

Debido a que los grupos se produjeron uno por uno, esta solución funciona de manera eficiente con secuencias largas o infinitas.

Answer 7

Ésta es una respuesta tardía a este tema, pero aquí es un método que no utiliza ningún tipo de almacenamiento temporal:

public static class EnumerableExt 
{ 
    public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> input, int blockSize) 
    { 
     var enumerator = input.GetEnumerator(); 

     while (enumerator.MoveNext()) 
     { 
      yield return nextPartition(enumerator, blockSize); 
     } 
    } 

    private static IEnumerable<T> nextPartition<T>(IEnumerator<T> enumerator, int blockSize) 
    { 
     do 
     { 
      yield return enumerator.Current; 
     } 
     while (--blockSize > 0 && enumerator.MoveNext()); 
    } 
} 

Y algunos código de prueba:

class Program 
{ 
    static void Main(string[] args) 
    { 
     var someNumbers = Enumerable.Range(0, 10000); 

     foreach (var block in someNumbers.Partition(100)) 
     { 
      Console.WriteLine("\nStart of block."); 

      foreach (int number in block) 
      { 
       Console.Write(number); 
       Console.Write(" "); 
      } 
     } 

     Console.WriteLine("\nDone."); 
     Console.ReadLine(); 
    } 
} 

Answer 8

respuesta de Mehrdad Afshari es excelente. Aquí es el un método de extensión que lo encapsula:

using System.Collections.Generic; 
using System.Linq; 

public static class EnumerableExtensions 
{ 
    public static IEnumerable<IEnumerable<T>> GroupsOf<T>(this IEnumerable<T> enumerable, int size) 
    { 
     return enumerable.Select((v, i) => new {v, i}).GroupBy(x => x.i/size, x => x.v); 
    } 
}