를 사용하면 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사용하여 단순화하는 언어에 도입 된 태스크 라이브러리를 병렬 사용하는 데에서 당신을 방지 ContinueWith하고 당신이 하향식 (top-down) 방식으로 프로그램을 계속 할 수 있도록.

이 때문에 다음과 같이 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();

예외 처리 처리가 포함 된 작업을 생성하는 사용자 지정 작업 팩토리를 만들 수 있습니다. 이 같은:

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

하지만 솔직히 말해서 왜 완료 처리 코드를 갖고 싶은지 잘 모르겠습니다. 어쨌든이 결정은 응용 프로그램의 논리에 따라 다릅니다.