Debugging multilevel applications in C# Introduction to Reverse Debugging

Debugging multilevel applications in C#

Just like “Back to The Future” is a movie that is considered to be a symbolic part of the 90s, the same way bugs are inherent in development. This is especially true with multilayer applications where finding a bug may be a real challenge. Even with all kind of tests, various bugs slip into production every now and then. Is there some way to inspect them in the production environment? How to find out what happened on your clients’ machine? This article contains a short tour of RevDeBug – Time Machine for Visual Studio. Check it out!

What is time travel debugging?

Standard Visual Studio debugging tool contains instruments such as step-into, step-over or step-out. Reverse debugging allows you to travel in an opposite direction, to inspect what causes the bug in your project. This infographic gives you a simple explanation of this process:

reverse debugging infographic
Infographic: What is reverse debugging?

Reverse debugging tool for Visual Studio

RevDeBug is a Visual Studio extension for C# frameworks, which allows you not only to implement reverse debugging in your own projects but also to monitor them on production. It creates a recording with all application states (values, methods calls, exceptions etc.). With this information, you will be able to easily travel back in time, through every layer of your code. How does it work in practice? We may summarize that to these two steps:

  1. Recording of a session with a bug is being sent automatically from application user to developer.
  2. The developer is prospecting this stream of values to find the root of the problem.

This technology is particularly suitable for multilevel projects, where finding the root of the error may pose a big challenge. It also allows you to work with a problem without laborious bug recreating – as you are working on data straight from production.

Travel in code, in the order of its execution time.

Travel in code, in the order of its execution time.

Debugging multithreaded and multilevel applications

Challenges of debugging multithreaded applications are not simple to face. What’s more, threading problems are notoriously troublesome to replicate. Determining the state of the program at the time of failure can be difficult; understanding why a particular state is problematic can be even more demanding. That’s why reverse debugging technology is such a helpful mechanism when it is coming to a crash. RevDebug allows you to track every thread of your application. Check out how it looks in the Visual Studio:

Track every thread of your application, basing on data from production

Track every thread of your application, basing on data from production.

It’s not the only feature of RevDeBug, which supports developers in debugging complex applications. With the latest update, we give you also a call stack and scope stack (which provides fine-grained navigation within the current method and makes it easier to iterate over loops and conditionals).

Scope stack is a tool designed for better navigation within the scope of the particular method, loop or conditional.

RevDeBug call stack is a tool which gives you detailed information about methods called at runtime from the beginning of a program until the execution of the current state.

RevDeBug call stack is a tool which gives you detailed information about methods called at runtime from the beginning of a program until the execution of the current state.

Time traveling is only one function of RevDeBug, an advanced reverse debugger for c# applications. Want to know more? Check out our other articles:

Alice Gajos

By training production engineer, at heart .net programmer. Currently technology advocate at RevDeBug.