Cara termudah untuk melakukan metode api dan lupakan di c # 4.0

Saya sangat suka pertanyaan ini:

Cara termudah untuk melakukan metode api dan lupa di C #?

Saya hanya ingin tahu bahwa sekarang kita memiliki ekstensi Paralel di C # 4.0, adakah cara yang lebih bersih untuk melakukan Fire & Forget dengan Parallel linq?

Bukan jawaban untuk 4.0, tetapi perlu dicatat bahwa di .Net 4.5 Anda dapat membuatnya lebih sederhana dengan:

#pragma warning disable 4014
Task.Run(() =>
{
    MyFireAndForgetMethod();
}).ConfigureAwait(false);
#pragma warning restore 4014

Pragma adalah menonaktifkan peringatan yang memberi tahu Anda bahwa Anda menjalankan Tugas ini sebagai api dan lupa.

Jika metode di dalam kurung kurawal mengembalikan Tugas:

#pragma warning disable 4014
Task.Run(async () =>
{
    await MyFireAndForgetMethod();
}).ConfigureAwait(false);
#pragma warning restore 4014

Mari kita uraikan:

Task.Run mengembalikan sebuah Tugas, yang menghasilkan peringatan kompilator (peringatan CS4014) yang mencatat bahwa kode ini akan dijalankan di latar belakang - itulah yang Anda inginkan, jadi kami menonaktifkan peringatan 4014.

Secara default, Tasks mencoba untuk "mengirim kembali ke Thread asli," yang berarti bahwa Tugas ini akan berjalan di latar belakang, kemudian mencoba untuk kembali ke Thread yang memulainya. Seringkali aktifkan dan lupakan Tugas selesai setelah Thread asli selesai. Itu akan menyebabkan ThreadAbortException dilempar. Dalam kebanyakan kasus, ini tidak berbahaya - hanya memberi tahu Anda, saya mencoba bergabung kembali, saya gagal, tetapi Anda toh tidak peduli. Tapi masih agak berisik untuk memiliki ThreadAbortExceptions baik di log Anda di Produksi, atau di debugger Anda di dev lokal..ConfigureAwait(false)hanyalah cara untuk tetap rapi dan secara eksplisit mengatakan, menjalankan ini di latar belakang, dan hanya itu.

Karena ini bertele-tele, terutama pragma jelek, saya menggunakan metode perpustakaan untuk ini:

public static class TaskHelper
{
    /// <summary>
    /// Runs a TPL Task fire-and-forget style, the right way - in the
    /// background, separate from the current thread, with no risk
    /// of it trying to rejoin the current thread.
    /// </summary>
    public static void RunBg(Func<Task> fn)
    {
        Task.Run(fn).ConfigureAwait(false);
    }

    /// <summary>
    /// Runs a task fire-and-forget style and notifies the TPL that this
    /// will not need a Thread to resume on for a long time, or that there
    /// are multiple gaps in thread use that may be long.
    /// Use for example when talking to a slow webservice.
    /// </summary>
    public static void RunBgLong(Func<Task> fn)
    {
        Task.Factory.StartNew(fn, TaskCreationOptions.LongRunning)
            .ConfigureAwait(false);
    }
}

Pemakaian:

TaskHelper.RunBg(async () =>
{
    await doSomethingAsync();
}

Dengan Taskkelas ya, tetapi PLINQ benar-benar untuk menanyakan koleksi.

Sesuatu seperti berikut ini akan melakukannya dengan Tugas.

Task.Factory.StartNew(() => FireAway());

Atau bahkan...

Task.Factory.StartNew(FireAway);

Atau...

new Task(FireAway).Start();

dimana FireAwayadalah

public static void FireAway()
{
    // Blah...
}

Jadi berdasarkan ketegasan nama kelas dan metode ini mengalahkan versi threadpool dengan antara enam dan sembilan belas karakter tergantung pada yang Anda pilih :)

ThreadPool.QueueUserWorkItem(o => FireAway());

Saya memiliki beberapa masalah dengan jawaban utama untuk pertanyaan ini.

Pertama, dalam situasi api-dan-lupakan yang sebenarnya , Anda mungkin tidak akan awaitmelakukan tugas itu, jadi tidak ada gunanya menambahkan ConfigureAwait(false). Jika Anda tidak awaitmengembalikan nilai ConfigureAwait, maka itu tidak mungkin berpengaruh.

Kedua, Anda perlu menyadari apa yang terjadi saat tugas selesai dengan pengecualian. Pertimbangkan solusi sederhana yang disarankan @ ade-miller:

Task.Factory.StartNew(SomeMethod);  // .NET 4.0
Task.Run(SomeMethod);               // .NET 4.5

Ini menimbulkan bahaya: jika pengecualian yang tidak tertangani lolos dari SomeMethod(), pengecualian itu tidak akan pernah diamati, dan mungkin ¹ dicabut kembali pada utas finalizer, membuat aplikasi Anda mogok. Oleh karena itu, saya akan merekomendasikan menggunakan metode helper untuk memastikan bahwa pengecualian yang dihasilkan diamati.

Anda bisa menulis sesuatu seperti ini:

public static class Blindly
{
    private static readonly Action<Task> DefaultErrorContinuation =
        t =>
        {
            try { t.Wait(); }
            catch {}
        };

    public static void Run(Action action, Action<Exception> handler = null)
    {
        if (action == null)
            throw new ArgumentNullException(nameof(action));

        var task = Task.Run(action);  // Adapt as necessary for .NET 4.0.

        if (handler == null)
        {
            task.ContinueWith(
                DefaultErrorContinuation,
                TaskContinuationOptions.ExecuteSynchronously |
                TaskContinuationOptions.OnlyOnFaulted);
        }
        else
        {
            task.ContinueWith(
                t => handler(t.Exception.GetBaseException()),
                TaskContinuationOptions.ExecuteSynchronously |
                TaskContinuationOptions.OnlyOnFaulted);
        }
    }
}

Implementasi ini harus memiliki overhead minimal: kelanjutan hanya dipanggil jika tugas tidak berhasil diselesaikan, dan harus dijalankan secara sinkron (bukan dijadwalkan secara terpisah dari tugas asli). Dalam kasus "malas", Anda bahkan tidak akan dikenai alokasi untuk delegasi kelanjutan.

Memulai operasi asinkron kemudian menjadi sepele:

Blindly.Run(SomeMethod);                              // Ignore error
Blindly.Run(SomeMethod, e => Log.Warn("Whoops", e));  // Log error

_{1. Ini adalah perilaku default di .NET 4.0. Dalam .NET 4.5, perilaku default diubah sedemikian rupa sehingga pengecualian yang tidak teramati tidak akan ditampilkan kembali pada utas finalizer (meskipun Anda masih dapat mengamati mereka melalui acara UnobservedTaskException di TaskScheduler). Namun, konfigurasi default dapat diganti, dan meskipun aplikasi Anda memerlukan .NET 4.5, Anda tidak boleh berasumsi bahwa pengecualian tugas yang tidak teramati tidak akan berbahaya.}

Hanya untuk memperbaiki beberapa masalah yang akan terjadi dengan jawaban Mike Strobel:

Jika Anda menggunakan var task = Task.Run(action)dan setelah menetapkan kelanjutan untuk tugas itu, maka Anda akan menghadapi risiko Taskmembuat beberapa pengecualian sebelum Anda menetapkan kelanjutan penangan pengecualian ke Task. Jadi, kelas di bawah ini harus bebas dari risiko ini:

using System;
using System.Threading.Tasks;

namespace MyNameSpace
{
    public sealed class AsyncManager : IAsyncManager
    {
        private Action<Task> DefaultExeptionHandler = t =>
        {
            try { t.Wait(); }
            catch { /* Swallow the exception */ }
        };

        public Task Run(Action action, Action<Exception> exceptionHandler = null)
        {
            if (action == null) { throw new ArgumentNullException(nameof(action)); }

            var task = new Task(action);

            Action<Task> handler = exceptionHandler != null ?
                new Action<Task>(t => exceptionHandler(t.Exception.GetBaseException())) :
                DefaultExeptionHandler;

            var continuation = task.ContinueWith(handler,
                TaskContinuationOptions.ExecuteSynchronously
                | TaskContinuationOptions.OnlyOnFaulted);
            task.Start();

            return continuation;
        }
    }
}

Di sini, tasktidak dijalankan secara langsung, melainkan dibuat, kelanjutan ditetapkan, dan baru kemudian tugas dijalankan untuk menghilangkan risiko tugas menyelesaikan eksekusi (atau memunculkan beberapa pengecualian) sebelum menetapkan kelanjutan.

The RunMetode sini kembali kelanjutan Tasksehingga saya bisa menulis unit test memastikan eksekusi selesai. Anda dapat dengan aman mengabaikannya dalam penggunaan Anda.