Apa tujuan dari "menunggu kembali" di C #?

Apakah ada setiap skenario di mana menulis metode seperti ini:

public async Task<SomeResult> DoSomethingAsync()
{
    // Some synchronous code might or might not be here... //
    return await DoAnotherThingAsync();
}

alih-alih ini:

public Task<SomeResult> DoSomethingAsync()
{
    // Some synchronous code might or might not be here... //
    return DoAnotherThingAsync();
}

akan masuk akal?

Mengapa menggunakan return awaitkonstruk ketika Anda dapat langsung kembali Task<T>dari DoAnotherThingAsync()doa batin ?

Saya melihat kode dengan return awaitdi banyak tempat, saya pikir saya mungkin melewatkan sesuatu. Tapi sejauh yang saya mengerti, tidak menggunakan kata kunci async / menunggu dalam hal ini dan langsung mengembalikan Tugas akan setara secara fungsional. Mengapa menambahkan overhead tambahan dari awaitlapisan tambahan ?

Ada satu kasus licik ketika returndalam metode normal dan return awaitdalam asyncmetode berperilaku berbeda: ketika dikombinasikan dengan using(atau, lebih umum, apa pun return awaitdalam satu tryblok).

Pertimbangkan dua versi metode ini:

Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return foo.DoAnotherThingAsync();
    }
}

async Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return await foo.DoAnotherThingAsync();
    }
}

Metode pertama akan Dispose()dengan Fooobjek segera setelah DoAnotherThingAsync()kembali metode, yang kemungkinan jauh sebelum benar-benar selesai. Ini berarti versi pertama mungkin buggy (karena Foodibuang terlalu cepat), sedangkan versi kedua akan berfungsi dengan baik.

Jika Anda tidak perlu async(yaitu, Anda dapat mengembalikan Tasklangsung), maka jangan gunakan async.

Ada beberapa situasi di mana return awaitberguna, seperti jika Anda memiliki dua operasi asinkron untuk dilakukan:

var intermediate = await FirstAsync();
return await SecondAwait(intermediate);

Untuk lebih lanjut tentang asynckinerja, lihat artikel MSDN dan video Stephen Toub tentang topik ini.

Pembaruan: Saya telah menulis posting blog yang lebih detail.

Satu-satunya alasan Anda ingin melakukannya adalah jika ada yang lain awaitdalam kode sebelumnya, atau jika Anda dengan cara tertentu memanipulasi hasilnya sebelum mengembalikannya. Cara lain yang mungkin terjadi adalah melalui try/catchperubahan yang mengubah cara pengecualian ditangani. Jika Anda tidak melakukan semua itu maka Anda benar, tidak ada alasan untuk menambahkan biaya tambahan untuk membuat metode async.

Kasus lain yang mungkin perlu Anda tunggu hasilnya adalah yang ini:

async Task<IFoo> GetIFooAsync()
{
    return await GetFooAsync();
}

async Task<Foo> GetFooAsync()
{
    var foo = await CreateFooAsync();
    await foo.InitializeAsync();
    return foo;
}

Dalam hal ini, GetIFooAsync()harus menunggu hasil GetFooAsynckarena jenis Tberbeda antara kedua metode dan Task<Foo>tidak langsung ditugaskan Task<IFoo>. Tapi jika Anda menunggu hasilnya, itu hanya menjadi Fooyang adalah langsung dialihkan ke IFoo. Kemudian metode async hanya mengemas kembali hasilnya di dalam Task<IFoo>dan pergi Anda pergi.

Membuat metode "thunk" async yang dinyatakan sederhana membuat mesin status async dalam memori sedangkan yang non-async tidak. Meskipun hal itu sering dapat mengarahkan orang untuk menggunakan versi non-async karena lebih efisien (yang benar) juga berarti bahwa jika terjadi hang, Anda tidak memiliki bukti bahwa metode tersebut terlibat dalam "tumpukan pengembalian / kelanjutan" yang terkadang membuatnya lebih sulit untuk memahami hang.

Jadi ya, ketika perf tidak kritis (dan biasanya tidak) saya akan melempar async pada semua metode thunk sehingga saya memiliki mesin negara async untuk membantu saya mendiagnosis hang nanti, dan juga untuk membantu memastikan bahwa jika mereka Metode thunk pernah berkembang seiring waktu, mereka pasti akan mengembalikan tugas yang salah alih-alih melempar.

Jika Anda tidak akan menggunakan pengembalian menunggu, Anda dapat merusak jejak tumpukan Anda saat debugging atau ketika itu dicetak dalam log pada pengecualian.

Ketika Anda mengembalikan tugas, metode memenuhi tujuannya dan itu keluar dari tumpukan panggilan. Saat Anda menggunakanreturn await Anda meninggalkannya di tumpukan panggilan.

Sebagai contoh:

Tumpukan panggilan saat menggunakan menunggu: A menunggu tugas dari B => B menunggu tugas dari C

Tumpukan panggilan saat tidak menggunakan menunggu: A menunggu tugas dari C, yang telah dikembalikan B.

Ini juga membingungkan saya dan saya merasa bahwa jawaban sebelumnya mengabaikan pertanyaan Anda yang sebenarnya:

Mengapa menggunakan pengembalian menunggu konstruksi ketika Anda bisa langsung mengembalikan Tugas dari doa DoAnotherThingAsync () dalam?

Yah kadang-kadang Anda benar - benar menginginkan Task<SomeType>, tetapi sebagian besar waktu Anda benar-benar menginginkan contoh SomeType, yaitu, hasil dari tugas.

Dari kode Anda:

async Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return await foo.DoAnotherThingAsync();
    }
}

Seseorang yang tidak terbiasa dengan sintaks (saya, misalnya) mungkin berpikir bahwa metode ini harus mengembalikan a Task<SomeResult>, tetapi karena ditandai dengan async, itu berarti bahwa jenis pengembalian yang sebenarnya adalah SomeResult. Jika Anda hanya menggunakan return foo.DoAnotherThingAsync(), Anda akan mengembalikan Tugas, yang tidak dapat dikompilasi. Cara yang benar adalah mengembalikan hasil tugas, jadi return await.