Asynchroniczne oczekiwanie w LINQ select

Istniejący kod działa, ale blokuje wątek.

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

Tworzy nowe zadanie dla każdego zdarzenia, ale

.Select(t => t.Result)

Blokuje wątek czekający na zakończenie każdego nowego zadania.

Z drugiej strony Twój kod daje ten sam wynik, ale zachowuje asynchroniczność.

Tylko jeden komentarz do Twojego pierwszego kodu. This line

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

Wytworzy pojedyncze zadanie, więc zmienna powinna być nazwana w liczbie pojedynczej.

W końcu twój ostatni kod robi to samo, ale jest bardziej zwięzły

Dla odniesienia: zadanie.Czekaj. / Zadanie.WhenAll

Użyłem tego kodu:

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

TAK:

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

Wolę to jako metodę rozszerzenia:

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

Tak, że jest użyteczna przy łańcuchowaniu metodą:

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

Przy obecnych metodach dostępnych w Linq wygląda to dość brzydko:

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

Mam nadzieję, że kolejne wersje. NET wymyślą bardziej eleganckie narzędzia do obsługi zbiorów zadań i zadań kolekcji.

Chciałem zadzwonić Select(...), ale upewnić się, że działa w kolejności, ponieważ równoległe działanie powodowałoby inne problemy z współbieżnością, więc skończyło się na tym. Nie mogę wywołać .Result, ponieważ zablokuje to wątek interfejsu użytkownika.

public static class TaskExtensions
{
    public static async Task<IEnumerable<TResult>> SelectInSequenceAsync<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, Task<TResult>> asyncSelector)
    {
        var result = new List<TResult>();
        foreach (var s in source)
        {
            result.Add(await asyncSelector(s));
        }
        
        return result;
    }
}

Użycie:

var inputs = events.SelectInSequenceAsync(ev => ProcessEventAsync(ev))
                   .Where(i => i != null)
                   .ToList();

"to, że możesz, nie znaczy, że powinieneś."

Prawdopodobnie możesz używać async / wait w wyrażeniach LINQ tak, aby zachowywały się dokładnie tak, jak chcesz, ale czy jakikolwiek inny programista czytający Twój kod nadal zrozumie jego zachowanie i intencję?

(w szczególności: czy operacje asynchroniczne powinny być uruchamiane równolegle, czy są celowo sekwencyjne? Czy oryginalny deweloper w ogóle o tym pomyślał?)

Widać to również wyraźnie w pytaniu, które wydaje się być zapytany przez programistę próbującego zrozumieć cudzy kod, nie znając jego intencji. Aby upewnić się, że to się nie powtórzy, najlepiej jest przepisać wyrażenie LINQ jako instrukcję pętli, jeśli to możliwe.