Before getting straight into developing your favorite Hello, World! application in ASP.NET, we feel it’s important that you become familiar with the underlying structure of ASP.NET. This section describes some of the most important classes packaged in the System.Web.UI namespace in the ASP.NET framework.
The System.Web.UI namespace defines classes and interfaces used in constructing and rendering elements on a Web Form. The most important class in the System.Web.UI is the Control class, which defines properties, methods, and events that are common in all server controls in the Web Forms framework. Another important class in this namespace is Page, which is a derivative of the Control class. All ASP.NET web pages are instances of derivatives of the Page class. To have an extensible framework, the System.Web.UI namespace also includes the UserControl class, which is similar to the Page class except that it is mainly used as the base class for user controls. We will make use of the UserControl and Page classes in “Custom Server Controls” and “ASP.NET Application Development” later in this chapter.
The Control class is the root of all controls. For example, a text box is a control; a button or a combo box is also a control. The Control class basically encapsulates common functionalities and properties of all user-interface widgets. As you get deeper into ASP.NET development, everything you see is a Control derivative of some sort.
The Control class has the following important properties: Controls, ID, Parent, EnableViewState, Visible, Context, and ViewState. We will go over each of these properties briefly to show you what the Control class is made up of and how deriving from Control class would create a model that is consistent and easy to work with.
The Controls property represents the children of the control instance; the Parent property defines the parent of the control. Together, these two properties enable a hierarchy of controls on a web page. The ID property allows the control to be accessed programmatically by just using the ID and the dot notation to get to the object’s properties and methods, i.e., MyObjectId.propertyname. It also allows us to write event handlers for events raised by this control.
The EnableViewState flag indicates whether the control will maintain
its view state, as well as all view states of its child controls. If
this flag is set to true, the control will
remember its previous view state when the page posts back to
itself.[42] For example, if
EnableViewState is set to true, when the user
performs some operation that requires a postback, the user’s
previous selection or form-field data are preserved automatically.
When the page is sent back to the browser, the user can just continue
filling in the form as if he never left it. This is how all
derivatives of the Control class maintain their states between
requests and free developers from the plumbing works with hidden form
fields.
The Context property enables us to get to information about the current HTTP request, such as the Application, Server, Session, Request, and Response objects. ASP developers should be familiar with these intrinsic objects. You will most likely use the Context property when you are processing the web page’s OnLoad event to get to application- or session-level variables and request parameters to set up your page. Through the Context property, you can also get other information, such as cached resources, including database connections, for performance improvement; the trace property, for debugging purposes; and the user property, for security validation.
The ViewState property is an instance of the StateBag class, which is used to store name/value pairs of information that can be made accessible across multiple requests for the same web page. These name/value pairs are instances of the StateItem class.
The list of methods for the Control class is much longer than what we’ve covered in this section; however, this short list is probably all you need to know to get started with the Control class:
- CreateChildControls method
Called before any compositional custom control is rendered. A compositional custom control is similar to an ActiveX control: it composes other controls. You would not use this method simply to use the control. When developing custom controls, this method can be overridden so that custom-control developers can create and layout child controls prior to rendering the control, whether for the first time or for postbacks.
- Render method
Similar to the CreateChildControls, primarily used to develop custom controls. Control developers override this method to render the control content through the provided HtmlTextWriter parameter.
We will revisit the Render and CreateChildControls methods when we show you how to create custom controls in Section 7.5.4 later in this chapter.
As mentioned earlier, the Page class is actually a derivative of the Control class. This means it inherits all properties, methods, and events exposed by the Control class. In addition to the inherited things, the Page class defines more specific properties, methods, and events for a web page in the ASP.NET framework.
If you’ve done ASP development, you already know that Application, Request, Response, Server, and Session are intrinsic objects that you can access while scripting your ASP page. With ASP.NET, these objects are actually properties of the Page class. In addition to these familiar objects, the Page class also exposes other properties such as Cache, ErrorPage, IsPostBack, IsValid, Trace, and Validators.
This list is not complete; however, it includes some of the more important features that we want to introduce:
- ErrorPage property
Specifies the page to display when an error occurs. You can also specify the error page by using the @Page directive as shown in Section 7.4 in this chapter.
- Validators property
Groups together server controls that can validate themselves inside the Validators property of the Page. (In ASP.NET, a web page usually consists of a number of server controls.) This is so that when the Page needs to validate itself, it can delegate the validation to all of these controls and then set the IsValid property to the appropriate value.
- Trace property
References a TraceContext object, through which you can issue warning or error messages. Tracing can be switched on or off at anytime from the
web.configsetting.web.configis an XML-based text file that stores the runtime configuration for an ASP.NET application. Changes to this file take effect immediately, unlikeglobal.asain ASP development. The main configuration file is at the root of your web application; however, you can have a configuration file for each subdirectory in your web application. The closest configuration file overrides the settings of distant configuration files. Being able to switch off tracing in a configuration file like this is much better than doing so manually in ASP development, where you must go through all ASP files to remove all instances of Response.Write debugging messages when you are ready to deploy your application.
- LoadControl method
Loads server controls into the page programmatically. You can also have static server control declared on the page using the server-side object syntax as described in Section 7.4 later in this chapter.
- SavePageStateToPersistenceMedium and LoadPageStateFromPersistenceMedium methods
By default, save and load view state for all controls as hidden fields on the page. If you don’t want this setting, you can override the SavePageStateFromPersistenceMedium method to save the view state anywhere other than hidden fields. You will also have to override the LoadPageStateFromPersistenceMedium method to have the saved view states loaded back onto the page prior to rendering.
The UserControl class is very similar to the Page class (see the previous section) with the omission of page-specific properties or methods such as ErrorPage, IsValid, User, Validators, MapPath, Validate, and CreateHtmlTextWriter.
The UserControl class is typically used as the base class for custom controls. We can also build custom controls by inheriting directly from the Control class; however, it’s better to start from UserControl because it is not as raw as the Control class. If you find that UserControl supports a number of properties and methods that you don’t really want in your custom control, you might choose to inherit the raw Control class instead. We show you how to create custom controls in the Section 7.5.4 section later in this chapter.
If you’ve done any client-side DHTML scripting, you know how all HTML tags are mapped to scriptable objects. ASP.NET brings this mapping to the server side. Before each time the web page is rendered and sent back the client, you can access and manipulate each of the objects on the page.
ASP.NET maps HTML tags with objects in the hierarchy of server-side classes defined in the System.Web.UI.HtmlControls namespace. These server objects are called HtmlControls because they closely mapped to standard HTML elements.
For example, here is a simple HTML page that relies on client-side scripting to change the output page dynamically. (This page won’t run on browsers that do not support client-side scripting or browsers that have client-side scripting turned off.)
<html> <head> <script language=vbscript> sub cmd1_onclick( )txtMessage.InnerHtml = "(Client-side) Your name is: " & frm1.txtName.value end sub </script> </head> <body> <form id=frm1> Enter Name: <input id="txtName" type=text size=40> <input type=buttonid=cmd1value="Click Me"> <span id="txtMessage"></span> </form> </body> </html>
We will convert this page so that it relies on server control instead of the IE Document Object Model. Since the output of the page is controlled from the server side, the page works regardless of what kind of browser you are using. One drawback to this is that all interaction with the page requires a postback to the server.
To take advantage of server controls mapping, all you have to do is
to add the id and runat
attributes, and your server-side script will be able to access and
manipulate the server controls:
<html> <head><script id=scr1 language=c# runat=server>void svr_cmd1_onclick(Object o, EventArgs e){txtMessage.InnerHtml ="(Server-side) Your name is: " + txtName.Value;} </script> </head> <body> <form id=frm1runat=server> Enter Name: <input id="txtName" type=text size=40runat=server> <input type=button id=cmd1 value="Click Me"onserverclick="svr_cmd1_onclick" runat=server> <span id="txtMessage"runat=server></span> </form> </body> </html>
By adding the
runat=server
attribute to the HTML form and its
controls, you have exposed an HtmlForm object, an
HtmlInputText object, an HtmlInputButton
object, and an HtmlGenericControl object (the span) to
your server-side script, as depicted in Figure 7-1.
As you can see in the previous script, you can manipulate the
HtmlGenericControl object’s txtMessage to set its
InnerHtml
property.
Most classes in the System.Web.UI.HtmlControls namespace are derivatives of the HtmlControl class, which in turn derives from the Control class of the System.Web.UI namespace. See Figure 7-2 for a graphical presentation of the hierarchy. The HtmlControl class serves as the base class for these HtmlControls because most HTML elements share common characteristics that are defined in this HtmlControl base class. They share properties such as ID, Disabled, Value, InnerHtml, InnerText, Style, and TagName. Because these HtmlControls ultimately are derivatives of the Control class, they also have methods and events that the Control class exposes.
Table 7-1 maps the HtmlControls to standard HTML
tags. This means when you have an HTML
tag that is flagged to run on the server
side with runat="server", ASP.NET creates an
appropriate HtmlControl that you can program against.
Table 7-1. HtmlControls mapping to HTML tags
While providing HtmlControls, which map to standard HTML elements, ASP.NET also provides another group of UI controls, the WebControl class (see Figure 7-3). In addition to providing all traditional controls similar to HtmlControls, WebControls also provide much richer controls such as Calendar, Grid, and Validator.
WebControls are richer, more powerful, and more flexible than HtmlControls. It seems that it is the natural choice for new ASP.NET applications; however, HtmlControls are better if you are migrating ASP applications. Another thing that might make you consider using HtmlControls is that with it, your client-side scripts can still access and manipulate the objects.
Most classes in this namespace are based on WebControl, which is again a derivative of the Control class. The WebControl class provides the common properties and methods inherited by all of its descendants, including access key, tab index, tool tip, color, font, and border setting.
[42] Postback is the condition when an ASP page posts the data back to itself for processing. In conventional ASP programming, the state of the fields in the form have to be managed manually. In ASP.NET, we can have these field states managed automatically with a simple EnableViewState flag.