Async aguardam no linq select

Preciso modificar um programa existente e ele contém o seguinte código:

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

Mas isso me parece muito estranho, antes de tudo, o uso de asynce awaitno select. De acordo com esta resposta de Stephen Cleary, eu deveria ser capaz de abandoná-las.

Então o segundo Selectque seleciona o resultado. Isso não significa que a tarefa não é assíncrona e é executada de forma síncrona (muito esforço por nada) ou será executada de forma assíncrona e quando concluída, o restante da consulta é executado?

Devo escrever o código acima como segue, de acordo com outra resposta de Stephen Cleary :

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

e é completamente o mesmo assim?

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

Enquanto estou trabalhando neste projeto, gostaria de alterar o primeiro exemplo de código, mas não estou muito interessado em alterar (aparentemente trabalhando) código assíncrono. Talvez eu esteja apenas me preocupando por nada e todos os três exemplos de código façam exatamente a mesma coisa?

ProcessEventsAsync tem esta aparência:

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

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

Mas isso me parece muito estranho, antes de tudo o uso de assíncrono e aguardo no select. De acordo com esta resposta de Stephen Cleary, eu deveria ser capaz de abandoná-las.

A chamada para Selecté válida. Essas duas linhas são essencialmente idênticas:

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

(Há uma pequena diferença em relação a como uma exceção síncrona seria lançada ProcessEventAsync, mas no contexto desse código isso não importa.)

Em seguida, o segundo Select que seleciona o resultado. Isso não significa que a tarefa não é assíncrona e é executada de forma síncrona (muito esforço por nada) ou será executada de forma assíncrona e quando concluída, o restante da consulta é executado?

Isso significa que a consulta está bloqueando. Portanto, não é realmente assíncrono.

Dividindo:

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

primeiro iniciará uma operação assíncrona para cada evento. Então esta linha:

                   .Select(t => t.Result)

esperará que essas operações sejam concluídas uma de cada vez (primeiro aguarda a operação do primeiro evento, depois o próximo, depois o próximo, etc.).

Esta é a parte da qual não me importo, porque bloqueia e também inclui exceções AggregateException.

e é completamente o mesmo assim?

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

Sim, esses dois exemplos são equivalentes. Os dois iniciam todas as operações assíncronas ( events.Select(...)), aguardam de forma assíncrona que todas as operações sejam concluídas em qualquer ordem ( await Task.WhenAll(...)) e depois prosseguem com o restante do trabalho ( Where...).

Ambos os exemplos são diferentes do código original. O código original está bloqueando e incluirá exceções AggregateException.

O código existente está funcionando, mas está bloqueando o encadeamento.

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

cria uma nova tarefa para cada evento, mas

.Select(t => t.Result)

bloqueia o encadeamento aguardando o término de cada nova tarefa.

Por outro lado, seu código produz o mesmo resultado, mas permanece assíncrono.

Apenas um comentário no seu primeiro código. Está linha

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

produzirá uma única tarefa para que a variável seja nomeada no singular.

Finalmente, seu último código faz o mesmo, mas é mais sucinto

Para referência: Task.Wait / Task.WhenAll

Com os métodos atuais disponíveis no Linq, parece bastante feio:

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

Esperamos que as seguintes versões do .NET apresentem ferramentas mais elegantes para lidar com coleções de tarefas e tarefas de coleções.

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

como isso:

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

Eu prefiro isso como um método de extensão:

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

Para que seja utilizável com o encadeamento de métodos:

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