Méthode la plus simple pour faire un feu et oublier la méthode en c # 4.0

J'aime vraiment cette question:

Le moyen le plus simple de faire un feu et d'oublier la méthode en C #?

Je veux juste savoir que maintenant que nous avons des extensions Parallel en C # 4.0, y a-t-il une meilleure façon plus propre de faire Fire & Forget avec Parallel linq?

Pas une réponse pour 4.0, mais il convient de noter que dans .Net 4.5, vous pouvez rendre cela encore plus simple avec:

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

Le pragma est de désactiver l'avertissement qui vous indique que vous exécutez cette tâche en tant que feu et oubliez.

Si la méthode à l'intérieur des accolades renvoie une tâche:

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

Décomposons cela:

Task.Run renvoie une tâche, qui génère un avertissement du compilateur (avertissement CS4014) indiquant que ce code sera exécuté en arrière-plan - c'est exactement ce que vous vouliez, nous désactivons donc l'avertissement 4014.

Par défaut, les tâches tentent de «rétablir le thread d'origine», ce qui signifie que cette tâche s'exécutera en arrière-plan, puis tentera de revenir au thread qui l'a démarré. Souvent, déclenchez et oubliez que les tâches se terminent une fois le thread d'origine terminé. Cela entraînera la levée d'une ThreadAbortException. Dans la plupart des cas, c'est inoffensif - c'est juste vous dire, j'ai essayé de rejoindre, j'ai échoué, mais vous vous en fichez de toute façon. Mais il est toujours un peu bruyant d'avoir ThreadAbortExceptions soit dans vos journaux en production, soit dans votre débogueur en développement local. .ConfigureAwait(false)est juste un moyen de rester ordonné et de dire explicitement, exécutez ceci en arrière-plan, et c'est tout.

Comme c'est verbeux, en particulier le pragma laid, j'utilise une méthode de bibliothèque pour cela:

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

Usage:

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

Avec la Taskclasse oui, mais PLINQ est vraiment pour interroger des collections.

Quelque chose comme ce qui suit le fera avec Task.

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

Ou même...

Task.Factory.StartNew(FireAway);

Ou...

new Task(FireAway).Start();

Où FireAwayest

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

Donc, en raison de la concordance des noms de classe et de méthode, cela bat la version de threadpool de six à dix-neuf caractères selon celui que vous choisissez :)

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

J'ai quelques problèmes avec la réponse principale à cette question.

Premièrement, dans une véritable situation d' incendie et d'oubli , vous n'aurez probablement pas awaitla tâche, il est donc inutile d'ajouter ConfigureAwait(false). Si vous n'indiquez pas awaitla valeur renvoyée par ConfigureAwait, cela ne peut avoir aucun effet.

Deuxièmement, vous devez être conscient de ce qui se passe lorsque la tâche se termine avec une exception. Considérez la solution simple suggérée par @ ade-miller:

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

Cela introduit un danger: si une exception non gérée s'échappe SomeMethod(), cette exception ne sera jamais, et elle pourrait ¹ soit relancée sur le thread finaliseur, plantage de votre application. Je recommanderais donc d'utiliser une méthode d'assistance pour s'assurer que toutes les exceptions qui en résultent sont respectées.

Vous pourriez écrire quelque chose comme ceci:

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

Cette implémentation doit avoir une surcharge minimale: la continuation n'est invoquée que si la tâche ne se termine pas correctement, et elle doit être appelée de manière synchrone (au lieu d'être planifiée séparément de la tâche d'origine). Dans le cas "paresseux", vous n'encourrez même pas une allocation pour le délégué de continuation.

Lancer une opération asynchrone devient alors trivial:

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

_{1. C'était le comportement par défaut dans .NET 4.0. Dans .NET 4.5, le comportement par défaut a été modifié de telle sorte que les exceptions non observées ne seraient pas renvoyées sur le thread du finaliseur (bien que vous puissiez toujours les observer via l'événement UnobservedTaskException sur TaskScheduler). Cependant, la configuration par défaut peut être remplacée, et même si votre application nécessite .NET 4.5, vous ne devez pas supposer que les exceptions de tâches non observées seront inoffensives.}

Juste pour résoudre un problème qui se produira avec la réponse de Mike Strobel:

Si vous utilisez var task = Task.Run(action)et après attribuez une continuation à cette tâche, vous courrez le risque de Tasklever une exception avant d'affecter une continuation de gestionnaire d'exceptions au Task. Ainsi, la classe ci-dessous devrait être exempte de ce risque:

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

Ici, le taskn'est pas exécuté directement, au lieu de cela, il est créé, une continuation est affectée, et alors seulement la tâche est exécutée pour éliminer le risque que la tâche termine l'exécution (ou lève une exception) avant d'attribuer une continuation.

La Runméthode ici renvoie la suite Taskpour que je puisse écrire des tests unitaires en m'assurant que l'exécution est terminée. Vous pouvez cependant l'ignorer en toute sécurité dans votre utilisation.