异步等待在LINQ选择

我需要修改现有程序，它包含以下代码：

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

但这对我来说似乎很奇怪，首先是在select中使用async和await。根据Stephen Cleary的回答，我应该可以删除那些内容。

然后第二个Select选择结果。这不是说任务根本不异步，而是同步执行（付出了很多努力却没有做），还是会异步执行任务，完成后是否执行其余查询？

我是否应该根据Stephen Cleary的另一个答案，像下面那样编写上面的代码：

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中使用async和await。根据Stephen Cleary的回答，我应该可以删除那些内容。

的呼叫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，因此变量应以单数命名。

最后，您的最后一个代码相同，但更简洁

供参考：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()