Breakpoints are great, but they're not enough. You need to be able to view and modify data, find out how the execution path got you to the current location, and what's going on in the environment. To help you out, Visual Studio .NET provides many useful tools you can use while debugging. The following subsections show some of the tools you may want to investigate.
Watching Variables Using Your Mouse
If you want to investigate the value of a simple variable while debugging in Break mode, you could use the Immediate window or one of several other windows. The simplest technique, however, is to simply hover the mouse pointer over the variable. Visual Studio .NET will display a tool tip containing the name of the variable and the value contained within the variable. Figure 9.11 shows the tool tip while in Break mode.
Figure 9.11. Hover your cursor over a variable in Break mode to see the value of that variable.
You can use the Watch window to view the value of variables and expressions as your code is executing. This can be useful if you want to be able to single-step through code, and for each line of code, investigate the value of one or more variables or expressions. Use the Debug, Windows, Watch menu to display the window shown in Figure 9.12. You can add new variables or expressions just by typing within the Name column. You can also modify the values of your variables (but not expressions, of course) by typing within the Value column.
Figure 9.12. The Watch window can display the value of variables or expressions.
Right-click a specific watch within the Watch window and select Delete Watch from the context menu to delete it.
Adding Watch Values Using QuickWatch
If you are in Break mode and wish to view the contents of a variable or expression in the current procedure, position your cursor on that variable (or select the expression) and select Debug, QuickWatch. You will then see a dialog box like the one in Figure 9.13, showing your watch variable/expression. Click Add Watch to add a watch to the Watch window.
Figure 9.13. QuickWatch is great for looking up the value of an expression, and it allows you to easily add a watch to the Watch window.
Call Stack Window
While in Break mode, Visual Studio .NET allows you to display the list of procedures you have executed to get your current location. This is very handy when you are not sure how you got to where you are. You can display the Call Stack window, shown in Figure 9.14, by selecting Debug, Windows, Call Stack.
Figure 9.14. The Call Stack window lets you see where you came from as you debug an application.
The grayed-out procedures in the Call Stack window are procedures you didn't call directly they were called by the .NET Framework in order to get to your code. You can double-click any of your own procedures in the Call Stack window to have Visual Studio .NET highlight the procedure call within your code.
Using the Command Window
The Command window (also known as the Immediate window) allows you to perform simple calculations. Use the Debug, Windows, Immediate menu item to display this window. You can also display or modify the value of a variable. The statements you enter into the Command window may be any valid Visual Basic expression. For example, you can print the results of an operation, print the contents of a variable or property, or even set the value of a variable or property. Use the "?" operator (which stands for "print the value of the expression that follows") to display a value or to run a function. Simply enter an assignment or method call that doesn't return a value into the window to execute the expression. Figure 9.15 shows the Command window in use.
Unlike in Visual Basic 6.0, in Visual Studio .NET, you must be in Break mode in order to enter text into the Command window. You'll also find other differences. For example, you cannot delete lines in the Command window. Right-click and use the Clear All context menu item to delete text from the window.
Other Useful Debugging Windows
Visual Studio .NET provides even more windows and tools. Some of these are tools you'll use every day; others are a bit more specialized and won't be used as part of your daily routine.
If you wish to keep an eye on all the local variables in a procedure, you can select Debug, Windows, Locals from the menu bar. This window, shown in Figure 9.16, will display each of the variables in each procedure as you work through the procedures in your debugging session. This window also displays information about controls on the current page.
Figure 9.16. The Locals window shows you all your local variables.
If you just want to watch local variables, and nothing more, you can use the Autos window (Debug, Windows, Autos). Figure 9.17 shows the Autos window while debugging a simple procedure.
Figure 9.17. The Autos window shows all local variables.
You might be wondering where the name "Autos window" came from. It's one of those C/C++/C# things in those languages, local variables are often called auto variables (hence, the window name).
The Me window, accessed via the Debug, Windows, Me menu item, displays all the objects within the current class. Figure 9.18 shows the Me window in use.
Figure 9.18. The Me window shows all objects and variables within the current class.
The Locals, Autos, and Me windows are related. The Locals window shows a union of the information provided by the Autos and Me windows that is, local variables and class variables.
The Threads window, accessed via the Debug, Windows, Threads menu item, displays a list of all executing threads in your application. Most of the time, in simple ASP.NET applications, you'll only be working with a single thread. Figure 9.19 shows the Threads window for a simple debugging session.
Figure 9.19. The Threads window displays all executing threads.
The Modules window will show you all the modules that were loaded in order to run an application. (This information is fun, if you're interested in how things work "under the covers.") Display this window using the Debug, Windows, Modules menu item. Figure 9.20 shows the Modules window for the sample application.
Figure 9.20. The Modules window shows you all loaded modules.
If you like digging into the bits and bytes of your code, check out the Disassembly window by selecting Debug, Windows, Disassembly. This may be more information than you ever wanted to know about your code, but it's all there for your entertainment and education. Should you ever really want to know what Visual Basic .NET is doing under the covers, here's how you can find out! Figure 9.21 shows the disassembly of some simple VB .NET code.
Figure 9.21. The Disassembly window shows you the assembly language version of your code.
The Registers window, shown in Figure 9.22, will display what is in the registers of the machine after the current instruction in your .NET application. Use the Debug, Windows, Registers menu item to display this window. (We doubt most Visual Basic .NET developers will ever take advantage of this window we've included it here for completeness only.)
Figure 9.22. The Registers window shows you each register of your computer.