Асинхронізація чекає у вибору linq

Мені потрібно змінити існуючу програму, яка містить такий код:

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

Але це здається мені дуже дивним, в першу чергу використанням asyncі awaitу виборі. Відповідно до цієї відповіді Стівена Клірі, я мав би змогу їх відмовити.

Потім друга, 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();

Але це здається мені дуже дивним, перш за все використання асинхронізації та очікування у виборі. Відповідно до цієї відповіді Стівена Клірі, я мав би змогу їх відмовити.

Дзвінок на адресу Selectдійсний. Ці два рядки по суті однакові:

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

(Існує незначна різниця щодо того, як буде викинуто синхронний виняток ProcessEventAsync, але в контексті цього коду це зовсім не має значення.)

Потім другий Select, який вибирає результат. Чи це не означає, що завдання зовсім не асинхронізується і виконується синхронно (стільки зусиль ні за що), чи завдання буде виконано асинхронно, і коли воно виконано, решта запиту буде виконана?

Це означає, що запит блокується. Тож насправді це не асинхронно.

Розбийте його:

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