Async exception not caught by debugger

Question

I'm working on an MVC5 project in VS2013. I seem to be finding that most (but not all) of my exceptions are being ignored by the debugger and as a result I end up with the exception and stack trace simply being written to the browser, precluding any examination of the objects involved in the exception.

For instance - I deliberately code an exception to prove the point:

    <Authorize(Roles:="IdentityAdmin")>
Public Async Function Import(model As RegisterViewModel) As Task(Of ActionResult)
    Dim a As Object = "he"
    Dim b As Integer = a

Clearly the last line will throw a 'type mismatch' exception which I think should result in the debugger halting execution, highlighting the error in the VS2013 UI to enable me to examine the various objects and determine the problem.

Instead I simply find myself with the browser detailing the exception and VS2013 unresponsive:

Server Error in '/' Application.

Input string was not in a correct format.

Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

Exception Details: System.FormatException: Input string was not in a correct format.

Source Error:

Line 291: If Db.Users.Find(acct.username) Is Nothing Then

Line 292: Dim a As Object = "he"

Line 293: Dim b As Integer = a

When I insert the same exception-generating code into a non-async part of the code the VS debugger does catch the exception - so I am guessing this is an issue with debugging async code. Is it really the case that the VS debugger can't catch these exceptions?

UPDATE

After further searching I came across a suggestion to disable 'Just My Code' and manually enable various types of exception. There was the expected hailstorm of First Chance Exceptions most of which I could tune out by disabling certain exceptions. But this DID 'fix' the behaviour described above. It seems that the debugger is regarding my child async threads as 'Not My Code'. Slightly baffled but I guess this could be an answer of sorts?

This worked for me too! If you answer your own question, I (and others) can vote for it. I voted up all your other posts to give you more rep, because there are some restrictions when rep is below 50. — Tom Bushell
– Tom Bushell, Commented Apr 23, 2014 at 20:21
Yes this is the answer. "Just my Code" should (IMO) always be turned off--it creates problems/confusions, and doesn't add much value. — Matt Smith
– Matt Smith, Commented Apr 23, 2014 at 22:16

Rich Freeman · Accepted Answer · 2014-04-25 07:40:57Z

2

As per the update above, the problematic behaviour detailed in the question seems to be fixed by a combination of:

Turn off 'Just My Code' in the debugger options.
Enable certain classes of exceptions in Debug/Exceptions.. - in my case Common Language Runtime Exceptions and Managed Debugging Assistants seemed to ensure that the debugger caught all my exceptions (async or otherwise).
Disable thrown (but unremarkable) exceptions which cause most grief (wrong globalisation etc).

The last two stages were happened upon somewhat by trial and error and I suspect I should ultimately chase down most of these non-breaking exceptions when I clean the project up.

answered Apr 25, 2014 at 7:40

Rich Freeman

1,0472 gold badges10 silver badges23 bronze badges

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

Comments

Andrew Hall - MSFT · Accepted Answer · 2014-04-25 17:12:31Z

Disabling Just My Code should not make a difference in this case, enabling "Break when an exception is thrown" is what you want to make the debugger stop at the correct place.

The issue is that when you make the method Async, it runs in a background Task. The Task will catch any exceptions that occur in the code it is executing and re-throw that exception to whatever uses the result of the Task. So for example if you have the following MVC code

Async Function Index() As Task(Of ActionResult)
    Dim n as Integer = Await Method1()
    Return View()
End Function

Async Function Method1() As Task(Of Integer)
   Dim a As Integer = 0
   Dim b As Integer = 1 / b
   Return b
End Function

The Task executing the code inside of Method1 will catch the exception, and throw it in Index since it is using the result of Method1, then the Task executing Index will catch that exception and re-throw it to the MVC framework code that is using the result of Index, and then the MVC framework handles the exception and displays the error page.

When Just My Code is enabled and methods are executing synchronously the debugger will stop when an exception propagates out of user code with the message that it was "user unhandled". In the case above if an exception propagates from Index to the MVC framework which is not your code, the debugger will stop when JMC is enabled. Since in the case of an asynchronous method the exception is not unhandled but caught by the Task, it does not cross out of user code so disabling Just My code will not make a difference.

The reverse of this is, if an exception occurs in your synchronous method and you have disabled Just My Code, the debugger would not stop anyway, because there is no notion of "User Unhandled" when JMC is disabled and the MVC framework will ultimately handle that exception.

Very interesting thank you. The JMC solution I proposed does seem to work when used in conjunction with enabling the 'Exceptions...' but having just tried your suggestion (JMC enabled, set CLR exceptions to Thrown=true) also seems to be an answer - and is probably the better one if it works in all cases and it feels less 'hit-and-miss' in respect of disabling first-chance-exceptions.

Collectives™ on Stack Overflow

Async exception not caught by debugger

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related