Executando várias tarefas assíncronas e aguardando a conclusão de todas elas

Preciso executar várias tarefas assíncronas em um aplicativo de console e aguardar a conclusão de todas elas antes de continuar o processamento.

Existem muitos artigos por aí, mas pareço ficar mais confuso quanto mais leio. Eu li e entendi os princípios básicos da biblioteca de tarefas, mas estou claramente perdendo um link em algum lugar.

Entendo que é possível encadear tarefas para que elas sejam iniciadas após a conclusão de outra (que é praticamente o cenário para todos os artigos que li), mas quero que todas as minhas tarefas sejam executadas ao mesmo tempo e que quero saber uma vez. estão todos concluídos.

Qual é a implementação mais simples para um cenário como este?

Ambas as respostas não mencionaram o esperado Task.WhenAll:

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

await Task.WhenAll(task1, task2);

A principal diferença entre Task.WaitAlle Task.WhenAllé que o primeiro será bloqueado (semelhante ao uso Waitem uma única tarefa), enquanto o último não será e poderá ser aguardado, retornando o controle ao chamador até que todas as tarefas sejam concluídas.

Além disso, o tratamento de exceções é diferente:

Task.WaitAll:

Pelo menos uma das instâncias da tarefa foi cancelada - ou - uma exceção foi lançada durante a execução de pelo menos uma das instâncias da tarefa. Se uma tarefa foi cancelada, o AggregateException contém um OperationCanceledException em sua coleção InnerExceptions.

Task.WhenAll:

Se alguma das tarefas fornecidas for concluída em um estado com falha, a tarefa retornada também será concluída em um estado com falha, em que suas exceções conterão a agregação do conjunto de exceções não desempacotadas de cada uma das tarefas fornecidas.

Se nenhuma das tarefas fornecidas falhar, mas pelo menos uma delas foi cancelada, a tarefa retornada terminará no estado Cancelado.

Se nenhuma das tarefas falhar e nenhuma delas foi cancelada, a tarefa resultante terminará no estado RanToCompletion. Se a matriz / enumerável fornecida não contiver tarefas, a tarefa retornada passará imediatamente para um estado RanToCompletion antes de retornar ao chamador.

Você pode criar muitas tarefas como:

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

Task.WaitAll(TaskList.ToArray());

A melhor opção que eu vi é o seguinte método de extensão:

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

Chame assim:

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

Ou com um lambda assíncrono:

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

Você pode usar o WhenAllque retornará um tipo de retorno aguardável Taskou WaitAllque não tem retorno e bloqueará a execução de código adicional semelhante Thread.Sleepaté que todas as tarefas sejam concluídas, canceladas ou com falha.

Exemplo

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

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

Se você deseja executar as tarefas em uma ordem prática, pode se inspirar nesta resposta.

Deseja encadear os Tasks ou eles podem ser chamados de maneira paralela?

Para encadear
Basta fazer algo como

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

e não se esqueça de verificar a Taskinstância anterior em cada uma, ContinueWithpois ela pode estar com defeito.

Pela maneira paralela
O método mais simples que me deparei: Parallel.Invoke Caso contrário, existe Task.WaitAllou você pode usar WaitHandles para fazer uma contagem regressiva para zero ações restantes (espere, há uma nova classe CountdownEvent:) ou ...

É assim que eu faço isso com uma matriz 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

Mais uma resposta ... mas geralmente me encontro em um caso, quando preciso carregar dados simultaneamente e colocá-los em variáveis, como:

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
}

Eu preparei um pedaço de código para mostrar como usar a tarefa para alguns desses cenários.

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