Cara paling mudah untuk melakukan api dan melupakan metode dalam C #?

Saya melihat di WCF mereka punya [OperationContract(IsOneWay = true)] atribut. Tapi WCF tampaknya agak lambat dan berat hanya untuk membuat fungsi nonblocking. Idealnya akan ada sesuatu seperti static void nonblocking MethodFoo(){}, tapi saya rasa itu tidak ada.

Apa cara tercepat untuk membuat panggilan metode nonblocking di C #?

Misalnya

class Foo
{
    static void Main()
    {
        FireAway(); //No callback, just go away
        Console.WriteLine("Happens immediately");
    }

    static void FireAway()
    {
        System.Threading.Thread.Sleep(5000);
        Console.WriteLine("5 seconds later");
    }
}

NB : Semua orang yang membaca ini harus memikirkan apakah mereka benar-benar ingin metode ini selesai. (Lihat # 2 jawaban teratas) Jika metode ini harus selesai, maka di beberapa tempat, seperti aplikasi ASP.NET, Anda perlu melakukan sesuatu untuk memblokir dan menjaga utas tetap hidup. Kalau tidak, ini bisa mengarah pada "fire-forget-but-never-sebenarnya-execute", dalam hal ini, tentu saja, akan lebih mudah untuk menulis tanpa kode sama sekali. ( Deskripsi yang baik tentang cara kerjanya di ASP.NET )

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

(lima tahun kemudian...)

Task.Run(() => FireAway());

seperti yang ditunjukkan oleh luisperezphd .

Untuk C # 4.0 dan yang lebih baru, menurut saya jawaban terbaik sekarang diberikan di sini oleh Ade Miller: Cara paling sederhana untuk melakukan api dan melupakan metode dalam c # 4.0

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

Atau bahkan...

Task.Factory.StartNew(FireAway);

Atau...

new Task(FireAway).Start();

dimana FireAwayadalah

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

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

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

Untuk .NET 4.5:

Task.Run(() => FireAway());

Untuk menambah jawaban Will , jika ini adalah aplikasi konsol, cukup masukkan a AutoResetEventdan a WaitHandleuntuk mencegahnya keluar sebelum utas pekerja selesai:

Using System;
Using System.Threading;

class Foo
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        ThreadPoolQueueUserWorkItem(new WaitCallback(FireAway), autoEvent);
        autoEvent.WaitOne(); // Will wait for thread to complete
    }

    static void FireAway(object stateInfo)
    {
        System.Threading.Thread.Sleep(5000);
        Console.WriteLine("5 seconds later");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Cara mudah adalah membuat dan memulai utas dengan parameter lambda:

(new Thread(() => { 
    FireAway(); 
    MessageBox.Show("FireAway Finished!"); 
}) { 
    Name = "Long Running Work Thread (FireAway Call)",
    Priority = ThreadPriority.BelowNormal 
}).Start();

Dengan menggunakan metode ini di atas ThreadPool.QueueUserWorkItem Anda dapat memberi nama utas baru Anda agar lebih mudah untuk debugging. Selain itu, jangan lupa untuk menggunakan penanganan kesalahan yang luas dalam rutinitas Anda karena pengecualian yang tidak ditangani di luar debugger akan secara tiba-tiba merusak aplikasi Anda:

Cara yang disarankan untuk melakukan ini ketika Anda menggunakan Asp.Net dan .Net 4.5.2 adalah dengan menggunakan QueueBackgroundWorkItem. Ini adalah kelas pembantu:

public static class BackgroundTaskRunner
{     
    public static void FireAndForgetTask(Action action)
    {
        HostingEnvironment.QueueBackgroundWorkItem(cancellationToken => // .Net 4.5.2 required
        {
            try
            {
                action();
            }
            catch (Exception e)
            {
                // TODO: handle exception
            }
        });
    }

    /// <summary>
    /// Using async
    /// </summary>
    public static void FireAndForgetTask(Func<Task> action)
    {
        HostingEnvironment.QueueBackgroundWorkItem(async cancellationToken => // .Net 4.5.2 required
        {
            try
            {
                await action();
            }
            catch (Exception e)
            {
                // TODO: handle exception
            }
        });
    }
}

Contoh penggunaan:

BackgroundTaskRunner.FireAndForgetTask(() =>
{
    FireAway();
});

atau menggunakan async:

BackgroundTaskRunner.FireAndForgetTask(async () =>
{
    await FireAway();
});

Ini berfungsi dengan baik di Situs Web Azure.

Referensi: Menggunakan QueueBackgroundWorkItem untuk Menjadwalkan Pekerjaan Latar Belakang dari Aplikasi ASP.NET di .NET 4.5.2

Memanggil beginInvoke dan tidak menangkap EndInvoke bukanlah pendekatan yang baik. Jawabannya sederhana: Alasan mengapa Anda harus memanggil EndInvoke adalah karena hasil doa (bahkan jika tidak ada nilai balik) harus di-cache oleh .NET hingga EndInvoke dipanggil. Sebagai contoh jika kode yang dipanggil melempar pengecualian maka pengecualian di-cache dalam data doa. Sampai Anda memanggil EndInvoke, ia tetap ada dalam memori. Setelah Anda menelepon EndInvoke, memori dapat dirilis. Untuk kasus khusus ini dimungkinkan memori akan tetap sampai proses dimatikan karena data dikelola secara internal oleh kode doa. Saya kira GC akhirnya akan mengumpulkannya tetapi saya tidak tahu bagaimana GC akan tahu bahwa Anda telah meninggalkan data vs hanya mengambil waktu yang sangat lama untuk mengambilnya. Saya ragu itu. Karenanya kebocoran memori dapat terjadi.

Lebih banyak dapat ditemukan di http://haacked.com/archive/2009/01/09/asynchronous-fire-and-forget-with-lambdas.aspx

Hampir 10 tahun kemudian:

Task.Run(FireAway);

Saya akan menambahkan penanganan pengecualian dan masuk ke dalam FireAway

Pendekatan .NET 2.0 dan kemudian yang paling sederhana adalah menggunakan Asynchnonous Programming Model (mis. BeginInvoke pada delegasi):

static void Main(string[] args)
{
      new MethodInvoker(FireAway).BeginInvoke(null, null);

      Console.WriteLine("Main: " + Thread.CurrentThread.ManagedThreadId);

      Thread.Sleep(5000);
}

private static void FireAway()
{
    Thread.Sleep(2000);

    Console.WriteLine("FireAway: " + Thread.CurrentThread.ManagedThreadId );  
}