Ausführen mehrerer asynchroner Aufgaben und Warten auf deren Abschluss

Ich muss mehrere asynchrone Aufgaben in einer Konsolenanwendung ausführen und warten, bis sie alle abgeschlossen sind, bevor ich sie weiter verarbeite.

Es gibt viele Artikel da draußen, aber ich scheine umso verwirrter zu werden, je mehr ich lese. Ich habe die Grundprinzipien der Aufgabenbibliothek gelesen und verstanden, aber irgendwo fehlt mir eindeutig ein Link.

Ich verstehe, dass es möglich ist, Aufgaben so zu verketten, dass sie nach Abschluss eines anderen beginnen (was so ziemlich das Szenario für alle Artikel ist, die ich gelesen habe), aber ich möchte, dass alle meine Aufgaben gleichzeitig ausgeführt werden, und ich möchte es einmal wissen Sie sind alle fertig.

Was ist die einfachste Implementierung für ein solches Szenario?

In beiden Antworten wurde das Erwartete nicht erwähnt Task.WhenAll:

var task1 = DoWorkAsync();
var task2 = DoMoreWorkAsync();

await Task.WhenAll(task1, task2);

Der Hauptunterschied zwischen Task.WaitAllund Task.WhenAllbesteht darin, dass erstere blockiert werden (ähnlich wie bei Waiteiner einzelnen Aufgabe), während letztere nicht abgewartet werden können und dem Anrufer die Kontrolle zurückgeben, bis alle Aufgaben abgeschlossen sind.

Darüber hinaus unterscheidet sich die Ausnahmebehandlung:

Task.WaitAll::

Mindestens eine der Task-Instanzen wurde abgebrochen, oder während der Ausführung mindestens einer der Task-Instanzen wurde eine Ausnahme ausgelöst. Wenn eine Aufgabe abgebrochen wurde, enthält die AggregateException eine OperationCanceledException in ihrer InnerExceptions-Auflistung.

Task.WhenAll::

Wenn eine der bereitgestellten Aufgaben in einem fehlerhaften Zustand ausgeführt wird, wird die zurückgegebene Aufgabe auch in einem fehlerhaften Zustand ausgeführt, in dem ihre Ausnahmen die Aggregation der nicht ausgepackten Ausnahmen aus jeder der bereitgestellten Aufgaben enthalten.

Wenn keine der bereitgestellten Aufgaben fehlerhaft ist, aber mindestens eine abgebrochen wurde, endet die zurückgegebene Aufgabe im Status Abgebrochen.

Wenn keine der Aufgaben fehlerhaft ist und keine der Aufgaben abgebrochen wurde, endet die resultierende Aufgabe im Status RanToCompletion. Wenn das bereitgestellte Array / die Aufzählung keine Aufgaben enthält, wechselt die zurückgegebene Aufgabe sofort in einen RanToCompletion-Status, bevor sie an den Aufrufer zurückgegeben wird.

Sie können viele Aufgaben erstellen wie:

List<Task> TaskList = new List<Task>();
foreach(...)
{
   var LastTask = new Task(SomeFunction);
   LastTask.Start();
   TaskList.Add(LastTask);
}

Task.WaitAll(TaskList.ToArray());

Die beste Option, die ich gesehen habe, ist die folgende Erweiterungsmethode:

public static Task ForEachAsync<T>(this IEnumerable<T> sequence, Func<T, Task> action) {
    return Task.WhenAll(sequence.Select(action));
}

Nennen Sie es so:

await sequence.ForEachAsync(item => item.SomethingAsync(blah));

Oder mit einem asynchronen Lambda:

await sequence.ForEachAsync(async item => {
    var more = await GetMoreAsync(item);
    await more.FrobbleAsync();
});

Sie können verwenden, WhenAllwelche einen erwarteten Taskoder WaitAllkeinen Rückgabetyp zurückgeben und die weitere Codeausführung blockieren, Thread.Sleepbis alle Aufgaben abgeschlossen, abgebrochen oder fehlerhaft sind.

Beispiel

var tasks = new Task[] {
    TaskOperationOne(),
    TaskOperationTwo()
};

Task.WaitAll(tasks);
// or
await Task.WhenAll(tasks);

Wenn Sie die Aufgaben in einer bestimmten Reihenfolge ausführen möchten, können Sie sich von dieser Antwort inspirieren lassen.

Möchten Sie die Tasks verketten oder können sie parallel aufgerufen werden?

Zum Verketten
Mach einfach so etwas

Task.Run(...).ContinueWith(...).ContinueWith(...).ContinueWith(...);
Task.Factory.StartNew(...).ContinueWith(...).ContinueWith(...).ContinueWith(...);

und vergessen Sie nicht, die vorherige TaskInstanz in jeder zu überprüfen, ContinueWithda dies möglicherweise fehlerhaft ist.

Für die parallele Art
Die einfachste Methode, auf die ich gestoßen bin: Parallel.Invoke Andernfalls gibt es Task.WaitAlloder Sie können sogar WaitHandles verwenden, um einen Countdown bis zu null verbleibenden Aktionen durchzuführen (warten Sie, es gibt eine neue Klasse :) CountdownEventoder ...

So mache ich es mit einem Array Func <> :

var tasks = new Func<Task>[]
{
   () => myAsyncWork1(),
   () => myAsyncWork2(),
   () => myAsyncWork3()
};

await Task.WhenAll(tasks.Select(task => task()).ToArray()); //Async    
Task.WaitAll(tasks.Select(task => task()).ToArray()); //Or use WaitAll for Sync

Noch eine Antwort ... aber ich befinde mich normalerweise in einem Fall, in dem ich Daten gleichzeitig laden und in Variablen einfügen muss, wie:

var cats = new List<Cat>();
var dog = new Dog();

var loadDataTasks = new Task[]
{
    Task.Run(async () => cats = await LoadCatsAsync()),
    Task.Run(async () => dog = await LoadDogAsync())
};

try
{
    await Task.WhenAll(loadDataTasks);
}
catch (Exception ex)
{
    // handle exception
}

Ich habe einen Code vorbereitet, um Ihnen zu zeigen, wie Sie die Aufgabe für einige dieser Szenarien verwenden können.

    // method to run tasks in a parallel 
    public async Task RunMultipleTaskParallel(Task[] tasks) {

        await Task.WhenAll(tasks);
    }
    // methode to run task one by one 
    public async Task RunMultipleTaskOneByOne(Task[] tasks)
    {
        for (int i = 0; i < tasks.Length - 1; i++)
            await tasks[i];
    }
    // method to run i task in parallel 
    public async Task RunMultipleTaskParallel(Task[] tasks, int i)
    {
        var countTask = tasks.Length;
        var remainTasks = 0;
        do
        {
            int toTake = (countTask < i) ? countTask : i;
            var limitedTasks = tasks.Skip(remainTasks)
                                    .Take(toTake);
            remainTasks += toTake;
            await RunMultipleTaskParallel(limitedTasks.ToArray());
        } while (remainTasks < countTask);
    }