Question

我尝试使用LINQ IEnumerable.Aggregate函数创建一个由通过异步调用检索的文件组成的字符串。不是百分之百确定它是可能的，而且我也意识到还有其他解决方案，但我想尝试一下。

现在我的代码看起来像这样：

private static async Task<string> GetFiles(IEnumerable<string> filePaths)
{
    return filePaths.Aggregate(async (current, path) => current + await GetFile(path));
}

但＆＃34; async＆＃34;方法调用内部的错误标记为＆＃34;异步方法的返回必须为void，Task或Task＆＃34;。我总体上得到了这个错误，但我不确定如何安排这个具体案例来避免它。有什么想法吗？

更新：只是为了澄清，GetFile（）方法确实是异步的，并返回Task<string>：

private static async Task<string> GetFile(string filePath) { ... }

无需深入了解具体代码，但感兴趣的人使用HttpClient.GetAsync(filePath)并返回其response.Content.ReadAsStringAsync().Result。

Answer 1

Aggregate方法不会异步工作。它不支持基于任务的代理。您需要在调用Aggregate方法之前等待它来自己创建结果序列。

这样的事情应该有效：

private static async Task<string> GetFiles(IEnumerable<string> filePaths)
{
    var files = filePaths
        .Select(p => GetFile(p))
        .ToArray();
    var results = await Task.WhenAll(files);

    return results
        .Aggregate((current, path) => current + path);
}

Answer 2

正如@Sriram所说，LINQ和async-await并没有很好地协同工作，因为没有对异步任务代表的内置支持。

可以做的是自己创建聚合的异步重载：

public static class AsynchronousEnumerable
{
    public static async Task<TSource> AggregateAsync<TSource>
                                      (this IEnumerable<TSource> source,
                                       Func<TSource, TSource, Task<TSource>> func)
    {
       using (IEnumerator<TSource> e = source.GetEnumerator())
       {
            if (!e.MoveNext())
            {
                throw new InvalidOperationException("Sequence contains no elements");
            }

            TSource result = e.Current;
            while (e.MoveNext()) result = await func(result, e.Current);
            return result;
        }
    }
}

现在您可以执行以下操作：

private static Task<string> GetFiles(IEnumerable<string> filePaths)
{
    return filePaths.AggregateAsync(async (current, path) => current + 
                                                             await GetFile(path));
}

Answer 3

如果你想在async内使用Aggregate，你必须意识到任何异步都会返回一个Task。考虑到这一点，很明显，Aggregate调用的结果也应该是一个任务。

例如，计算异步返回的数字集合的总和：

private static async Task<int> GetSumAsync(IEnumerable<Task<int>> numbers) {
  return await numbers
    .Aggregate(Task.FromResult(0), async (sumSoFar, nextNumber) => (await sumSoFar) + (await nextNumber));
}

我对你希望用你的GetFiles方法做什么感到有点困惑。您确实意识到Aggregate将集合简化为一件事，对吧？（'sum'函数就是一个很好的例子）

使用IEnumerable.Aggregate与异步调用

3 个答案: