Share via

Visual InterDev

  • Article

Many ASP pages contain both client and server script. You can set breakpoints in both client and server script, and as each script executes, it can call the debugger at breakpoints.

Note   If you are writing ASP pages that use the scripting object model, you can set options that help you find errors and trace events. For details, see Debugging Script Objects in ASP Pages.

If the server is not running on your computer, you use remote debugging to debug the server script in the page. For details about how to set up remote debugging, see Debugging Remotely.

Note   It is highly recommended that you do not use Active Desktop™ mode of Microsoft® Internet Explorer 4.0 when you are debugging.

Enabling Debugging for ASP Pages

Before you can debug script in ASP pages, you must enable debugging. You can manually enable debugging for your ASP application as described under "Enabling ASP Debugging on the Server" in the Troubleshooting topic. Alternatively, Microsoft® Visual InterDev™ can automatically enable debugging on the server as needed.

Note   To debug script in ASP pages, you must be running version 4.0 or later of Microsoft® Internet Information Server (IIS).

To enable script debugging in ASP pages

  1. In the Project Explorer, right-click the project and choose Properties to display the Property Pages dialog box.

  2. Choose the Launch tab.

  3. Under Server script, make sure Automatically enable ASP server-side debugging on launch is checked.

When these options are set, each time you start a debugging session Visual InterDev checks that the server is configured for debugging. This includes:

  • Setting the IIS application to run in its own memory space (in COM terms, it runs "out of process").

  • Enabling the IIS application's debugging options.

  • Setting up a Microsoft® Transaction Server (MTS) package to allow you to attach the debugger to the Web application. The package's identify is set when you first start the debugging session by asking you to provide your name and password.

When you quit your debugging session, Visual InterDev restores the server debugging settings and out-of-process setting to their previous values.

Debugging Pages Containing Client and Server Script

When you set a breakpoint in client script in a page that contains both server and client script, the debugger tracks the breakpoint even though the position of the breakpoint can change significantly in the file after server script has executed. If server script causes the client script to be written several times into the page, the debugger tracks each breakpoint separately.

You can set breakpoints in server script, client script, or both. If you set breakpoints in both, the debugger will stop at the server script breakpoints first. When you continue to run, the page is sent to the browser, and the debugger will then stop at breakpoints in client script.

To debug pages containing both client and server script

  1. In Visual InterDev, set breakpoints in the lines of client and server script that you want to debug.

  2. Make the page your project's start page. In the Project Explorer, right-click the page and choose Set as Start Page.

  3. From the Debug menu, choose Start.

    Visual InterDev attempts to attach the debugger to the document running on the server.

  4. If this is the first time you have started the debugger since opening the current project, you are prompted to provide user information used to identify the debugging process on the server. Enter your domain and name (in the form domain\name) and password.

  5. Proceed with debugging. When server script execution reaches the line with the breakpoint, the debugger displays the page in the editor with that line highlighted.

    When you step out of server script, the page will continue executing until it gets to another server script. When the debugger has finished with server script, the server sends the page to the browser, which displays it.

  6. If necessary, trigger the event (such as a button click) that will run the client script you want to debug.

    The debugger stops at the breakpoint and displays the version of the page that is being processed by the browser.

When you are debugging pages that contain both server and client script, remember that server script can potentially insert HTML text and client script into the page. For example, a few lines of server script can dynamically create a large table out of database information, or can write or rearrange client script on the page.

After processing the page, the server removes the server script. As a consequence, the page being processed by the browser can look quite different than it does in the Visual InterDev editor with both server and client script in it. For details about how server script is processed, see Understanding Script Processing.

Debugging Embedded Server Script

A special case occurs when you want to debug server script that appears inside a block of client script. In the following, server script first extracts a value from a form and stores it in a variable. Later, inside the block of client script, a block of embedded server script dynamically inserts the value of the variable into a client statement:

<%loginName = Request.Form("loginName")%>

<SCRIPT LANGUAGE="VBScript">
Sub ShowWelcome
   txt = "<%=loginName%>"
   MsgBox("Welcome, " & txt)
End sub
</SCRIPT>

Note   When you write server script inside of client script, the editor does not follow color-coding convention for server script.

If you set a breakpoint on the line with the embedded server script, it is not clear whether you want the debugger to stop on the server script (<%=loginName%>) or later in the client script (txt = ). Visual InterDev therefore offers you two options:

  • Client breakpoint only. The breakpoint is interpreted as a client breakpoint, and the debugger does not stop when the server is processing the embedded server script.

  • Server and client breakpoint. The debugger stops twice — the first time when it processes the server script, and then again when it reaches the same line in client script.

The default is client breakpoint only. To stop both times, you enable a debugger option.

To enable breakpoints for embedded server script

  1. From the Tools menu, choose Options, and then open the Debugger node.

  2. Choose the option Insert breakpoints in Active Server Pages for breakpoints in client script.

When you are running the debugger and it breaks on embedded server script, it does not stop directly on the line containing the server script. Instead, it stops on the line of client script or HTML that immediately follows the preceding line of server script. In some cases, this can cause the breakpoint to appear many lines before the embedded server script.

For example, if you set a breakpoint on the embedded server script (<%=loginName%>) in the following example, the debugger will stop on the <HTML> tag.

<%loginName = Request.Form("loginName")%>
<HTML>
<HEAD>
<SCRIPT LANGUAGE="VBScript">
Sub ShowWelcome
   txt = "<%=loginName%>"
   MsgBox("Welcome, " & txt)
End sub
</SCRIPT>
</HEAD>

This behavior occurs because when the server is processing the page, it ignores anything that isn't server script. The server doesn't "see" the lines of HTML and client script that precede the embedded server script. To the server, the beginning of the line containing the embedded server script is therefore the one immediately following the preceding line of server script.

To move to the embedded server script, use the debugger's Step Into command.