¿La manera más simple de hacer fuego y olvidar el método en C #?

Vi en WCF que tienen el [OperationContract(IsOneWay = true)]atributo. Pero WCF parece un poco lento y pesado solo para crear una función sin bloqueo. Idealmente, habría algo como no bloqueo de vacío estático MethodFoo(){}, pero no creo que exista.

¿Cuál es la forma más rápida de crear una llamada a un método sin bloqueo en C #?

P.ej

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 : Todos los que lean esto deberían pensar si realmente quieren que el método termine. (Consulte la respuesta principal n. ° 2) Si el método tiene que finalizar, en algunos lugares, como una aplicación ASP.NET, deberá hacer algo para bloquear y mantener vivo el hilo. De lo contrario, esto podría llevar a "disparar-olvidar-pero-nunca-realmente-ejecutar", en cuyo caso, por supuesto, sería más simple no escribir ningún código. ( Una buena descripción de cómo funciona esto en ASP.NET )

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

(cinco años después...)

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

como lo señaló luisperezphd .

Para C # 4.0 y más reciente, me parece que la mejor respuesta ahora la da Ade Miller: la forma más sencilla de hacer fuego y olvidar el método en c # 4.0

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

O incluso...

Task.Factory.StartNew(FireAway);

O...

new Task(FireAway).Start();

Donde FireAwayesta

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

Entonces, en virtud de la brevedad del nombre de la clase y el método, esto supera a la versión del conjunto de hilos entre seis y diecinueve caracteres, dependiendo del que elija :)

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

Para .NET 4.5:

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

Para agregar a la respuesta de Will , si esta es una aplicación de consola, simplemente agregue una AutoResetEventy una WaitHandlepara evitar que salga antes de que se complete el subproceso de trabajo:

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

Una manera fácil es crear e iniciar un hilo con lambda sin parámetros:

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

Al usar este método sobre ThreadPool.QueueUserWorkItem, puede nombrar su nuevo hilo para facilitar la depuración. Además, no olvide utilizar el manejo extensivo de errores en su rutina porque cualquier excepción no manejada fuera de un depurador bloqueará abruptamente su aplicación:

La forma recomendada de hacer esto cuando usa Asp.Net y .Net 4.5.2 es mediante QueueBackgroundWorkItem. Aquí hay una clase auxiliar:

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

Ejemplo de uso:

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

o usando asíncrono:

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

Esto funciona muy bien en los sitios web de Azure.

Referencia: Uso de QueueBackgroundWorkItem para programar trabajos en segundo plano desde una aplicación ASP.NET en .NET 4.5.2

Llamar a beginInvoke y no capturar EndInvoke no es un buen enfoque. La respuesta es simple: la razón por la que debe llamar a EndInvoke es porque los resultados de la invocación (incluso si no hay un valor de retorno) deben ser almacenados en caché por .NET hasta que se llame a EndInvoke. Por ejemplo, si el código invocado genera una excepción, la excepción se almacena en caché en los datos de invocación. Hasta que llame a EndInvoke, permanece en la memoria. Después de llamar a EndInvoke, se puede liberar la memoria. Para este caso particular, es posible que la memoria permanezca hasta que el proceso se cierre porque el código de invocación mantiene internamente los datos. Supongo que el GC eventualmente podría recopilarlo, pero no sé cómo el GC sabría que has abandonado los datos en lugar de solo tomarte un tiempo realmente largo para recuperarlos. Dudo que lo haga. Por lo tanto, puede ocurrir una pérdida de memoria.

Se puede encontrar más en http://haacked.com/archive/2009/01/09/asynchronous-fire-and-forget-with-lambdas.aspx

Casi 10 años después:

Task.Run(FireAway);

Agregaría manejo y registro de excepciones dentro de FireAway

El enfoque más simple de .NET 2.0 y posterior es utilizar el modelo de programación asinchnonous (es decir, BeginInvoke en un delegado):

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