Using the Debugger


ASP.NET Developer's JumpStart
By Paul D. Sheriff, Ken Getz
Table of Contents
Chapter 9.  Debugging in Visual Studio .NET

Visual Studio .NET provides a useful toolbar you can use while debugging but doesn't display it by default. In this section, you'll see both how to load the Debug toolbar and how to get started debugging.

Three Modes of Existence

While creating applications in Visual Studio .NET, you'll find yourself in one of three "modes." Each mode has a specific function, and knowing which mode you are in is important. The three modes are as follows:

  • Design mode. In this mode you build your user interface and write your code.

  • Break mode. In this mode you can single-step through code, view and modify variable values, and inspect memory.

  • Run mode. In this mode you are, effectively, testing your application within the Visual Studio .NET environment.

You can determine which mode you are in by looking at the Visual Studio .NET title bar. At the end of the other information in the title bar, you will see one of the following: [design], , or [break]. Get used to looking at the title bar for information on what mode you are currently in. There are things you can and cant do in each mode.


What can't you do in design mode? You can't use the Immediate window to test out code or expressions as you could in VB6. In break mode, you can't modify code, as you could in VB6. If you're coming to VB .NET from VB6, you may find some of these new limitations frustrating and confusing.

It is Break mode we'll focus on in this chapter, because it's in Break mode that you'll be able to single-step through code and debug the code as it runs.

Finding the Debug Toolbar

Visual Studio .NET provides many options for debugging your code, and although you can use menu items or keyboard shortcuts, you may find the Debug toolbar the easiest way to work. To make sure the Debug toolbar is visible, right-click the toolbar area of the Visual Studio .NET IDE and then select the Debug toolbar from the list of available toolbars. Once you've made the selection, you will see the toolbar shown in Figure 9.1.

Figure 9.1. The Debug toolbar gives you most of the debugging functionality without needing to dig into keyboard shortcuts or menu items.


From this toolbar, you will be able to run, stop, and pause the application. You will also be able to perform other functions related to debugging your application. From the left, the tools are as follows:

  • Start. Runs the project.

  • Break All. Pauses the project.

  • Stop Debugging.

  • Restart. Continues running the application from the current location.

  • Show Next Statement. Jumps to the next statement that will be executed while single-stepping through code.

  • Step Into. Single-steps into procedures in your code.

  • Step Over. Single-steps, running procedures full speed.

  • Step Out. Runs full speed from the current location back to the procedure that called the current procedure.

  • Hexadecimal Display. Toggles the display of all values in the QuickWatch window between decimal and hexadecimal formats.

  • Breakpoints/Immediate. Displays and then toggles between displaying the Breakpoints and Immediate windows.

You will learn more about these and other tools in this chapter.


While in Break mode, you have other tricks up your sleeve, as well. You can select the next line of code you'd like to execute, for example, by simply dragging the current line indicator to a different line (within the same procedure). You'll find debugging in Visual Studio .NET to be a very powerful experience!

Invoking the Debugger

To begin debugging your application, select Debug, Step Into or the Debug, Step Over menu options (or the corresponding toolbar items). The hotkeys for each of these may be different, depending on how you customized your profile when you first ran Visual Studio .NET. For example, if you are set up as a Visual Studio developer, the hotkeys for these two commands will be F11 and F10, respectively. If you are set up as a Visual Basic developer, however, you will use F8 and Shift+F8, respectively.


No matter how hard you try, debugging from within an ASP.NET application simply doesn't work unless you press F5 (or use the Debug, Start menu item) to begin running your code. (Your application must have a start page in order for this to work. Right-click the correct page, in the Solution Explorer window, and select Set as Start Page from the context menu.) There are other ways to accomplish the same goal, but this is how we've gotten debugging to work. Certainly, selecting a page, right-clicking, and selecting the Build and Browse or View With… context menu item will not allow you to debug. In addition, before you can debug an ASP.NET project, you must set the project properties correctly. Right-click the project in the Solution Explorer, select Properties from the context menu, and verify that on the Configuration Properties, Debugging page, the ASP.NET Debugging check box is selected. Otherwise, you'll never be able to debug the current project.

Stepping into Code

Single-step mode executes each statement in your code, one at a time. You can step through code by clicking the Step Into button on the Debug toolbar or by selecting Debug, Step Into.

If, while debugging, you encounter a user-defined procedure during single-step execution, you will single-step into each statement within that procedure before returning to the called procedure.

Stepping over Code

Stepping over code is very similar to stepping into code, except that rather than executing every statement within a called procedure, stepping over code executes the entire procedure, while your debugging session never leaves the current procedure. This allows you to quickly step over procedures that you've already determined to be error free.

Use procedure step mode by clicking the Step Over toolbar button or selecting Debug, Step Over.


We're not going to attempt to describe the keystrokes associated with each debugging toolbar item, because the keystrokes depend on the profile you've selected. Instead, check the Debug menu for each item and determine the keystrokes from the tips provided on the menus.


If you are moving from Visual Basic 6.0, you may be used to changing your code while in Break mode and then continuing with these changes in place. Visual Studio .NET doesn't make this possible, at least not in this first release. You must stop your application, make your changes, and then restart your debugging session in order to test your changes.

Entering Break Mode

When your application is running, you may invoke the debugger and enter the Break mode in several ways:

  • Press Ctrl+Break while your code is running.

  • Place a Stop statement in your code. (Be wary of this technique! We'll have more discussion of this later in the chapter.)

  • Set a breakpoint in your code.

  • Select Debug, Step Into to run the program.

The Stop Statement

If you want to place a permanent breakpoint into your code, place a Stop statement at the location where you want the breakpoint. You'll want to make sure you remove any Stop statements prior to distributing your application even when you create the release version of your application, Stop statements drop into Break mode (or they halt the application, if the debugger isn't available).

One good way to make sure any Stop statements are removed from your code at release time is to always surround them with conditional compilation directives that only include the statements if you've built a Debug build, like this:

 Private Sub BreakPointsSample()   Dim intValue As Integer #If DEBUG Then     Stop #End If   intValue = 10   Proc1() End Sub 


    ASP. NET Developer's JumpStart
    ASP.NET Developers JumpStart
    ISBN: 0672323575
    EAN: 2147483647
    Year: 2002
    Pages: 234 © 2008-2017.
    If you may any questions please contact us: