มีระเบียบการตั้งชื่อที่ชัดเจนสำหรับวิธีการส่งคืน IAsyncEnumerable หรือไม่

หลังจาก C # 5 แนะนำasyncและawaitโมเดลสำหรับการโปรแกรมแบบอะซิงโครนัสชุมชน C # มาถึงการประชุมการตั้งชื่อเพื่อเพิ่มคำต่อท้าย "Async" ลงในเมธอดที่ส่งคืนชนิดที่ไม่ต้องรอคอยเช่นนี้

interface Foo
{
   Task BarAsync();
}

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

ตอนนี้ C # 8 ได้นำเสนอแนวคิดของการแจกแจงแบบอะซิงโครนัสซึ่งตัวเองไม่สามารถรอได้ แต่สามารถใช้ร่วมกับawait foreachดูเหมือนว่ามีสองตัวเลือกสำหรับวิธีการตั้งชื่อที่ส่งคืนIAsyncEnumerable:

interface Foo
{
    // No "Async" suffix, indicating that the return value is not awaitable.
    IAsyncEnumerable<T> Bar<T>();
}

หรือ

interface Foo
{
    // With "Async" suffix, indicating that the overall logic is asynchronous.
    IAsyncEnumerable<T> BarAsync<T>();
}

มีแนวทางการตั้งชื่อที่ชัดเจน (จากทีมภาษา C #,. NET Foundation หรือหน่วยงานอื่น ๆ ) เกี่ยวกับตัวเลือกข้างต้นเช่นวิธีการตั้งชื่อการประชุม C # 5 เป็นมาตรฐานที่ชัดเจนและไม่ถูกตัดสินตามความเห็นของโปรแกรมเมอร์?

ไม่มีแนวทางที่ดีไปกว่าสิ่งที่ทีมงาน. NET ทำอยู่แล้ว :

• ChannelReader.ReadAllAsyncส่งกลับค่าIAsyncEnumerable<T>
• ใน EF Core 3 ผลลัพธ์จะถูกส่งคืนIAsyncEnumerableโดยการเรียกAsAsyncEnumerable ()
• ใน System.Linq.Async, ToAsyncEnumerable ()จะแปลง IEnumerables, Tasks และ Observables ให้เป็นIAsyncEnumerables
• ผู้ประกอบการอื่น ๆ ทั้งหมดในการSystem.Linq.Asyncรักษาชื่อของพวกเขา ไม่มีSelectAsyncหรือเพียงSelectAsAsyncEnumerableSelect

ในทุกกรณีมันชัดเจนว่าผลลัพธ์ของวิธีการคืออะไร ในทุกกรณีผลลัพธ์ของวิธีการนั้นต้องรอawait foreachก่อนจึงจะสามารถใช้งานได้

ดังนั้นแนวทางที่แท้จริงยังคงเหมือนเดิม - ให้แน่ใจว่าชื่อทำให้พฤติกรรมชัดเจน :

• เมื่อชื่อชัดเจนแล้วเช่นกับAsAsyncEnumerable()หรือToAsyncEnumerable()ไม่จำเป็นต้องเพิ่มคำต่อท้ายใด ๆ
• ในกรณีอื่น ๆ ให้เพิ่มAsyncคำต่อท้ายเพื่อให้นักพัฒนาทราบว่าพวกเขาต้องการawait foreachผลลัพธ์

เครื่องวิเคราะห์รหัสและเครื่องกำเนิดไฟฟ้าไม่สนใจชื่อวิธีการตรวจจับกลิ่นโดยการตรวจสอบรหัสเอง วิเคราะห์รหัสจะบอกคุณว่าคุณลืมที่จะรองานหรือไม่ว่าคุณจะเรียกวิธีการและตัวแปร เครื่องกำเนิดไฟฟ้าสามารถใช้การสะท้อนเพื่อตรวจสอบและปล่อยawait foreachIAsyncEnumerableIAsyncEnumerableawait foreach

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

และแน่นอนว่าทุกคนรู้ว่าคำนำหน้าทั่วไปสำหรับเขตข้อมูลอินสแตนซ์ส่วนตัวคือ_:)

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

ฉันคิดว่าชื่อที่ส่งคืนตามปกติมีความเหมาะสม GetFoos () หรือคล้ายกัน

Asyncต่อท้ายและแม้กระทั่งคำหลักasyncเป็นเพียงสำเร็จรูปมันไม่มีความหมายนอกเหนือจากข้อโต้แย้งความเข้ากันได้ย้อนหลังบางอย่าง C # มีข้อมูลทั้งหมดเพื่อแยกฟังก์ชั่นเหล่านั้นเช่นเดียวกับที่แตกต่างกันyieldในวิธีการที่กลับมาIEnumerableเพราะคุณรู้ว่าคุณไม่จำเป็นต้องเพิ่มอะไรเช่นenumerableหรือคำหลักอื่น ๆ ในวิธีการดังกล่าว

คุณต้องเพิ่มคำต่อท้ายAsyncเพียงเพราะ C # จะบ่นเกี่ยวกับการโอเวอร์โหลดดังนั้นโดยพื้นฐานแล้วทั้งสองนั้นเหมือนกันและพวกเขาทำสิ่งเดียวกันโดยกฎทั้งหมดของความแตกต่าง

public interface IMyContract
{
    Task<int> Add(int a, int b);
    int Add(int a, int b);
}

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

public interface IMyContract : IEnumerable<int>, IEnumerable<long>
{
}

และแม้กระทั่งสิ่งนี้:

public interface IMyContractAsync
{
    Task<int> Add(int a, int b);
}

public interface IMyContract : IMyContractAsync
{
    int Add(int a, int b);
}

ดังนั้นนี่คือมัน คุณเพิ่มAsyncเพียงเพื่อหยุดคอมไพเลอร์ให้บ่น ไม่ต้องอธิบายให้ชัดเจน ไม่ทำให้ดีขึ้น ถ้าไม่มีบ่น - Task<IAsyncEnumerable>ไม่มีเหตุผลที่จะเพิ่มมันดังนั้นในกรณีของคุณผมจะหลีกเลี่ยงปัญหานี้เว้นแต่มันจะกลายเป็น

PS:เพียงแค่ดีขึ้นของการทำความเข้าใจของภาพทั้งหมดที่นี่ - ถ้าบางครั้งในคนเพิ่มในอนาคตใน C นามสกุลวิธี # ควอนตัมคอมพิวเตอร์ (fantazy ฮะ) ซึ่งจะดำเนินการในกระบวนทัศน์ที่แตกต่างกันเราอาจจะต้องต่อท้ายอีกเช่นควอนท์หรืออะไรเพราะ C # จะบ่นเป็นอย่างอื่น มันจะเป็นวิธีการเดียวกันแน่นอน แต่มันจะทำงานอีกวิธีหนึ่ง เช่นเดียวกับความหลากหลายที่ทำ เหมือนอินเทอร์เฟซทำ