Có thể "chờ đợi lợi nhuận trả về DoSomethingAsync ()"

Các khối trình lặp thông thường (tức là "trả về lợi nhuận") không tương thích với "async" và "await"?

Điều này cung cấp một ý tưởng tốt về những gì tôi đang cố gắng làm:

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

Tuy nhiên, tôi gặp lỗi trình biên dịch trích dẫn "không thể tải chuỗi thông báo từ tài nguyên".

Đây là một nỗ lực khác:

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

Nhưng một lần nữa, trình biên dịch trả về lỗi: "không thể tải chuỗi thông báo từ tài nguyên".

Đây là mã lập trình thực trong dự án của tôi

Điều này rất hữu ích khi tôi có một Nhiệm vụ danh sách, tác vụ đó có thể được tải xuống HTML từ một URL và tôi sử dụng cú pháp "tác vụ trả về chờ đợi", kết quả là tôi muốn IEnumerable<Foo>. Tôi không muốn viết mã này:

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

Nhưng có vẻ như tôi phải làm vậy.

Cảm ơn vì bất kì sự giúp đỡ.

Những gì bạn đang mô tả có thể được thực hiện bằng Task.WhenAllphương pháp này. Lưu ý cách mã chuyển thành một lớp lót đơn giản. Điều xảy ra là mỗi url riêng lẻ bắt đầu tải xuống và sau đó WhenAllđược sử dụng kết hợp các hoạt động đó thành một url duy nhất Taskcó thể được chờ đợi.

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

tl; dr Các phần tử lặp khi được triển khai với lợi nhuận là một cấu trúc chặn, vì vậy ngay bây giờ đang chờ đợi và lợi nhuận không tương thích.

Long Bởi vì việc lặp qua an IEnumerablelà một thao tác chặn, việc gọi một phương thức được đánh dấu là asyncsẽ vẫn thực thi nó theo cách chặn, vì nó phải đợi thao tác đó kết thúc.

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

Sự chờ đợi Methodtrộn lẫn ý nghĩa. Bạn có muốn đợi cho đến khi Taskcó một IEnumerablekhối rồi lặp lại nó không? Hay bạn đang cố gắng chờ đợi từng giá trị của IEnumerable?

Tôi giả sử điều thứ hai là hành vi mong muốn và trong trường hợp đó, ngữ nghĩa của Iterator hiện có sẽ không hoạt động. Các IEnumerator<T>giao diện cơ bản là

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

Tôi đang bỏ qua Reset()vì nó không có ý nghĩa gì đối với một chuỗi kết quả không đồng bộ. Nhưng những gì bạn cần là một cái gì đó như thế này:

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

Tất nhiên, foreachcũng sẽ không hoạt động với điều này và bạn phải lặp lại theo cách thủ công như sau:

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

Theo các tính năng mới tại C # 8.0 ( liên kết số 1 và liên kết số 2 ), chúng tôi sẽ IAsyncEnumerable<T>hỗ trợ giao diện cho phép bạn thực hiện lần thử thứ hai. Nó sẽ trông giống thế này:

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

Chúng ta có thể đạt được hành vi tương tự ở C # 5 nhưng với ngữ nghĩa khác:

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

Câu trả lời của Brian Gideon ngụ ý rằng mã gọi sẽ nhận được một tập hợp các kết quả thu được song song một cách không đồng bộ. Đoạn mã trên ngụ ý rằng mã gọi sẽ nhận được kết quả giống như từ một luồng một theo cách không đồng bộ.

Tôi biết rằng tôi đã quá muộn với câu trả lời, nhưng đây là một giải pháp đơn giản khác có thể đạt được với thư viện này:
GitHub: https://github.com/tyrotoxin/AsyncEnumerable
NuGet.org: https://www.nuget .org / package / AsyncEnumerator /
Nó đơn giản hơn nhiều so với 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);
  });
}

Tính năng này sẽ có sẵn kể từ C # 8.0. https://blogs.msdn.microsoft.com/dotnet/2018/11/12/building-c-8-0/

Của MSDN

Luồng không đồng bộ

Tính năng async / await của C # 5.0 cho phép bạn sử dụng (và tạo ra) các kết quả không đồng bộ trong mã đơn giản mà không cần gọi lại:

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

Sẽ không hữu ích lắm nếu bạn muốn sử dụng (hoặc tạo ra) các luồng kết quả liên tục, chẳng hạn như bạn có thể nhận được từ thiết bị IoT hoặc dịch vụ đám mây. Các luồng không đồng bộ có sẵn cho điều đó.

Chúng tôi giới thiệu IAsyncEnumerable, chính xác là những gì bạn mong đợi; phiên bản không đồng bộ của IEnumerable. Ngôn ngữ cho phép bạn chờ đợi trước những điều này để tiêu thụ các phần tử của chúng và mang lại lợi nhuận cho chúng để tạo ra các phần tử.

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

Có một kế hoạch để làm

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

Nhưng hiện tại thì không thể

Trước hết, hãy nhớ rằng nội dung Async vẫn chưa kết thúc. Nhóm C # vẫn còn một chặng đường dài trước khi C # 5 được phát hành.

Điều đó đang được nói, tôi nghĩ rằng bạn có thể muốn tập hợp các nhiệm vụ đang bị sa thải trong DownloadAllHtmlchức năng theo một cách khác.

Ví dụ: bạn có thể sử dụng một cái gì đó như sau:

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

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

Không phải là DownloadAllUrlhàm KHÔNG phải là một lệnh gọi không đồng bộ. Tuy nhiên, bạn có thể thực hiện lệnh gọi không đồng bộ trên một hàm khác (tức là DownloadHtmlAsync).

Thư viện song song nhiệm vụ có các chức năng .ContinueWhenAnyvà .ContinueWhenAllchức năng.

Điều đó có thể được sử dụng như thế này:

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

Thật không may, lợi nhuận không hoạt động với sự chờ đợi. Nhưng đây là những gì Rx dành cho. Xem https://msdn.microsoft.com/library/hh242985

Giải pháp này hoạt động như mong đợi. Lưu ý await Task.Run(() => enumerator.MoveNext())phần.

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