Try turning the previous Web page into an ASP.NET application.

1. Create a file named BunchOfControls.aspx.

2. Add the source code in Listing 3-3 to the file.

   Listing 3-3

   <%@ Page Language=C# %>
   
   <script runat="server">
     protected void Page_Load(object sender, EventArgs ea) 
     {
        ddl.Items.Add("Item 1");
        ddl.Items.Add("Item 2");
        ddl.Items.Add("Item 3");
        ddl.Items.Add("Item 4");
     }
   </script > 
   <h2> Page in ASP.NET </h2>
   <form id="Form1" runat="server" >
      <asp:Label Text="Type in me" runat="server" />  
      <asp:TextBox id="textinfo" runat="server" />  
      <BR>
      <asp:DropDownList id="ddl" runat="server" />
      <BR>
      <asp:Button id="pressme" Text="Press Me!"
   runat="server" />
   </form>

3. Save the file in a virtual directory (either create one or use the one from the previous chapter).

Many of the same elements seen in the classic ASP page also appear here. There's a top level Page directive. The Language directive is new for ASP.NET, stipulating that any code encountered by the ASP.NET runtime should be interpreted as C# code. There's a server-side script block that handles the Page_Load event. Following the script block is an HTML <form> tag. Notice the <form> tag has an attribute named runat, and the attribute is set to server. The runat=server attribute tells the ASP.NET runtime to generate a server-side control to handle that aspect of the page.

By including the runat=server attribute in the control tag, the ASP.NET runtime implicitly creates an instance of the control in memory. The resulting assembly includes a member variable of the same type and name as the control listed on the page. Notice the ASP.NET code specifies the DropDownList named ddl to run at the server. To access the control programmatically, the code block (expressed inline in this case) simply needs to refer to the DropDownList as ddl. The example above accesses the member variable to add items to the drop-down list.

To access the control using code behind, you'd explicitly declare the DropDownList variable as ddl. This is required because ASP.NET derives the code-beside class from System.Web.UI.Page. Visual Studio will do this for you automatically, as we'll see shortly.

Further down the ASP.NET code, you'll see each of the other elements (the label, the text box, the selection control, and the Submit button) are also represented as server-side controls. The job of each of these controls is to add a little bit of HTML to the response. Each time you add a server-side control to the page, ASPNET adds an instance of the control to a control tree the page maintains in memory. The control tree will show that every single element is encapsulated by one of these server-side controls—even the title text that seems to be floating near the top of the page.

To get a good idea as to how ASP.NET's Page model works, we'll run the page again, but we'll turn on the tracing mechanism. We'll examine tracing in more detail when we look at ASP.NET's diagnostic features. For now, you simply need to know that ASP.NET will dump the entire context of a request and a response if you set the page's Trace attribute to true. Here's the page directive with tracing turned on:

<%@ Page Language=C#  trace=true %>

Figure 3-3 shows what the page looks like with tracing turned on.

Figure 3-3 The ASPX file from Listing 3-3 rendered in Internet Explorer.

If you look at the raw text of the response (by selecting View | Source from the Internet Explorer menu), you see that ASP.NET responds with pretty straightforward run-of-the-mill HTML. There's a bit extra near the top—the hidden __VIEWSTATE field—which we'll cover a bit later. After that, the rest is familiar HTML describing a form. Listing 3-4 shows the raw HTML emitted by the ASP.NET code from Listing 3-3.

<h2> Page in ASP.NET </h2>
<form method="post" action="BunchOfControls.aspx" id="Form1">
<div>
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/
wEPDwUJODQ1ODEzNjQ4D2QWAmYPZBYCAgUPD2QPFgRmAgECAgIDFgQQBQZJdGVtIDEFBkl0ZW0gMWcQBQZJdGVtIDIFB
kl0ZW0gMmcQBQZJdGVtIDMFBkl0ZW0gM2cQBQZJdGVtIDQFBkl0ZW0gNGdkZBIoyTUHSvKe61yeF4ReR/90QFst" />
</div>

   <span>Type in me</span>   
   <input name="textinfo" type="text" id="textinfo" />  
   <BR>
   <select name="ddl" id="ddl">
   <option value="Item 1">Item 1</option>
   <option value="Item 2">Item 2</option>
   <option value="Item 3">Item 3</option>
   <option value="Item 4">Item 4</option>

</select>
   <BR>
   <input type="submit" name="pressme" value="Press Me!" id="pressme" />
</form>

You don't see any of the runat=server attributes anywhere in the rendered page. That's because the runat=server attributes are there to instruct ASP.NET how to construct the page's control tree.

After turning the page's Trace property to true, the ASP.NET will spew a ton of information your way in the form of a page trace. If you scroll down just a bit, you can see that part of ASP.NET's page trace includes the page's control tree. Figure 3-4 shows what the previous page's trace looks like with the focus on the control tree.

Figure 3-4 The ASP.NET page's control tree shown in the page trace.

The first line in the page's control tree trace is an item named __Page. This is in fact the System.Web.UI.Page object running in memory. Beneath that are a whole host of other items. You'll recognize some of their names as they were named in the ASP.NET source code. Notice the Form1, textinfo, and pressme items. Those names came from the tags in the original ASPX file.

What's happening here is that ASP.NET is breaking down the page rendering architecture into small, easily managed pieces. Every item in the list above derives from the System.Web.UI.Control class. Every time the System.Web.UI.Page needs to render the page, it simply walks the control tree, asking each control to render itself. For example, when the ASP.NET runtime asks the TextBox server-side control to render itself, the TextBox control adds the following HTML to the output stream heading for the browser:

   <input name="textinfo" type="text" id="textinfo" />
  

This works similarly for the other controls. For example, the DropDownList is responsible for emitting the select and option tags (the option tags represent the collection of items held by the DropDownList control).

   <select name="ddl" id="ddl">
      <option value="Item 1">Item 1</option>
      <option value="Item 2">Item 2</option>
      <option value="Item 3">Item 3</option>
      <option value="Item 4">Item 4</option>
   </select>

Now that you see how these tags work, let's see how to manage them in Visual Studio.