This site uses cookies to offer you a better browsing experience. Find out more on Privacy Policy.

Debug Like a Magician – OzCode

February 21, 2017 Łukasz Kurzyniec

I am a typical .NET developer and I use Visual Studio on a daily basis. I like this development environment because it has a lot of built-in features that make working easier and faster. Moreover, if these features are not enough for me, then I can install external extensions. For years, the ReSharper was my number one add-on for Visual Studio. But recently, things have changed – I discovered OzCode, an innovative debugging extension, and it soon became my new favourite.

Even in a perfect world where the entire codebase is covered by unit tests, you find yourself debugging to better understand how your code behaves. The need for a powerful debugger increases when working on legacy systems, with an unknown legacy code. After using OzCode for a couple of months, I know for sure that this extension helps reduce debugging time. By saving time during the implementation of a task, it simply saves money.

OzCode provides more than 20 debugging related features built into Visual Studio debugging. Let me introduce you to some of the features that I like the most.

Live debugging with Head-Up Display

OzCode can display all values of variables just above them. Moreover, it can also display the value returned from a method. This means that you no longer need to hover over variables to see their values. And that is not all! OzCode is really helpful with conditional statements (e.g. if statement or ?: operator), because it uses green and red highlighting to indicate matched and unmatched parts of code. The most powerful feature from this group is the ability to explore the history view of how your code was executed.

Head-Up Display

Search, Reveal, Custom Expression and Filter for the boost

Working with big objects (multiple properties declared inside) can be difficult. Trying to find a value in a collection of this kind of objects can only make it worse. However, debugging them with OzCode is really fast and simple.

First of all, with OzCode you can easily search through either properties/fields or their values. By default, OzCode searches 3 levels deep into your object, but you can also drill down if you need to. Another related feature is the ability to focus only on the properties you are interested in. Mark them with a star and they will appear next to each object. OzCode will also allow you to define your own custom properties without changing the source code! OzCode will display such a property like a regular one among others. At the end, you can filter the collection using a condition.

Search and Reveal


Custom Expression and Filter

As you can see, while defining custom property and/or filter you are able to use the IntelliSense code completion feature, which is super cool and very helpful.

Exceptions better than ever

Tracking down exceptions with OzCode is extremely fast and easy. OzCode has a completely redesigned exception window to make it much more powerful and productive. You can easily navigate through all exceptions in a single window by using the breadcrumb trail. All relevant information is easily accessible and readable. On top of that, the exception window contains two very useful links: ‘Go to where exception was thrown’ and ‘Go to where exception was handled’, which can take you to the appropriate place in the source code.

Exceptions

Compare with a simple click

When comparing two objects you need to be very perceptive and focused. OzCode helps you with that too. There is a special tool where you can add/define up to 5 objects to compare. When you choose an object to compare, OzCode automagically highlights objects that are comparable to that object. You can also compare an object with a snapshot of that object, which you have saved. The resulting compared objects are shown one after another in a row for better readability. In addition, OzCode marks the differences between them in red. For long string properties, you can compare values in an external diff tool, such as KDiff or WinMerge.

Compare

LINQ Debugging tools FTW (EAP)

The dream comes true! OzCode can help you thoroughly debug LINQ expressions. It gives three additional visualisations which assist the LINQ debugging process. Let us start with Numeric Indicators. They are displayed next to each lambda expression and show how many items are produced. After clicking one of them, OzCode turns into the LINQ Debugging Mode and another visualisation shows up – LINQ DataTip. This window demonstrates the exact result of a particular lambda expression. Additionally, it is possible to switch on the “before” view to see the consumed items.

The last and the most powerful visualisation is the LINQ Analysis Window. This mighty tool shows up after clicking on a small lambda icon () on the LINQ DataTip window. It demonstrates all LINQ pipeline steps (all lambda expressions) in the breadcrumb trail. Each step presents the source collection on the left and the result collection on the right. In the middle, there is a special bar which indicates matches between both sides, and it is really useful. Moreover, OzCode fully supports both kinds of syntax – Query Syntax and Method Syntax! This means that you are not forced to use a specific one; you can use your favourite.

Numeric Indicators and LINQ DataTip


LINQ Analysis Window

OzCode also helps you track down exceptions inside LINQ expression by highlighting a Numeric Indicator in red. Now, you can locate the item that caused the exception using two remaining visualisations.

Exception in LINQ query


The entire LINQ Debugging feature is still in early preview release, so you can try it only in an EAP version of OzCode. You can download it here.

Conclusion

OzCode is a truly magical visual debugger extension, which can reduce the time spent on debugging by half. It makes the debugging process much more efficient thanks to more than 20 powerful features. Do not hesitate, buy it now – you will not regret it!

References

Last posts