Procedure 8-1. Create the Project

1. Open the project that you created in Chapter 7. The URL for this project should be http://localhost/XMLWebServices/Chapter07/CustomFaultCodes/ValidatorService.

2. Select Copy Project from the Project menu, and then copy the project to http://localhost/XMLWebServices/Chapter08/Debugging/ValidatorService.

3. Open the new project in Visual Studio .NET, and then save the solution file for the new project.

Procedure 8-2. Prepare the Project for Debugging

1. In Solution Explorer, right-click the Validation.asmx file and select Set As Start Page from the shortcut menu.

   

   Setting the start page tells Visual Studio .NET which XML Web service file should be loaded when the debugger is started. We have only one .asmx file in our example project, but should you develop a project that contains multiple XML Web service files, this feature allows you to select a specific file.

2. Select the ValidatorService item in Solution Explorer, and then choose Properties from the Project menu.

3. Click on the Configuration Properties folder icon.

4. Click on the Debugging item in the list.

   This loads the properties that relate to the Visual Studio .NET debugger.

   

5. Change the Debug Mode setting to Wait For An External Process To Connect.

   The Wait For An External Process To Connect setting allows you to use a Windows Forms client for debugging. When the debugger is started, Visual Studio .NET will wait until an XML Web service request is received. This differs from the default mode, in which Internet Explorer is started as soon as the debugger is started.

6. Click OK to close the properties dialog box.

7. Build the project by pressing Ctrl+Shift+B or choosing Build Solution from the Project menu .

Procedure 8-3. Create the Client Project

1. Copy the client template project to the location C:XMLWebServices­SBSProjectsChapter08. (For details about copying the template, see the sidebar "XML Web Service Client Projects" in Chapter 7

2. Open the copy of the client template project in Visual Studio .NET.

3. Add a Web reference pointing to the XML Web service that we created in the previous section of this chapter. The URL for that example is http://localhost/XMLWebServices/Chapter08/Debugging/ValidatorService/Validation.asmx. (Refer to the steps in the section "Creating a Web Reference" in Chapter 4 if you need more details on how to add a Web reference.)

4. In Solution Explorer, right-click the Web reference and then select Rename from the shortcut menu. Change the name of the reference to Validator.

5. Open the Form1 code file by double-clicking the Form1 entry in Solution Explorer (either Form1.cs or Form1.vb, depending on which language you are using).

6. Double-click on the Validate button in the Form1 design view. This opens the source file for the Form1 class.

7. Add the following code statements so that the ValidateButton_Click method is complete. This code is executed when the user clicks the button. The changes from the template code are marked in bold. We have added these statements to make exploring the debugger easier. By default, the XML Web service proxy class will wait for 30 seconds for a response from the server before assuming that a problem exists and throwing an exception. The statements that we have added to the example cause the client to wait indefinitely.

   Example 8-1. C#

   private void ValidateButton_Click(object sender, 
       System.EventArgs e) {
       // create the ValidationObject that we will send to 
       // the XML Web service
       ValidationObject x_object = new ValidationObject();
   
       // set the card type for the validation object based
       // on the user selection in the CardType ComboBox
       switch (CardType.Text) {
           case "AMEX":
               x_object.o_card_type = CARD_TYPE.AMEX;
               break;
           case "MasterCard":
               x_object.o_card_type = CARD_TYPE.MASTERCARD;
               break;                                
           case "VISA":
               x_object.o_card_type = CARD_TYPE.VISA;
               break;
       }
   
       // set the card number value in the ValidationObject
       x_object.o_card_number = CardNumber.Text;
   
       try {
           // request validation from the XML Web service
           // via the proxy class
           ValidatorService x_service = new ValidatorService();
           // set the time out to "infinite" to prevent the 
           // client from timing out while we use the debugger
           x_service.Timeout = System.Threading.Timeout.Infinite;
           x_service.ValidateCard(ref x_object);
   
           // set the text of the result label based
           // on the response from the XML Web service
           if (x_object.o_valid) {
               Result.Text = "Number Valid";
           } else {
               Result.Text = "Number Invalid";
           }
       } catch (System.Web.Services.Protocols.SoapException x_ex) {
           switch (x_ex.Code.ToString()) {
               case "Client.IllegalCharacter":
                   Result.Text = "Illegal Character";
                   break;
               case "Client.InvalidLength":
                   Result.Text = "Invalid Length";
                   break;
               case "Client.InvalidPrefix":
                   Result.Text = "Invalid Prefix";
                   break;
               default:
                   Result.Text = "Unexpected Error";
                   break;
           }
       }
   }

   Example 8-2. Visual Basic .NET

   Private  Sub ValidateButton_Click(ByVal sender As Object, ByVal e _
       As System.EventArgs) Handles ValidateButton.Click
       ’ create the ValidationObject that we will send to 
       ’ the XML Web service
       Dim x_object As ValidationObject =  New ValidationObject() 
    
       ’ set the card type for the validation object based
       ’ on the user selection in the CardType ComboBox
       Select Case CardType.Text
           Case "AMEX"
               x_Object.o_card_type = CARD_TYPE.AMEX
           Case "MasterCard"
               x_Object.o_card_type = CARD_TYPE.MASTERCARD
           Case "VISA"
               x_Object.o_card_type = CARD_TYPE.VISA
       End Select
    
       ’ set the card number value in the ValidationObject
       x_Object.o_card_number = CardNumber.Text
    
       Try
           ’ request validation from the XML Web service
           ’ via the proxy class
           Dim x_service As ValidatorService =  New ValidatorService()
           ’ set the time out to "infinite" to prevent the 
           ’ client from timing out while we use the debugger
           x_service.Timeout = System.Threading.Timeout.Infinite
           x_service.ValidateCard(x_object)
    
           ’ set the text of the result label based
           ’ on the response from the XML Web service
           If x_Object.o_valid Then
               Result.Text = "Number Valid"
           Else 
               Result.Text = "Number Invalid"
           End If
        Catch x_ex As System.Web.Services.Protocols.SoapException
           Select Case x_ex.Code.ToString()
               Case "Client.IllegalCharacter"
                   Result.Text = "Illegal Character"
               Case "Client.InvalidLength"
                   Result.Text = "Invalid Length"
               Case "Client.InvalidPrefix"
                   Result.Text = "Invalid Prefix"
               Case Else
                   Result.Text = "Unexpected Error"
           End Select
       End Try
   End Sub

8. Build the solution by pressing Ctrl+Shift+B or selecting Build Solution from the Project menu.

Procedure 8-4. View the XML Web Service Code File

1. Open the XML Web service project that you created at the start of this section.

   It might seem strange to close the XML Web service project and then create the client and open the service again, but we can’t debug the project unless we have a client to use, and we could not create the client without adding a Web reference to the service.

2. In Solution Explorer, right-click on the Validation.asmx file and select View Code from the shortcut menu.

Procedure 8-5. Set the Breakpoint

1. Scroll down the code file until you reach the ValidateCard method.

2. Find the statement that creates the Validator object. The statement is as follows:

   Example 8-3. C#

   Validator x_validator = new Validator();

   Example 8-4. Visual Basic .NET

   Dim x_validator As Validator = New Validator()

3. Right-click the statement, and select Insert Breakpoint from the shortcut menu.

   

   Visual Studio .NET will insert a breakpoint, indicated by a red circle in the left margin of the code file, for the ValidateCard method. Here’s how the C# code file looks after adding the breakpoint:

   

Procedure 8-6. Start the Debugger and Trigger the Breakpoint

1. Select Start from the Debug menu (or press F5).

   This command starts the Visual Studio .NET debugger. You will see the windows within Visual Studio .NET change and the code window expand to fill more of the screen. We explain the purpose of these windows in the sidebar "Advanced Debugging Features" later in the chapter.

2. Start the client application.

   Using Windows Explorer, execute the client application we created earlier in this chapter. C# programmers can find the file at C:XMLWebServicesSBSProjectsChapter08 WindowsFormsClientindebugWindowsFormsClient.exe. Visual Basic .NET programmers will find the file at C:XMLWebServicesSBSPro­jectsChapter08 WindowsFormsClientinWindowsForms­Client.exe.

3. Ensure that the VISA item is selected as the card type, and then enter 1234 as the card number. The following screen shot shows the client interface with these details.

   

4. Click the Validate button.

   Clicking the Validate button will cause the client to invoke the ValidateCard method of the XML Web service. Because we have placed a breakpoint at the start of this method, the Visual Studio .NET debugger will suspend the execution of the service project at this point. The following screen shot shows the code window once the breakpoint has been triggered.

   

Procedure 8-7. Step Through the Code

1. Select Step Over from the Debug menu, or press the F10 key.

   Step Over instructs the debugger to execute the next line of code in the ValidateCard method. Notice that the line where we placed the breakpoint is highlighted in red and that the next code statement (the debugger ignores comments) is highlighted in yellow. The yellow highlighting indicates the code line that is about to be executed. Here’s the window for the C# code file:

   

2. Press F10 again to execute the switch (C#) or Select Case (Visual Basic .NET) statement. The yellow highlighting jumps to the code section that processes VISA requests. Stepping through the code follows the execution of the XML Web service, allowing you to see which statements will be executed for a request from a client. In this case, because we specified that we wanted to validate a VISA card number, the debugger has jumped to the VISA clause of the switch/Select Case statement.

3. Press F10 until the throw GetException statement is highlighted.

   We asked you to supply a card number that we knew was invalid to ensure that this statement would be executed. Remember that the CreditCardValidation.dll library throws exceptions to indicate different types of problems with card numbers.

   Example 8-5. C#

   throw GetException(x_ex);

   Example 8-6. Visual Basic .NET

   Throw GetException(x_ex)

4. Select Step Into from the Debug menu, or press the F11 key.

   Step Into differs from Step Over in only one respect: if the statement that is executed is a function call, Step Over executes the entire function and then highlights the next code statement in the current method. Step Into moves the highlight to the first statement within the called function. Selecting Step Into for a statement that is not a function call is the same as selecting Step Over.

   In our case, we have stepped into the GetException function, and the highlight is moved to the start of the If statement.

5. Select Step Out from the Debug menu, or press Shift+F11.

   Step Out is used when you are stepping through the code inside a function and want to return to the calling function. In our case, we have stepped out of the GetException method back to the ValidateCard method.

6. Select Continue from the Debug menu, or press F5.

   Continue instructs the debugger to resume execution of the code until the next breakpoint is reached. Because we have created only one breakpoint, the ValidateCard method will be completed and the result will be returned to the client.

7. Select Stop Debugging from the Debug menu, or press Shift+F5 to stop the debugger.

   Visual Studio .NET will close the debugger and restore your code editing windows.

Procedure 8-8. Configure the Breakpoint

1. Right-click on the code statement that is marked in red in the code window, and then select Breakpoint Properties from the shortcut menu. The Breakpoint Properties dialog box appears.

   The Breakpoint Properties dialog box shows the conditional settings for the selected breakpoint.

   

2. Click the Hit Count button to display the Breakpoint Hit Count dialog box.

   The value of the When The Breakpoint Is Hit combo box is set to Break Always, which is the default behavior for new breakpoints. Each time the breakpoint is hit, the debugger suspends execution.

3. Select Break When The Hit Count Is Greater Than Or Equal To from the combo box list. Set the numeric value in the field to the right of the combo box to 2. You can see the correct settings here:

   

   This combination of settings specifies that after the breakpoint has been hit a certain number of times it will be triggered on each subsequent hit. In our example, the breakpoint will not be triggered the first time that it is hit but will be triggered for each hit thereafter.

4. Click OK to close the Breakpoint Hit Count dialog box.

5. Click OK to close the Breakpoint Properties dialog box.

Procedure 8-9. Configure the Breakpoint

1. In the Visual Studio .NET code window, right-click on the code statement that is highlighted in red and select Breakpoint Properties from the shortcut menu. The Breakpoint Properties dialog box appears.

2. Click the Condition button to open the Breakpoint Condition dialog box.

3. Enter the following statement into the text box.

   Example 8-7. C#

   p_object.o_card_number == "999"

   Example 8-8. Visual Basic .NET

   p_object.o_card_number = "999"

   The expression we have specified causes the breakpoint to trigger when the client asks the XML Web service to validate a card with the number 999.

   

4. Select the Is True option.

5. Click the OK button to close the Breakpoint Condition dialog box.

6. Click the OK button to close the Breakpoint Properties dialog box.

Procedure 8-10. Disable and Enable the Breakpoint

1. In the Visual Studio .NET code window, right-click the breakpoint and select Disable Breakpoint from the shortcut menu.

   The red circle in the margin of the code file becomes hollow. The following screen shot shows a disabled breakpoint. While disabled, the breakpoint will not be triggered.

   

2. Right-click the disabled breakpoint, and select Enable Breakpoint from the shortcut menu.

   The breakpoint is enabled and the hollow red circle changes back to a solid circle to indicate that the breakpoint is active.

3. Right-click the breakpoint, and select Remove Breakpoint from the shortcut menu.

   The breakpoint is removed from the code file. Deleting a breakpoint is a permanent action; you must create a new breakpoint if you need to suspend execution at this statement.

   Tip

   All of the breakpoints in a project can be disabled or removed at once by using the Disable All Breakpoints and Clear All Breakpoints commands on the Debug menu.