Uruchamianie wielu zadań asynchronicznych i oczekiwanie na ich zakończenie

Muszę uruchomić wiele zadań asynchronicznych w aplikacji konsoli i poczekać na zakończenie wszystkich zadań przed dalszym przetwarzaniem.

Istnieje wiele artykułów, ale im bardziej czytam, tym bardziej się mylę. Przeczytałem i rozumiem podstawowe zasady biblioteki Zadań, ale najwyraźniej gdzieś brakuje linku.

Rozumiem, że możliwe jest łączenie zadań w taki sposób, aby zaczynały się po ukończeniu kolejnego (co jest w zasadzie scenariuszem dla wszystkich artykułów, które przeczytałem), ale chcę, aby wszystkie moje zadania działały jednocześnie i chcę to wiedzieć raz wszystkie są ukończone.

Jaka jest najprostsza implementacja dla takiego scenariusza?

Obie odpowiedzi nie wspomniały o oczekiwanym Task.WhenAll:

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

await Task.WhenAll(task1, task2);

Główna różnica między Task.WaitAlli Task.WhenAllpolega na tym, że pierwsze blokuje (podobnie jak Waitw przypadku pojedynczego zadania), podczas gdy drugie nie może i może być oczekiwane, dając kontrolę nad dzwoniącym, aż wszystkie zadania zakończą się.

Co więcej, obsługa wyjątków różni się:

Task.WaitAll:

Przynajmniej jedna z instancji Zadania została anulowana lub zgłoszony został wyjątek podczas wykonywania co najmniej jednej z instancji Zadania. Jeśli zadanie zostało anulowane, AggregateException zawiera OperationCanceledException w kolekcji InnerExceptions.

Task.WhenAll:

Jeśli którekolwiek z dostarczonych zadań zostaną zakończone w stanie błędu, zwrócone zadanie zostanie również ukończone w stanie Usterka, w którym jego wyjątki będą zawierać agregację zestawu nieopakowanych wyjątków z każdego z dostarczonych zadań.

Jeśli żadne z dostarczonych zadań nie spowodowało błędu, ale co najmniej jedno z nich zostało anulowane, zwrócone zadanie zakończy się w stanie Anulowane.

Jeśli żadne z zadań nie uległo awarii i żadne z zadań nie zostało anulowane, wynikowe zadanie zakończy się w stanie RanToCompletion. Jeśli podana tablica / wyliczenie nie zawiera żadnych zadań, zwrócone zadanie natychmiast przejdzie w stan RanToCompletion, zanim zostanie zwrócone do programu wywołującego.

Możesz utworzyć wiele zadań, takich jak:

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

Task.WaitAll(TaskList.ToArray());

Najlepszą opcją, jaką widziałem, jest następująca metoda rozszerzenia:

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

Nazwij to tak:

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

Lub z asynchroniczną lambda:

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

Możesz użyć, WhenAllktóry zwróci oczekiwany Tasklub WaitAllktóry nie ma typu zwrotu i zablokuje dalsze wykonywanie kodu podobnie do Thread.Sleepmomentu, aż wszystkie zadania zostaną zakończone, anulowane lub zakłócone.

Przykład

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

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

Jeśli chcesz uruchomić zadania w praktycznej kolejności, możesz uzyskać inspirację z tego odpowiedzi .

Czy chcesz Taskpołączyć łańcuchy , czy można je wywoływać równolegle?

Do łączenia
Po prostu zrób coś takiego

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

i nie zapomnij sprawdzić poprzedniej Taskinstancji w każdej z nich, ContinueWithponieważ może to być wina.

Dla równoległego sposobu
Najprostsza metoda, na którą natknąłem się: w Parallel.Invoke przeciwnym razie Task.WaitAllmożesz użyć WaitHandles do odliczania do zera akcji (poczekaj, jest nowa klasa:) CountdownEventlub ...

Tak to robię za pomocą tablicy 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

Jeszcze jedna odpowiedź ... ale zwykle znajduję się w przypadku, gdy muszę jednocześnie ładować dane i umieszczać je w zmiennych, takich jak:

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
}

Przygotowałem kawałek kodu, aby pokazać, jak korzystać z zadania w niektórych z tych scenariuszy.

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