Apakah ada konvensi penamaan yang pasti untuk metode pengembalian IAsyncEnumerable?

Setelah C # 5 memperkenalkan asyncdan awaitmemodelkan untuk pemrograman asinkron, komunitas C # tiba pada konvensi penamaan untuk menambahkan akhiran "Async" ke metode yang mengembalikan tipe yang ditunggu, seperti ini:

interface Foo
{
   Task BarAsync();
}

Banyak penganalisa kode statis (baik berbasis Roslyn dan non-Roslyn) sejak itu ditulis bergantung pada konvensi penamaan ini ketika mendeteksi bau kode di sekitar pemrograman asinkron.

Sekarang C # 8 telah memperkenalkan konsep enumerables asynchronous, yang sendiri tidak dapat ditunggu tetapi dapat digunakan bersamaan await foreach, tampaknya ada dua opsi untuk metode penamaan yang kembali IAsyncEnumerable:

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

atau

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

Apakah ada pedoman konvensi penamaan yang definitif (dari tim bahasa C #, .NET Foundation, atau pihak berwenang lainnya) mengenai opsi di atas, seperti bagaimana konvensi penamaan C # 5 distandarisasi dengan jelas dan tidak diserahkan kepada penilaian programmer berdasarkan pendapat?

Tidak ada pedoman yang lebih baik daripada apa yang sudah dilakukan oleh tim .NET :

• ChannelReader.ReadAllAsync mengembalikan sebuahIAsyncEnumerable<T>
• Di EF Core 3, hasilnya dikembalikan sebagai IAsyncEnumerabledengan memanggil AsAsyncEnumerable ()
• Dalam System.Linq.Async, ToAsyncEnumerable () mengkonversi IEnumerables, Tugas dan diamati dalam IAsyncEnumerables
• Semua operator lain System.Linq.Asyncmempertahankan nama mereka. Tidak ada SelectAsyncatau SelectAsAsyncEnumerable, adil Select.

Dalam semua kasus, jelas apa hasil dari metode ini. Dalam semua kasus, hasil dari metode harus ditunggu await foreachsebelum mereka dapat digunakan.

Jadi pedoman sebenarnya tetap sama - pastikan namanya membuat perilaku jelas :

• Ketika nama sudah jelas, misalnya dengan AsAsyncEnumerable()atau ToAsyncEnumerable(), tidak perlu menambahkan akhiran apa pun.
• Dalam kasus lain, tambahkan Asyncakhiran agar pengembang tahu mereka perlu await foreachhasilnya.

Penganalisa kode dan generator tidak terlalu peduli dengan nama metode, mereka mendeteksi bau dengan memeriksa kode itu sendiri. Sebuah analisa kode akan memberitahu Anda bahwa Anda lupa untuk menunggu Tugas atau await foreachsebuah IAsyncEnumerabletidak peduli bagaimana Anda memanggil metode dan variabel. Generator cukup menggunakan refleksi untuk memeriksa IAsyncEnumerabledan memancarkanawait foreach

Ini adalah gaya analisis yang memeriksa nama-nama. Tugas mereka adalah memastikan kode menggunakan gaya yang konsisten sehingga pengembang dapat memahami kode tersebut. Penganalisis gaya akan memberi tahu Anda bahwa suatu metode tidak mengikuti gaya yang Anda pilih. Gaya itu bisa menjadi panduan gaya tim atau yang umum diterima.

Dan tentu saja, semua orang tahu awalan umum untuk bidang instance pribadi adalah _:)

Ini bukan metode async, jadi nama tidak boleh diakhiri dengan 'Async'. Suffix metode itu adalah konvensi untuk memperjelas bahwa metode itu harus ditunggu, atau hasilnya ditangani sebagai Tugas.

Saya pikir nama yang mengembalikan koleksi normal adalah tepat. GetFoos (), atau serupa.

Async suffix dan bahkan kata kunci asynchanya boilerplate, tidak ada artinya selain beberapa argumen keterbelakangan. C # memiliki semua informasi untuk membedakan fungsi-fungsi itu sama seperti perbedaan yielddalam metode yang kembali IEnumerable, karena Anda tahu Anda tidak perlu menambahkan sesuatu seperti enumerableatau beberapa kata kunci lain pada metode tersebut.

Anda perlu menambahkan akhiran Async hanya karena C # akan mengeluh tentang kelebihan, jadi pada dasarnya keduanya sama dan mereka melakukan hal yang sama dengan semua aturan polimorfisme (jika kita tidak memperhitungkan faktor manusia dari perilaku yang merusak secara intenasional):

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

Tetapi Anda tidak dapat menulisnya seperti ini karena kompilator akan mengeluh. Tapi hey! Ini akan menelan monstrositas yang satu ini:

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

dan bahkan ini:

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

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

Jadi ini dia. Anda menambahkan Async hanya untuk menghentikan kompiler untuk mengeluh. Bukan untuk mengklarifikasi hal-hal. Bukan untuk membuat mereka lebih baik. Jika tidak ada keluhan - tidak ada alasan untuk menambahkannya, maka dalam kasus Anda, saya akan menghindari ini, kecuali jika itu terjadi Task<IAsyncEnumerable>.

PS: Hanya untuk lebih memahami seluruh gambar di sini - jika suatu saat nanti seseorang menambahkan ekstensi metode komputer C # (fantazy, huh) yang akan beroperasi dalam paradigma yang berbeda, kita mungkin akan membutuhkan akhiran lain seperti Quant atau sesuatu, karena C # akan mengeluh sebaliknya. Ini akan menjadi metode yang sama persis tetapi itu akan bekerja dengan cara lain. Seperti halnya polimorfisme. Sama seperti antarmuka lakukan.