Visual Studio: How to break on handled exceptions?

Question

I would like Visual Studio to break when a handled exception happens (i.e. I don't just want to see a "First chance" message, I want to debug the actual exception).

e.g. I want the debugger to break at the exception:

try
{
   System.IO.File.Delete(someFilename);
}
catch (Exception)
{
   //we really don't care at runtime if the file couldn't be deleted
}

I came across these notes for Visual Studio.NET:

1) In VS.NET go to the Debug Menu >> "Exceptions..." >> "Common Language Runtime Exceptions" >> "System" and select "System.NullReferenceException"

2) In the bottom of that dialog there is a "When the exception is thrown:" group box, select "Break into the debugger"

3) Run your scenario. When the exception is thrown, the debugger will stop and notify you with a dialog that says something like: "An exception of type "System.NullReferenceException" has been thrown. [Break] [Continue]"

Hit [Break]. This will put you on the line of code that's causing the problem.

But they do not apply to Visual Studio 2005 (there is no Exceptions option on the Debug menu).

Does anyone know where the find this options dialog in Visual Studio that the "When the exception is thrown" group box, with the option to "Break into the debugger"?

Update: The problem was that my Debug menu didn't have an Exceptions item. I customized the menu to manually add it.

Answer 1

With a solution open, go to the Debug - Windows - Exception Settings (Ctrl+Alt+E) menu option. From there you can choose to break on Thrown or User-unhandled exceptions.

EDIT: My instance is set up with the C# "profile" perhaps it isn't there for other profiles?

Answer 2

There is an 'exceptions' window in VS2005 ... try Ctrl+Alt+E when debugging and click on the 'Thrown' checkbox for the exception you want to stop on.

Answer 3

Took me a while to find the new place for expection settings, therefore a new answer.

Since Visual Studio 2015 you control which Exceptions to stop on in the Exception Settings Window (Debug->Windows->Exception Settings). The shortcut is still Ctrl-Alt-E.

The simplest way to handle custom exceptions is selecting "all exceptions not in this list".

Here is a screenshot from the english version:

Here is a screenshot from the german version:

Answer 4

From Visual Studio 2015 and onward, you need to go to the "Exception Settings" dialog (Ctrl+Alt+E) and check off the "Common Language Runtime Exceptions" (or a specific one you want i.e. ArgumentNullException) to make it break on handled exceptions.

Step 1 Step 2

Answer 5

Check Managing Exceptions with the Debugger page, it explains how to set this up.

Essentially, here are the steps (during debugging):

1. On the Debug menu, click Exceptions.

2. In the Exceptions dialog box, select Thrown for an entire category of exceptions, for example, Common Language Runtime Exceptions.

   -or-

   Expand the node for a category of exceptions, for example, Common Language Runtime Exceptions, and select Thrown for a specific exception within that category.

Answer 6

A technique I use is something like the following. Define a global variable that you can use for one or multiple try catch blocks depending on what you're trying to debug and use the following structure:

if(!GlobalTestingBool)
{
   try
   {
      SomeErrorProneMethod();
   }
   catch (...)
   {
      // ... Error handling ...
   }
}
else
{
   SomeErrorProneMethod();
}

I find this gives me a bit more flexibility in terms of testing because there are still some exceptions I don't want the IDE to break on.

Answer 7

The online documentation seems a little unclear, so I just performed a little test. Choosing to break on Thrown from the Exceptions dialog box causes the program execution to break on any exception, handled or unhandled. If you want to break on handled exceptions only, it seems your only recourse is to go through your code and put breakpoints on all your handled exceptions. This seems a little excessive, so it might be better to add a debug statement whenever you handle an exception. Then when you see that output, you can set a breakpoint at that line in the code.

Answer 8

There are some other aspects to this that need to be unpacked. Generally, an app should not throw exceptions unless something exceptional happens.

Microsoft's documentation says:

For conditions that are likely to occur but might trigger an exception, consider handling them in a way that will avoid the exception.

and

A class can provide methods or properties that enable you to avoid making a call that would trigger an exception.

Exceptions degrade performance and disrupt the debugging experience because you should be able to break on all exceptions in any running code.

If you find that your debugging experience is poor because the debugger constantly breaks on pointless exceptions, you may need to detect handled exceptions in your tests. This technique allows you to fail tests when code throws unexpected exceptions.

Here are some helper functions for doing that

public class HandledExceptionGuard
{
    public static void DoesntThrowException(Action test,
      Func<object?, Exception, bool>? ignoreException = null)
    {
        var errors = new List<ExceptionInformation>();

        EventHandler<FirstChanceExceptionEventArgs> handler = (s, e) =>
        {
            if (e.Exception is AssertFailedException) return;
            if (ignoreException?.Invoke(s, e.Exception) ?? false) return;
            errors.Add(new ExceptionInformation(s, e.Exception, AppDomain.CurrentDomain.FriendlyName));
        };

        AppDomain.CurrentDomain.FirstChanceException += handler;

        test();

        AppDomain.CurrentDomain.FirstChanceException -= handler;

        if (errors.Count > 0)
        {
            throw new ExceptionAssertionException(errors);
        }
    }

    public async static Task DoesntThrowExceptionAsync(Func<Task> test,
      Func<object?, Exception, bool>? ignoreException = null)
    {
        var errors = new List<ExceptionInformation>();

        EventHandler<FirstChanceExceptionEventArgs> handler = (s, e) =>
        {
            if (e.Exception is AssertFailedException) return;
            if (ignoreException?.Invoke(s, e.Exception) ?? false) return;
            errors.Add(new ExceptionInformation(s, e.Exception, AppDomain.CurrentDomain.FriendlyName));
        };

        AppDomain.CurrentDomain.FirstChanceException += handler;

        await test();

        AppDomain.CurrentDomain.FirstChanceException -= handler;

        if (errors.Count > 0)
        {
            throw new ExceptionAssertionException(errors);
        }
    }
}

If you wrap any code in these methods as below, the test will fail when a handled exception occurs. You can ignore exceptions with the callback. This validates your code against unwanted handled exceptions.

[TestClass]
public class HandledExceptionTests
{
    private static void SyncMethod()
    {
        try
        {
            throw new Exception();
        }
        catch (Exception)
        {

        }
    }

    private static async Task AsyncMethod()
    {
        try
        {
            await Task.Run(() => throw new Exception());
        }
        catch (Exception)
        {

        }
    }

    [TestMethod]
    public void SynchronousTest()
    {
        HandledExceptionGuard.DoesntThrowException(() => SyncMethod());
    }

    [TestMethod]
    public async Task AsyncTest()
    {
        await HandledExceptionGuard.DoesntThrowExceptionAsync(() => AsyncMethod());
    }
}