Async aguarda en linq select

Necesito modificar un programa existente y contiene el siguiente código:

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

Pero esto me parece muy extraño, en primer lugar, el uso de asyncy awaiten la selección. De acuerdo con esta respuesta por Stephen Cleary que debe ser capaz de soltar esos.

Luego el segundo Selectque selecciona el resultado. ¿No significa esto que la tarea no es asíncrona en absoluto y se realiza de forma sincrónica (tanto esfuerzo para nada), o la tarea se realizará de forma asincrónica y cuando se realiza el resto de la consulta se ejecuta?

¿Debo escribir el código anterior como el siguiente según otra respuesta de Stephen Cleary :

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

y es completamente igual a esto?

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

Mientras estoy trabajando en este proyecto, me gustaría cambiar el primer ejemplo de código, pero no estoy demasiado interesado en cambiar (aparentemente trabajando) el código asíncrono. ¿Tal vez solo me estoy preocupando por nada y las 3 muestras de código hacen exactamente lo mismo?

ProcessEventsAsync tiene este aspecto:

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

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

Pero esto me parece muy extraño, en primer lugar, el uso de async y aguardar en la selección. De acuerdo con esta respuesta de Stephen Cleary, debería poder dejarlos.

La llamada a Selectes válida. Estas dos líneas son esencialmente idénticas:

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

(Hay una pequeña diferencia con respecto a cómo se generaría una excepción síncrona ProcessEventAsync, pero en el contexto de este código no importa en absoluto).

Luego, el segundo Seleccionar que selecciona el resultado. ¿No significa esto que la tarea no es asíncrona en absoluto y se realiza de forma sincrónica (tanto esfuerzo para nada), o la tarea se realizará de forma asincrónica y cuando se realiza el resto de la consulta se ejecuta?

Significa que la consulta está bloqueando. Por lo tanto, no es realmente asíncrono.

Desglosándolo:

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

primero comenzará una operación asincrónica para cada evento. Entonces esta línea:

                   .Select(t => t.Result)

esperará a que esas operaciones se completen una a la vez (primero espera la operación del primer evento, luego la siguiente, luego la siguiente, etc.).

Esta es la parte que no me importa, porque bloquea y también incluye cualquier excepción AggregateException.

y es completamente igual a esto?

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í, esos dos ejemplos son equivalentes. Ambos comienzan todas las operaciones asincrónicas ( events.Select(...)), luego esperan asincrónicamente a que se completen todas las operaciones en cualquier orden ( await Task.WhenAll(...)), luego continúan con el resto del trabajo (Where... ).

Ambos ejemplos son diferentes del código original. El código original está bloqueando y envolverá las excepciones AggregateException.

El código existente funciona, pero bloquea el hilo.

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

crea una nueva tarea para cada evento, pero

.Select(t => t.Result)

bloquea el hilo esperando que finalice cada nueva tarea.

Por otro lado, su código produce el mismo resultado pero se mantiene asíncrono.

Solo un comentario en tu primer código. Esta línea

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

producirá una sola tarea, por lo que la variable debe nombrarse en singular.

Finalmente su último código hace lo mismo pero es más sucinto

Para referencia: Task.Wait / Task.WhenAll

Con los métodos actuales disponibles en Linq, se ve bastante feo:

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();

Esperemos que las siguientes versiones de .NET presenten herramientas más elegantes para manejar colecciones de tareas y tareas de colecciones.

Usé este código:

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

Me gusta esto:

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

Prefiero esto como un método de extensión:

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

Para que se pueda usar con el método de encadenamiento:

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