LINQ SELECTで非同期待機

既存のプログラムを変更する必要があり、次のコードが含まれています。

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

しかし、これは最初のすべての使用の、私にとって非常に奇妙なようだasyncし、await選択します。スティーブン・クリアリーのこの回答によると、私はそれらを落とすことができるはずです。

次に、Select結果を選択する2番目。これは、タスクがまったく非同期ではなく、同期的に実行される（何もしないために多大な労力を要する）ことを意味しませんか？それとも、タスクは非同期的に実行され、完了したら残りのクエリが実行されますか？

私はに応じて次のように上記のコードを記述する必要がありステファン・クリアリーによって別の答え：

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で待機します。スティーブン・クリアリーのこの回答によると、私はそれらを落とせるはずです。

への呼び出しSelectは有効です。これらの2行は基本的に同じです：

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

（から同期例外がスローされる方法に関して若干の違いがありProcessEventAsyncますが、このコードのコンテキストではまったく問題ではありません。）

次に、結果を選択する2番目の選択。これは、タスクがまったく非同期ではなく、同期的に実行される（何もしないために多大な労力を要する）ことを意味しませんか？それとも、タスクは非同期的に実行され、完了したら残りのクエリが実行されますか？

これは、クエリがブロックされていることを意味します。したがって、実際には非同期ではありません。

それを分解する：

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

最初に各イベントの非同期操作を開始します。次に、この行：

                   .Select(t => t.Result)

これらの操作が一度に1つ完了するまで待機します（最初に最初のイベントの操作を待機し、次に次のイベントを待機します）。

これは、ブロックし、例外をでラップするため、私が気にしない部分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();

はい、これら2つの例は同等です。両方がすべての非同期操作を開始し（events.Select(...)）、すべての操作が任意の順序で完了するのを非同期的に待機し（await Task.WhenAll(...)）、残りの作業を続行します（Where...）。

これらの例はどちらも元のコードとは異なります。元のコードはブロックしており、例外をでラップしAggregateExceptionます。

既存のコードは機能していますが、スレッドをブロックしています。

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

イベントごとに新しいタスクを作成しますが、

.Select(t => t.Result)

新しいタスクが終了するのを待つスレッドをブロックします。

一方、コードは同じ結果を生成しますが、非同期のままです。

最初のコードに関するコメントは1つだけです。この線

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