ทำไมคุณจะ 'รอ' วิธีการแล้วถามค่าส่งคืนทันที

ในบทความ MSDN นี้มีการให้รหัสตัวอย่างต่อไปนี้ (แก้ไขเล็กน้อยเพื่อความกะทัดรัด):

public async Task<ActionResult> Details(int? id)
{
    if (id == null)
    {
        return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
    }

    Department department = await db.Departments.FindAsync(id);

    if (department == null)
    {
        return HttpNotFound();
    }

    return View(department);
}

FindAsyncวิธีการดึงDepartmentวัตถุโดยใช้ ID Task<Department>ของตนและผลตอบแทน จากนั้นแผนกจะถูกตรวจสอบทันทีเพื่อดูว่าเป็นโมฆะหรือไม่ ตามที่ฉันเข้าใจแล้วการขอค่าของภารกิจในลักษณะนี้จะบล็อกการเรียกใช้โค้ดจนกว่าจะส่งคืนค่าจากเมธอดที่รอคอยซึ่งส่งคืนการโทรแบบซิงโครนัสอย่างมีประสิทธิภาพ

ทำไมคุณถึงทำเช่นนี้? มันจะง่ายกว่าFind(id)ไหมถ้าจะเรียกวิธีการซิงโครนัสถ้าคุณจะบล็อกทันทีล่ะ?

ตามที่ฉันเข้าใจแล้วการขอค่าของงานในลักษณะนี้จะบล็อกการเรียกใช้โค้ดจนกว่าจะส่งคืนค่าจากวิธีที่รอการตอบกลับทำให้การโทรแบบซิงโครนัสมีประสิทธิภาพ

ไม่มาก

เมื่อคุณเรียกawait db.Departments.FindAsync(id)ใช้งานจะถูกส่งออกและเธรดปัจจุบันจะถูกส่งกลับไปยังพูลเพื่อใช้งานโดยการดำเนินการอื่น การไหลของการดำเนินการถูกปิดกั้น (ตามที่มันจะไม่คำนึงถึงการใช้งานdepartmentทันทีถ้าฉันเข้าใจสิ่งต่าง ๆ ได้อย่างถูกต้อง) แต่สิ่งอื่น ๆ ด้ายตัวเองมีอิสระที่จะใช้ในขณะที่คุณรอการดำเนินการจะเสร็จสมบูรณ์ปิดเครื่อง (และ ส่งสัญญาณโดยเหตุการณ์หรือพอร์ตเสร็จสิ้น)

ถ้าคุณเรียกd.Departments.Find(id)ใช้เธรดจะนั่งที่นั่นและรอการตอบกลับแม้ว่าการประมวลผลส่วนใหญ่จะทำบนฐานข้อมูล

คุณกำลังเพิ่มทรัพยากร CPU อย่างมีประสิทธิภาพเมื่อดิสก์ถูกผูกไว้

ฉันเกลียดที่ไม่มีตัวอย่างใดแสดงว่าเป็นไปได้ที่จะรอสองสามบรรทัดก่อนที่จะรองาน พิจารณาสิ่งนี้.

Foo foo = await getFoo();
Bar bar = await getBar();

Console.WriteLine(“Do some other stuff to prepare.”);

doStuff(foo, bar);

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

Task<Foo> foo = getFoo();
Task<Bar> bar = getBar();

Console.WriteLine(“Do some other stuff to prepare.”);

doStuff(await foo, await bar);

ตอนนี้ด้วยรหัสที่เขียนใหม่เราจะไม่หยุดและรอค่าของเราจนกว่าเราจะต้องทำ ฉันมักจะมองหาโอกาสประเภทนี้อยู่เสมอ ความฉลาดหลักแหลมเมื่อเรารอคอยอาจนำไปสู่การปรับปรุงประสิทธิภาพที่สำคัญ เรามีหลายแกนวันนี้และอาจใช้พวกเขา

ดังนั้นจึงมีสิ่งอื่น ๆ อีกมากมายที่เกิดขึ้นเบื้องหลังที่นี่ Async / Await เป็นน้ำตาลประโยค อันดับแรกดูที่ลายเซ็นของฟังก์ชัน FindAsync ส่งคืนภารกิจ เมื่อคุณเห็นความมหัศจรรย์ของคำหลักแล้วจะเป็นการลบงานนั้นออกจากแผนก

ฟังก์ชั่นการโทรไม่ปิดกั้น สิ่งที่เกิดขึ้นคือการมอบหมายให้แผนกและทุกอย่างที่ทำตามคำหลักที่รอคอยได้รับการปิดกล่องและสำหรับทุกเจตนาและวัตถุประสงค์ที่ส่งผ่านไปยังวิธีการ Task.ContinueWith วิธี (ฟังก์ชั่น FindAsync จะดำเนินการโดยอัตโนมัติ

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

ดังนั้นสิ่งที่เกิดขึ้นคือคุณได้รับความมหัศจรรย์ของการปฏิบัติการ Async โดยไม่มีข้อผิดพลาด

ไม่มันไม่กลับมาทันที การรอคอยทำให้การเรียกเมธอดไม่ตรงกัน เมื่อ FindAsync มีการเรียกใช้วิธีการรายละเอียดจะกลับมาพร้อมกับงานที่ยังไม่เสร็จสิ้น เมื่อ FindAsync เสร็จสิ้นก็จะส่งกลับผลลัพธ์ไปยังตัวแปรแผนกและดำเนินการส่วนที่เหลือของวิธีรายละเอียด

ฉันชอบคิดว่า "async" เหมือนสัญญาสัญญาที่ระบุว่า "ฉันสามารถดำเนินการแบบอะซิงโครนัสได้หากคุณต้องการ แต่คุณสามารถโทรหาฉันเหมือนฟังก์ชั่นซิงโครนัสอื่น ๆ ได้"

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

Task<Department> deptTask = db.Departments.FindAsync(id);

และหลังจากนั้นพูดว่า 10 บรรทัดลงฟังก์ชั่นที่คุณโทร

Department d = await deptTask;

ดังนั้นการปฏิบัติมันเป็นฟังก์ชั่นไม่ตรงกัน

มันขึ้นอยู่กับคุณ.

"ถ้าคุณจะบล็อกทันที" anwser คือ "ใช่" เฉพาะเมื่อคุณต้องการการตอบสนองที่รวดเร็วรอ / ทำให้ตรงกัน ตัวอย่างเช่นเธรด UI มาเป็นวิธีการแบบอะซิงโครนัสเธรด UI จะกลับมาและรับฟังการคลิกปุ่มต่อไปในขณะที่โค้ดด้านล่าง "รอ" จะถูกเปิดใช้งานโดยเธรดอื่น ๆ และสุดท้ายจะได้ผลลัพธ์