是否可以“等待收益返回 DoSomethingAsync()”

您所描述的可以使用 Task.WhenAll 方法完成。注意代码是如何变成一个简单的单行代码的。发生的情况是每个单独的 url 开始下载，然后使用 WhenAll 将这些操作组合成一个可以等待的 Task。

Task<IEnumerable<string>> DownLoadAllUrls(string[] urls)
{
    return Task.WhenAll(from url in urls select DownloadHtmlAsync(url));
}

---

tl; dr 用 yield 实现的迭代器是一个阻塞结构，所以目前 await 和 yield 是不兼容的。

Long 因为遍历 IEnumerable 是一个阻塞操作，调用标记为 async 的方法仍将以阻塞方式执行它，因为它必须等待该操作完成。

async Task<IEnumerable<Foo>> Method(String [] Strs)
{
  foreach(var str in strs)
  {
    yield return await DoSomethingAsync( str)
  }
}  

等待的 Method 混合了含义。您要等到 Task 有一个 IEnumerable 然后阻止对其进行迭代吗？或者您是否尝试等待 IEnumerable 的每个值？

我假设第二个是期望的行为，在这种情况下，现有的迭代器语义将不起作用。 IEnumerator<T>接口基本上是

public interface IEnumerator<T>
  T Current;
  bool MoveNext();
}

我忽略了 Reset()，因为它对一系列异步结果没有意义。但是你需要的是这样的：

public interface IAsyncEnumerator<T>
  T Current;
  Task<bool> MoveNext();
}

当然，foreach 也不适用于此，您必须像这样手动迭代：

var moveNext = await asyncEnumerator.MoveNext();
while(moveNext) {

  // get the value that was fetche asynchronously
  var v = asyncEnumerator.Current;

  // do something with that value

  // suspend current execution context until next value arrives or we are done
  moveNext = await asyncEnumerator.MoveNext();
}

---

根据 C# 8.0（link#1 和 link#2）的新功能，我们将提供 IAsyncEnumerable<T> 接口支持，以便实现您的第二次尝试。它看起来像这样：

async Task<Foo> DoSomethingAsync(string url)
{
    ...
}       
// producing IAsyncEnumerable<T>
async IAsyncEnumerable<Foo> DownLoadAllURL(string[] strs)
{
    foreach (string url in strs)
    {
        yield return await DoSomethingAsync(url);
    }
}
...
// using
await foreach (Foo foo in DownLoadAllURL(new string[] { "url1", "url2" }))
{
    Use(foo);
}

我们可以在 C# 5 中实现相同的行为，但语义不同：

async Task<Foo> DoSomethingAsync(string url)
{
    ...
}
IEnumerable<Task<Foo>> DownLoadAllURL(string[] strs)
{
    foreach (string url in strs)
    {
        yield return DoSomethingAsync(url);
    }
}

// using
foreach (Task<Foo> task in DownLoadAllURL(new string[] { "url1", "url2" }))
{
    Foo foo = await task;
    Use(foo);
}

Brian Gideon 的回答暗示调用代码将异步获得一组并行获得的结果。上面的代码暗示调用代码将以异步方式从流中一一获取结果。

---

我知道我回答得太晚了，但这里有另一个可以使用此库实现的简单解决方案：
GitHub：https://github.com/tyrotoxin/AsyncEnumerable
NuGet.org：https://www.nuget.org/packages/AsyncEnumerator/
它更简单比 Rx。

using System.Collections.Async;

static IAsyncEnumerable<string> ProduceItems(string[] urls)
{
  return new AsyncEnumerable<string>(async yield => {
    foreach (var url in urls) {
      var html = await UrlString.DownLoadHtmlAsync(url);
      await yield.ReturnAsync(html);
    }
  });
}

static async Task ConsumeItemsAsync(string[] urls)
{
  await ProduceItems(urls).ForEachAsync(async html => {
    await Console.Out.WriteLineAsync(html);
  });
}

---

此功能将从 C# 8.0 开始提供。 https://blogs.msdn.microsoft.com/dotnet/2018/11/12/building-c-8-0/

来自 MSDN

异步流

C# 5.0 的 async/await 特性允许您以简单的代码使用（和生成）异步结果，而无需回调：

async Task<int> GetBigResultAsync()
{
    var result = await GetResultAsync();
    if (result > 20) return result; 
    else return -1;
}

如果您想要消费（或产生）连续的结果流，例如您可能从物联网设备或云服务获得的结果，那么它就没有多大帮助。异步流就是为此而存在的。

我们引入了 IAsyncEnumerable，这正是您所期望的； IEnumerable 的异步版本。该语言允许您在这些上等待 foreach 以使用它们的元素，并让它们返回以生成元素。

async IAsyncEnumerable<int> GetBigResultsAsync()
{
    await foreach (var result in GetResultsAsync())
    {
        if (result > 20) yield return result; 
    }
}

---

有一个计划要做

https://github.com/dotnet/csharplang/issues/43

但目前不可能

---

首先，请记住，异步的东西还没有完成。在 C# 5 发布之前，C# 团队还有很长的路要走。

话虽如此，我认为您可能希望以不同的方式收集在 DownloadAllHtml 函数中触发的任务。

例如，您可以使用如下内容：

IEnumerable<Task<string>> DownloadAllUrl(string[] urls)
{
    foreach(var url in urls)
    {
        yield return DownloadHtmlAsync(url);
    }
}

async Task<string> DownloadHtmlAsync(url)
{
    // Do your downloading here...
}

并不是说 DownloadAllUrl 函数是不是异步调用。但是，您可以在另一个函数（即 DownloadHtmlAsync）上实现异步调用。

任务并行库具有 .ContinueWhenAny 和 .ContinueWhenAll 函数。

可以这样使用：

var tasks = DownloadAllUrl(...);
var tasksArray = tasks.ToArray();
var continuation = Task.Factory.ContinueWhenAll(tasksArray, completedTasks =>
{
    completedtask
});
continuation.RunSynchronously();

---

不幸的是，收益不适用于等待。但这就是 Rx 的用途。查看https://msdn.microsoft.com/library/hh242985

---

此解决方案按预期工作。注意 await Task.Run(() => enumerator.MoveNext()) 部分。

using (var enumerator = myEnumerable.GetEnumerator())
{
    while (true)
    {
        if (enumerator.Current != null)
        {
            //TODO: do something with enumerator.Current
        }

        var enumeratorClone = monitorsEnumerator;
        var hasNext = await Task.Run(() => enumeratorClone.MoveNext());
        if (!hasNext)
        {
            break;
        }
    }
}

---