Menekan "peringatan CS4014: Karena panggilan ini tidak ditunggu, eksekusi metode saat ini berlanjut ..."

Ini bukan duplikat dari "Cara memanggil metode async dengan aman di C # tanpa menunggu" .

Bagaimana cara saya dengan baik menekan peringatan berikut?

peringatan CS4014: Karena panggilan ini tidak ditunggu, pelaksanaan metode saat ini berlanjut sebelum panggilan selesai. Pertimbangkan untuk menerapkan operator 'menunggu' ke hasil panggilan.

Contoh sederhana:

static async Task WorkAsync()
{
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

static async Task StartWorkAsync()
{
    WorkAsync(); // I want fire-and-forget 

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Apa yang saya coba dan tidak suka:

static async Task StartWorkAsync()
{
    #pragma warning disable 4014
    WorkAsync(); // I want fire-and-forget here
    #pragma warning restore 4014
    // ...
}

static async Task StartWorkAsync()
{
    var ignoreMe = WorkAsync(); // I want fire-and-forget here
    // ...
}

Diperbarui , karena jawaban yang diterima asli telah diedit, saya telah mengubah jawaban yang diterima menjadi yang menggunakan C # 7.0 discards , karena menurut saya tidak ContinueWithsesuai di sini. Kapan pun saya perlu mencatat pengecualian untuk operasi kebakaran dan lupakan, saya menggunakan pendekatan yang lebih rumit yang diusulkan oleh Stephen Cleary di sini .

Dengan C # 7 sekarang Anda dapat menggunakan discards :

_ = WorkAsync();

Anda dapat membuat metode ekstensi yang akan mencegah peringatan. Metode ekstensi bisa kosong atau Anda bisa menambahkan penanganan pengecualian di .ContinueWith()sana.

static class TaskExtensions
{
    public static void Forget(this Task task)
    {
        task.ContinueWith(
            t => { WriteLog(t.Exception); },
            TaskContinuationOptions.OnlyOnFaulted);
    }
}

public async Task StartWorkAsync()
{
    this.WorkAsync().Forget();
}

Namun ASP.NET menghitung jumlah tugas yang sedang berjalan, sehingga tidak akan bekerja dengan Forget()ekstensi sederhana seperti yang tercantum di atas dan malah gagal dengan pengecualian:

Modul atau pengendali asinkron selesai ketika operasi asinkron masih tertunda.

Dengan .NET 4.5.2 dapat diselesaikan dengan menggunakan HostingEnvironment.QueueBackgroundWorkItem:

public static Task HandleFault(this Task task, CancellationToken cancelToken)
{
    return task.ContinueWith(
        t => { WriteLog(t.Exception); },
        cancelToken,
        TaskContinuationOptions.OnlyOnFaulted,
        TaskScheduler.Default);
}

public async Task StartWorkAsync()
{
    System.Web.Hosting.HostingEnvironment.QueueBackgroundWorkItem(
        cancelToken => this.WorkAsync().HandleFault(cancelToken));
}

Anda dapat menghias metode ini dengan atribut berikut:

[System.Diagnostics.CodeAnalysis.SuppressMessage("Await.Warning", "CS4014:Await.Warning")]
static async Task StartWorkAsync()
{
    WorkAsync();
    // ...
}

Pada dasarnya Anda memberi tahu kompiler bahwa Anda tahu apa yang Anda lakukan dan tidak perlu khawatir tentang kemungkinan kesalahan.

Bagian penting dari kode ini adalah parameter kedua. Bagian "CS4014:" adalah yang menekan peringatan. Anda dapat menulis apa pun yang Anda inginkan di sisanya.

Dua cara saya berurusan dengan ini.

Simpan ke variabel buang (C # 7)

Contoh

_ = Task.Run(() => DoMyStuff()).ConfigureAwait(false);

Sejak diperkenalkannya discards di C # 7, saya sekarang menganggap ini lebih baik daripada menekan peringatan. Karena itu tidak hanya menekan peringatan, tetapi juga membuat niat api-dan-lupa menjadi jelas.

Selain itu, kompiler akan dapat mengoptimalkannya dalam mode rilis.

Tekan saja

#pragma warning disable 4014
...
#pragma warning restore 4014

adalah solusi yang cukup bagus untuk "memecat dan melupakan".

Alasan mengapa peringatan ini ada adalah karena dalam banyak kasus itu bukan niat Anda untuk menggunakan metode yang mengembalikan tugas tanpa menunggu itu. Menekan peringatan ketika Anda berniat untuk menembak dan melupakan itu masuk akal.

Jika Anda kesulitan mengingat cara mengeja #pragma warning disable 4014, cukup biarkan Visual Studio menambahkannya untuk Anda. Tekan Ctrl +. untuk membuka "Tindakan Cepat" dan kemudian "Menekan CS2014"

Semua seutuhnya

Adalah bodoh untuk membuat metode yang membutuhkan beberapa kutu untuk dieksekusi, hanya untuk tujuan menekan peringatan.

Cara mudah untuk menghentikan peringatan adalah dengan hanya menetapkan Tugas saat memanggilnya:

Task fireAndForget = WorkAsync(); // No warning now

Maka dalam posting asli Anda, Anda akan melakukan:

static async Task StartWorkAsync()
{
    // Fire and forget
    var fireAndForget = WorkAsync(); // Tell the compiler you know it's a task that's being returned 

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Alasan untuk peringatan itu adalah WorkAsync mengembalikan Taskyang tidak pernah dibaca atau ditunggu. Anda dapat mengatur kembali tipe WorkAsync voiddan peringatan akan hilang.

Biasanya metode mengembalikan a Taskketika penelepon perlu mengetahui status pekerja. Dalam kasus api-dan-lupa, kekosongan harus dikembalikan agar menyerupai bahwa penelepon independen dari metode yang disebut.

static async void WorkAsync()
{
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

static async Task StartWorkAsync()
{
    WorkAsync(); // no warning since return type is void

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Mengapa tidak membungkusnya di dalam metode async yang mengembalikan batal? Agak panjang tapi semua variabel digunakan.

static async Task StartWorkAsync()
{   
     async void WorkAndForgetAsync() => await WorkAsync();
     WorkAndForgetAsync(); // no warning
}

Saya menemukan pendekatan ini secara tidak sengaja hari ini. Anda dapat menentukan delegasi dan menetapkan metode async ke delegasi terlebih dahulu.

    delegate Task IntermediateHandler();



    static async Task AsyncOperation()
    {
        await Task.Yield();
    }

dan menyebutnya seperti itu

(new IntermediateHandler(AsyncOperation))();

...

Saya pikir itu menarik bahwa kompiler tidak akan memberikan peringatan yang sama persis ketika menggunakan delegasi.