在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版本能够提供更优雅的工具来处理任务的集合和集合的任务。

在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<TResult>> SelectAsync<TSource, TResult>(
    this IEnumerable<TSource> source, Func<TSource, Task<TResult>> method,
    int concurrency = int.MaxValue)
{
    var semaphore = new SemaphoreSlim(concurrency);
    try
    {
        return await Task.WhenAll(source.Select(async s =>
        {
            try
            {
                await semaphore.WaitAsync();
                return await method(s);
            }
            finally
            {
                semaphore.Release();
            }
        }));
    } finally
    {
        semaphore.Dispose();
    }
}

如果没有参数，它的行为与上面的简单版本完全相同。当参数为1时，它将依次执行所有任务:

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

注意:按顺序执行任务并不意味着执行将在错误时停止!

就像使用更大的并发值或不指定参数一样，所有任务都将执行，如果其中任何任务失败，生成的AggregateException将包含抛出的异常。

如果您希望一个接一个地执行任务，并且在第一个任务中失败，请尝试其他解决方案，例如xhafan (https://stackoverflow.com/a/64363463/379279)建议的解决方案。

我有同样的问题@KTCheek，因为我需要它按顺序执行。然而，我想我会尝试使用IAsyncEnumerable(在。net Core 3中引入)和await foreach(在c# 8中引入)。下面是我想出的:

public static class IEnumerableExtensions {
    public static async IAsyncEnumerable<TResult> SelectAsync<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, Task<TResult>> selector) {
        foreach (var item in source) {
            yield return await selector(item);
        }
    }
}

public static class IAsyncEnumerableExtensions {
    public static async Task<List<TSource>> ToListAsync<TSource>(this IAsyncEnumerable<TSource> source) {
        var list = new List<TSource>();

        await foreach (var item in source) {
            list.Add(item);
        }

        return list;
    }
}

可以这样解释:

var inputs = await events.SelectAsync(ev => ProcessEventAsync(ev)).ToListAsync();

更新:或者你可以添加一个对System.Linq.Async的引用，然后你可以说:

var inputs = await events
    .ToAsyncEnumerable()
    .SelectAwait(async ev => await ProcessEventAsync(ev))
    .ToListAsync();

我想调用Select(…)，但要确保它按顺序运行，因为并行运行会导致一些其他并发问题，所以我最终得到了这样的结果。 我不能调用. result，因为它会阻塞UI线程。

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

用法:

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

我知道任务。当我们可以并行运行时，WhenAll就是我们要走的路。

现有的代码可以工作，但是阻塞了线程。

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

为每个事件创建一个新任务，但是

.Select(t => t.Result)

阻塞等待每个新任务结束的线程。

另一方面，您的代码产生相同的结果，但保持异步。

对第一个代码只做一个注释。这条线

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

将生成一个Task<TResult[]>，因此变量应以单数形式命名。

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

参考:任务。等待/任务。WhenAll