Comment attendre une liste de tâches de manière asynchrone en utilisant LINQ?

J'ai une liste de tâches que j'ai créées comme ceci:

public async Task<IList<Foo>> GetFoosAndDoSomethingAsync()
{
    var foos = await GetFoosAsync();

    var tasks = foos.Select(async foo => await DoSomethingAsync(foo)).ToList();

    ...
}

En utilisant .ToList(), les tâches devraient toutes commencer. Maintenant, je veux attendre leur achèvement et renvoyer les résultats.

Cela fonctionne dans le ...bloc ci-dessus :

var list = new List<Foo>();
foreach (var task in tasks)
    list.Add(await task);
return list;

Il fait ce que je veux, mais cela semble plutôt maladroit. Je préfère de loin écrire quelque chose de plus simple comme celui-ci:

return tasks.Select(async task => await task).ToList();

... mais cela ne compile pas. Qu'est-ce que je rate? Ou n'est-il tout simplement pas possible d'exprimer les choses de cette façon?

LINQ ne fonctionne pas parfaitement avec le asynccode, mais vous pouvez le faire:

var tasks = foos.Select(DoSomethingAsync).ToList();
await Task.WhenAll(tasks);

Si vos tâches renvoient toutes le même type de valeur, vous pouvez même le faire:

var results = await Task.WhenAll(tasks);

ce qui est assez sympa. WhenAllrenvoie un tableau, donc je pense que votre méthode peut renvoyer les résultats directement:

return await Task.WhenAll(tasks);

Pour développer la réponse de Stephen, j'ai créé la méthode d'extension suivante pour conserver le style fluide de LINQ. Vous pouvez alors faire

await someTasks.WhenAll()

namespace System.Linq
{
    public static class IEnumerableExtensions
    {
        public static Task<T[]> WhenAll<T>(this IEnumerable<Task<T>> source)
        {
            return Task.WhenAll(source);
        }
    }
}

Un problème avec Task.WhenAll est qu'il créerait un parallélisme. Dans la plupart des cas, cela peut être encore mieux, mais parfois vous voulez l'éviter. Par exemple, lire des données par lots à partir de la base de données et envoyer des données à un service Web distant. Vous ne voulez pas charger tous les lots dans la mémoire, mais appuyez sur la base de données une fois que le lot précédent a été traité. Donc, vous devez briser l'asynchronisme. Voici un exemple:

var events = Enumerable.Range(0, totalCount/ batchSize)
   .Select(x => x*batchSize)
   .Select(x => dbRepository.GetEventsBatch(x, batchSize).GetAwaiter().GetResult())
   .SelectMany(x => x);
foreach (var carEvent in events)
{
}

Remarque .GetAwaiter (). GetResult () le convertissant en synchronisation. DB ne serait touché paresseusement qu'une fois que batchSize des événements ont été traités.

Utilisez Task.WaitAllou Task.WhenAllselon ce qui est approprié.

Task.WhenAll devrait faire l'affaire ici.