Where to handle an exception in a task of async action?

Question

The sample code is like this:

Action action = async () =>
{
    Console.WriteLine("Action start...");
    await Task.Delay(1000);
    throw new Exception("Exception from an async action");
};

Task.Run(action);

Console.ReadKey();

Where to handle the exception?

score 5 · Accepted Answer · answered Jul 21 '16 at 09:17

There are two things wrong with the code.

First, it is using an async void delegate, which prevents exceptions from working normally (for more information on avoiding async void, see my MSDN article on async best practices). It should be using Func<Task> instead of Action (for more information on async-friendly delegate types, see my blog post on synchronous and asynchronous delegate types):

Func<Task> action = async () =>
{
  Console.WriteLine("Action start...");
  await Task.Delay(1000);
  throw new Exception("Exception from an async action");
};

The second thing wrong is that it's using fire-and-forget when running the delegate on the thread pool. The "forget" part of "fire-and-forget" means "ignore all exceptions". To properly propagate exceptions, the task returned from Task.Run should be awaited (for more information on how await works with tasks, see my blog post on async and await):

await Task.Run(action);

Yes, you are correct. Actually, I have read your article before I posted here. The problem is I need to write an method to accept an Action instance as the parameter and execute it via a task. I didn't figure out a way to avoid unhandled exceptions causing my code crashed. — Wang, Jul 22 '16 at 01:30
@Wang: If the type *has* to be an `Action` (synchronous), and the implementation *has* to be asynchronous - which is a very rare position to be in - then you'll just have to catch all exceptions within your lambda expression. — Stephen Cleary, Jul 22 '16 at 01:34

score 2 · Answer 2 · edited May 23 '17 at 12:32

2

You can handle it inside task itself or outside by the caller, just mind the await on Task.Run, this ensures you catch exception instead of making it a silent death.`

Func<Task> action = async () =>
{
    Console.WriteLine("Action start...");
    await Task.Delay(1000);
    throw new Exception("Exception from an async action");
};

try
{
   await Task.Run(action);
}
catch(Exception ex)
{
    Console.WriteLine(ex.Message);
}

Console.ReadKey();

Also, check this post about differences of async/await exception handling

edited May 23 '17 at 12:32

Community

1
1

answered Jul 21 '16 at 05:57

VidasV

4,335
1
28
50

But the OP doesn't await the `Task`. – Zein Makki Jul 21 '16 at 06:09
1

Neither he does try/catch, this is why we are providing answers for him, right? – VidasV Jul 21 '16 at 06:12
1

Have you executed your code piece? I would not post it if this could be resolved so easy. – Wang Jul 22 '16 at 01:08
You are absolutely right... Sorry for misleading you. Try replacing Action with Func as Stephen suggests. I will also, edit mine. – VidasV Jul 22 '16 at 06:16

Zein Makki · Answer 3 · 2016-07-21T06:09:33.573

Since your using Task.Run(action); and you're not awaiting the task object returned, the exception is thrown in another thread and you can't handle it in the caller thread (using ContinueWith for example);

Then You need to handle the exception inside the Action delegate:

Action action = async () =>
{
    try
    {
        Console.WriteLine("Action start...");
        await Task.Delay(1000);
        throw new Exception("Exception from an async action");
    }
    catch(Exception ex)
    {
        // do something
    }
};

score 0 · Answer 4 · answered Jul 21 '16 at 06:45

Quite often people think that when using async-await several threads are involved, while in fact it is not, unless you specify to do so.

Read Eric Lippert about async-await search somewhere in the middle for async await.

He compares async await with a cook: when toasting bread he can wait until the bread is toasted before boiling water for tea and eggs. It would be more efficient if he started boiling water and then turn back to see if the bread is toasted.

The same happens in your code. During your await task.Delay your thread doesn't start waiting. Instead it goes up its call stack to see if one of the callers (who all must be async!) is not awaiting, and thus can continue processing without the result of its calls. After a while it returns to see if the Task.Delay is finished and continues the next statement where the exception is thrown.

Note that in this scenario there is only one thread involved. Exception catching is done as all other exception catching. Although the catcher can check the call stack, he is not sure what pieces of code are executed and which ones aren't. In this respect there is no big difference with non-async-await

Where to handle an exception in a task of async action?

4 Answers4