随着System.Threading.Tasks.Task<TResult>我要管理可能被抛出的异常。我在寻找做到这一点的最好办法。到目前为止，我创建了一个基类，管理所有的呼叫内捕获的异常.ContinueWith(...)

我不知道是否有更好的方法也做到这一点。或者，即使是做一个好办法。

public class BaseClass
{
    protected void ExecuteIfTaskIsNotFaulted<T>(Task<T> e, Action action)
    {
        if (!e.IsFaulted) { action(); }
        else
        {
            Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
            {
                /* I display a window explaining the error in the GUI 
                 * and I log the error.
                 */
                this.Handle.Error(e.Exception);
            }));            
        }
    }
}   

public class ChildClass : BaseClass
{
    public void DoItInAThread()
    {
        var context = TaskScheduler.FromCurrentSynchronizationContext();
        Task.Factory.StartNew<StateObject>(() => this.Action())
                    .ContinueWith(e => this.ContinuedAction(e), context);
    }

    private void ContinuedAction(Task<StateObject> e)
    {
        this.ExecuteIfTaskIsNotFaulted(e, () =>
        {
            /* The action to execute 
             * I do stuff with e.Result
             */

        });        
    }
}

Answer 1:

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

上述C＃5.0和

您可以使用async和await关键字来简化这个伟大的为您处理。

async和await引入的语言使用，简化任务并行库，阻止您不必使用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和

您可以处理使用异常ContinueWith超载是需要从一个值TaskContinuationOptions枚举，就像这样：

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

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

该OnlyOnFaulted的成员TaskContinuationOptions枚举表明，如果在先行任务抛出异常的延续应该只执行。

当然，你可以有一个以上的呼叫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();

Answer 2:

你可以创建一些自定义任务的工厂，将生产与嵌入式异常处理处理任务。事情是这样的：

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

但是，如果说实话，我真的不知道为什么你想拥有完成处理代码。在任何情况下，这个决定取决于应用程序的逻辑。

文章来源: What is the best way to catch exception in Task?