เหตุใดฉันจึงควรเลือก 'await Task whenAll' มากกว่าการรอหลายครั้ง

ในกรณีที่ฉันไม่สนใจลำดับการทำงานให้เสร็จและเพียงแค่ต้องการให้ทุกอย่างเสร็จสมบูรณ์ฉันควรใช้await Task.WhenAllแทนหลาย ๆ ตัวawaitหรือไม่ เช่นDoWork2ด้านล่างเป็นวิธีที่ต้องการDoWork1(และทำไม?):

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

ใช่ใช้WhenAllเพราะเผยแพร่ข้อผิดพลาดทั้งหมดในครั้งเดียว ด้วยการรอหลายครั้งคุณจะสูญเสียข้อผิดพลาดหากมีการรอคอยก่อนหน้านี้

ข้อแตกต่างที่สำคัญอีกประการหนึ่งคือWhenAllจะรอให้งานทั้งหมดเสร็จสิ้นแม้จะมีความล้มเหลว (งานที่ผิดพลาดหรือถูกยกเลิก) การรอด้วยตนเองตามลำดับจะทำให้เกิดการทำงานพร้อมกันโดยไม่คาดคิดเนื่องจากส่วนของโปรแกรมที่ต้องการรอจะดำเนินต่อไปในช่วงต้น

ฉันคิดว่ามันทำให้การอ่านโค้ดง่ายขึ้นเช่นกันเพราะความหมายที่คุณต้องการจะถูกบันทึกไว้ในโค้ดโดยตรง

ความเข้าใจของฉันคือเหตุผลหลักที่ชอบTask.WhenAllใช้หลายตัวawaitคือประสิทธิภาพ / งาน "ปั่น": DoWork1วิธีการทำสิ่งนี้:

• เริ่มต้นด้วยบริบทที่กำหนด
• บันทึกบริบท
• รอ t1
• คืนค่าบริบทเดิม
• บันทึกบริบท
• รอ t2
• คืนค่าบริบทเดิม
• บันทึกบริบท
• รอ t3
• คืนค่าบริบทเดิม

ในทางตรงกันข้ามDoWork2ทำสิ่งนี้:

• เริ่มต้นด้วยบริบทที่กำหนด
• บันทึกบริบท
• รอ t1, t2 และ t3 ทั้งหมด
• คืนค่าบริบทเดิม

ไม่ว่านี่จะเป็นข้อตกลงที่ใหญ่พอสำหรับกรณีเฉพาะของคุณหรือไม่แน่นอน "ขึ้นอยู่กับบริบท" (ให้อภัยการเล่นสำนวน)

วิธีการอะซิงโครนัสถูกนำไปใช้เป็นสถานะเครื่อง เป็นไปได้ที่จะเขียนเมธอดเพื่อไม่ให้คอมไพล์ลงใน state-machine ซึ่งมักเรียกกันว่าวิธี async แบบ fast-track สิ่งเหล่านี้สามารถดำเนินการได้ดังนี้:

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

เมื่อใช้งานTask.WhenAllเป็นไปได้ที่จะรักษารหัสแทร็กด่วนนี้ในขณะที่ยังคงมั่นใจว่าผู้โทรสามารถรอให้งานทั้งหมดเสร็จสิ้นได้เช่น:

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

(ข้อจำกัดความรับผิดชอบ: คำตอบนี้นำมา / ได้รับแรงบันดาลใจจากหลักสูตร TPL Async ของ Ian Griffiths เรื่องPluralsight )

อีกเหตุผลหนึ่งที่ชอบจัดการเมื่อ All is Exception

สมมติว่าคุณมีบล็อกการลองจับวิธี DoWork ของคุณและสมมติว่าพวกเขาเรียกวิธี DoTask ที่แตกต่างกัน:

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)
    {
        // ...
    }

}

ในกรณีนี้ถ้าทั้ง 3 งานมีข้อยกเว้นจะถูกจับได้เฉพาะงานแรกเท่านั้น ข้อยกเว้นใด ๆ ในภายหลังจะสูญหายไป กล่าวคือถ้า t2 และ t3 มีข้อยกเว้นจะจับเฉพาะ t2 เท่านั้น ฯลฯ ข้อยกเว้นของงานที่ตามมาจะไม่ถูกสังเกต

โดยที่ใน WhenAll - ถ้างานใดงานหนึ่งหรือทั้งหมดเกิดข้อผิดพลาดงานที่ได้จะมีข้อยกเว้นทั้งหมด คีย์เวิร์ด await ยังคงแสดงข้อยกเว้นแรกอีกครั้ง ดังนั้นข้อยกเว้นอื่น ๆ จึงยังไม่สามารถสังเกตได้อย่างมีประสิทธิภาพ วิธีหนึ่งในการเอาชนะสิ่งนี้คือการเพิ่มความต่อเนื่องที่ว่างเปล่าหลังจากภารกิจ WhenAll และรอคอยที่นั่น ด้วยวิธีนี้หากงานล้มเหลวคุณสมบัติผลลัพธ์จะทำให้เกิดข้อยกเว้นรวมทั้งหมด:

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)
    {
        // ...
    }
}

คำตอบอื่น ๆ สำหรับคำถามนี้มีเหตุผลทางเทคนิคว่าทำไมจึงawait Task.WhenAll(t1, t2, t3);เป็นที่ต้องการ คำตอบนี้จะมุ่งเป้าไปที่การมองจากด้านที่นุ่มนวลกว่า (ซึ่ง @usr กล่าวถึง) ในขณะที่ยังคงได้ข้อสรุปเดียวกัน

await Task.WhenAll(t1, t2, t3); เป็นแนวทางที่ใช้ได้ผลมากกว่าเนื่องจากเป็นการประกาศเจตนาและเป็นปรมาณู

ด้วยเหตุawait t1; await t2; await t3;นี้จึงไม่มีอะไรขัดขวางเพื่อนร่วมทีม (หรือแม้กระทั่งตัวคุณเองในอนาคต!) จากการเพิ่มรหัสระหว่างawaitข้อความแต่ละข้อความ แน่นอนว่าคุณได้บีบอัดเป็นบรรทัดเดียวเพื่อให้บรรลุเป้าหมายนั้น แต่ก็ไม่ได้ช่วยแก้ปัญหา นอกจากนี้รูปแบบที่ไม่ดีโดยทั่วไปในการตั้งค่าทีมที่จะรวมคำสั่งหลาย ๆ คำไว้ในบรรทัดรหัสที่กำหนดเนื่องจากอาจทำให้ไฟล์ต้นฉบับยากขึ้นสำหรับสายตามนุษย์ในการสแกน

พูดง่ายๆawait Task.WhenAll(t1, t2, t3);ก็คือดูแลรักษาได้มากขึ้นเนื่องจากมันสื่อสารเจตนาของคุณได้ชัดเจนยิ่งขึ้นและมีความเสี่ยงน้อยกว่าต่อข้อบกพร่องเฉพาะที่อาจมาจากการอัปเดตโค้ดที่มีความหมายดีหรือแม้แต่การผสานผิดพลาด