async / await - เมื่อใดที่จะส่งคืน Task vs void?

ภายใต้สถานการณ์ใดที่เราจะต้องการใช้

public async Task AsyncMethod(int num)

แทน

public async void AsyncMethod(int num)

สถานการณ์เดียวที่ฉันนึกออกคือถ้าคุณต้องการให้ภารกิจติดตามความคืบหน้า

นอกจากนี้ในวิธีต่อไปนี้ async และรอคำสำคัญไม่จำเป็นหรือไม่

public static async void AsyncMethod2(int num)
{
    await Task.Factory.StartNew(() => Thread.Sleep(num));
}

1) Taskโดยปกติคุณต้องการที่จะกลับมาเป็น ข้อยกเว้นหลักควรเป็นเมื่อคุณจำเป็นต้องมีvoidชนิดส่งคืน (สำหรับเหตุการณ์) หากไม่มีเหตุผลที่จะไม่อนุญาตให้โทรหาawaitงานของคุณทำไมไม่อนุญาต

2) asyncวิธีการที่ส่งกลับvoidเป็นพิเศษในอีกแง่มุม: พวกเขาแสดงถึงการดำเนินการ async ระดับบนสุดและมีกฎเพิ่มเติมที่เข้ามาเล่นเมื่องานของคุณส่งคืนข้อยกเว้น วิธีที่ง่ายที่สุดคือการแสดงความแตกต่างด้วยตัวอย่าง:

static async void f()
{
    await h();
}

static async Task g()
{
    await h();
}

static async Task h()
{
    throw new NotImplementedException();
}

private void button1_Click(object sender, EventArgs e)
{
    f();
}

private void button2_Click(object sender, EventArgs e)
{
    g();
}

private void button3_Click(object sender, EventArgs e)
{
    GC.Collect();
}

fข้อยกเว้นของ "เสมอ" สังเกต ข้อยกเว้นที่ปล่อยให้วิธีการแบบอะซิงโครนัสระดับสูงสุดนั้นได้รับการปฏิบัติเช่นเดียวกับข้อยกเว้นอื่น ๆ ที่ไม่สามารถจัดการได้ gไม่เคยสังเกตข้อยกเว้น เมื่อตัวรวบรวมขยะมาเพื่อล้างภารกิจนั้นจะเห็นว่างานส่งผลให้เกิดข้อยกเว้นและไม่มีใครจัดการข้อยกเว้น เมื่อเกิดเหตุการณ์ขึ้นTaskScheduler.UnobservedTaskExceptionตัวจัดการจะทำงาน คุณไม่ควรปล่อยให้เรื่องนี้เกิดขึ้น เพื่อใช้ตัวอย่างของคุณ

public static async void AsyncMethod2(int num)
{
    await Task.Factory.StartNew(() => Thread.Sleep(num));
}

ใช่ใช้งานasyncและawaitที่นี่ช่วยให้แน่ใจว่าวิธีการของคุณยังคงทำงานได้อย่างถูกต้องหากมีข้อผิดพลาดเกิดขึ้น

สำหรับข้อมูลเพิ่มเติมโปรดดู: http://msdn.microsoft.com/en-us/magazine/jj991977.aspx

ฉันเจอบทความที่มีประโยชน์เกี่ยวกับasyncและvoidเขียนโดยJérôme Laban: https://jaylee.org/archive/2012/07/08/c-sharp-async-tips-and-tricks-part2-jaylee.org และ .html

บรรทัดล่างคือว่าasync+voidสามารถผิดพลาดของระบบและโดยปกติควรจะใช้เฉพาะในตัวจัดการเหตุการณ์ด้าน UI

เหตุผลที่อยู่เบื้องหลังนี้คือบริบทการซิงโครไนซ์ที่ใช้โดย AsyncVoidMethodBuilder ซึ่งไม่มีในตัวอย่างนี้ เมื่อไม่มีบริบทการซิงโครไนซ์ของสภาพแวดล้อมข้อยกเว้นใด ๆ ที่ไม่สามารถจัดการได้โดยเนื้อความของเมธอด async void จะถูกสร้างขึ้นมาใหม่บน ThreadPool ในขณะที่ดูเหมือนว่าไม่มีโลจิคัลสถานที่อื่นที่ข้อยกเว้นชนิดที่ไม่สามารถจัดการได้ถูกโยนทิ้ง แต่ผลลัพธ์ที่โชคร้ายคือกระบวนการกำลังถูกยกเลิกเนื่องจากข้อยกเว้นที่ไม่สามารถจัดการได้บน ThreadPool จะยุติกระบวนการอย่างมีประสิทธิภาพตั้งแต่. NET 2.0 คุณสามารถดักจับข้อยกเว้นที่ไม่ได้จัดการทั้งหมดโดยใช้เหตุการณ์ AppDomain.UnhandledException แต่ไม่มีวิธีกู้คืนกระบวนการจากเหตุการณ์นี้

เมื่อเขียนตัวจัดการเหตุการณ์ UI เมธอดเป็นโมฆะของ async จะไม่เจ็บปวดอย่างใดเพราะข้อยกเว้นจะได้รับการปฏิบัติในลักษณะเดียวกับที่พบในวิธีการที่ไม่ใช้ async พวกเขาถูกโยนลงไปในดิสแพตเชอร์ มีความเป็นไปได้ที่จะกู้คืนจากข้อยกเว้นดังกล่าวโดยมีความถูกต้องมากกว่าสำหรับกรณีส่วนใหญ่ นอกตัวจัดการเหตุการณ์ UI อย่างไรก็ตามวิธีการโมฆะ async เป็นอันตรายอย่างใดที่จะใช้และอาจไม่ง่ายที่จะหา

ฉันได้แนวคิดที่ชัดเจนจากข้อความนี้

1. วิธีการ Async เป็นโมฆะมีความหมายที่แตกต่างกันในการจัดการข้อผิดพลาด เมื่อมีข้อยกเว้นถูกโยนออกจากงาน async หรือวิธีการ async Task ข้อยกเว้นนั้นจะถูกดักจับและวางไว้บนวัตถุ Task ด้วยเมธอด async เป็นโมฆะไม่มีวัตถุภารกิจดังนั้นข้อยกเว้นใด ๆ ที่ถูกโยนออกมาจากวิธีการ async void จะถูกยกขึ้นโดยตรงบน เริ่มต้น

ข้อยกเว้นจากวิธีการ Async Void ไม่สามารถดักจับได้

private async void ThrowExceptionAsync()
{
  throw new InvalidOperationException();
}
public void AsyncVoidExceptions_CannotBeCaughtByCatch()
{
  try
  {
    ThrowExceptionAsync();
  }
  catch (Exception)
  {
    // The exception is never caught here!
    throw;
  }
}

ข้อยกเว้นเหล่านี้สามารถตรวจสอบได้โดยใช้ AppDomain.UnhandledException หรือเหตุการณ์ catch-all ที่คล้ายกันสำหรับแอปพลิเคชัน GUI / ASP.NET แต่การใช้เหตุการณ์เหล่านั้นสำหรับการจัดการข้อยกเว้นปกติเป็นสูตรสำหรับความไม่แน่นอน (มันขัดข้องแอปพลิเคชัน)

2. วิธีการ Async เป็นโมฆะมีความหมายที่แตกต่างกันในการเขียน วิธีการ Async ที่คืนค่าภารกิจหรืองานสามารถประกอบได้อย่างง่ายดายโดยใช้ await, Task.WhenAny, Task.WhenAll และอื่น ๆ วิธีการ Async ที่ส่งคืนเป็นโมฆะไม่ได้ให้วิธีที่ง่ายในการแจ้งรหัสการโทรที่พวกเขาได้เสร็จสิ้นแล้ว มันง่ายที่จะเริ่มวิธีการ async เป็นโมฆะหลายวิธี แต่มันไม่ง่ายที่จะตัดสินว่าเมื่อมันเสร็จสิ้นแล้ว วิธีการโมฆะ Async จะแจ้งให้ทราบ SynchronizationContext ของพวกเขาเมื่อพวกเขาเริ่มต้นและเสร็จสิ้น แต่ SynchronizationContext ที่กำหนดเองเป็นโซลูชั่นที่ซับซ้อนสำหรับรหัสแอปพลิเคชันปกติ

3. วิธี Async Void มีประโยชน์เมื่อใช้การซิงโครไนซ์ตัวจัดการเหตุการณ์เนื่องจากพวกเขายกข้อยกเว้นของพวกเขาโดยตรงบน SynchronizationContext

สำหรับรายละเอียดเพิ่มเติมตรวจสอบลิงค์นี้ https://msdn.microsoft.com/en-us/magazine/jj991977.aspx

ปัญหาในการโทรเป็นโมฆะ async คือคุณไม่ได้รับงานคืนคุณไม่มีทางรู้ว่าเมื่องานของฟังก์ชั่นเสร็จสมบูรณ์ (ดูhttps://blogs.msdn.microsoft.com/oldnewthing/20170720-00/ ? p = 96655 )

นี่คือสามวิธีในการเรียกใช้ฟังก์ชัน async:

async Task<T> SomethingAsync() { ... return t; }
async Task SomethingAsync() { ... }
async void SomethingAsync() { ... }

ในทุกกรณีฟังก์ชั่นจะถูกเปลี่ยนเป็นห่วงโซ่ของงาน ความแตกต่างคือสิ่งที่ฟังก์ชั่นส่งคืน

ในกรณีแรกฟังก์ชันส่งคืนงานที่สร้าง t ในที่สุด

ในกรณีที่สองฟังก์ชั่นส่งคืนงานที่ไม่มีผลิตภัณฑ์ แต่คุณยังสามารถรอที่จะรู้ว่าเมื่อมันทำงานให้เสร็จ

กรณีที่สามเป็นคดีที่น่ารังเกียจ กรณีที่สามเป็นเหมือนกรณีที่สองยกเว้นว่าคุณไม่ได้รับงานคืน คุณไม่มีทางรู้ว่าเมื่องานของฟังก์ชั่นเสร็จสมบูรณ์

กรณีโมฆะ async เป็น "ไฟและลืม": คุณเริ่มต้นห่วงโซ่งาน แต่คุณไม่สนใจเมื่อมันเสร็จ เมื่อฟังก์ชั่นกลับมาสิ่งที่คุณรู้คือทุกอย่างที่รอจนถึงครั้งแรกได้ดำเนินการแล้ว ทุกอย่างหลังจากการรอครั้งแรกจะทำงานในบางจุดที่ไม่ระบุในอนาคตที่คุณไม่สามารถเข้าถึงได้

ฉันคิดว่าคุณสามารถใช้async voidเพื่อเริ่มการทำงานของแบ็คกราวน์ได้เช่นกันตราบใดที่คุณระมัดระวังในการตรวจจับยกเว้น คิด?

class Program {

    static bool isFinished = false;

    static void Main(string[] args) {

        // Kick off the background operation and don't care about when it completes
        BackgroundWork();

        Console.WriteLine("Press enter when you're ready to stop the background operation.");
        Console.ReadLine();
        isFinished = true;
    }

    // Using async void to kickoff a background operation that nobody wants to be notified about when it completes.
    static async void BackgroundWork() {
        // It's important to catch exceptions so we don't crash the appliation.
        try {
            // This operation will end after ten interations or when the app closes. Whichever happens first.
            for (var count = 1; count <= 10 && !isFinished; count++) {
                await Task.Delay(1000);
                Console.WriteLine($"{count} seconds of work elapsed.");
            }
            Console.WriteLine("Background operation came to an end.");
        } catch (Exception x) {
            Console.WriteLine("Caught exception:");
            Console.WriteLine(x.ToString());
        }
    }
}

คำตอบของฉันง่าย ๆ ที่คุณไม่สามารถรอวิธีการโมฆะ

Error   CS4008  Cannot await 'void' TestAsync   e:\test\TestAsync\TestAsyncProgram.cs

ดังนั้นหากวิธีการนั้นเป็นแบบอะซิงจะเป็นการดีกว่าที่จะต้องรอเพราะคุณสามารถปล่อยข้อได้เปรียบแบบอะซิงก์ได้

ตามเอกสารของ Microsoftไม่ควรใช้async void

อย่าทำสิ่งนี้: ตัวอย่างต่อไปนี้ใช้async voidซึ่งทำให้การร้องขอ HTTP เสร็จสมบูรณ์เมื่อถึงการรอครั้งแรก:

• ซึ่งเป็นแนวปฏิบัติที่ไม่ดีในแอป ASP.NET Core เสมอ

• เข้าถึง HttpResponse หลังจากการร้องขอ HTTP เสร็จสมบูรณ์

• เกิดปัญหากระบวนการ