Ответ 1

Есть два способа сделать это, в зависимости от версии используемого вами языка.

С# 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.

С# 4.0 и ниже

Вы можете обрабатывать исключения, используя ContinueWith overload, который принимает значение из 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();

Ответ 2

Вы можете создать некоторую пользовательскую задачу factory, которая будет создавать задачи с встроенной обработкой обработки исключений. Что-то вроде этого:

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

Вы можете забыть об обработке исключений для Заданий, созданных из этого factory в вашем клиентском коде. В то же время вы все еще можете ждать завершения таких Заданий или использовать их в стиле "Пожар и Забыть":

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

Но если честно, я не совсем уверен, почему вы хотите иметь код обработки завершения. В любом случае это решение зависит от логики вашего приложения.