Tại sao tôi nên chọn một nhiệm vụ 'đang chờ Nhiệm vụ.When ALL' hơn nhiều lần chờ đợi?

Trong trường hợp tôi không quan tâm đến thứ tự hoàn thành nhiệm vụ và chỉ cần tất cả chúng để hoàn thành, tôi vẫn nên sử dụng await Task.WhenAllthay vì nhiều await? ví dụ: DoWork2bên dưới một phương thức ưa thích để DoWork1(và tại sao?):

using System;
using System.Threading.Tasks;

namespace ConsoleApp
{
    class Program
    {
        static async Task<string> DoTaskAsync(string name, int timeout)
        {
            var start = DateTime.Now;
            Console.WriteLine("Enter {0}, {1}", name, timeout);
            await Task.Delay(timeout);
            Console.WriteLine("Exit {0}, {1}", name, (DateTime.Now - start).TotalMilliseconds);
            return name;
        }

        static async Task DoWork1()
        {
            var t1 = DoTaskAsync("t1.1", 3000);
            var t2 = DoTaskAsync("t1.2", 2000);
            var t3 = DoTaskAsync("t1.3", 1000);

            await t1; await t2; await t3;

            Console.WriteLine("DoWork1 results: {0}", String.Join(", ", t1.Result, t2.Result, t3.Result));
        }

        static async Task DoWork2()
        {
            var t1 = DoTaskAsync("t2.1", 3000);
            var t2 = DoTaskAsync("t2.2", 2000);
            var t3 = DoTaskAsync("t2.3", 1000);

            await Task.WhenAll(t1, t2, t3);

            Console.WriteLine("DoWork2 results: {0}", String.Join(", ", t1.Result, t2.Result, t3.Result));
        }


        static void Main(string[] args)
        {
            Task.WhenAll(DoWork1(), DoWork2()).Wait();
        }
    }
}

Có, sử dụng WhenAllvì nó tuyên truyền tất cả các lỗi cùng một lúc. Với nhiều lần chờ, bạn sẽ mất lỗi nếu một trong những lần chờ trước đó bị ném.

Một sự khác biệt quan trọng khác là WhenAllsẽ chờ tất cả các nhiệm vụ hoàn thành ngay cả khi có lỗi (nhiệm vụ bị lỗi hoặc bị hủy). Chờ đợi theo cách thủ công sẽ gây ra sự đồng thời bất ngờ vì một phần chương trình của bạn muốn chờ đợi sẽ thực sự tiếp tục sớm.

Tôi nghĩ rằng nó cũng làm cho việc đọc mã dễ dàng hơn bởi vì ngữ nghĩa mà bạn muốn được ghi lại trực tiếp trong mã.

Sự hiểu biết của tôi là lý do chính để thích Task.WhenAllnhiều awaits là hiệu năng / nhiệm vụ "chasing": DoWork1phương thức làm một cái gì đó như thế này:

• bắt đầu với một bối cảnh nhất định
• lưu lại bối cảnh
• chờ t1
• khôi phục bối cảnh ban đầu
• lưu lại bối cảnh
• chờ t2
• khôi phục bối cảnh ban đầu
• lưu lại bối cảnh
• chờ t3
• khôi phục bối cảnh ban đầu

Ngược lại, DoWork2làm điều này:

• bắt đầu với một bối cảnh nhất định
• lưu lại bối cảnh
• chờ tất cả t1, t2 và t3
• khôi phục bối cảnh ban đầu

Cho dù đây là một thỏa thuận đủ lớn cho trường hợp cụ thể của bạn, tất nhiên, là "phụ thuộc vào ngữ cảnh" (tha thứ cho trò chơi chữ).

Một phương pháp không đồng bộ được thực hiện như một máy trạng thái. Có thể viết các phương thức để chúng không được biên dịch thành các máy trạng thái, điều này thường được gọi là phương thức async theo dõi nhanh. Đây có thể được thực hiện như vậy:

public Task DoSomethingAsync()
{
    return DoSomethingElseAsync();
}

Khi sử dụng Task.WhenAll, có thể duy trì mã theo dõi nhanh này trong khi vẫn đảm bảo người gọi có thể đợi tất cả các tác vụ được hoàn thành, ví dụ:

public Task DoSomethingAsync()
{
    var t1 = DoTaskAsync("t2.1", 3000);
    var t2 = DoTaskAsync("t2.2", 2000);
    var t3 = DoTaskAsync("t2.3", 1000);

    return Task.WhenAll(t1, t2, t3);
}

(Tuyên bố miễn trừ trách nhiệm: Câu trả lời này được lấy / lấy cảm hứng từ khóa học TPL Async của Ian Griffiths về Pluralsight )

Một lý do khác để thích Khi AllAll là xử lý Ngoại lệ.

Giả sử bạn đã có một khối thử bắt trên các phương thức DoWork của mình và giả sử họ đang gọi các phương thức DoTask khác nhau:

static async Task DoWork1() // modified with try-catch
{
    try
    {
        var t1 = DoTask1Async("t1.1", 3000);
        var t2 = DoTask2Async("t1.2", 2000);
        var t3 = DoTask3Async("t1.3", 1000);

        await t1; await t2; await t3;

        Console.WriteLine("DoWork1 results: {0}", String.Join(", ", t1.Result, t2.Result, t3.Result));
    }
    catch (Exception x)
    {
        // ...
    }

}

Trong trường hợp này, nếu cả 3 nhiệm vụ đưa ra ngoại lệ, chỉ có nhiệm vụ đầu tiên sẽ bị bắt. Bất kỳ ngoại lệ sau này sẽ bị mất. Tức là nếu t2 và t3 ném ngoại lệ, chỉ t2 sẽ bị bắt; vv Các ngoại lệ nhiệm vụ tiếp theo sẽ không được quan sát.

Trong trường hợp như khi AllAll - nếu có hoặc tất cả các tác vụ bị lỗi, tác vụ kết quả sẽ chứa tất cả các ngoại lệ. Từ khóa await vẫn luôn ném lại ngoại lệ đầu tiên. Vì vậy, các ngoại lệ khác vẫn không được quan sát một cách hiệu quả. Một cách để khắc phục điều này là thêm phần tiếp tục trống sau nhiệm vụ Khi Tất cả và đặt sự chờ đợi ở đó. Theo cách này, nếu tác vụ thất bại, thuộc tính kết quả sẽ đưa ra Ngoại lệ tổng hợp đầy đủ:

static async Task DoWork2() //modified to catch all exceptions
{
    try
    {
        var t1 = DoTask1Async("t1.1", 3000);
        var t2 = DoTask2Async("t1.2", 2000);
        var t3 = DoTask3Async("t1.3", 1000);

        var t = Task.WhenAll(t1, t2, t3);
        await t.ContinueWith(x => { });

        Console.WriteLine("DoWork1 results: {0}", String.Join(", ", t.Result[0], t.Result[1], t.Result[2]));
    }
    catch (Exception x)
    {
        // ...
    }
}

Các câu trả lời khác cho câu hỏi này cung cấp lý do kỹ thuật tại sao await Task.WhenAll(t1, t2, t3);được ưa thích. Câu trả lời này sẽ nhằm mục đích xem xét nó từ một khía cạnh nhẹ nhàng hơn (mà @usr ám chỉ) trong khi vẫn đi đến kết luận tương tự.

await Task.WhenAll(t1, t2, t3); là một cách tiếp cận chức năng hơn, vì nó tuyên bố ý định và là nguyên tử.

Với await t1; await t2; await t3;, không có gì ngăn cản đồng đội (hoặc thậm chí là bản thân tương lai của bạn!) Thêm mã giữa các cá nhânawait câu lệnh . Chắc chắn, bạn đã nén nó thành một dòng để thực hiện điều đó, nhưng điều đó không giải quyết được vấn đề. Bên cạnh đó, hình thức nói chung là xấu trong cài đặt nhóm để bao gồm nhiều câu lệnh trên một dòng mã nhất định, vì nó có thể làm cho tệp nguồn của mắt người khó quét hơn.

Nói một cách đơn giản, await Task.WhenAll(t1, t2, t3);có thể duy trì nhiều hơn, vì nó truyền đạt ý định của bạn rõ ràng hơn và ít bị tổn thương hơn với các lỗi đặc biệt có thể phát sinh từ các bản cập nhật có ý nghĩa đối với mã hoặc thậm chí chỉ hợp nhất đã sai.