Запуск нескольких асинхронных задач и ожидание их завершения

Мне нужно запустить несколько асинхронных задач в консольном приложении и дождаться их завершения перед дальнейшей обработкой.

Есть много статей, но я, кажется, растерялся, когда больше читаю. Я прочитал и понял основные принципы библиотеки задач, но мне явно не хватает ссылки где-то.

Я понимаю, что можно объединить задачи так, чтобы они запускались после завершения другого (что в значительной степени является сценарием для всех статей, которые я прочитал), но я хочу, чтобы все мои задачи выполнялись одновременно, и я хочу знать один раз они все завершены.

Какая простейшая реализация для такого сценария?

В обоих ответах не упоминалось ожидаемое Task.WhenAll:

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

await Task.WhenAll(task1, task2);

Основное различие между Task.WaitAllи Task.WhenAllзаключается в том, что первый будет блокировать (аналогично использованиюWait в одной задаче), а последний не будет и его можно ожидать, передавая управление вызывающей стороне до завершения всех задач.

Более того, обработка исключений отличается:

Task.WaitAll:

По крайней мере, один из экземпляров Задачи был отменен или возникла исключительная ситуация при выполнении хотя бы одного из экземпляров Задачи. Если задача была отменена, AggregateException содержит OperationCanceledException в своей коллекции InnerExceptions.

Task.WhenAll:

Если любая из предоставленных задач завершается в состоянии Failed, возвращаемая задача также завершается в состоянии Failed, где ее исключения будут содержать агрегацию набора развернутых исключений для каждой из предоставленных задач.

Если ни одна из поставленных задач не была выполнена, но хотя бы одна из них была отменена, возвращенная задача завершится в состоянии Отменено.

Если ни одна из задач не была выполнена, и ни одна из задач не была отменена, результирующая задача завершится в состоянии RanToCompletion. Если предоставленный массив / enumerable не содержит задач, возвращаемая задача немедленно перейдет в состояние RanToCompletion, прежде чем она будет возвращена вызывающей стороне.

Вы можете создать много задач, таких как:

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

Task.WaitAll(TaskList.ToArray());

Лучший вариант, который я видел, это следующий метод расширения:

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

Назовите это так:

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

Или с асинхронной лямбдой:

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

Вы можете использовать WhenAllметод, который будет возвращать ожидаемый объект Taskили WaitAllкоторый не имеет типа возврата, и будет блокировать дальнейшее выполнение кода симулировано до Thread.Sleepтех пор, пока все задачи не будут завершены, отменены или сбои.

пример

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

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

Если вы хотите выполнять задачи в определенном порядке, вы можете получить вдохновение от этого ответа.

Вы хотите соединить цепочки Taskили они могут быть вызваны параллельно?

Для цепочки
Просто сделай что-то вроде

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

и не забудьте проверить предыдущий Taskэкземпляр в каждом, так ContinueWithкак он может быть неисправен.

Для параллельного подхода
Самый простой метод, с которым я сталкивался: в Parallel.Invoke противном случае есть Task.WaitAllили вы даже можете использовать WaitHandles для обратного отсчета до нуля оставленных действий (подождите, есть новый класс:) CountdownEvent, или ...

Вот как я это делаю с массивом 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

Еще один ответ ... но я обычно нахожусь в случае, когда мне нужно одновременно загрузить данные и поместить их в переменные, например:

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
}

Я подготовил фрагмент кода, чтобы показать вам, как использовать задачу для некоторых из этих сценариев.

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