Exécuter plusieurs tâches asynchrones et attendre qu'elles se terminent toutes

J'ai besoin d'exécuter plusieurs tâches asynchrones dans une application console et d'attendre qu'elles se terminent toutes avant de poursuivre le traitement.

Il y a beaucoup d'articles là-bas, mais je semble devenir plus confus à mesure que je lis. J'ai lu et compris les principes de base de la bibliothèque de tâches, mais il me manque clairement un lien quelque part.

Je comprends qu'il est possible d'enchaîner les tâches pour qu'elles commencent après la fin d'une autre (ce qui est à peu près le scénario de tous les articles que j'ai lus), mais je veux que toutes mes tâches s'exécutent en même temps, et je veux le savoir une fois ils sont tous terminés.

Quelle est la mise en œuvre la plus simple pour un scénario comme celui-ci?

Les deux réponses ne mentionnent pas l'attente Task.WhenAll:

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

await Task.WhenAll(task1, task2);

La principale différence entre Task.WaitAllet Task.WhenAllest que le premier bloquera (similaire à l'utilisation Waitsur une seule tâche) tandis que le second ne sera pas et peut être attendu, ce qui rend le contrôle à l'appelant jusqu'à ce que toutes les tâches soient terminées.

Plus encore, la gestion des exceptions diffère:

Task.WaitAll:

Au moins une des instances de tâche a été annulée - ou - une exception a été levée lors de l'exécution d'au moins une des instances de tâche. Si une tâche a été annulée, l'AggregateException contient une OperationCanceledException dans sa collection InnerExceptions.

Task.WhenAll:

Si l'une des tâches fournies se termine dans un état défaillant, la tâche renvoyée se terminera également dans un état défaillant, où ses exceptions contiendront l'agrégation de l'ensemble des exceptions non encapsulées de chacune des tâches fournies.

Si aucune des tâches fournies n'est défaillante mais qu'au moins l'une d'entre elles a été annulée, la tâche renvoyée se terminera à l'état Annulé.

Si aucune des tâches n'est défaillante et qu'aucune des tâches n'a été annulée, la tâche résultante se terminera à l'état RanToCompletion. Si le tableau / énumérateur fourni ne contient aucune tâche, la tâche renvoyée passera immédiatement à un état RanToCompletion avant d'être renvoyée à l'appelant.

Vous pouvez créer de nombreuses tâches comme:

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

Task.WaitAll(TaskList.ToArray());

La meilleure option que j'ai vue est la méthode d'extension suivante:

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

Appelez ça comme ceci:

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

Ou avec un lambda asynchrone:

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

Vous pouvez utiliser WhenAllce qui retournera un fichier attendu Taskou WaitAllqui n'a pas de type de retour et bloquera l'exécution du code jusqu'à Thread.Sleepce que toutes les tâches soient terminées, annulées ou en panne.

Exemple

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

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

Si vous souhaitez exécuter les tâches dans un ordre pratique, vous pouvez vous inspirer de cette réponse.

Voulez-vous enchaîner les Tasks ou pouvez-vous les invoquer de manière parallèle?

Pour enchaîner Faites
juste quelque chose comme

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

et n'oubliez pas de vérifier l' Taskinstance précédente dans chacune ContinueWithcar elle pourrait être défectueuse.

Pour la manière parallèle
La méthode la plus simple que j'ai rencontrée:Parallel.Invoke sinon il y a Task.WaitAllou vous pouvez même utiliser WaitHandles pour faire un compte à rebours jusqu'à zéro actions (attendez, il y a une nouvelle classe:) CountdownEvent, ou ...

Voici comment je le fais avec un tableau 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

Encore une autre réponse ... mais je me retrouve généralement dans un cas, quand j'ai besoin de charger des données simultanément et de les mettre en variables, comme:

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
}

J'ai préparé un morceau de code pour vous montrer comment utiliser la tâche pour certains de ces scénarios.

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