Come attendere un elenco di attività in modo asincrono utilizzando LINQ?

Ho un elenco di attività che ho creato in questo modo:

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

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

    ...
}

Utilizzando .ToList(), le attività dovrebbero iniziare tutte. Ora voglio attendere il loro completamento e restituire i risultati.

Funziona nel ...blocco sopra :

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

Fa quello che voglio, ma sembra piuttosto goffo. Preferisco di gran lunga scrivere qualcosa di più semplice come questo:

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

... ma questo non viene compilato. Cosa mi sto perdendo? O semplicemente non è possibile esprimere le cose in questo modo?

LINQ non funziona perfettamente con il asynccodice, ma puoi farlo:

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

Se le tue attività restituiscono tutte lo stesso tipo di valore, puoi anche farlo:

var results = await Task.WhenAll(tasks);

che è abbastanza carino. WhenAllrestituisce un array, quindi credo che il tuo metodo possa restituire direttamente i risultati:

return await Task.WhenAll(tasks);

Per espandere la risposta di Stephen, ho creato il seguente metodo di estensione per mantenere lo stile fluente di LINQ. Puoi quindi fare

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 problema con Task.WhenAll è che creerebbe un parallelismo. Nella maggior parte dei casi potrebbe essere anche meglio, ma a volte vuoi evitarlo. Ad esempio, la lettura di dati in batch dal DB e l'invio di dati a un servizio Web remoto. Non si desidera caricare tutti i batch in memoria, ma premere il DB una volta che il batch precedente è stato elaborato. Quindi, devi rompere l'asincronicità. Ecco un esempio:

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)
{
}

Nota .GetAwaiter (). GetResult () che lo converte in sincronizzazione. Il DB verrebbe colpito in modo pigro solo una volta che batchSize degli eventi è stato elaborato.

Utilizzare Task.WaitAllo Task.WhenAllqualunque sia appropriato.

Task.WhenAll dovrebbe fare il trucco qui.