在C＃4.0中执行“忘却”方法的最简单方法

我真的很喜欢这个问题：

在C＃中最简单的方法来做一个“忘了”的方法？

我只是想知道，既然我们在C＃4.0中具有Parallel扩展，是否有更好的更清洁的方法来使用Parallel linq进行Fire＆Forget？

这不是4.0的答案，但是值得注意的是，在.Net 4.5中，您可以使用以下方法使此过程更加简单：

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

实用程序是禁用警告，该警告告诉您您正在运行此任务，而忘记了。

如果花括号内的方法返回Task：

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

让我们分解一下：

Task.Run返回一个Task，该任务会生成一个编译器警告（警告CS4014），指出该代码将在后台运行-这正是您想要的，因此我们禁用警告4014。

默认情况下，Tasks尝试“编组回原始线程”，这意味着此Task将在后台运行，然后尝试返回到启动它的线程。通常，当执行完原始线程后，便会忘记执行任务。这将导致引发ThreadAbortException。在大多数情况下，这是无害的-只是告诉您，我尝试重新加入，但失败了，但是您无论如何都不在乎。但是，无论是在Production的日志中还是在本地dev的调试器中都具有ThreadAbortExceptions，仍然有点麻烦。.ConfigureAwait(false)只是保持整洁并明确地说在后台运行该程序的一种方法，仅此而已。

由于这比较罗word，尤其是丑陋的编译指示，因此我使用了一种库方法：

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

用法：

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

随着 Task类是，但是PLINQ实际上是用于查询集合的。

像下面这样的东西可以用Task来完成。

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

甚至...

Task.Factory.StartNew(FireAway);

要么...

new Task(FireAway).Start();

哪里FireAway是

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

因此，凭借类名和方法名的简洁性，这取决于选择的字符集，使线程池版本比六个字符多十九个字符：)

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

对于这个问题的主要答案，我有几个问题。

首先，在真正的“一劳永逸”情况下，您可能不会await执行任务，因此追加是没有用的ConfigureAwait(false)。如果您没有await返回的值ConfigureAwait，那么它可能不会起作用。

其次，您需要知道任务完成并发生异常时会发生什么。考虑@ ade-miller建议的简单解决方案：

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

这带来了一种危险：如果未处理的异常从中逸出SomeMethod()，则该异常将永远不会被观察到，并且可能在终结器线程上被重新抛出¹，从而使您的应用程序崩溃。因此，我建议使用辅助方法来确保观察到任何结果异常。

您可以这样写：

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

此实现应具有最小的开销：仅当任务未成功完成时才调用继续，并且应同步调用（而不是与原始任务分开计划）。在“惰性”情况下，您甚至不会为延续委托分配任何资源。

启动异步操作变得微不足道：

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

_{1.这是.NET 4.0中的默认行为。在.NET 4.5中，默认行为已更改，使得未观察到的异常会不会重新抛出终结线程（虽然你仍然可以通过上的TaskScheduler的UnobservedTaskException事件观察它们）。但是，默认配置可以被覆盖，即使您的应用程序需要.NET 4.5，您也不应假定未观察到的任务异常将是无害的。}

只是为了解决Mike Strobel的答案可能发生的一些问题：

如果您使用var task = Task.Run(action)并为该任务分配了延续，那么在将Task异常处理程序延续分配给之前，您将有引发一些异常的风险Task。因此，下面的类应该没有这种风险：

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

在这里，task不是直接运行，而是创建了，分配了延续，然后才运行任务，以消除任务在分配延续之前完成执行（或引发某些异常）的风险。

Run这里的方法返回延续，Task因此我能够编写单元测试以确保执行完成。不过，您可以放心使用它。