Question

I noticed that exceptions thrown from a thread other than my main application thread are not caught by the DispatcherUnhandledException event handler. So I have to manually throw them like this:

Task.Factory.StartNew(() =>
{
    throw new Exception("oops! something went wrong...");

}).ContinueWith((task) =>
{
    if (task.IsFaulted)
    {
        App.Current.Dispatcher.Invoke(new Action(() =>
        {
            throw task.Exception.InnerExceptions.First();
        }));
    }
});

However, I don’t want to add the above ContinueWith method to every single Task I create. I would rather have some way for this to be handled automatically.

Answer 1

The following class solves this problem:

/// <summary>
/// Extends the System.Threading.Tasks.Task by automatically throwing the first exception to the main application thread.
/// </summary>
public class TaskEx
{
    public Task Task { get; private set; }

    private TaskEx(Action action)
    {
        Task = Task.Factory.StartNew(action).ContinueWith((task) =>
        {
            ThrowTaskException(task);
        });
    }

    public static TaskEx StartNew(Action action)
    {
        if (action == null)
        {
            throw new ArgumentNullException();
        }

        return new TaskEx(action);
    }

    public TaskEx ContinueWith(Action<Task> continuationAction)
    {
        if (continuationAction == null)
        {
            throw new ArgumentNullException();
        }

        Task = Task.ContinueWith(continuationAction).ContinueWith((task) =>
        {
            ThrowTaskException(task);
        });

        return this;
    }

    private void ThrowTaskException(Task task)
    {
        if (task.IsFaulted)
        {
            App.Current.Dispatcher.Invoke(new Action(() =>
            {
                throw task.Exception.InnerExceptions.First();
            }));
        }
    }
}

Now I can simply use the following code (exactly the same as the Task class):

TaskEx.StartNew(() =>
{
    // do something that may cause an exception
}).ContinueWith((task) =>
{
    // then do something else that may cause an exception
}).ContinueWith((task) =>
{
    // then do yet something else that may cause an exception
});

Unlike the Task class, however, any exception thrown from one of these threads will be AUTOMATICALLY caught by my DispatcherUnhandledException event handler.