5

I'm getting some behaviour which I cannot understand when throwing exceptions in async methods.

The following code will throw an exception immediately when calling the ThrowNow method. If I comment that line out and throw the exception directly then the exception is swallowed and not raised in the Unobserved event handler.

public static async void ThrowNow(Exception ex){
    throw ex;
}

public static async Task TestExAsync()
{
    ThrowNow(new System.Exception("Testing")); // Throws exception immediately
    //throw new System.Exception("Testing");   // Exception is swallowed, not raised in unobserved event

    await Task.Delay(1000);
}

void Main()
{  
    var task = TestExAsync();
}

Something a little more confusing, if I remove the async keyword from the ThrowNow method, the exception is swallowed yet again.

I thought async methods run synchronously until reaching a blocking method. In this case, it seems that removing the async keyword is making it behave asynchronously.

Improve this question

2 Answers 2

Reset to default
7

I thought async methods run synchronously until reaching a blocking method.

They do, but they're still aware that they're executing within an asynchronous method.

If you throw an exception directly from an async void method, the async mechanism is aware that you'd have no way of observing that exception - it won't be thrown back to the caller, because exceptions thrown in async methods are only propagated through tasks. (The returned task becomes faulted.) It would be odd for an exception thrown before the first blocking await expression to be thrown directly, but exceptions afterwards to be handled differently.

As far as I'm aware, an exception thrown by an async void method is passed directly to the synchronization context, if there is one. (A continuation is posted to the synchronization context that just throws the exception.) In a simple console app, there isn't a synchronization context, so instead it's thrown as an unreported exception.

If you change your void method to return Task, then instead you'll just have an exception which could have been observed, but isn't (because you're not using the return value in TestExAsync).

Does that make any sense? Let me know if you'd like more clarification - it's all a bit tortuous (and I don't know how well documented it is).

EDIT: I've found a bit of documentation, in the C# 5 spec section 10.15.2:

If the return type of the async function is void, evaluation differs from the above in the following way: Because no task is returned, the function instead communicates completion and exceptions to the current thread's synchronization context. The exact definition of synchronization context is implementation-dependent, but is a representation of "where" the current thread is running. The synchronization context is notified when evaluation of a void-returning async function commences, completes successfully, or causes an uncaught exception to be thrown.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

Yup, the general recommendation for async is to never return void unless you need to do so to match a method signature (for overloading a subclass or implementing an interface).
As far as I know, using async-await from a console application isn't documented very well.
"If you throw an exception directly from an async void method, the async mechanism is aware that you'd have no way of observing that exception - it won't be thrown back to the caller," - In this case though, the async void method is throwing an exception back, instantly, or so it appears. (I should mention the use of LINQPad here so I guess it's a console app under the hood). Could it be that the exception being thrown in the async void method is doing so in such a quick fashion that it appears to be throwing instantly? BTW this is not an unobserved exception.
@VincePanuccio: No, the problem isn't the speed. The method isn't directly throwing the exception - it's telling its synchronization context about the exception, which is in turn rethrowing it because it hasn't got any other way of indicating it.
0

Something a little more confusing, if I remove the async keyword from the ThrowNow method, the exception is swallowed yet again.

Exceptions are not "swallowed".

In addition to what Jon Skeet said, consider this code where ThrowNow is not marked async:

static void ThrowNow(Exception ex)
{
    throw ex;
}

static async Task TestExAsync()
{
    ThrowNow(new System.Exception("Testing"));

    await Task.Delay(1000);
}

static void Main()
{
    var task = TestExAsync();

    Console.WriteLine(task.Exception);
}

As you can see, exceptions are not "swallowed", they're just communicated to you in the task returned from an asynchronous method.

Obviously, that also means you cannot try catch them, unless you await the task:

static void Main()
{
    AsyncMain();
}

static async void AsyncMain()
{
    var task = TestExAsync();

    try
    {
        await task;
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex);
    }
}
Improve this answer

2 Comments

Exceptions can be swallowed blogs.msdn.com/b/pfxteam/archive/2011/09/28/10217876.aspx
@VincePanuccio They can be unobserved and posted to the synchronization context, as Jon Skeet said. But you claimed they are "swallowed" when ThrowNow is not marked async. My answer shows you that nothing is swallowed in that scenario, which seems to be what your question is about.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.