Debugging in Visual Studio with OzCode

Introduction

As developers, we often forget (and sometimes even dread) the debugging step in the software development ladder, but when the time comes to debug our software, we usually perform the same manual steps, constantly expanding and examining various pieces of information, trying to capture in our minds the complete picture of what went wrong and why.

OzCode, the innovative C# debugging extension for Visual Studio, completely transforms the way we debug our C# code! OzCode enhances the Visual Studio debugging experience with powerful visualizations, smart object inspection, searching and filtering collections, allowing you to focus on the relevant data. In this article, we demonstrate some of OzCode's capabilities.

Getting Started: Reveal, Simplify and Search

After installing OzCode, you will notice a number of new things when you run your program under the debugger. As soon as a breakpoint is hit, hover over any of the variables, and you will see OzCode's enhanced DataTip:

The DataTip, or the Object Inspector, is where you spend most of your time inspecting values, trying to find what you're looking for. OzCode's DataTip allows you to get lots of information about your objects without having to expand each and every one of them. In Figure 1, all 30 of the customers look alike, making it hard to tell which is which. Each Customer object might contain many properties, but we might only be interested in a few. Using OzCode's Reveal we can look for just the ones we want without wasting time:

Reveal allows us to focus only on the properties that we're interested in, such as ID and FullName, by clicking on the icon next to the property name, and those "starred" properties will immediately appear for all the items of the same type in that collection.

OzCode also allows you to do a Search inside any type of object, by using the Search text box at the bottom of the DataTip. The results will be shown as soon as they are found:

Now that we've made our objects look more clear, it is time to make sense of how the rest of the code is being used, what methods are being called and what values are returned from them. We can get all this information in a glance with OzCode's strong>Simplify. When stepping over a statement, OzCode provides a visual representation of what each predicate is evaluated to, and the return value of any inline and nested method calls.

Clicking on the icon will place additional information on each part of the statement, allowing us to see the overall result, and let us drill-down into individual steps:

Using the arrows (or pressing the shortcut keys Alt-K or Alt-J), we can drill down into individual parts of the if statement. In the example in Figure 6, if we press down once, we will see that the method IsLotteryWinner returned true (therefore IsVIP was not even executed), but IsBudgetAvailable returned false, therefore the result of the entire statement is false. Drilling down once more would show us the result of CalculateGiftCost as well.

Simplify makes it really easy to figure out why certain values were returned after the fact, without having to use temporary variables or evaluating expressions in the Watch.

Visualizing the Debugger

When you debug your program with OzCode installed, you will notice a couple of new icons. Most of those icons provide contextual actions, depending on what is happening in your code. Other icons appear always, allowing you to perform debugging-related operations easily.

QuickActions allow you to perform various operations on the code that is currently being debugged. The image in Figure 8 shows a set of context actions available for the current line being stepped on in the debugger. QuickActions can be activated with a mouse-click, or by pressing Alt-Shift-D.

The first option we see in Figure 8 is Show all Instances. This feature allows you to find all the instances of the particular type that is currently loaded in your application's memory (the managed heap):

Here we can see all the instances that are currently active in memory. OzCode remembers all previous settings defined for a particular type, such as Reveal, as well as allowing you to Search inside the displayed items.

Show all Instances is also useful for exploring the managed heap and visualizing any reference or boxed value type – by specifying its fully qualified name (aided by IntelliSense). In Figure 10 below, all the System. String instances of our process are being displayed:

In addition, we can use Show all Instances to find all the values of particular properties or fields of an object in all instances, by clicking on the   icon next to the property:

Finally, clicking the icon at the class name level will allow you to quickly add (or remove any existing) breakpoints in all the members in the type!

Next, we'll look at how we can get rich information about the code that is executing without changing a single line, or littering the code with logging statements.

Suppose you have a method, and it's being called from multiple threads, so it's not really convenient to try and debug it by just putting in a breakpoint and trying to step through the code – you'd be constantly flipping around between threads and losing context. With OzCode's Tracepoints, we can trace all calls to this method. Clicking the icon next to the method name will allow you to trace every entry into the method. After selecting it, the following window will open:

You can specify any custom message in the Expression field, as well as specifying the values for any local variables or other code expressions in general. In the bottom text box, you'll see a preview of what this expression will look like.

After continuing execution, you'll see at the bottom-right corner of your Visual Studio a new icon, indicating that trace messages are available:

You can view the trace messages by clicking View Messages, and they will open in the OzCode built-in trace log viewer, allowing you to search, filter, and sort the trace messages to find what you're looking for:

There are many more contextual actions available for a wide variety of objects, with the Magic Wand, feature, allowing you to perform additional operations, such as setting conditional breakpoints without leaving the DataTip!

Working with Exceptions

Every once in a while we have to deal with Exceptions in our code. OzCode's Exceptions Trail makes it easy to investigate any exception. When an exception occurs, you can view its details using the "View exception details" QuickAction:

Which will open the following window:

As you can see in Figure 18, all nested inner exceptions appear in a nice breadcrumb control, allowing to investigate the root cause easily, as well as searching for the exception text in Google or StackOverflow straight from the Exceptions Trail window. At the bottom you can see all the details about the selected exception, and all other OzCode features, such as Reveal or Search are available. Finally, this window will continue showing exception details even after you stop debugging, allowing you to navigate the call stack even when the process was terminated.

Comparing and Filtering

OzCode makes it easy to find the needle in a haystack of data. Suppose we have a collection of 30 items, each item is a Person object with a name and an age. Now, let's say we want to show only those who are under the age of 30, so we can Filter the collection. The following animation demonstrates how to do this:

Another cool thing we can do with OzCode is to Compare two (or more) different instances of an object, and seeing the differences between them. In Figure 20 below, we can see 2 instances of a PhoneBook object, one of which doesn't display information correctly. We can see the differences highlighted in red:

Getting OzCode

There are many more things OzCode can do that make C# debugging a breeze! We urge you to check out all of instructional videos, and watch our instructional videos on how to get started.

You can try OzCode FREE for 30 days, and it works with Visual Studio 2010, 2012, 2013 and will soon support the upcoming Visual Studio 2015.

Magical Debugging!