async & await - polling untuk alternatif [ditutup]

Sekarang kita tahu apa yang tersedia untuk c # 5, tampaknya masih ada celah bagi kita untuk memengaruhi pilihan dua kata kunci baru untuk ' Asynchrony ' yang diumumkan oleh Anders Heijsberg kemarin di 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 memiliki penjelasan tentang pilihan dua kata kunci saat ini, dan cara mereka salah mengerti dalam studi kegunaan. Komentar memiliki beberapa proposisi lain.

Tolong - satu saran per jawaban, duplikat akan dihapus.

Mengingat bahwa saya tidak jelas tentang arti / keperluan async, saya tidak bisa benar-benar membantahnya, tetapi saran terbaik saya untuk mengganti awaitadalah:

yield while (lihat! tidak ada kata kunci baru)

Catatan setelah memikirkan hal ini sedikit lebih banyak, saya bertanya-tanya apakah menggunakan kembaliwhile cara ini adalah ide yang baik - kecenderungan alami akan mengharapkan boolean sesudahnya.

(Berpikir: menemukan kata kunci yang baik seperti mencari nama domain yang bagus :)

Bagaimana kalau tidak memiliki kata kunci?

Saya ingin kompiler menyadari bahwa, sebagian besar waktu, ketika saya memanggil metode asinkron, saya ingin hasilnya.

Document doc = DownloadDocumentAsync();

Itu dia. Alasan orang mengalami kesulitan memikirkan kata kunci untuk hal ini adalah karena itu seperti memiliki kata kunci untuk "lakukan hal yang akan Anda lakukan jika semuanya normal". Itu harus menjadi default, tidak memerlukan kata kunci.

Memperbarui

Saya awalnya menyarankan kompiler harus pintar dengan inferensi tipe untuk mencari tahu apa yang harus dilakukan. Berpikir lebih jauh tentang ini, saya akan menjaga implementasi yang ada di CTP seperti apa adanya, tetapi membuat beberapa tambahan sepele untuk itu, sehingga untuk mengurangi kasus di mana Anda harus menggunakan awaitkata kunci secara eksplisit.

Kami menciptakan sebuah atribut: [AutoAwait]. Ini hanya dapat diterapkan pada metode. Salah satu cara untuk menerapkan ini pada metode Anda adalah menandainya async. Tetapi Anda juga bisa melakukannya dengan tangan, misalnya:

[AutoAwait]
public Task<Document> DownloadDocumentAsync()

Kemudian di dalam asyncmetode apa pun , kompiler akan menganggap Anda ingin menunggu panggilan DownloadDocumentAsync, jadi Anda tidak perlu menentukannya. Panggilan apa pun ke metode itu akan secara otomatis menunggunya.

Document doc = DownloadDocumentAsync();

Sekarang, jika Anda ingin "menjadi pintar" dan memperoleh Task<Document>, Anda menggunakan operator start, yang hanya dapat muncul sebelum pemanggilan metode:

Task<Document> task = start DownloadDocumentAsync();

Rapi, saya pikir. Sekarang pemanggilan metode biasa berarti apa yang biasanya artinya: tunggu sampai metode selesai. Danstart menunjukkan sesuatu yang berbeda: jangan menunggu.

Untuk kode yang muncul di luar asyncmetode, satu-satunya cara Anda diizinkan memanggil [AutoAwait]metode adalah dengan mengawali dengan metode tersebut start. Ini memaksa Anda untuk menulis kode yang memiliki arti yang sama terlepas dari apakah kode itu muncul dalamasync metode atau tidak.

Lalu saya mulai menjadi serakah! :)

Pertama, saya ingin asyncmenerapkan metode antarmuka:

interface IThing
{
    async int GetCount();
} 

Ini pada dasarnya berarti bahwa metode implementasi harus kembali Task<int>atau sesuatu yang kompatibel dengan await, dan penelepon ke metode tersebut akan mendapatkan [AutoAwait]perilaku.

Juga ketika saya menerapkan metode di atas, saya ingin dapat menulis:

async int GetCount()

Jadi saya tidak perlu menyebutkan Task<int> sebagai tipe pengembalian.

Juga, saya ingin asyncmenerapkan tipe delegasi (yang, bagaimanapun juga, seperti antarmuka dengan satu metode). Begitu:

public async delegate TResult AsyncFunc<TResult>();

Seorang asyncdelegasi memiliki - Anda dapat menebaknya - [AutoAwait]perilaku. Dari suatu asyncmetode Anda dapat memanggilnya dan itu akan secara otomatis awaitdiedit (kecuali jika Anda memilih untuk melakukannya saja start). Jadi jika Anda mengatakan:

AsyncFunc<Document> getDoc = DownloadDocumentAsync;

Itu hanya berfungsi. Ini bukan panggilan metode. Belum ada tugas yang dimulai - dan async delegatebukan tugas. Ini pabrik untuk membuat tugas. Anda bisa mengatakan:

Document doc = getDoc();

Dan itu akan memulai tugas dan menunggu sampai selesai dan memberi Anda hasilnya. Atau Anda bisa mengatakan:

Task<Document> t = start getDoc();

Jadi satu tempat di mana "pipa ledeng" bocor adalah bahwa jika Anda ingin membuat delegasi ke suatu asyncmetode, Anda harus tahu untuk menggunakan suatu async delegatetipe. Jadi, bukannya FuncAnda harus mengatakanAsyncFunc , dan seterusnya. Meskipun suatu hari hal semacam itu mungkin diperbaiki oleh inferensi tipe yang ditingkatkan.

Pertanyaan lain adalah apa yang harus terjadi jika Anda mengatakan mulai dengan metode biasa (non-async). Jelas kesalahan kompilasi akan menjadi opsi yang aman. Tetapi ada kemungkinan lain.

hearken unto AsyncFetch(…)

(jika Anda tidak mengerti, baca entri blog Eric . Setidaknya lebih baik daripada for sooth Romeo wherefore art thou AsyncFetch(…))

Saya pikir asyncbaik-baik saja, tapi mungkin itu karena saya mengasosiasikannya dengan halaman ASP.NET async - ide yang sama.

Untuk await kata kunci yang saya suka continue afteratau resume after.

Saya tidak suka yieldatau salah satu variannya, karena semantiknya sedemikian rupa sehingga metodenya mungkin tidak pernah benar-benar menghasilkan eksekusi; itu tergantung pada keadaan tugas.

Saya menambahkan komentar di blog Eric juga, saya tidak melihat masalah dengan menggunakan kata kunci yang sama async

var data = async DownloadFileAsync(url);

Saya hanya menyatakan bahwa saya ingin mengunduh file secara tidak sinkron. Ada sedikit redundensi di sini, "async" muncul dua kali, karena itu ada dalam nama metode juga. Compiler dapat menjadi lebih pintar dan mendeteksi konvensi bahwa metode yang diakhiri dengan "Async" adalah metode async yang benar, dan menambahkannya bagi kita dalam kode yang dikompilasi. Jadi, alih-alih Anda mungkin hanya ingin menelepon

var data = async DownloadFile(url);

sebagai lawan memanggil yang sinkron

var data = DownloadFile(url);

Heck, kita juga harus dapat mendefinisikannya dengan cara yang sama, karena kata kunci async ada dalam deklarasi kita, mengapa kita harus menambahkan "Async" secara manual ke setiap nama metode - kompilator dapat melakukannya untuk kita.

async = tugas - Memodifikasi fungsi untuk mengembalikan tugas, jadi mengapa tidak menggunakan kata kunci "tugas"?

await = finish - Kami tidak perlu menunggu, tetapi tugas harus "selesai" sebelum menggunakan hasilnya.

Saya suka yield until. yield while, sudah disarankan, bagus dan tidak memperkenalkan kata kunci baru, tapi saya pikir "sampai" menangkap perilaku sedikit lebih baik.

Saya pikir yield <something>ini adalah ide yang hebat, karena hasil sudah menangkap ide membuat sisa metode ini menjadi kelanjutan yang sangat baik. Mungkin seseorang bisa memikirkan kata yang lebih baik daripada "sampai."

Saya hanya ingin mendaftarkan suara saya untuk saran Aaron G tentang comefrom- penggunaan yang tepat pertama yang saya lihat dari pernyataan COMEFROM INTERCAL . Idenya adalah bahwa itu kebalikan dari GOTO (melompat dari pernyataan GOTO) karena membuat beberapa tempat dalam kode Anda melompat ke pernyataan COMEFROM.

Karena kita berurusan dengan Task<T>s, bagaimana menggunakan startkata kunci sebelum pernyataan, seperti pada:

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

Perlu dicatat bahwa F # juga menggunakan asynckata kunci dalam alur kerja async-nya, yang hampir sama persis dengan fungsi async baru di C # 5. Karena itu, saya akan menjaga yang sama

Untuk awaitkata kunci dalam F #, mereka hanya menggunakan let!bukan let. C # tidak memiliki sintaks tugas yang sama, sehingga mereka membutuhkan sesuatu di sisi kanan =tanda. Seperti yang dikatakan Benjol, fungsinya sama yieldsehingga hampir menjadi varian dari itu.

yield async FetchAsync(..)

Ini berjalan sempurna dengan asyncpengubah yang Anda butuhkan pada metode yang Anda minta. Dan juga semantik dari saat yield returnini, Anda kembali dan menghasilkan eksekusi ke kode penghitungan sementara dalam hal ini Anda menghasilkan eksekusi Anda ke metode asinkron.

Bayangkan jika di masa depan akan ada kegunaan lain untuk yield, kita bisa menambahkan di yield xmana x adalah fitur baru yang mengkilap alih-alih memiliki semua kata kunci yang berbeda untuk melakukan sebagian besar hal yang sama, menghasilkan eksekusi.

Terus terang, saya tidak begitu mengerti argumen 'tidak menghasilkan eksekusi'. Lagi pula, bukankah titik memanggil metode lain sudah untuk 'menghasilkan eksekusi' ke metode itu? Terlepas dari apakah itu asinkron atau tidak? Saya saya kehilangan sesuatu di sini?

Dan bagus untuk Anda jika asyncpengembaliannya sinkron tetapi memiliki kata kunci di sana harus menandakan bahwa ada kemungkinan metode tersebut akan berjalan secara tidak sinkron dan Anda akan menghasilkan eksekusi ke metode lain. Metode Anda harus menjelaskan hal itu terlepas dari apakah metode itu benar-benar melakukan panggilan tidak sinkron atau tidak.

IMO Saya pikir berbagai kasus 'tidak menghasilkan' adalah detail implementasi. Saya lebih suka menjamin konsistensi dalam bahasa (yaitu menggunakan kembali yield).

Bagaimana complete, seperti dalam "Saya ingin tugas selesai"?

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

task(untuk deklarasi metode) dan async(dalam tubuh metode)