La forma más sencilla de hacer un método de incendio y olvido en c # 4.0

Realmente me gusta esta pregunta:

¿La forma más sencilla de hacer un método de disparo y olvido en C #?

Solo quiero saber que ahora que tenemos extensiones Parallel en C # 4.0, ¿hay una forma mejor y más limpia de hacer Fire & Forget con Parallel linq?

No es una respuesta para 4.0, pero vale la pena señalar que en .Net 4.5 puede hacer esto aún más simple con:

#pragma warning disable 4014
Task.Run(() =>
{
    MyFireAndForgetMethod();
}).ConfigureAwait(false);
#pragma warning restore 4014

El pragma es deshabilitar la advertencia que le dice que está ejecutando esta Tarea como disparar y olvidar.

Si el método dentro de las llaves devuelve una tarea:

#pragma warning disable 4014
Task.Run(async () =>
{
    await MyFireAndForgetMethod();
}).ConfigureAwait(false);
#pragma warning restore 4014

Analicemos eso:

Task.Run devuelve una tarea, que genera una advertencia del compilador (advertencia CS4014) que indica que este código se ejecutará en segundo plano; eso es exactamente lo que deseaba, por lo que deshabilitamos la advertencia 4014.

De forma predeterminada, las tareas intentan "Marshal de nuevo en el subproceso original", lo que significa que esta tarea se ejecutará en segundo plano y luego intentará volver al subproceso que lo inició. A menudo, las Tareas de disparo y olvido finalizan una vez finalizado el hilo original. Eso hará que se lance una ThreadAbortException. En la mayoría de los casos, esto es inofensivo, solo te dice que intenté unirme, fallé, pero de todos modos no te importa. Pero todavía es un poco ruidoso tener ThreadAbortExceptions en sus registros en Producción o en su depurador en el desarrollo local..ConfigureAwait(false)es solo una forma de mantenerse ordenado y decir explícitamente, ejecute esto en segundo plano, y eso es todo.

Como esto es prolijo, especialmente el pragma feo, utilizo un método de biblioteca para esto:

public static class TaskHelper
{
    /// <summary>
    /// Runs a TPL Task fire-and-forget style, the right way - in the
    /// background, separate from the current thread, with no risk
    /// of it trying to rejoin the current thread.
    /// </summary>
    public static void RunBg(Func<Task> fn)
    {
        Task.Run(fn).ConfigureAwait(false);
    }

    /// <summary>
    /// Runs a task fire-and-forget style and notifies the TPL that this
    /// will not need a Thread to resume on for a long time, or that there
    /// are multiple gaps in thread use that may be long.
    /// Use for example when talking to a slow webservice.
    /// </summary>
    public static void RunBgLong(Func<Task> fn)
    {
        Task.Factory.StartNew(fn, TaskCreationOptions.LongRunning)
            .ConfigureAwait(false);
    }
}

Uso:

TaskHelper.RunBg(async () =>
{
    await doSomethingAsync();
}

Con la Taskclase sí, pero PLINQ es realmente para consultar colecciones.

Algo como lo siguiente lo hará con Task.

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 concisión del nombre de la clase y el método, esto supera a la versión de threadpool entre seis y diecinueve caracteres, según el que elija :)

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

Tengo un par de problemas con la respuesta principal a esta pregunta.

En primer lugar, en una situación real de disparar y olvidar , probablemente no se hará awaitla tarea, por lo que es inútil agregar ConfigureAwait(false). Si no lo hace, awaitel valor devuelto porConfigureAwait , no es posible que tenga ningún efecto.

En segundo lugar, debe estar al tanto de lo que sucede cuando la tarea se completa con una excepción. Considere la solución simple que sugirió @ ade-miller:

Task.Factory.StartNew(SomeMethod);  // .NET 4.0
Task.Run(SomeMethod);               // .NET 4.5

Esto introduce un peligro: si una excepción no controlada se escapa de SomeMethod(), nunca se podrá observar que la excepción, y pueden ¹ pueden volver a generar en el subproceso finalizador, bloquear su aplicación. Por lo tanto, recomendaría usar un método auxiliar para garantizar que se observen las excepciones resultantes.

Podrías escribir algo como esto:

public static class Blindly
{
    private static readonly Action<Task> DefaultErrorContinuation =
        t =>
        {
            try { t.Wait(); }
            catch {}
        };

    public static void Run(Action action, Action<Exception> handler = null)
    {
        if (action == null)
            throw new ArgumentNullException(nameof(action));

        var task = Task.Run(action);  // Adapt as necessary for .NET 4.0.

        if (handler == null)
        {
            task.ContinueWith(
                DefaultErrorContinuation,
                TaskContinuationOptions.ExecuteSynchronously |
                TaskContinuationOptions.OnlyOnFaulted);
        }
        else
        {
            task.ContinueWith(
                t => handler(t.Exception.GetBaseException()),
                TaskContinuationOptions.ExecuteSynchronously |
                TaskContinuationOptions.OnlyOnFaulted);
        }
    }
}

Esta implementación debe tener una sobrecarga mínima: la continuación solo se invoca si la tarea no se completa correctamente y debe invocarse de forma sincrónica (en lugar de programarse por separado de la tarea original). En el caso "perezoso", ni siquiera incurrirá en una asignación para el delegado de continuación.

Iniciar una operación asincrónica se vuelve trivial:

Blindly.Run(SomeMethod);                              // Ignore error
Blindly.Run(SomeMethod, e => Log.Warn("Whoops", e));  // Log error

_{1. Este era el comportamiento predeterminado en .NET 4.0. En .NET 4.5, el comportamiento predeterminado se cambió de modo que las excepciones no observadas no se volvieran a lanzar en el hilo del finalizador (aunque aún puede observarlas a través del evento UnobservedTaskException en TaskScheduler). Sin embargo, la configuración predeterminada se puede anular, e incluso si su aplicación requiere .NET 4.5, no debe asumir que las excepciones de tareas no observadas serán inofensivas.}

Solo para solucionar algún problema que sucederá con la respuesta de Mike Strobel:

Si usa var task = Task.Run(action)y luego asigna una continuación a esa tarea, correrá el riesgo de Tasklanzar alguna excepción antes de asignar una continuación del controlador de excepciones al Task. Por lo tanto, la clase siguiente debería estar libre de este riesgo:

using System;
using System.Threading.Tasks;

namespace MyNameSpace
{
    public sealed class AsyncManager : IAsyncManager
    {
        private Action<Task> DefaultExeptionHandler = t =>
        {
            try { t.Wait(); }
            catch { /* Swallow the exception */ }
        };

        public Task Run(Action action, Action<Exception> exceptionHandler = null)
        {
            if (action == null) { throw new ArgumentNullException(nameof(action)); }

            var task = new Task(action);

            Action<Task> handler = exceptionHandler != null ?
                new Action<Task>(t => exceptionHandler(t.Exception.GetBaseException())) :
                DefaultExeptionHandler;

            var continuation = task.ContinueWith(handler,
                TaskContinuationOptions.ExecuteSynchronously
                | TaskContinuationOptions.OnlyOnFaulted);
            task.Start();

            return continuation;
        }
    }
}

Aquí, taskno se ejecuta directamente, sino que se crea, se asigna una continuación y solo entonces se ejecuta la tarea para eliminar el riesgo de que la tarea complete la ejecución (o arroje alguna excepción) antes de asignar una continuación.

El Runmétodo aquí devuelve la continuación, Taskpor lo que puedo escribir pruebas unitarias asegurándome de que la ejecución esté completa. Sin embargo, puede ignorarlo con seguridad en su uso.