Navigating Exception Backtraces in Visual Studio

• Download source - 1.74 KB

Introduction

Ever been angry about Visual Studio's inability to provide easy exception backtrace navigation? Here is the solution.

I wrote a nice little debug helper function called PrintException which has proven very useful to me and my team for our everyday work. It prints the relevant information about an exception and its inner exceptions to the output recursively. The clue is, that it does this in a format that is understood by the error parser of Microsoft Visual Studio. So if you get an exception, you can easily navigate to the exact location in your source files by double-clicking on the lines in the printed stacktrace. It also prints all inner exceptions recursively with increasing indent for better readability.

Using the Code

Basically all you need to do is to wrap your main routine with a try-catch statement and call Debug.PrintException(e); on the caught exception e. Once the exception has been printed to standard out, you may also stop the debugger and you still can navigate to the source of error by double-clicking on a backtrace line. Here is an example:

public static class PrintExceptionTest
{
  static void test()
  {
    try { test1(); }
    catch (Exception e) { throw new Exception("outer exception message", e); }
  }

  static void test1()
  {
    throw new InvalidOperationException("inner exception message");
  }

  public static void Main()
  {
    try { test(); }
    catch (Exception e) { Debug.PrintException(e); }
    Console.ReadLine();
  }
}

The formatted exceptions in the output window look like this:

********************************************************************************
Exception: "outer exception message"
--------------------------------------------------------------------------------
InnerException:
   ********************************************************************************
   InvalidOperationException: "inner exception message"
   --------------------------------------------------------------------------------
     c:\C#\snippets\print_exception.cs(58,1):   PrintExceptionTest.test1()
     c:\C#\snippets\print_exception.cs(48,1):   PrintExceptionTest.test()
   ********************************************************************************
  c:\C#\snippets\print_exception.cs(52,1):   PrintExceptionTest.test()
  c:\C#\snippets\print_exception.cs(65,1):   PrintExceptionTest.Main()
******************************************************************************** 

As I have experienced, the innermost exception is the most important one, so I do a depth first recursion on the inner exceptions. Your mileage may vary.

Note: Error parser formatting works, of course, only when the exception is raised in an assembly that has been compiled in debug mode. Also the redirection of standard out to Visual Studio's output window (the only place where you can navigate using the built-in error parser) is only activated by default for a Windows Forms application, not for a Console application.

The Code

Since the code snippet that does the exception formatting is so tiny I put it up here directly:

using System;

public static class Debug
{
  public static void PrintException(Exception exception)
  {
    PrintException(exception, "");
  }

  public static void PrintException(Exception exception, string indent)
  {
    string stars = new string('*', 80);
    Console.WriteLine(indent + stars);
    Console.WriteLine(indent + "{0}: \"{1}\"", 
	exception.GetType().Name, exception.Message);
    Console.WriteLine(indent + new string('-', 80));
    if (exception.InnerException != null)
    {
      Console.WriteLine(indent + "InnerException:");
      PrintException(exception.InnerException, indent + "   ");
    }
    foreach (string line in exception.StackTrace.Split(new string[] 
	{ " at " }, StringSplitOptions.RemoveEmptyEntries))
    {
      if (string.IsNullOrEmpty(line.Trim())) continue;
      string[] parts;
      parts = line.Trim().Split(new string[] { " in " }, 
	StringSplitOptions.RemoveEmptyEntries);
      string class_info = parts[0];
      if (parts.Length == 2)
      {
        parts = parts[1].Trim().Split(new string[] { "line" }, 
		StringSplitOptions.RemoveEmptyEntries);
        string src_file = parts[0];
        int line_nr = int.Parse(parts[1]);
        Console.WriteLine(indent + "  {0}({1},1):   {2}", 
		src_file.TrimEnd(':'), line_nr, class_info);
      }
      else
        Console.WriteLine(indent + "  " + class_info);
    }
    Console.WriteLine(indent + stars);
  }
} 

That's it. Works very well for me. Let me know if you came across a special case where the formatting did not work.

If you are interested in my other articles, see my blog on C# and Ruby.

History

• 22^nd November, 2007: Initial post

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)