Il modo più semplice per fare un incendio e dimenticare il metodo in C #?

Ho visto in WCF che hanno l' [OperationContract(IsOneWay = true)]attributo. Ma WCF sembra un po 'lento e pesante solo per creare una funzione non bloccante. Idealmente ci sarebbe qualcosa di simile al vuoto statico senza blocco MethodFoo(){}, ma non credo che esista.

Qual è il modo più rapido per creare una chiamata di metodo non bloccante in C #?

Per esempio

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 : Chiunque legga questo dovrebbe pensare se vogliono davvero che il metodo finisca. (Vedi risposta principale n. 2) Se il metodo deve terminare, in alcuni casi, come un'applicazione ASP.NET, dovrai fare qualcosa per bloccare e mantenere attivo il thread. Altrimenti, questo potrebbe portare a "fuoco-dimentica-ma-mai-effettivamente-esegui", nel qual caso, ovviamente, sarebbe più semplice non scrivere alcun codice. ( Una buona descrizione di come funziona in ASP.NET )

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

(Cinque anni dopo...)

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

come sottolineato da luisperezphd .

Per C # 4.0 e successivi, mi sembra che la risposta migliore sia stata data qui da Ade Miller: modo più semplice per fare un incendio e dimenticare il metodo in c # 4.0

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

O anche...

Task.Factory.StartNew(FireAway);

O...

new Task(FireAway).Start();

Dove FireAway si trova

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

Quindi, in virtù della terseness del nome della classe e del metodo, questo batte la versione di threadpool tra sei e diciannove caratteri a seconda di quello che scegli :)

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

Per .NET 4.5:

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

Per aggiungere alla risposta di Will , se si tratta di un'applicazione console, basta inserire an AutoResetEvente a WaitHandleper impedirne l'uscita prima che il thread di lavoro venga completato:

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

Un modo semplice è creare e avviare un thread con lambda senza parametri:

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

Utilizzando questo metodo su ThreadPool.QueueUserWorkItem è possibile assegnare un nome al nuovo thread per semplificare il debug. Inoltre, non dimenticare di utilizzare la gestione estesa degli errori nella routine perché eventuali eccezioni non gestite al di fuori di un debugger causano il crash improvviso dell'applicazione:

Il modo raccomandato per farlo quando si utilizzano Asp.Net e .Net 4.5.2 è usando QueueBackgroundWorkItem. Ecco una classe di aiuto:

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

Esempio di utilizzo:

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

o usando asincrono:

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

Funziona perfettamente sui siti Web di Azure.

Riferimento: utilizzo di QueueBackgroundWorkItem per pianificare processi in background da un'applicazione ASP.NET in .NET 4.5.2

Chiamare beginInvoke e non intercettare EndInvoke non è un buon approccio. La risposta è semplice: il motivo per cui è necessario chiamare EndInvoke è perché i risultati dell'invocazione (anche se non è presente alcun valore restituito) devono essere memorizzati nella cache di .NET fino a quando non viene chiamato EndInvoke. Ad esempio, se il codice invocato genera un'eccezione, l'eccezione viene memorizzata nella cache nei dati di chiamata. Fino a quando si chiama EndInvoke rimane in memoria. Dopo aver chiamato EndInvoke, la memoria può essere rilasciata. Per questo caso particolare è possibile che la memoria rimanga finché il processo non si arresta perché i dati sono gestiti internamente dal codice di chiamata. Immagino che alla fine il GC potrebbe raccoglierlo, ma non so come il GC saprebbe che hai abbandonato i dati piuttosto che impiegare davvero molto tempo per recuperarli. Ne dubito. Quindi può verificarsi una perdita di memoria.

Maggiori informazioni su http://haacked.com/archive/2009/01/09/asynchronous-fire-and-forget-with-lambdas.aspx

Quasi 10 anni dopo:

Task.Run(FireAway);

Aggiungerei la gestione e la registrazione delle eccezioni all'interno di FireAway

L'approccio .NET 2.0 e successivi più semplice sta usando il modello di programmazione asincrono (ovvero BeginInvoke su un delegato):

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