¿Es posible "esperar el retorno de rendimiento DoSomethingAsync ()"

¿Los bloques de iteradores regulares (es decir, "rendimiento de retorno") son incompatibles con "async" y "await"?

Esto da una buena idea de lo que estoy tratando de hacer:

async Task<IEnumerable<Foo>> Method(String [] Strs)
{
    // I want to compose the single result to the final result, so I use the SelectMany
    var finalResult = UrlStrings.SelectMany(link =>   //i have an Urlstring Collection 
                   await UrlString.DownLoadHtmlAsync()  //download single result; DownLoadHtmlAsync method will Download the url's html code 
              );
     return finalResult;
}

Sin embargo, obtengo un error del compilador que menciona "no se puede cargar la cadena de mensajes desde los recursos".

Aquí hay otro intento:

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

Pero nuevamente, el compilador devuelve un error: "no se puede cargar la cadena de mensajes desde los recursos".

Aquí está el código de programación real en mi proyecto.

Esto es muy útil cuando tengo una tarea de lista, esa tarea se puede descargar HTML desde una URL y uso la sintaxis "rendimiento, retorno, espera de tarea", el resultado es que quiero IEnumerable<Foo>. No quiero escribir este código:

async Task<IEnumerable<String>> DownLoadAllURL(String [] Strs)
{
    List<Foo> htmls= new ...
    foreach(var str in strs)
    {
        var html= await DownLoadHtmlAsync( str)
        htmls.Add(item)
    }
    return htmls;
}

Pero parece que tengo que hacerlo.

Gracias por cualquier ayuda.

Lo que está describiendo se puede lograr con el Task.WhenAllmétodo. Observe cómo el código se convierte en una simple frase. Lo que sucede es que cada URL individual comienza a descargarse y luego WhenAllse usa para combinar esas operaciones en una única Taskque se puede esperar.

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

tl; dr Los iteradores implementados con yield son una construcción de bloqueo, por lo que a partir de ahora, await y yield son incompatibles.

Long Debido a que iterar sobre una IEnumerablees una operación de bloqueo, llamar a un método marcado como asynctodavía lo ejecutará de manera de bloqueo, ya que tiene que esperar a que termine esa operación.

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

La espera Methodmezcla significados. ¿Quieres esperar hasta que Tasktenga un IEnumerabley luego bloquear la iteración sobre él? ¿O está tratando de esperar cada valor de IEnumerable?

Supongo que el segundo es el comportamiento deseado y, en ese caso, la semántica del iterador existente no funcionará. La IEnumerator<T>interfaz es básicamente

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

Lo ignoro Reset()porque no tiene sentido para una secuencia de resultados asincrónicos. Pero lo que necesitarías es algo como esto:

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

Por supuesto, foreachtampoco funcionará con esto y tendrías que iterar manualmente de esta manera:

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

De acuerdo con las nuevas características en C # 8.0 ( enlace # 1 y enlace # 2 ) tendremos IAsyncEnumerable<T>soporte de interfaz que permitirá implementar su segundo intento. Se verá así:

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

Podemos lograr el mismo comportamiento en C # 5 pero con una semántica diferente:

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

La respuesta de Brian Gideon implica que el código de llamada obtendrá de forma asincrónica una colección de resultados que se obtuvieron en paralelo. El código anterior implica que el código de llamada obtendrá resultados como de una secuencia uno por uno de manera asincrónica.

Sé que llego demasiado tarde con la respuesta, pero aquí hay otra solución simple que se puede lograr con esta biblioteca:
GitHub: https://github.com/tyrotoxin/AsyncEnumerable
NuGet.org: https: //www.nuget .org / packages / AsyncEnumerator /
Es mucho más simple que 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);
  });
}

Esta función estará disponible a partir de C # 8.0. https://blogs.msdn.microsoft.com/dotnet/2018/11/12/building-c-8-0/

De MSDN

Secuencias asincrónicas

La característica async / await de C # 5.0 le permite consumir (y producir) resultados asincrónicos en código sencillo, sin devoluciones de llamada:

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

No es tan útil si desea consumir (o producir) flujos continuos de resultados, como los que podría obtener de un dispositivo IoT o un servicio en la nube. Las transmisiones asíncronas están ahí para eso.

Presentamos IAsyncEnumerable, que es exactamente lo que esperaría; una versión asincrónica de IEnumerable. El lenguaje te permite esperar a que cada uno de estos consuma sus elementos y les dé retorno para producir elementos.

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

Había un plan que hacer

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

Pero actualmente no es posible

En primer lugar, tenga en cuenta que las cosas de Async no están terminadas. El equipo de C # todavía tiene un largo camino por recorrer antes de que se lance C # 5.

Dicho esto, creo que es posible que desee recopilar las tareas que se están ejecutando en la DownloadAllHtmlfunción de una manera diferente.

Por ejemplo, puede usar algo como esto:

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

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

No es que la DownloadAllUrlfunción NO sea una llamada asíncrona. Pero, puede implementar la llamada asíncrona en otra función (es decir DownloadHtmlAsync).

La biblioteca de tareas paralelas tiene las funciones .ContinueWhenAnyy .ContinueWhenAll.

Eso se puede usar así:

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

Lamentablemente, Yield no funciona con await. Pero para eso está Rx. Consulte https://msdn.microsoft.com/library/hh242985

Esta solución funciona como se esperaba. Tenga en cuenta la await Task.Run(() => enumerator.MoveNext())parte.

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