Task.WhenAny and Unobserved Exceptions

25
votes

Let's say I have three tasks, a, b, and c. All three are guaranteed to throw an exception at a random time between 1 and 5 seconds. I then write the following code:

await Task.WhenAny(a, b, c);

This will ultimately throw an exception from whichever task faults first. Since there's no try...catch here, this exception will bubble up to some other place in my code.

What happens when the remaining two tasks throw an exception? Aren't these unobserved exceptions, which will cause the entire process to be killed? Does that mean that the only way to use WhenAny is inside of a try...catch block, and then somehow observe the remaining two tasks before continuing on?

Follow-up: I'd like the answer to apply both to .NET 4.5 and .NET 4.0 with the Async Targeting Pack (though clearly using TaskEx.WhenAny in that case).

2
c#.nettask-parallel-library.net-4.5async-await
Did you try running the code to see what would happen? – Servy
@Servy The finalizer doesn't throw, but I can't see a good reason why not. – David Pfeffer
I think you meant Task.WhenAny(), await Task.WaitAny() wouldn't even compile. – svick
There is a false premise here: Task.WhenAny and Task.WaitAny will never throw exceptions. – porges
@DavidPfeffer I don't think so. Awaiting the task returned from WhenAny does not throw. It returns the task that caused the WhenAny to run to completion, and awaiting that task will throw. – Dave Van den Eynde

2 Answers

27
votes

What happens when the remaining two tasks throw an exception?

Those Tasks will complete in a faulted state.

Aren't these unobserved exceptions, which will cause the entire process to be killed?

Not anymore.

In .NET 4.0, the Task destructor would pass its unobserved exception to TaskScheduler.UnobservedTaskException, which would terminate the process if unhandled.

In .NET 4.5, this behavior was changed. Now, unobserved exceptions get passed to TaskScheduler.UnobservedTaskException, but then they are ignored if unhandled.

5
votes

Yes, the remaining task exceptions are unobserved. Pre .NET 4.5 you are obliged to observe them (not sure how the situation is on .NET 4.5, but it changed).

I usually write myself a helper method for fire-and-forget tasks like these:

    public static void IgnoreUnobservedExceptions(this Task task)
    {
        if (task.IsCompleted)
        {
            if (task.IsFaulted)
            {
                var dummy = task.Exception;
            }
            return;
        }

        task.ContinueWith(t =>
            {
                var dummy = t.Exception;
            }, TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
    }

You might want to include logging in production apps.