During debugging we can explore variables and expressions at different points in a C# program. But what really helps to locate bugs is to see how they change while the program runs. Let’s see how Visual Studio’s ‘Watch’ window helps with that.
IN THIS ARTICLE:
# Debug in Visual Studio and track C# code with ‘Watch’
When we write C# applications, we at some point we run into a programming bug. For a basic program scanning the code is often enough to find the mistake. But for complex programs that isn’t doable. Luckily, we have a good alternative: debugging.
Debugging is the process of identifying and removing errors from our application (Asad & Ali, 2017). For that we often use special tools that help manage the complexities of analysing programming code.
To use debugging tools we first need to start our C# application under a debugger. In Visual Studio we do that with F5 (‘Start Debugging’;), F11 (‘Step Into’;), or the ‘Run To Cursor’ option.
Then when our program pauses (or so-called breaks) under the debugger, we can analyse the state of the program at that particular point (Liberty & MacDonald, 2009). We might for instance inspect the current values of variables or see what an expression evaluates to.
One powerful debugging feature is to step through the code. This executes the program line by line, and we can see in detail how it behaves with each step (Asad & Ali, 2017; Dorman, 2010). But there’s often a lot of code that changes, and we aren’t interested in everything.
Luckily, Visual Studio’s ‘Watch’ window shows us what the values of variables and expressions are at each debugging step (Stephens, 2014). With this helpful debugging tool we can track (or watch) specific expressions we’re interested in.
So if we suspect that some variables and expressions contribute to the programming bug, we’ll add them to the ‘Watch’ window. Then when we step through the code while debugging, we’ll see how their values change with each line of code executed.
Let’s see how ‘Watch’ helps us track variables, validate ideas, and test possible bug solutions all while debugging.
# Use the ‘Watch’ debugging window in Visual Studio
Visual Studio’s ‘Watch’ window is only available when we’re debugging code. And so we’ll first need to start debugging in Visual Studio. Ways to do that are to place a breakpoint or use the ‘Run To Cursor’ option.
Then once our program pauses under the debugger, look for the ‘Watch’ window that looks like:
By the way, values in the ‘Watch’ window remain there until we remove them. So your ‘Watch’ window isn’t necessarily empty like the one shown here.
Cannot see the ‘Watch’ window in Visual Studio’s debugging mode? To open it, click on the ‘Debug’ menu item in Visual Studio, point to ‘Windows’, highlight ‘Watch’, and then select ‘Watch 1’ (or any of the other watch windows). An alternative is the Ctrl + Alt + W, 1 key combination.
The four different ‘Watch’ windows (‘Watch 1’, ‘Watch 2’, ‘Watch 3’, and ‘Watch 4’) all work in the same way – there are just multiple of them so we can use a certain window for a specific purpose.
In this article we simply speak of the ‘Watch’ window, but know that this can refer to any of those four identical windows.
# Add variables and expressions to the ‘Watch’ window
To evaluate and track an expression in the ‘Watch’ window we first need to add that expression. When our program paused under the debugger, there are several ways to do that.
The first approach is a right-click on a code element in the editor and then choose ‘Add Watch’:
Another option is to first select the expression, and then hold down the left mouse button to drag the selected code unto the ‘Watch’ window:
The third approach is to double-click on an empty row in the ‘Watch’ window. Then type in an expression followed by Enter.
The fourth option is when you have the ‘QuickWatch’ window open. There press the ‘Add Watch’ button to more the expression from ‘QuickWatch’ to the ‘Watch’ window.
We typically add variables and expressions to the ‘Watch’ window. But we can add practically any valid C# code to that window – including methods and objects (Dorman, 2010).
# Track expressions in the ‘Watch’ window
When we have an expression in the ‘Watch’ window, we can see how it changes as we step through the code. That gives a good idea of how the program behaves and where its behaviour is different from what we expect.
Say we have the following expressions in our ‘Watch’ window:
Now say we place a breakpoint and then start debugging. Then just before our program executes the first breakpoint it pauses under the debugger. That allows us to see what values the expressions in the ‘Watch’ window have at that exact point in the program:
In this example
royaltyAmount has a value of 0 and both Boolean expressions are
false. Then when we step through the code with ‘Step Into’ (F11) we see how the expressions change:
Because the line just executed initialised our
booksWritten variable to 2, the
booksWritten > 1 expression in the ‘Watch’ window changes from
true. That value in ‘Watch’ also highlights in red to show it just updated.
Let’s continue with this example and execute the next line of code. That line sets the
royaltyAmount variable to an initial value of 0.15, as the ‘Watch’ window also shows:
When we arrive at the example’s if statement, the ‘Watch’ window helps to figure out why the nested if statement doesn’t execute. Let’s see how:
We see here that the nested if statement evaluates two expressions that, thanks to the logical AND operator (
&&), both need to be
true. The first expression checks if
booksWritten is greater than 1, which is
true as we see in the ‘Watch’ window. But the second expression wants
royaltyAmount to be bigger than 15, which is not the case according to ‘Watch’.
Actually, ‘Watch’ shows that
royaltyAmount has a value of 0.15 instead 15. When we realise those royalties are a percentage, the bug is likely that we mixed up their numerical representation (that is, using an integer to express a percentage instead of a decimal value).
Even though this is a basic example, it already shows how ‘Watch’ helps to check assumptions our code makes.
# Change values in the ‘Watch’ window
Another feature of the ‘Watch’ window is that we can change the values of its variables. Then when we step through the code under the debugger, we can see how those changed values affect our program. This way we can easily experiment and test out ideas to help locate the bug.
To change a variable in the ‘Watch’ window, we double-click on the variable’s field in the ‘Value’ column. That makes a text selection appear to edit the variable:
We then type in a new value (let’s say 20) and press Enter. That highlights the variable’s value in red to show it recently changed:
When we adjust a variable in the ‘Watch’ window, other expressions may change too. For instance, when we changed
royaltyAmount to 20, the expression
royaltyAmount >= 15 went from
true (and is now highlighted in red too).
Expressions that we place in the ‘Watch’ window remain there across multiple debugging sessions. But values we change only apply to the current session.
So when we stop and start debugging again, we’ll need to change the values in ‘Watch’ again.
Let’s see how changing values in ‘Watch’ affects stepping through the code under the debugger.
In the image below the debugger is about to execute the
Console.WriteLine() line highlighted in yellow. That line is inside a nested if statement which checks if
booksWritten is bigger than 1 and
royaltyAmount 15 or more. Those expressions are both
true – we’ve just changed
royaltyAmount to 20, after all.
Because we adjusted
royaltyAmount in the ‘Watch’ window, the
Console.WriteLine() line can now execute and we can explore how this affects our program.
A changed variable in the ‘Watch’ window keeps its new value as we step through the code. But when we execute a line of code that changes its value, the variable changes with it.
And so the ‘Watch’ window does not prevent our program from changing the variable.
# Remove values from the ‘Watch’ window
The expressions in the ‘Watch’ window remain there across debugging sessions. And so when we don’t need them the next time we start debugging, we better remove them.
To remove an expression from ‘Watch’ we right-click on it and then select ‘Delete Watch’. Or we select the expression and press the Delete key.
To empty the entire ‘Watch’ window we right-click somewhere in this window and select ‘Clear All’. (Or we press Ctrl + A to select all watches and remove them with Delete.)
To troubleshoot C# code we often run our program under a debugger. That makes it possible to explore our program at different points while it runs. We start debugging in Visual Studio with F5 (‘Start Debugging’;), F11 (‘Step Into’;), or the ‘Run To Cursor’ option. Once our program pauses under the debugger we likely want to keep track of some variables and expressions we suspect cause the bug.
We do that with the ‘Watch’ window. That window, of which Visual Studio actually has multiple (‘Watch 1’ through ‘Watch 4’), shows the current values of expressions. When we step through our program and execute code line by line, the expressions in ‘Watch’ update and we see how the code affects those values. This way we can keep an eye on (or watch) the code elements we suspect cause the bug.
Besides tracking expressions we can also change them in the ‘Watch’ window. This makes it possible to quickly see how the program would behave with different values, without us needing to stop debugging and change the code.
Asad, A. & Ali, H. (2017). The C# Programmer’s Study Guide (MCSD). New York, NY: Apress.
Dorman, S. (2010). Sams Teach Yourself Visual C# 2010 in 24 Hours. Indianapolis, IN: Sams/Pearson Education.
Liberty, J. & MacDonald, B. (2009). Learning C# 3.0: Master the Fundamentals of C# 3.0. Sebastopol, CA: O’Reilly Media.
Stephens, R. (2014). C# 5.0 Programmer Reference. Indianapolis, IN: John Wiley & Sons.
Last updated on (published ).
- Step through C# code: run a program line by line in Visual Studio
In Visual Studio we can analyse our C# program line by line. This tutorial explores stepping through a C# application under the code debugger.
- How to start and stop debugging C# code in Visual Studio?
Before we can fix our C# programming code in Visual Studio, we need to start and stop the debugger. Learn more about that in this article.
- Debug example: fix C# if statements in Visual Studio
Knowing where to start is often half the debugging work. This tutorial looks at debugging C# if statements, including tips for quick troubleshooting.
- Quickly debug expressions with Visual Studio’s ‘QuickWatch’
When debugging C# code, it often helps to quickly see what some expression evaluates to. The ‘QuickWatch’ window helps us do that and more.
- Quickly debug C# code with Visual Studio’s ‘Run To Cursor’ option
Before we can analyse and debug our C# program in Visual Studio, we have to start debugging. A quick way to do that is with ‘Run To Cursor’.
« All C# visual studio articles