Async ждут в linq select

Мне нужно изменить существующую программу, и она содержит следующий код:

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

Но это кажется мне очень странным, в первую очередь использование asyncи awaitв select. Согласно этому ответу Стивена Клири, я смогу отбросить их.

Затем второй, Selectкоторый выбирает результат. Не означает ли это, что задача вообще не асинхронная и выполняется синхронно (столько усилий ни за что), или задача будет выполняться асинхронно, и когда она будет выполнена, остальная часть запроса будет выполнена?

Должен ли я написать приведенный выше код следующим образом в соответствии с другим ответом Стивена Клири :

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

Пока я работаю над этим проектом, я хотел бы изменить первый пример кода, но я не слишком заинтересован в изменении (явно работающем) асинхронного кода. Может быть, я просто беспокоюсь, и все 3 примера кода делают одно и то же?

ProcessEventsAsync выглядит так:

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

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

Но это кажется мне очень странным, в первую очередь использование async и await в select. Согласно этому ответу Стивена Клири, я смогу отбросить их.

Звонок Selectдействителен. Эти две строки практически идентичны:

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

(Существует небольшая разница в том, как генерируется синхронное исключение ProcessEventAsync, но в контексте этого кода это не имеет значения).

Затем второй выбор, который выбирает результат. Разве это не означает, что задача вообще не асинхронная и выполняется синхронно (столько усилий ни за что), или задача будет выполняться асинхронно, и когда она будет выполнена, остальная часть запроса будет выполнена?

Это означает, что запрос блокируется. Так что это не совсем асинхронно.

Разбивая это:

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

сначала запустит асинхронную операцию для каждого события. Тогда эта строка:

                   .Select(t => t.Result)

будет ожидать выполнения этих операций по одной (сначала ожидает операцию первого события, затем следующую, затем следующую и т. д.).

Это та часть, которая меня не волнует, потому что она блокирует, а также оборачивает любые исключения AggregateException.

и это абсолютно так же, как это?

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

Да, эти два примера эквивалентны. Они оба запускают все асинхронные операции ( events.Select(...)), затем асинхронно ждут завершения всех операций в любом порядке ( await Task.WhenAll(...)), а затем приступают к остальной части работы ( Where...).

Оба эти примера отличаются от исходного кода. Исходный код блокирует и будет заключать исключения в AggregateException.

Существующий код работает, но блокирует поток.

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

создает новую задачу для каждого события, но

.Select(t => t.Result)

блокирует поток, ожидающий завершения каждой новой задачи.

С другой стороны, ваш код дает тот же результат, но остается асинхронным.

Только один комментарий к вашему первому коду. Эта линия

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

создаст одну задачу, поэтому переменная должна быть названа в единственном числе.

Наконец ваш последний код делает то же самое, но более кратким

Для справки: Task.Wait / Task.WhenAll

С текущими методами, доступными в Linq, это выглядит довольно уродливо:

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

Надеемся, что следующие версии .NET предложат более элегантный инструментарий для обработки коллекций задач и задач коллекций.

Я использовал этот код:

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

как это:

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

Я предпочитаю это как метод расширения:

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

Так что это можно использовать с цепочкой метода:

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