З 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
             */

        });        
    }
}

Це можна зробити двома способами, залежно від версії мови, якою ви користуєтесь.

C # 5.0 і вище

Ви можете використовувати ключові слова asyncта, awaitщоб спростити для вас значну частину цього.

asyncі awaitбули введені в мову для спрощення використання бібліотеки завдань Parallel , запобігаючи необхідності використання ContinueWithта дозволяючи продовжувати програмувати зверху вниз.

Через це ви можете просто використовувати try/catch block, щоб зловити виняток, наприклад:

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

Ви можете створити власну фабрику завдань, яка буде створювати вбудовані завдання із обробкою винятків. Щось на зразок цього:

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

Ви можете забути про обробку винятків для завдань, виготовлених на цьому заводі, у коді вашого клієнта. У той же час ви все ще можете почекати закінчення таких завдань або використовувати їх у стилі Fire-and-Forget:

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

Але якщо чесно, я не дуже впевнений, чому ви хочете мати код обробки завершень. У будь-якому випадку це рішення залежить від логіки вашої заявки.