LINQ Elenco partizioni in liste di 8 membri

Question

Come si può prendere una lista (usando LINQ) e dividerla in una lista di liste partizionando l'elenco originale ogni 8 voci?

Immagino che qualcosa del genere implicherebbe Skip e/o Take, ma sono ancora piuttosto nuovo per LINQ.

Edit: con C#/.Net 3.5

Edit2: Questa domanda è formulata in modo diverso rispetto l'altra domanda "duplicato". Anche se i problemi sono simili, le risposte in questa domanda sono superiori: sia la risposta "accettata" è molto solida (con la dichiarazione yield) sia il suggerimento di Jon Skeet di usare MoreLinq (che non è raccomandato nella domanda "altro".) A volte i duplicati sono buoni in quanto costringono a riesaminare un problema.

Answer 1

Usare il seguente metodo di estensione per rompere l'ingresso in sottoinsiemi

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; 
     } 
    } 
} 

Answer 2

Abbiamo solo un tale metodo in MoreLINQ come metodo Batch:

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

o

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

Answer 3

È meglio usare una libreria lik e MoreLinq, ma se proprio dovessi farlo usando "LINQ plain", è possibile utilizzare 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} } 

In sostanza, si usa la versione di Select() che fornisce un indice per il valore di essere consumato, dividiamo l'indice per 8 per identificare a quale gruppo appartiene ciascun valore. Quindi raggruppiamo la sequenza con questa chiave di raggruppamento. L'ultimo Select riduce lo IGrouping<> in uno IEnumerable<IEnumerable<T>> (e non è strettamente necessario poiché IGrouping è un IEnumerable).

È abbastanza semplice trasformarlo in un metodo riutilizzabile prendendo in considerazione la costante 8 nell'esempio e sostituendolo con un parametro specificato. Non è necessariamente la soluzione più elegante e non è più una soluzione di streaming pigra ... ma funziona.

È anche possibile scrivere il proprio metodo di estensione utilizzando i blocchi iteratore (yield return) che potrebbero fornire prestazioni migliori e utilizzare meno memoria di GroupBy. Questo è ciò che il metodo Batch() di MoreLinq fa IIRC.

Answer 4

Take non sarà molto efficiente, perché non rimuove le voci prese.

perché non utilizzare un semplice ciclo:

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; 
    } 
} 

Answer 5

E 'non è quello che i progettisti originali Linq avevano in mente, ma il check-out questo abuso di 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); 
} 

penso che vince il premio "golf" per questa domanda. Lo ToList è molto importante poiché si desidera assicurarsi che il raggruppamento sia stato effettivamente eseguito prima di provare a fare qualcosa con l'output.Se rimuovi il ToList, otterrai alcuni strani effetti collaterali.

Answer 6

from b in Enumerable.Range(0,8) select items.Where((x,i) => (i % 8) == b); 

Answer 7

La soluzione più semplice è data da Mel:

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

conciso ma più lento. Il suddetto metodo divide un oggetto IEnumerable in blocchi di dimensioni fisse desiderate con un numero totale di blocchi non importante. Per dividere un IEnumerable in numero N di pezzi di dimensioni pari o vicino al pari dimensioni, si potrebbe fare:

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

Per accelerare le cose, un approccio diretto farebbe:

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); 
} 

questo è più veloce di qualsiasi cosa attualmente sul pianeta ora :) I metodi equivalenti per un'operazione Splithere