Async attende in linq select

Devo modificare un programma esistente e contiene il seguente codice:

var inputs = events.Select(async ev => await ProcessEventAsync(ev))
                   .Select(t => t.Result)
                   .Where(i => i != null)
                   .ToList();

Ma questo mi sembra molto strano, prima di tutto l'uso di asynce awaitnella selezione. Secondo questa risposta di Stephen Cleary dovrei riuscire a lasciar perdere.

Quindi il secondo Selectche seleziona il risultato. Questo non significa che l'attività non è affatto asincrona e viene eseguita in modo sincrono (così tanto sforzo per nulla), oppure l'attività verrà eseguita in modo asincrono e al termine verrà eseguita la parte restante della query?

Dovrei scrivere il codice sopra come segue secondo un'altra risposta di Stephen Cleary :

var tasks = await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev)));
var inputs = tasks.Where(result => result != null).ToList();

ed è completamente uguale a questo?

var inputs = (await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev))))
                                       .Where(result => result != null).ToList();

Mentre sto lavorando a questo progetto mi piacerebbe cambiare il primo esempio di codice ma non sono troppo entusiasta di cambiare il codice asincrono (apparentemente funzionante). Forse mi sto solo preoccupando per niente e tutti e 3 gli esempi di codice fanno esattamente la stessa cosa?

ProcessEventsAsync è simile al seguente:

async Task<InputResult> ProcessEventAsync(InputEvent ev) {...}

var inputs = events.Select(async ev => await ProcessEventAsync(ev))
                   .Select(t => t.Result)
                   .Where(i => i != null)
                   .ToList();

Ma questo mi sembra molto strano, prima di tutto l'uso di asincrono e attendere nella selezione. Secondo questa risposta di Stephen Cleary dovrei riuscire a lasciar perdere.

La chiamata a Selectè valida. Queste due linee sono sostanzialmente identiche:

events.Select(async ev => await ProcessEventAsync(ev))
events.Select(ev => ProcessEventAsync(ev))

(C'è una piccola differenza riguardo al modo in cui verrebbe generata un'eccezione sincrona ProcessEventAsync, ma nel contesto di questo codice non importa affatto.)

Quindi il secondo Seleziona che seleziona il risultato. Questo non significa che l'attività non è affatto asincrona e viene eseguita in modo sincrono (così tanto sforzo per nulla), oppure l'attività verrà eseguita in modo asincrono e al termine verrà eseguita la parte restante della query?

Significa che la query sta bloccando. Quindi non è davvero asincrono.

Abbattendo:

var inputs = events.Select(async ev => await ProcessEventAsync(ev))

avvia prima un'operazione asincrona per ciascun evento. Quindi questa linea:

                   .Select(t => t.Result)

attenderà il completamento di tali operazioni una alla volta (prima attende l'operazione del primo evento, quindi il successivo, quindi il successivo, ecc.).

Questa è la parte che non mi interessa, perché blocca e avvolgerebbe anche qualsiasi eccezione AggregateException.

ed è completamente uguale a questo?

var tasks = await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev)));
var inputs = tasks.Where(result => result != null).ToList();

var inputs = (await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev))))
                                       .Where(result => result != null).ToList();

Sì, questi due esempi sono equivalenti. Entrambi avviano tutte le operazioni asincrone ( events.Select(...)), quindi attendono in modo asincrono il completamento di tutte le operazioni in qualsiasi ordine ( await Task.WhenAll(...)), quindi procedono con il resto del lavoro ( Where...).

Entrambi questi esempi sono diversi dal codice originale. Il codice originale sta bloccando e includerà le eccezioni AggregateException.

Il codice esistente funziona, ma sta bloccando il thread.

.Select(async ev => await ProcessEventAsync(ev))

crea una nuova attività per ogni evento, ma

.Select(t => t.Result)

blocca il thread in attesa che ogni nuova attività termini.

D'altra parte il tuo codice produce lo stesso risultato ma rimane asincrono.

Solo un commento sul tuo primo codice. Questa linea

var tasks = await Task.WhenAll(events...

produrrà una singola attività, quindi la variabile dovrebbe essere nominata in singolare.

Finalmente il tuo ultimo codice fa lo stesso ma è più succinto

Per riferimento: Task.Wait / Task.WhenAll

Con gli attuali metodi disponibili in Linq sembra abbastanza brutto:

var tasks = items.Select(
    async item => new
    {
        Item = item,
        IsValid = await IsValid(item)
    });
var tuples = await Task.WhenAll(tasks);
var validItems = tuples
    .Where(p => p.IsValid)
    .Select(p => p.Item)
    .ToList();

Si spera che le seguenti versioni di .NET forniranno strumenti più eleganti per gestire raccolte di attività e attività di raccolte.

Ho usato questo codice:

public static async Task<IEnumerable<TResult>> SelectAsync<TSource,TResult>(this IEnumerable<TSource> source, Func<TSource, Task<TResult>> method)
{
      return await Task.WhenAll(source.Select(async s => await method(s)));
}

come questo:

var result = await sourceEnumerable.SelectAsync(async s=>await someFunction(s,other params));

Preferisco questo come metodo di estensione:

public static async Task<IEnumerable<T>> WhenAll<T>(this IEnumerable<Task<T>> tasks)
{
    return await Task.WhenAll(tasks);
}

In modo che sia utilizzabile con il concatenamento del metodo:

var inputs = await events
  .Select(async ev => await ProcessEventAsync(ev))
  .WhenAll()