Najprostszy sposób na wykonanie metody odpal i zapomnij w C #?

Widziałem w WCF, że mają [OperationContract(IsOneWay = true)]atrybut. Jednak funkcja WCF wydaje się być powolna i ciężka, aby utworzyć funkcję nieblokującą. Idealnie byłoby coś takiego jak nieblokująca się statyczna pustkaMethodFoo(){} , ale nie sądzę, że istnieje.

Jaki jest najszybszy sposób utworzenia wywołania metody nieblokującej w języku C #?

Na przykład

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 : Każdy, kto to czyta, powinien pomyśleć o tym, czy rzeczywiście chce, aby metoda została zakończona. (Zobacz pierwszą odpowiedź nr 2) Jeśli metoda musi się zakończyć, w niektórych miejscach, takich jak aplikacja ASP.NET, będziesz musiał zrobić coś, aby zablokować i utrzymać wątek przy życiu. W przeciwnym razie mogłoby to doprowadzić do „odpalenia-zapomnienia-ale-nigdy-nie-wykonania-wykonania”, w którym to przypadku oczywiście łatwiej byłoby napisać w ogóle żaden kod. ( Dobry opis tego, jak to działa w ASP.NET )

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

(pięć lat później...)

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

jak wskazał luisperezphd .

W przypadku języka C # 4.0 i nowszych wydaje mi się, że najlepszą odpowiedzią jest teraz Ade Miller: Najprostszy sposób wykonania polecenia odpal i zapomnij w języku c # 4.0

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

Lub nawet...

Task.Factory.StartNew(FireAway);

Lub...

new Task(FireAway).Start();

Gdzie FireAway jest

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

Tak więc dzięki zwięzłości nazwy klasy i metody przewyższa wersję puli wątków o od sześciu do dziewiętnastu znaków w zależności od tego, który wybierzesz :)

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

W przypadku platformy .NET 4.5:

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

Aby dodać do odpowiedzi Willa , jeśli jest to aplikacja konsolowa, po prostu wrzuć an AutoResetEventi a, WaitHandleaby zapobiec zamknięciu go przed zakończeniem wątku roboczego:

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

Prostym sposobem jest utworzenie i uruchomienie wątku z bezparametrową lambdą:

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

Używając tej metody w ThreadPool.QueueUserWorkItem, możesz nazwać nowy wątek, aby ułatwić debugowanie. Nie zapomnij także o zastosowaniu obszernej obsługi błędów w swojej procedurze, ponieważ wszelkie nieobsłużone wyjątki poza debugerem nagle spowodują awarię aplikacji:

Zalecanym sposobem zrobienia tego, gdy używasz Asp.Net i .Net 4.5.2, jest użycie QueueBackgroundWorkItem. Oto klasa pomocnicza:

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

Przykład użycia:

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

lub używając async:

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

Działa to świetnie w witrynach sieci Web platformy Azure.

Dokumentacja: Używanie QueueBackgroundWorkItem do planowania zadań w tle z aplikacji ASP.NET w .NET 4.5.2

Wywołanie funkcji beginInvoke bez przechwytywania EndInvoke nie jest dobrym podejściem. Odpowiedź jest prosta: Powodem, dla którego powinieneś wywołać EndInvoke, jest to, że wyniki wywołania (nawet jeśli nie ma wartości zwracanej) muszą być buforowane przez .NET do momentu wywołania EndInvoke. Na przykład, jeśli wywołany kod zgłasza wyjątek, wyjątek jest buforowany w danych wywołania. Dopóki nie wywołasz EndInvoke, pozostanie w pamięci. Po wywołaniu EndInvoke pamięć może zostać zwolniona. W tym konkretnym przypadku możliwe jest, że pamięć pozostanie do zakończenia procesu, ponieważ dane są utrzymywane wewnętrznie przez kod wywołania. Wydaje mi się, że GC może w końcu je zebrać, ale nie wiem, skąd GC wiedziałby, że porzuciłeś dane, a ich odzyskanie zajmuje naprawdę dużo czasu. Wątpię, że tak. Dlatego może wystąpić wyciek pamięci.

Więcej można znaleźć na http://haacked.com/archive/2009/01/09/asynchronous-fire-and-forget-with-lambdas.aspx

Prawie 10 lat później:

Task.Run(FireAway);

Dodałbym obsługę wyjątków i logowanie w FireAway

Najprostszym podejściem .NET 2.0 i nowszym jest użycie Asynchnonous Programming Model (tj. BeginInvoke na delegacie):

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