Ejecutar múltiples tareas asíncronas y esperar a que todas se completen

Necesito ejecutar múltiples tareas asíncronas en una aplicación de consola y esperar a que se completen antes de continuar con el procesamiento.

Hay muchos artículos por ahí, pero parece que me confundo más cuanto más leo. He leído y entiendo los principios básicos de la biblioteca de tareas, pero claramente me falta un enlace en alguna parte.

Entiendo que es posible encadenar tareas para que comiencen después de que se complete otra (que es más o menos el escenario para todos los artículos que he leído), pero quiero que todas mis tareas se ejecuten al mismo tiempo, y quiero saber una vez Todos están completos.

¿Cuál es la implementación más simple para un escenario como este?

Ambas respuestas no mencionaron lo esperado Task.WhenAll:

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

await Task.WhenAll(task1, task2);

La principal diferencia entre Task.WaitAlly Task.WhenAlles que el primero se bloqueará (similar al uso Waiten una sola tarea), mientras que el segundo no se podrá esperar, lo que devolverá el control a la persona que llama hasta que finalicen todas las tareas.

Más aún, el manejo de excepciones difiere:

Task.WaitAll:

Al menos una de las instancias de la Tarea se canceló, o se lanzó una excepción durante la ejecución de al menos una de las instancias de la Tarea. Si se canceló una tarea, AggregateException contiene una OperationCanceledException en su colección InnerExceptions.

Task.WhenAll:

Si alguna de las tareas suministradas se completa en un estado con error, la tarea devuelta también se completará en un estado con error, donde sus excepciones contendrán la agregación del conjunto de excepciones sin envolver de cada una de las tareas suministradas.

Si ninguna de las tareas suministradas falló pero al menos una de ellas se canceló, la tarea devuelta finalizará en el estado Cancelado.

Si ninguna de las tareas falló y ninguna de las tareas se canceló, la tarea resultante finalizará en el estado RanToCompletion. Si la matriz / enumerable suministrada no contiene tareas, la tarea devuelta pasará inmediatamente a un estado RanToCompletion antes de que se devuelva al llamante.

Podrías crear muchas tareas como:

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

Task.WaitAll(TaskList.ToArray());

La mejor opción que he visto es el siguiente método de extensión:

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

Llámalo así:

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

O con una lambda asíncrona:

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

Puede usar el WhenAllque devolverá un tipo de retorno Tasko el WaitAllque no tiene retorno y bloqueará la ejecución de código adicional de manera simular Thread.Sleephasta que todas las tareas se completen, cancelen o fallen.

Ejemplo

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

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

Si desea ejecutar las tareas en un orden práctico, puede obtener inspiración de esta respuesta.

¿Desea encadenar los Tasks, o pueden invocarse de forma paralela?

Para encadenar
Solo haz algo como

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

y no olvide verificar la Taskinstancia anterior en cada una, ContinueWithya que podría tener errores.

Para la manera paralela
El método más simple que encontré: de lo Parallel.Invoke contrario, hay Task.WaitAllo incluso puedes usar WaitHandles para hacer una cuenta regresiva a cero acciones restantes (espera, hay una nueva clase:) CountdownEvent, o ...

Así es como lo hago con una 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

Otra respuesta más ... pero generalmente me encuentro en un caso, cuando necesito cargar datos simultáneamente y ponerlos en variables, 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
}

He preparado un código para mostrarle cómo usar la tarea para algunos de estos escenarios.

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