在任务中捕获异常的最佳方法是什么？

有两种方法可以做到这一点，具体取决于您使用的语言版本。

C# 5.0 及以上

您可以使用 async 和 await 关键字为您简化大部分操作。

语言中引入了 async 和 await 以简化 Task Parallel Library 的使用，避免您必须使用 ContinueWith 并允许您继续以自上而下的方式进行编程。

因此，您可以简单地使用 try/catch 块来捕获异常，如下所示：

try
{
    // Start the task.
    var task = Task.Factory.StartNew<StateObject>(() => { /* action */ });

    // Await the task.
    await task;
}
catch (Exception e)
{
    // Perform cleanup here.
}

请注意，封装上述 必须 使用的方法应用了 async 关键字，以便您可以使用 await。

C# 4.0 及以下

您可以使用从 TaskContinuationOptions enumeration 获取值的 ContinueWith overload 处理异常，如下所示：

// Get the task.
var task = Task.Factory.StartNew<StateObject>(() => { /* action */ });

// For error handling.
task.ContinueWith(t => { /* error handling */ }, context,
    TaskContinuationOptions.OnlyOnFaulted);

TaskContinuationOptions 枚举的 OnlyOnFaulted 成员指示应该仅在前面的任务引发异常时执行继续。

当然，在处理非异常情况时，您可以对同一个先行词进行多次调用 ContinueWith：

// Get the task.
var task = new Task<StateObject>(() => { /* action */ });

// For error handling.
task.ContinueWith(t => { /* error handling */ }, context, 
    TaskContinuationOptions.OnlyOnFaulted);

// If it succeeded.
task.ContinueWith(t => { /* on success */ }, context,
    TaskContinuationOptions.OnlyOnRanToCompletion);

// Run task.
task.Start();

---

您可以创建一些自定义任务工厂，它将生成嵌入了异常处理处理的任务。像这样的东西：

using System;
using System.Threading.Tasks;

class FaFTaskFactory
{
    public static Task StartNew(Action action)
    {
        return Task.Factory.StartNew(action).ContinueWith(
            c =>
            {
                AggregateException exception = c.Exception;

                // Your Exception Handling Code
            },
            TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously
        ).ContinueWith(
            c =>
            {
                // Your task accomplishing Code
            },
            TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously
        );
    }

    public static Task StartNew(Action action, Action<Task> exception_handler, Action<Task> completion_handler)
    {
        return Task.Factory.StartNew(action).ContinueWith(
            exception_handler,
            TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously
        ).ContinueWith(
            completion_handler,
            TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously
        );
    }
};

您可以在客户端代码中忘记从该工厂生成的任务的异常处理。同时，您仍然可以等待此类任务的完成或以“即发即弃”的方式使用它们：

var task1 = FaFTaskFactory.StartNew( () => { throw new NullReferenceException(); } );
var task2 = FaFTaskFactory.StartNew( () => { throw new NullReferenceException(); },
                                      c => {    Console.WriteLine("Exception!"); },
                                      c => {    Console.WriteLine("Success!"  ); } );

task1.Wait(); // You can omit this
task2.Wait(); // You can omit this

但老实说，我不确定你为什么想要完成处理代码。无论如何，此决定取决于您的应用程序的逻辑。

---