Baru saja mendapat VS2012 dan mencoba menangani async.

Katakanlah saya punya metode yang mengambil beberapa nilai dari sumber pemblokiran. Saya tidak ingin penelepon metode untuk memblokir. Saya bisa menulis metode untuk mengambil callback yang dipanggil ketika nilainya tiba, tetapi karena saya menggunakan C # 5, saya memutuskan untuk membuat metode async sehingga penelepon tidak harus berurusan dengan callback:

// contrived example (edited in response to Servy's comment)
public static Task<string> PromptForStringAsync(string prompt)
{
    return Task.Factory.StartNew(() => {
        Console.Write(prompt);
        return Console.ReadLine();
    });
}

Inilah contoh metode yang menyebutnya. Jika PromptForStringAsynctidak async, metode ini akan membutuhkan peneleponan kembali di dalam panggilan balik. Dengan async, saya bisa menulis metode saya dengan cara yang sangat alami ini:

public static async Task GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    Console.WriteLine("Welcome {0}.", firstname);

    string lastname = await PromptForStringAsync("Enter your last name: ");
    Console.WriteLine("Name saved as '{0} {1}'.", firstname, lastname);
}

Sejauh ini baik. Masalahnya adalah ketika saya memanggil GetNameAsync:

public static void DoStuff()
{
    GetNameAsync();
    MainWorkOfApplicationIDontWantBlocked();
}

Intinya GetNameAsyncadalah asinkron. Saya tidak ingin memblokir, karena saya ingin kembali ke MainWorkOfApplicationIDontWantBlocked ASAP dan biarkan GetNameAsync melakukan hal itu di latar belakang. Namun, menyebutnya dengan cara ini memberi saya peringatan kompiler di GetNameAsynctelepon:

Warning 1   Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.

Saya sangat menyadari bahwa "eksekusi metode saat ini berlanjut sebelum panggilan selesai". Itulah titik kode asynchronous, kan?

Saya lebih suka kode saya dikompilasi tanpa peringatan, tetapi tidak ada yang bisa "diperbaiki" di sini karena kode melakukan apa yang saya inginkan. Saya bisa menghilangkan peringatan dengan menyimpan nilai pengembalian GetNameAsync:

public static void DoStuff()
{
    var result = GetNameAsync(); // supress warning
    MainWorkOfApplicationIDontWantBlocked();
}

Tapi sekarang saya punya kode berlebihan. Visual Studio tampaknya mengerti bahwa saya dipaksa untuk menulis kode yang tidak perlu ini, karena menekan peringatan "nilai tidak pernah digunakan" yang normal.

Saya juga bisa menghilangkan peringatan dengan membungkus GetNameAsync dengan metode yang tidak async:

    public static Task GetNameWrapper()
    {
        return GetNameAsync();
    }

Tapi itu kode yang lebih berlebihan. Jadi saya harus menulis kode saya tidak perlu atau mentolerir peringatan yang tidak perlu.

Apakah ada sesuatu tentang penggunaan async yang salah di sini?

Jika Anda benar-benar tidak membutuhkan hasilnya, Anda cukup mengubah GetNameAsynctanda tangan untuk mengembalikan void:

public static async void GetNameAsync()
{
    ...
}

Pertimbangkan untuk melihat jawaban atas pertanyaan terkait: Apa perbedaan antara mengembalikan batal dan mengembalikan Tugas?

Memperbarui

Jika Anda membutuhkan hasilnya, Anda dapat mengubah GetNameAsyncuntuk kembali, katakan Task<string>:

public static async Task<string> GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    string lastname = await PromptForStringAsync("Enter your last name: ");
    return firstname + lastname;
}

Dan gunakan sebagai berikut:

public static void DoStuff()
{
    Task<string> task = GetNameAsync();

    // Set up a continuation BEFORE MainWorkOfApplicationIDontWantBlocked
    Task anotherTask = task.ContinueWith(r => {
            Console.WriteLine(r.Result);
        });

    MainWorkOfApplicationIDontWantBlocked();

    // OR wait for the result AFTER
    string result = task.Result;
}

Saya cukup terlambat untuk diskusi ini, tetapi ada juga opsi untuk menggunakan #pragmaarahan pra-prosesor. Saya memiliki beberapa kode async di sana-sini yang secara eksplisit saya tidak ingin menunggu dalam beberapa kondisi, dan saya tidak menyukai peringatan dan variabel yang tidak digunakan sama seperti Anda semua:

#pragma warning disable 4014
SomeMethodAsync();
#pragma warning restore 4014

Itu "4014"datang dari halaman MSDN ini: Peringatan Kompiler (level 1) CS4014 .

Lihat juga peringatan / jawaban oleh @ ryan-horath di sini https://stackoverflow.com/a/12145047/928483 .

Pengecualian yang dilemparkan selama panggilan async yang tidak ditunggu akan hilang. Untuk menghilangkan peringatan ini, Anda harus menetapkan nilai pengembalian tugas panggilan async ke variabel. Ini memastikan Anda memiliki akses ke pengecualian yang dilontarkan, yang akan ditunjukkan dalam nilai pengembalian.

Pembaruan untuk C # 7.0

C # 7.0 menambahkan fitur baru, membuang variabel: Buang - Panduan C # , yang juga dapat membantu dalam hal ini.

_ = SomeMethodAsync();

Saya tidak terlalu menyukai solusi yang baik menetapkan tugas ke variabel yang tidak digunakan, atau mengubah metode tanda tangan untuk mengembalikan batal. Yang pertama membuat berlebihan, kode non-intuitif, sedangkan yang terakhir mungkin tidak dapat dilakukan jika Anda mengimplementasikan antarmuka atau menggunakan fungsi lain di mana Anda ingin menggunakan Tugas yang dikembalikan.

Solusi saya adalah membuat metode ekstensi dari Task, yang disebut DoNotAwait () yang tidak melakukan apa-apa. Ini tidak hanya akan menekan semua peringatan, ReSharper atau lainnya, tetapi membuat kode lebih mudah dipahami, dan menunjukkan kepada pengelola kode Anda di masa mendatang bahwa Anda benar-benar bermaksud agar panggilan tidak ditunggu.

Metode ekstensi:

public static class TaskExtensions
{
    public static void DoNotAwait(this Task task) { }
}

Pemakaian:

public static void DoStuff()
{
    GetNameAsync().DoNotAwait();
    MainWorkOfApplicationIDontWantBlocked();
}

Diedit untuk menambahkan: ini mirip dengan solusi Jonathan Allen di mana metode ekstensi akan memulai tugas jika belum dimulai, tetapi saya lebih suka memiliki fungsi tujuan tunggal sehingga maksud pemanggil benar-benar jelas.

async void BURUK!

1. Apa perbedaan antara mengembalikan batal dan mengembalikan Tugas?
2. https://jaylee.org/archive/2012/07/08/c-sharp-async-tips-and-tricks-part-2-async-void.html

Apa yang saya sarankan adalah Anda menjalankan secara eksplisit Taskmelalui metode anonim ...

misalnya

public static void DoStuff()
{
    Task.Run(async () => GetNameAsync());
    MainWorkOfApplicationIDontWantBlocked();
}

Atau jika Anda memang ingin memblokirnya Anda bisa menunggu dengan metode anonim

public static void DoStuff()
{
    Task.Run(async () => await GetNameAsync());
    MainWorkOfApplicationThatWillBeBlocked();
}

Namun, jika GetNameAsyncmetode Anda harus berinteraksi dengan UI atau bahkan apa pun yang terikat UI, (WINRT / MVVM, saya melihat Anda), maka itu akan menjadi sedikit lebih lucu =)

Anda harus meneruskan referensi ke dispatcher UI seperti ini ...

Task.Run(async () => await GetNameAsync(CoreApplication.MainView.CoreWindow.Dispatcher));

Dan kemudian dalam metode async Anda, Anda harus berinteraksi dengan UI atau elemen terikat UI berpikir bahwa pengirim ...

dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {  this.UserName = userName; });

Inilah yang sedang saya lakukan:

SomeAyncFunction().RunConcurrently();

Di mana RunConcurrentlydidefinisikan sebagai ...

 /// <summary> 
 /// Runs the Task in a concurrent thread without waiting for it to complete. This will start the task if it is not already running. 
 /// </summary> 
 /// <param name="task">The task to run.</param> 
 /// <remarks>This is usually used to avoid warning messages about not waiting for the task to complete.</remarks> 
 public static void RunConcurrently(this Task task) 
 { 
     if (task == null) 
         throw new ArgumentNullException("task", "task is null."); 

     if (task.Status == TaskStatus.Created) 
         task.Start(); 
 } 

https://github.com/docevaad/Anchor/blob/master/Tortuga.Anchor/Tortuga.Anchor.source/shared/TaskUtilities.cs

https://www.nuget.org/packages/Tortuga.Anchor/

Menurut artikel Microsoft pada peringatan ini, Anda bisa menyelesaikannya dengan hanya menetapkan tugas yang dikembalikan ke variabel. Di bawah ini adalah terjemahan dari kode yang disediakan dalam contoh Microsoft:

    // To suppress the warning without awaiting, you can assign the 
    // returned task to a variable. The assignment doesn't change how
    // the program runs. However, the recommended practice is always to
    // await a call to an async method.
    // Replace Call #1 with the following line.
    Task delayTask = CalledMethodAsync(delay);

Perhatikan bahwa melakukan ini akan menghasilkan pesan "Variabel lokal tidak pernah digunakan" di ReSharper.

Di sini, solusi sederhana.

public static class TasksExtensions
{
    public static void RunAndForget(this Task task)
    {
    }
}

Salam

Ini contoh sederhana Anda yang menyebabkan kode superflous. Biasanya Anda ingin menggunakan data yang diambil dari sumber pemblokiran di beberapa titik dalam program, jadi Anda ingin hasilnya kembali sehingga mungkin untuk mendapatkan data.

Jika Anda benar-benar memiliki sesuatu yang terjadi sepenuhnya terisolasi dari sisa program, async tidak akan menjadi pendekatan yang tepat. Mulai saja utas baru untuk tugas itu.

Apakah Anda benar-benar ingin mengabaikan hasilnya? seperti termasuk mengabaikan pengecualian yang tidak terduga?

Jika tidak, Anda mungkin ingin melihat pertanyaan ini: Api dan Lupakan pendekatan ,

Jika Anda tidak ingin mengubah tanda tangan metode untuk kembali void(karena pengembalian voidharus selalu dibatalkan ), Anda dapat menggunakan fitur C # 7.0+ Buang seperti ini, yang sedikit lebih baik daripada menetapkan ke variabel (dan harus menghapus sebagian besar lainnya) peringatan alat validasi sumber):

public static void DoStuff()
{
    _ = GetNameAsync(); // we don't need the return value (suppresses warning)
    MainWorkOfApplicationIDontWantBlocked();
}