Debugging with Dynamic Languages for ASP.NET, Part 2

Adding Controls and Code for Debugging

You can now add some controls to the page and then add code. The code will be simple, but enough to enable you to add breakpoints later.

To add controls and code for debugging

1. Switch to Design view, and then from the Standard tab of the toolbox, drag the following controls onto the page and set their properties as indicated:

   Control
   Properties

   Label
   ID: CaptionLabel
   Text: (empty)

   TextBox
   ID: NumberTextBox
   Text: (empty)

   Button
   ID: SquareButton
   Text: Square

   Label
   ID: ResultLabel
   Text: (empty)

   Note  For this walkthrough, the layout of the page is not important.

2. Right-click the page and click View Code.

   In this release, event handlers must be coded and bound manually. You cannot create them by double-clicking a control in Design view or by selecting an event in the Properties window.

3. Add an event handler for the button's Click event, with logic to call a function named Square to square the number entered by the user. The handler might look like the following example.

   Note   The code example deliberately does not include error checking.

   IronPython

   		
   def SquareButton_Click(sender, e):
   number = float(NumberTextBox.Text)
   result = Square(number)
   ResultLabel.Text = '%s squared is %8.2f' % \
   (NumberTextBox.Text, result)

   IronPython

   		
   def Square(number):
   return number + number

4. Add code to set the text of the CaptionLabel control to Enter a number: if this is the first time the page is running, and thereafter to Enter another number:. The handler will look like the following.

   IronPython

   		
   def Page_Load(sender, e):
   postback = sender.IsPostBack
   if IsPostBack:
   CaptionLabel.Text = "Enter another number: "
   else:
   CaptionLabel.Text = "Enter a number: "

   You can use the IsPostBack property by itself, as shown in the if statement, or qualified by sender, as shown in the assignment statement. When it is used by itself, it is recognized as a property of the script page just as it is in C# and Visual Basic. In the assignment statement, sender.IsPostBack is used because later in the walkthrough it illustrates a limitation of debugging in the current release.

   Note  In this case, sender and the implicit page reference happen to be the same, because Page_Load handles a page event.

5. Save the page.
6. Press CTRL+F5 to run the page without debugging.
7. Enter a number (other than 2) and press the Square button.

   Notice that the result is incorrect, because there is an intentional bug in the program.

8. Close the browser.

Debugging the Page

In this part of the walkthrough, you will use the debugger to examine the page code line by line as it is running, add breakpoints to the code, and run the page in debug mode. You will start by setting breakpoints.

To set breakpoints

1. In Source view, set a breakpoint on the following line:

   IronPython

   		
   postback = sender.IsPostBack

   Note  When your code is in a separate file, you can toggle breakpoints by pressing F9, by right-clicking a line and choosing Breakpoint, or by clicking in the margin to left of the line. In this release, the only mechanism that works for code embedded in a Web page is clicking in the margin.

2. Set another breakpoint on the following line of the SquareButton_Click handler:

   IronPython

   		
   result = Square(number)

You are now ready to run the debugger.

To run the debugger

1. In the Debug menu, click Start Debugging (or press F5) to run the page in debug mode.

   Note  The first time you debug, you will be prompted to modify the Web.config file to enable debugging. Debugging is disabled by default, for better performance.

   Because the breakpoint is in the Page_Load event handler, the page has not finished processing yet. The browser is open, but the page is not yet displayed.

2. Click the postback variable and press SHIFT+F9 to display its value in a Quick Watch window. The value is null.

3. Note  In this release, the Locals window, the Watch and QuickWatch windows, and the Immediate window are limited to local variables in IronPython.

4. Press F10 to execute the assignment statement, and check the value of postback (IronPython only) to see that it is now false.
5. In the Debug menu, click Windows and then click Locals.

   This opens the Locals window, which displays the values of variables and objects that are in scope at the current line being executed (IronPython only). The value of postback is false.

   Notice that sender, IsPostBack, CaptionLabel, and SquareButton do not appear in the Locals window.

6. In the Immediate window, use the question mark operator to examine the value of postback (IronPython only).

   The Immediate window display will look like the following:

   >? postback
   >false

7. In the Debug menu, click Windows, click Watch, and then click Watch 1 (IronPython only).

   Note:  If you are using Visual Studio Express Edition, the debugger offers only a single Watch window.

8. Right-click postback, then click Add Watch to add the postback variable to the watch.

   Note  In the current release, you cannot right-click to add a watch if the code is in the page instead of in a separate file. Instead, you can enter the name of the variable in the first cell of the Name column in the Watch window.

9. Press F10 several times to step through the if statement.

   When the last line of the if statement has executed, the execution pointer pauses on the next function. The body of the Page_Load method is still in scope, as you can see from examining the Locals window.

10. Press F5 to continue execution and display the page.
11. Enter the value 7 into the text box and click the Square button.

    The debugger is displayed again, with the breakpoint in the Page_Load event handler. Press F10 to execute the line. The Watch window shows that the value of postback is true.

12. Press F5 to continue.

    The debugger processes the Page_Load event handler and enters the SquareButton_Click handler, where it stops on the second breakpoint you set.

13. Press F11 to step into the Square function.
14. Continue stepping through the function until you return from it.

    Notice that the value of result still is not set (IronPython only).

15. Press F11 one more time, and note the incorrect value.

    In the current release, you have to stop the debugger in order to correct the code.

16. Press F5 to continue running the program.