Using the Debug Class
During the testing of your application, you may find that when you are stepping through code the application works fine, but when you run the program straight through it does not work the way you expected. The reason for this is that you can change the way your program runs by using the debugger the fact that you're executing the code extremely slowly can affect the behavior of the application! Instead of using the debugger to test values, you may find it convenient to print those values to the Immediate window.
You may print directly to the Output window (use the View, Other Windows, Output menu item to display this window and select Debug from the drop-down list at the top of the window) from within your application by executing the Debug.Write or Debug.WriteLine method. The values placed into the Immediate window using either of these methods will still be available in Break or Design mode. It can be useful to see those values without having to enter Break mode and thereby possibly change the execution of your program. You'll most likely use the WriteLine method of the Debug object, simply sending the method a string to display in the Output window, like this:
Debug.WriteLine("Now executing btnStart_Click()")
The Output window can display both Build and Debug information. Make sure you select Debug from the drop-down list at the top of the window in order to see the Debug.WriteLine output.
To illustrate these points, make sure DebugForm.aspx is the start page for the sample project, run the project, and select Debug Class on the Web page. Clicking this button loads a Web Form named DebugEvents.aspx. This form includes several calls to the Debug.WriteLine method in several different event procedures. This page illustrates the use of the Debug.WriteLine method and also gives you an idea of which events are fired when a Web Form loads and unloads. Figure 9.23 shows some of the sample output from these Debug.WriteLine method calls.
Figure 9.23. Sample output from DebugEvents Web Form.
If you're a VB6 developer, you may be used to the output from the Debug class going into the Immediate window. Look there all you like in Visual Studio .NET, but you won't find what you're looking for. This content now goes to the Output window instead.
Listing 9.1 shows part of the code that creates the output shown in Figure 9.23.
Listing 9.1 The Example Uses This Code to Help Demonstrate Debugging Techniques
Private Sub Page_Load( _ ByVal sender As System.Object, _ ByVal e As System.EventArgs) _ Handles MyBase.Load 'Put user code to initialize the page here Debug.WriteLine("Page_Load") End Sub Private Sub Page_PreRender( _ ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles MyBase.PreRender Debug.WriteLine("Page_PreRender") End Sub Private Sub Page_Unload( _ ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles MyBase.Unload Debug.WriteLine("Page_Unload") End Sub
The Debug class has several methods you might find useful, in addition to the WriteLine method. Table 9.4 describes some of the more common ones you might use.
Table 9.4. Methods of the Debug Class
|Method ||Description |
|Assert ||Stops the program if the condition you pass to this method does not evaluate to True. This method only works in the design mode: All Debug statements are removed from the final compiled program. |
|Write ||Writes a value to the output window without a CRLF. |
|WriteLine ||Writes a value to the output window with a CRLF. |
|WriteIf ||Writes a value to the output window without a CRLF, if a specified condition is true. |
|WriteLineIf ||Writes a value to the output window with a CRLF, if a specified condition is true. |
The Assert Method
The Debug.Assert method allows you to insert assertions in your code that is, debugging statements that display information into the Output window if a specific condition isn't met. Debug.Assert is a powerful debugging tool in that it allows you to ensure that you've passed correct parameters to a procedure or that a variable always contains a specific value or range of values. Some programmers insist that you shouldn't program an application without using the Debug.Assert method scattered throughout your whole application anytime you make any type of assumption about the current state of parameters of variables. The following code shows how you might check to see whether a number typed into a text box was typed in correctly:
Private Sub AssertSample() Dim intNum As Integer intNum = CInt(Val(txtNumber.Text)) Debug.Assert(intNum >= 0 And intNum <= 5, _ "Number must be between 0 and 5") End Sub
If you run this code and enter 6 into the text box on sample form (DebugClass.aspx), the assertion will return False. The .NET runtime will display a message into the Output window like the one shown in Figure 9.24.
Figure 9.24. Debug.Assert displays information like this into the Output window when the assertion fails.
Debug.Assert isn't normally used to validate input, as you've seen here. The validation controls provided by ASP.NET do a better job at that. We've purposefully selected a simple example here, just to demonstrate how you might use Debug.Assert. Normally, you'd use Debug.Assert to verify that the data sent to a procedure meets certain criteria that you just assume for example, that a string isn't too long or that a value that shouldn't be zero is, in fact, not equal to zero.
The WriteLineIf Method
If you only wish to write a line to the Output window when a specified condition is true, you can use the WriteLineIf method of the Debug class. For example, the sample page uses code like the following to check a condition before writing information to the Output window:
Private Sub WriteLineIfSample() Dim intNum As Integer intNum = CInt(txtNumber.Text) Debug.WriteLineIf(intNum >= 0 And intNum <= 5, _ "You input a correct number") End Sub
If you want to dig a little deeper, you'll find that the Debug class (and its cousin, the Trace class) are far more powerful than you've seen here. Each of these classes relies on the concept of "listener" objects that is, objects that "listen" for output and collect the output for display. By default, the only listener for the Debug class is the Output window. Without too much effort, you can create listeners that write output to a text file or to the Windows Event Log. Although doing this work is beyond the scope of this material, you can check out the Debug class in the online help for information on creating other listeners.