auswählen und übergeben sie ein Verfahren

Question

ich eine Liste haben und zur Zeit sind wir vorbei an einem einzigen Element zu einem Zeitpunkt auf eine andere Methode

foreach (var contact in tracker.Parse()) 

im Grunde sind wir der Auswahl von Kontakten aus Azure Blob Speichern und importieren Sie sie in Dynamics CRM. tracker.Parse() returns ist eine Liste von Kontakten.

Ich möchte alle 1000 und dann warten wählen, bis sie in dem anderen Verfahren abgeschlossen sind, bevor ich in den nächsten 1000

brauchen Anleitung, wie dies zu tun passieren.

Schätzen Sie die Hilfe!

Answer 1

Vielleicht so etwas wie ...

static void Main() 
{ 
    const int batchSize = 1000; 

    // Populate array with 5841 items of data 
    var lotsOfItems = new List<int>(); 
    for (int i = 0; i < 5841; i++) 
    { 
     lotsOfItems.Add(i); 
    } 

    // Process items in batches, waiting for each batch to complete before the next 
    int indexOfLastItemTaken = 0; 
    while (indexOfLastItemTaken < lotsOfItems.Count - 1) 
    { 
     var itemsTaken = lotsOfItems.Skip(indexOfLastItemTaken).Take(batchSize).ToList(); 
     ProcessItems(itemsTaken); 
     indexOfLastItemTaken += itemsTaken.Count(); 
    } 

    Console.Write("Done. Press any key to quit..."); 
    Console.ReadKey(); 
} 

static void ProcessItems(IEnumerable<int> input) 
{ 
    // do something with input 
    Console.WriteLine(new string('-', 15)); 
    Console.WriteLine($"Processing a new batch of {input.Count()} items:"); 
    Console.WriteLine(string.Join(",", input)); 
} 

Answer 2

Gruppe die Daten aus der Datenquelle in die Gruppengröße gewünscht und sie verarbeiten.

Linq Mit ihm kann mit Select und GroupBy Erweiterungen

int groupSize = 1000; 

//Batch the data 
var batches = tracker.Parse() 
    .Select((contact, index) => new { contact, index }) 
    .GroupBy(_ => _.index/groupSize, _ => _.contact); 

//Process the batches. 
foreach (var batch in batches) { 
    //Each batch would be IEnumerable<TContact> 
    ProcessBatch(batch); 
} 

dies erreicht werden kann, eine wiederverwendbare generische Methode umgewandelt werden, wenn nötig

public static void ProcessInBatches<TItem>(this IEnumerble<TItem> items, int batchSize, Action<IEnumerable<TItem>> processBatch) { 

    //Batch the data 
    var batches = items 
     .Select((item, index) => new { item, index }) 
     .GroupBy(_ => _.index/batchSize, _ => _.item); 

    //Process the batches. 
    foreach (var batch in batches) { 
     //Each batch would be IEnumerable<TItem> 
     processBatch(batch); 
    } 
}