C # ateş ve unut yöntemi yapmak için en basit yolu?

WCF'de bu [OperationContract(IsOneWay = true)]özelliklere sahip olduklarını gördüm . Ancak WCF, tıkanmasız bir işlev yaratmak için biraz yavaş ve ağır görünüyor. İdeal olarak statik boşluk MethodFoo(){}engelleme gibi bir şey olurdu , ama bunun var olduğunu düşünmüyorum.

C # 'da engellenmeyen bir yöntem çağrısı oluşturmanın en hızlı yolu nedir?

Örneğin

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");
    }
}

Not : Bunu okuyan herkes, yöntemin gerçekten bitmesini isteyip istemediklerini düşünmelidir. (Bkz. # 2 üst yanıt) Yöntemin tamamlanması gerekiyorsa, ASP.NET uygulaması gibi bazı yerlerde iş parçacığını engellemek ve canlı tutmak için bir şeyler yapmanız gerekir. Aksi takdirde, bu "yangın unut-ama-asla-gerçekten-yürütmek" yol açabilir, bu durumda, elbette, hiç kod yazmak daha kolay olurdu. ( Bunun ASP.NET'te nasıl çalıştığının iyi bir açıklaması )

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

(beş yıl sonra...)

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

luisperezphd tarafından işaret edildiği gibi .

C # 4.0 ve daha yeni sürümler için, en iyi cevabın şimdi Ade Miller tarafından verildiğine dikkat çekiyor: Bir yangın yapmanın ve c # 4.0'da yöntemi unutmanın en basit yolu

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

Ya da...

Task.Factory.StartNew(FireAway);

Veya...

new Task(FireAway).Start();

nerede FireAwayolduğunu

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

Sınıf ve yöntem adının tersliği sayesinde bu, seçtiğiniz konuya bağlı olarak threadpool sürümünü altı ila on dokuz karakter arasında yener :)

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

.NET 4.5 için:

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

Will'in cevabına eklemek için , bu bir konsol uygulamasıysa, işçi iş parçacığı tamamlanmadan önce çıkmasını önlemek için bir AutoResetEventve a atın WaitHandle:

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();
    }
}

Kolay bir yol, parametresiz lambda ile bir iş parçacığı oluşturmak ve başlatmaktır:

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

Bu yöntemi ThreadPool.QueueUserWorkItem üzerinde kullanarak, hata ayıklamayı kolaylaştırmak için yeni iş parçacığınızı adlandırabilirsiniz. Ayrıca, bir hata ayıklayıcı dışındaki herhangi bir işlenmemiş istisna aniden uygulamanızı aniden çökeceğinden, rutininizde kapsamlı hata işlemeyi kullanmayı unutmayın:

Asp.Net ve .Net 4.5.2 kullanırken bunu yapmanın önerilen yolu kullanmaktır QueueBackgroundWorkItem. İşte bir yardımcı sınıf:

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
            }
        });
    }
}

Kullanım örneği:

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

veya zaman uyumsuzluğu kullanarak:

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

Bu Azure Web Sitelerinde harika çalışıyor.

Başvuru: .NET 4.5.2'de bir ASP.NET Uygulamasından Arka Plan İşlerini Zamanlamak için QueueBackgroundWorkItem Kullanma

BeginInvoke'u çağırmak ve EndInvoke'u yakalamamak iyi bir yaklaşım değildir. Yanıt basit: EndInvoke'u çağırmanızın nedeni, çağrının sonuçlarının (dönüş değeri olmasa bile) EndInvoke çağrılıncaya kadar .NET tarafından önbelleğe alınması gerektiğidir. Örneğin, çağrılan kod bir istisna atarsa, istisna çağrı verilerinde önbelleğe alınır. EndInvoke'u çağırıncaya kadar bellekte kalır. EndInvoke'u çağırdıktan sonra bellek serbest bırakılabilir. Bu özel durumda, veriler dahili olarak çağırma kodu ile korunduğu için işlem kapanana kadar bellek kalır. Sanırım GC nihayetinde toplayabilir ama GC'nin veriyi terk ettiğinizi nasıl bildiğini bilmiyorum, ancak bu veriyi almak çok uzun zaman alıyor. Şüpheliyim. Böylece bellek sızıntısı meydana gelebilir.

Daha fazlasını http://haacked.com/archive/2009/01/09/asynchronous-fire-and-forget-with-lambdas.aspx adresinde bulabilirsiniz.

Neredeyse 10 yıl sonra:

Task.Run(FireAway);

FireAway içinde istisna işleme ve günlük kaydı eklerdim

En basit .NET 2.0 ve sonraki yaklaşım Asynchnonous Programming Model (Asynchnonous Programming Model) (yani bir delege üzerinde BeginInvoke) kullanmaktır:

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 );  
}