Maneira mais simples de fazer um incêndio e esquecer o método em c #?

Eu vi no WCF eles terem o [OperationContract(IsOneWay = true)]atributo Mas o WCF parece meio lento e pesado, apenas para criar uma função sem bloqueio. Idealmente, haveria algo como non-blocking estático MethodFoo(){}, mas acho que não existe.

Qual é a maneira mais rápida de criar uma chamada de método sem bloqueio em C #?

Por exemplo

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 : Todo mundo que lê isso deve pensar se realmente deseja que o método termine. (Consulte a segunda resposta principal) Se o método precisar terminar, em alguns lugares, como um aplicativo ASP.NET, você precisará fazer algo para bloquear e manter o thread ativo. Caso contrário, isso poderia levar a "ignorar, mas nunca executar de fato"; nesse caso, é claro, seria mais simples escrever nenhum código. ( Uma boa descrição de como isso funciona no ASP.NET )

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

(cinco anos depois...)

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

como apontado por luisperezphd .

Para C # 4.0 e mais recente, parece-me que a melhor resposta agora é dada aqui por Ade Miller: Maneira mais simples de disparar e esquecer o método no c # 4.0

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

Ou até ...

Task.Factory.StartNew(FireAway);

Ou...

new Task(FireAway).Start();

Onde FireAwayfica

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

Portanto, em virtude da dispersão do nome da classe e do método, a versão do pool de threads supera a versão entre seis e dezenove caracteres, dependendo da que você escolher :)

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

Para o .NET 4.5:

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

Para adicionar à resposta de Will , se esse for um aplicativo de console, basta inserir um AutoResetEvente a WaitHandlepara impedir que ele saia antes que o segmento de trabalho seja concluído:

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

Uma maneira fácil é criar e iniciar um encadeamento com lambda sem parâmetros:

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

Usando esse método em ThreadPool.QueueUserWorkItem, você pode nomear seu novo thread para facilitar a depuração. Além disso, não se esqueça de usar o tratamento extensivo de erros em sua rotina, pois quaisquer exceções não tratadas fora de um depurador causam um travamento abrupto no aplicativo:

A maneira recomendada de fazer isso quando você estiver usando Asp.Net e .Net 4.5.2 é usando QueueBackgroundWorkItem. Aqui está uma classe 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
            }
        });
    }
}

Exemplo de uso:

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

ou usando assíncrono:

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

Isso funciona muito bem nos sites da Azure.

Referência: Usando QueueBackgroundWorkItem para agendar trabalhos em segundo plano de um aplicativo ASP.NET no .NET 4.5.2

Chamar beginInvoke e não capturar EndInvoke não é uma boa abordagem. A resposta é simples: o motivo pelo qual você deve chamar EndInvoke é porque os resultados da chamada (mesmo se não houver valor de retorno) devem ser armazenados em cache pelo .NET até que EndInvoke seja chamado. Por exemplo, se o código chamado lança uma exceção, a exceção é armazenada em cache nos dados de chamada. Até você chamar EndInvoke, ele permanece na memória. Depois de ligar para o EndInvoke, a memória pode ser liberada. Nesse caso específico, é possível que a memória permaneça até que o processo seja encerrado porque os dados são mantidos internamente pelo código de chamada. Eu acho que o GC pode eventualmente coletá-lo, mas não sei como o GC saberia que você abandonou os dados vs. apenas demorou muito tempo para recuperá-lo. Duvido que sim. Portanto, um vazamento de memória pode ocorrer.

Mais informações podem ser encontradas em http://haacked.com/archive/2009/01/09/asynchronous-fire-and-forget-with-lambdas.aspx

Quase 10 anos depois:

Task.Run(FireAway);

Eu adicionaria manipulação e registro de exceções no FireAway

A abordagem mais simples do .NET 2.0 e posterior é usar o Modelo de programação assíncrona (ou seja, BeginInvoke em um 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 );  
}