วัตถุประสงค์ของ“ การรอคืนสินค้า” ใน C # คืออะไร

มีใด ๆสถานการณ์ที่เขียนวิธีการเช่นนี้

public async Task<SomeResult> DoSomethingAsync()
{
    // Some synchronous code might or might not be here... //
    return await DoAnotherThingAsync();
}

แทนสิ่งนี้:

public Task<SomeResult> DoSomethingAsync()
{
    // Some synchronous code might or might not be here... //
    return DoAnotherThingAsync();
}

จะทำให้รู้สึก

เหตุใดจึงต้องใช้การreturn awaitสร้างเมื่อคุณสามารถกลับTask<T>จากการDoAnotherThingAsync()เรียกใช้ภายในได้โดยตรง

ฉันเห็นโค้ดreturn awaitในหลาย ๆ ที่ฉันคิดว่าฉันอาจพลาดอะไรบางอย่างไป แต่เท่าที่ฉันเข้าใจไม่ใช้ async / รอคำหลักในกรณีนี้และกลับงานโดยตรงจะเทียบเท่ากับการทำงาน ทำไมต้องเพิ่มค่าใช้จ่ายเพิ่มเติมของawaitเลเยอร์เพิ่มเติม?

มีหนึ่งกรณีลับ ๆ ล่อ ๆ เมื่อreturnอยู่ในวิธีการปกติและreturn awaitในasyncวิธีการทำงานแตกต่างกัน: เมื่อรวมกับusing(หรือมากกว่าใด ๆreturn awaitในtryบล็อก)

พิจารณาเมธอดทั้งสองเวอร์ชันนี้:

Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return foo.DoAnotherThingAsync();
    }
}

async Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return await foo.DoAnotherThingAsync();
    }
}

วิธีแรกจะDispose()เป็นFooวัตถุทันทีที่DoAnotherThingAsync()วิธีการส่งกลับซึ่งมีแนวโน้มที่จะนานก่อนที่มันจะเสร็จสมบูรณ์จริง ซึ่งหมายความว่ารุ่นแรกอาจมีข้อผิดพลาด (เนื่องจากFooมีการจำหน่ายเร็วเกินไป) ในขณะที่รุ่นที่สองจะทำงานได้ดี

ถ้าคุณไม่จำเป็นต้องasync(เช่นคุณสามารถกลับมาTaskโดยตรง) asyncแล้วไม่ได้ใช้

มีบางสถานการณ์ที่return awaitมีประโยชน์เช่นถ้าคุณมีการดำเนินการแบบอะซิงโครนัสสองรายการ :

var intermediate = await FirstAsync();
return await SecondAwait(intermediate);

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับasyncประสิทธิภาพดูบทความและวิดีโอMSDNของ Stephen Toub ในหัวข้อ

อัปเดต:ฉันเขียนบทความในบล็อกซึ่งมีรายละเอียดมากกว่านี้

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

อีกกรณีหนึ่งที่คุณอาจต้องรอผลคือ:

async Task<IFoo> GetIFooAsync()
{
    return await GetFooAsync();
}

async Task<Foo> GetFooAsync()
{
    var foo = await CreateFooAsync();
    await foo.InitializeAsync();
    return foo;
}

ในกรณีนี้GetIFooAsync()จะต้องรอผลจากการGetFooAsyncเพราะชนิดของTความแตกต่างกันระหว่างสองวิธีการและไม่ได้มอบหมายโดยตรงกับTask<Foo> Task<IFoo>แต่ถ้าคุณรอผลที่ได้มันก็จะกลายเป็นFooซึ่งเป็นIFooมอบหมายโดยตรงกับ จากนั้นวิธีการ async จะทำการบรรจุผลลัพธ์ภายในTask<IFoo>และออกไป

การทำให้วิธี "thunk" เป็นอย่างอื่นง่าย ๆ async สร้างเครื่องสถานะ async ในหน่วยความจำในขณะที่ไม่ใช่ async หนึ่งไม่ ในขณะที่สามารถชี้คนที่ใช้รุ่นที่ไม่ใช่แบบอะซิงก์ได้เนื่องจากมีประสิทธิภาพมากกว่า (ซึ่งเป็นจริง) แต่ก็หมายความว่าในกรณีที่เกิดการแฮงค์คุณไม่มีหลักฐานว่าวิธีการนั้นมีส่วนเกี่ยวข้องใน ซึ่งบางครั้งทำให้ยากที่จะเข้าใจการแขวน

ดังนั้นใช่เมื่อ perf ไม่สำคัญ (และมักจะไม่ใช่) ฉันจะโยน async ในวิธีการอันธพาลเหล่านี้ทั้งหมดเพื่อให้ฉันมีเครื่องสถานะ async เพื่อช่วยฉันในการวินิจฉัยแฮงค์ในภายหลังและเพื่อช่วยให้แน่ใจว่าหาก วิธีการ thunk พัฒนาตลอดเวลาพวกเขาจะต้องกลับงานที่ผิดพลาดแทนที่จะโยน

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

เมื่อคุณกลับงานวิธีการบรรลุวัตถุประสงค์และออกจากสแตกการโทร เมื่อคุณใช้return awaitคุณจะทิ้งมันไว้ใน call stack

ตัวอย่างเช่น:

Call stack เมื่อใช้ await: A กำลังรองานจาก B => B กำลังรองานจาก C

Call stack เมื่อไม่ได้ใช้งานกำลังรอ: A กำลังรองานจาก C ซึ่ง B ได้กลับมา

สิ่งนี้ทำให้ฉันสับสนและฉันรู้สึกว่าคำตอบก่อนหน้านี้มองข้ามคำถามที่แท้จริงของคุณ:

เหตุใดจึงต้องใช้ return รอโครงสร้างเมื่อคุณสามารถส่งคืนงานโดยตรงจากการเรียก DoAnotherThingAsync () ภายใน?

บางครั้งคุณต้องการ a จริงๆTask<SomeType>แต่ส่วนใหญ่เวลาที่คุณต้องการตัวอย่างSomeTypeนั่นคือผลลัพธ์จากภารกิจ

จากรหัสของคุณ:

async Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return await foo.DoAnotherThingAsync();
    }
}

คนที่ไม่คุ้นเคยกับไวยากรณ์ (ผมเป็นต้น) อาจจะคิดว่าวิธีนี้ควรกลับTask<SomeResult>แต่เนื่องจากมันถูกทำเครื่องหมายด้วยก็หมายความว่าประเภทผลตอบแทนที่เกิดขึ้นจริงasync SomeResultหากคุณเพิ่งใช้return foo.DoAnotherThingAsync()คุณจะต้องส่งคืนภารกิจซึ่งจะไม่รวบรวม return awaitวิธีที่ถูกต้องคือการกลับผลของงานดังนั้น