async & คอย - สำรวจทางเลือก [ปิด]

ตอนนี้เรารู้ว่าสิ่งที่อยู่ในร้านสำหรับ C # 5 มีเห็นได้ชัดว่ายังคงเปิดสำหรับเราที่จะมีอิทธิพลต่อทางเลือกของสองคำใหม่สำหรับสasynchrony 'ที่ได้รับการประกาศโดย Anders Heijsberg เมื่อวานนี้ที่PDC10

async void ArchiveDocuments(List<Url> urls) {
    Task archive = null;
    for(int i = 0; i < urls.Count; ++i) {
        var document = await FetchAsync(urls[i]);
        if (archive != null)
            await archive;
        archive = ArchiveAsync(document);
    }
}

Eric Lippertมีคำอธิบายเกี่ยวกับการเลือกคำหลักสองคำในปัจจุบันและวิธีการที่พวกเขาเข้าใจผิดในการศึกษาการใช้งาน ความคิดเห็นมีข้อเสนออื่น ๆ

กรุณา - หนึ่งข้อเสนอแนะต่อคำตอบที่ซ้ำกันจะได้รับการอบ

เนื่องจากฉันไม่ชัดเจนเกี่ยวกับความหมาย / ความจำเป็นasyncฉันไม่สามารถโต้เถียงกับมันได้จริง ๆ แต่ข้อเสนอแนะที่ดีที่สุดสำหรับการเปลี่ยนawaitคือ:

yield while (ดู! ไม่มีคำหลักใหม่)

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

(คิดว่า: การค้นหาคำหลักที่ดีเป็นเหมือนการค้นหาชื่อโดเมนที่ดี :)

ถ้าไม่มีคำหลักล่ะ?

ฉันต้องการให้คอมไพเลอร์ตระหนักว่าส่วนใหญ่เวลาที่ฉันเรียกใช้วิธีการแบบอะซิงโครนัสฉันต้องการผลลัพธ์ของมัน

Document doc = DownloadDocumentAsync();

แค่นั้นแหละ. สาเหตุที่ผู้คนกำลังคิดหนักใจกับคำหลักสำหรับสิ่งนี้เพราะมันเหมือนมีคำหลักสำหรับ "ทำสิ่งที่คุณทำถ้าสิ่งต่าง ๆ เป็นปกติอย่างสมบูรณ์" นั่นควรเป็นค่าเริ่มต้นไม่จำเป็นต้องมีคำหลัก

ปรับปรุง

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

[AutoAwait]เราคิดค้นแอตทริบิวต์: สิ่งนี้สามารถใช้ได้กับวิธีการเท่านั้น asyncวิธีหนึ่งที่จะได้รับนี้นำไปใช้กับวิธีการของคุณคือการทำเครื่องหมาย แต่คุณสามารถทำได้ด้วยมือเช่น:

[AutoAwait]
public Task<Document> DownloadDocumentAsync()

จากนั้นภายในasyncวิธีการใด ๆคอมไพเลอร์จะถือว่าคุณต้องการรอการโทรถึงDownloadDocumentAsyncดังนั้นคุณไม่จำเป็นต้องระบุ การเรียกใช้วิธีการนั้นจะรอโดยอัตโนมัติ

Document doc = DownloadDocumentAsync();

ตอนนี้ถ้าคุณต้องการ "รับความฉลาด" และรับสิ่งTask<Document>นั้นคุณต้องใช้โอเปอเรเตอร์startซึ่งสามารถปรากฏได้ก่อนการเรียกใช้เมธอด:

Task<Document> task = start DownloadDocumentAsync();

ฉันคิดว่าเรียบร้อย ตอนนี้การเรียกใช้เมธอดธรรมดาหมายถึงความหมาย: รอวิธีการให้เสร็จสมบูรณ์ และstartบ่งบอกถึงสิ่งที่แตกต่าง: ไม่ต้องรอ

สำหรับรหัสที่ปรากฏอยู่นอกasyncเมธอดวิธีเดียวที่คุณได้รับอนุญาตให้เรียกใช้[AutoAwait]เมธอดคือโดยนำหน้าด้วยstartวิธีนั้น นี่เป็นการบังคับให้คุณเขียนโค้ดที่มีความหมายเหมือนกันไม่ว่าจะปรากฏในasyncวิธีการหรือไม่ก็ตาม

จากนั้นฉันก็เริ่มที่จะโลภ! :)

ประการแรกฉันต้องการasyncนำไปใช้กับวิธีการเชื่อมต่อ:

interface IThing
{
    async int GetCount();
} 

โดยทั่วไปหมายความว่าวิธีการใช้งานจะต้องส่งคืนTask<int>หรือสิ่งที่เข้ากันได้กับawaitและผู้โทรไปที่วิธีการจะได้รับ[AutoAwait]พฤติกรรม

นอกจากนี้เมื่อฉันใช้วิธีการข้างต้นฉันต้องการที่จะสามารถเขียน:

async int GetCount()

ดังนั้นฉันไม่ต้องพูดถึงTask<int>ว่าเป็นประเภทส่งคืน

นอกจากนี้ฉันต้องการasyncนำไปใช้กับประเภทผู้ได้รับมอบหมาย (ซึ่งหลังจากทั้งหมดเป็นเหมือนอินเทอร์เฟซที่มีวิธีการเดียว) ดังนั้น:

public async delegate TResult AsyncFunc<TResult>();

asyncผู้ร่วมประชุมมี - คุณ guessed มัน - [AutoAwait]พฤติกรรม จากasyncวิธีการที่คุณสามารถเรียกมันและมันจะถูกawaited โดยอัตโนมัติ(เว้นแต่คุณเลือกที่จะเพียงแค่start) ดังนั้นถ้าคุณพูดว่า:

AsyncFunc<Document> getDoc = DownloadDocumentAsync;

นั่นเป็นเพียงการทำงาน มันไม่ใช่วิธีการโทร ยังไม่มีการเริ่มงานเลย - async delegateไม่ใช่งาน มันเป็นโรงงานสำหรับทำภารกิจ คุณสามารถพูดได้:

Document doc = getDoc();

และนั่นจะเริ่มงานและรอให้งานเสร็จและให้ผลลัพธ์แก่คุณ หรือคุณสามารถพูดว่า:

Task<Document> t = start getDoc();

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

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

hearken unto AsyncFetch(…)

(ถ้าคุณไม่เข้าใจลองอ่านบล็อกของ Eric อย่างน้อยก็ดีกว่าfor sooth Romeo wherefore art thou AsyncFetch(…))

ฉันคิดว่าใช้ได้asyncแต่อาจเป็นเพราะฉันเชื่อมโยงกับเพจ async ASP.NET - แนวคิดเดียวกัน

สำหรับawaitคำหลักที่ฉันชอบหรือcontinue afterresume after

ฉันไม่ชอบyieldหรือรูปแบบใด ๆ ของมันเพราะความหมายเป็นเช่นนั้นวิธีการที่อาจไม่เคยให้การดำเนินการจริง; มันขึ้นอยู่กับสถานะของงาน

ฉันเพิ่มความคิดเห็นในบล็อกของ Eric ด้วยฉันไม่เห็นปัญหาใด ๆ เกี่ยวกับการใช้คำหลักเดียวกัน async

var data = async DownloadFileAsync(url);

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

var data = async DownloadFile(url);

ตรงข้ามกับการเรียกแบบซิงโครนัส

var data = DownloadFile(url);

เฮ้เราก็ควรจะสามารถกำหนดพวกเขาในลักษณะเดียวกันเนื่องจากคำหลัก async มีอยู่ในการประกาศของเราทำไมเราต้องเพิ่ม "Async" ในแต่ละชื่อวิธีด้วยตนเอง - คอมไพเลอร์สามารถทำเพื่อเรา

async = task - มันปรับเปลี่ยนฟังก์ชั่นเพื่อกลับงานดังนั้นทำไมไม่ใช้คำหลัก "งาน"?

await = finish - เราไม่จำเป็นต้องรอ แต่ภารกิจต้อง "เสร็จสิ้น" ก่อนที่จะใช้ผลลัพธ์

yield untilผมชอบ yield whileแนะนำแล้วดีมากและไม่แนะนำคำหลักใหม่ใด ๆ แต่ฉันคิดว่า "จนกระทั่ง" จับภาพพฤติกรรมได้ดีขึ้นเล็กน้อย

ฉันคิดว่าyield <something>เป็นความคิดที่ดีเพราะผลตอบแทนแล้วจับความคิดในการทำให้ส่วนที่เหลือของวิธีการต่อเนื่องเป็นอย่างดี บางทีบางคนอาจนึกถึงคำที่ดีกว่า "จนถึง"

ฉันต้องการลงทะเบียนการโหวตของฉันสำหรับคำแนะนำของ Aaron G comefrom- การใช้งานที่เหมาะสมครั้งแรกที่ฉันได้เห็นคำสั่งCOMEFROMของINTERCAL แนวคิดก็คือมันเป็นสิ่งที่ตรงกันข้ามกับ GOTO (กระโดดออกไปจากคำสั่ง GOTO) ที่ทำให้บางสถานที่ในรหัสของคุณข้ามไปที่คำสั่ง COMEFROM

เนื่องจากเรากำลังติดต่อกับTask<T>s วิธีการใช้startเป็นคำสำคัญที่นำหน้าคำสั่งเช่นเดียวกับใน:

start var document = FetchAsync(urls[i]);

เป็นที่น่าสังเกตว่า F # ยังใช้asyncคำหลักในเวิร์กโฟลว์ของ async ซึ่งเป็นสิ่งที่ค่อนข้างแน่นอนเหมือนกับฟังก์ชั่น async ใหม่ใน C # 5 ดังนั้นฉันจะเก็บมันไว้เหมือนเดิม

สำหรับawaitคำหลักใน F # พวกเขาเพียงแค่ใช้แทนlet! letC # ไม่มีรูปแบบการมอบหมายเดียวกันดังนั้นพวกเขาต้องการบางสิ่งที่ด้านขวาของ=เครื่องหมาย ดังที่ Benjol กล่าวว่ามันทำหน้าที่เหมือนกันyieldดังนั้นมันควรจะเป็นความแตกต่างของสิ่งนั้น

yield async FetchAsync(..)

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

ลองนึกภาพว่าในอนาคตจะมีการใช้งานอื่นyieldเราสามารถเพิ่มyield xตำแหน่งที่ x เป็นคุณลักษณะใหม่ที่เป็นประกายเงางามแทนที่จะมีคำหลักที่แตกต่างกันเหล่านี้ทั้งหมดสำหรับการทำสิ่งเดียวกันโดยส่วนใหญ่เป็นการดำเนินการที่ให้ผลตอบแทน

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

และดีสำหรับคุณถ้าการasyncส่งคืนแบบซิงโครนัส แต่มีคำหลักควรมีความหมายว่ามีโอกาสที่วิธีนั้นจะทำงานแบบอะซิงโครนัสและคุณจะยอมให้มีการดำเนินการกับวิธีอื่น วิธีการของคุณควรคำนึงถึงสิ่งนั้นโดยไม่คำนึงว่าวิธีการโทรแบบอะซิงโครนัสจริงหรือไม่

IMO ฉันคิดว่ากรณีต่างๆที่ 'ไม่ยอม' เป็นรายละเอียดการปฏิบัติ ฉันต้องการรับรองความสอดคล้องในภาษา (เช่นการนำมาใช้ซ้ำyield)

วิธีการเกี่ยวกับcompleteในขณะที่ "ฉันต้องการให้งานเสร็จ"?

Task<byte[]> downloadTask = DownloadFileAsync(url);
byte[] data = complete downloadTask;

task(สำหรับการประกาศเมธอด) และasync(ภายในเมธอดเนื้อหา)