Come passare da IEnumerable a lotti

Question

Sto sviluppando un programma C# che ha un "IEnumerable users" che memorizza gli ID di 4 milioni di utenti. Ho bisogno di scorrere l'Ienummerable ed estrarre un batch 1000 id ogni volta per eseguire alcune operazioni in un altro metodo.

Come estrarre 1000 id alla volta dall'inizio di Ienumerable ... fare qualcos'altro quindi recuperare il successivo lotto di 1000 e così via?

È possibile?

Answer 1

Sembra che tu debba utilizzare i metodi Skip e Take del tuo oggetto. Esempio:

users.Skip(1000).Take(1000) 

questo sarebbe saltare la prima 1000 e prendere il prossimo 1000. Si aveva solo bisogno di aumentare la quantità saltato con ogni chiamata

Si potrebbe utilizzare una variabile intera con il parametro per Skip e puoi regolare quanto viene saltato. Puoi quindi chiamarlo in un metodo.

public IEnumerable<user> GetBatch(int pageNumber) 
{ 
    return users.Skip(pageNumber * 1000).Take(1000); 
} 

Answer 2

Il modo più semplice per fare questo è probabilmente solo per utilizzare il metodo GroupBy in LINQ:

var batches = myEnumerable 
    .Select((x, i) => new { x, i }) 
    .GroupBy(p => (p.i/1000), (p, i) => p.x); 

Ma per una soluzione più sofisticata, vedono questo blog post su come creare il proprio metodo di estensione per fare questo. Duplicato qui per i posteri:

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> collection, int batchSize) 
{ 
    List<T> nextbatch = new List<T>(batchSize); 
    foreach (T item in collection) 
    { 
     nextbatch.Add(item); 
     if (nextbatch.Count == batchSize) 
     { 
      yield return nextbatch; 
      nextbatch = new List<T>(); 
      // or nextbatch.Clear(); but see Servy's comment below 
     } 
    } 

    if (nextbatch.Count > 0) 
     yield return nextbatch; 
} 

Answer 3

È possibile ottenere tale risultato utilizzando il metodo di estensione Take and Skip Enumerable. Per ulteriori informazioni sull'utilizzo cassa linq 101

Answer 4

È possibile utilizzare MoreLINQ's Batch operator (disponibile da NuGet):

foreach(IEnumerable<User> batch in users.Batch(1000)) 
    // use batch 

---

Se l'utilizzo semplice della libreria non è un'opzione, è possibile riutilizzare implementazione:

public static IEnumerable<IEnumerable<T>> Batch<T>(
     this IEnumerable<T> source, int size) 
{ 
    T[] bucket = null; 
    var count = 0; 

    foreach (var item in source) 
    { 
     if (bucket == null) 
      bucket = new T[size]; 

     bucket[count++] = item; 

     if (count != size)     
      continue; 

     yield return bucket.Select(x => x); 

     bucket = null; 
     count = 0; 
    } 

    // Return the last bucket with all remaining elements 
    if (bucket != null && count > 0)    
     yield return bucket.Take(count);    
} 

BTW per prestazioni si può semplicemente restituire il secchio senza chiamare Select(x => x). Select è ottimizzato per gli array, ma il delegato del selettore verrà comunque richiamato su ciascun elemento. Quindi, nel tuo caso è meglio usare

yield return bucket; 

Answer 5

È possibile utilizzare Take operator linq

Link: http://msdn.microsoft.com/fr-fr/library/vstudio/bb503062.aspx

Answer 6

provare a utilizzare questo:

public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(
     this IEnumerable<TSource> source, 
     int batchSize) 
    { 
     var batch = new List<TSource>(); 
     foreach (var item in source) 
     { 
      batch.Add(item); 
      if (batch.Count == batchSize) 
      { 
       yield return batch; 
       batch = new List<TSource>(); 
      } 
     } 

     if (batch.Any()) yield return batch; 
    } 

e di utilizzare la funzione di cui sopra:

foreach (var list in Users.Batch(1000)) 
{ 

} 

Answer 7

Alcuni cosa come questo dovrebbe funzionare:

List<MyClass> batch = new List<MyClass>(); 
foreach (MyClass item in items) 
{ 
    batch.Add(item); 

    if (batch.Count == 1000) 
    { 
     // Perform operation on batch 
     batch.Clear(); 
    } 
} 

// Process last batch 
if (batch.Any()) 
{ 
    // Perform operation on batch 
} 

E si potrebbe generalizzare questo in un metodo generico, in questo modo:

static void PerformBatchedOperation<T>(IEnumerable<T> items, 
             Action<IEnumerable<T>> operation, 
             int batchSize) 
{ 
    List<T> batch = new List<T>(); 
    foreach (T item in items) 
    { 
     batch.Add(item); 

     if (batch.Count == batchSize) 
     { 
      operation(batch); 
      batch.Clear(); 
     } 
    } 

    // Process last batch 
    if (batch.Any()) 
    { 
     operation(batch); 
    } 
}