Home > Articles > Programming > ASP .NET

  • Print
  • + Share This
This chapter is from the book

Server Controls

An important innovation in ASP.NET is server controls. They provide an event model that is startlingly similar to Windows GUI programming, and they encapsulate browser dependencies. They integrate seamlessly into the Visual Studio development environment. The end result is an extremely powerful tool for Web development.

We have been using server controls from the very beginning of the chapter, where we presented our "Hello" program. In this section we will look at server controls more systematically, and we will see a number of examples of interesting controls.

Web Controls

The most important kind of control in ASP.NET is the Web Forms server control or just Web control. These are new controls provided by the .NET Framework, with special tags such as <asp:textbox>. These controls run at the server, and they generate HTML code that is sent back to the browser. They are easy to work with, because they behave consistently. For example, you can determine the value returned by a control by using simple property notation.

Dim name As String = txtName.Text 

All of our previous examples of server controls in this chapter have been Web controls. In this section, we will look at several additional kinds of Web controls, including validation controls, list controls, and rich controls such as the Calendar control. But first we will look at HTML server controls.

HTML Server Controls

HTML server controls provide equivalent functionality to standard HTML controls, except that they run on the server, not on the client. In fact, the only way to distinguish an HTML server control from an ordinary HTML control on a Web page is the presence of the runat="server" attribute.

Here are two controls. Both are INPUT controls. The first is a server control. The second is of type password and is a regular HTML control.

<INPUT id=txtUserId
style="WIDTH: 135px; HEIGHT: 22px" type=text size=17
runat="server"></P>
<INPUT id=""
style="WIDTH: 138px; HEIGHT: 22px" type=password size=17 
name=txtPassword> 

Working with HTML server controls is much like working with the Web Forms server controls we've used already. In server-side code you access the control through a control variable that has the same name as the id attribute. However, we are dealing with HTML controls, so there are some differences. You access the string value of the control not through the Text property but through the Value property. Here is some code that uses the value entered by the user for the txtUserId control.

lblMessage.Text = "Welcome, " & txtUserId.Value 

The advantage of HTML server controls for the experienced Web programmer is that they match ordinary HTML controls exactly, so that your knowledge of the details of HTML control properties and behavior carries over to the ASP.NET world. However, this similarity means they carry over all the quirks and inconsistencies of HTML. For example, rather than having two different controls for the somewhat different behaviors of a textbox and a password control, HTML uses in both cases the INPUT control, distinguishing between the two by the type=password attribute. Web Forms controls, in contrast, are a fresh design and have an internal consistency. Also, as we shall soon see, there is a much greater variety to Web Forms controls.

HTML CONTROLS EXAMPLE

Let's look at an example of HTML controls. All of our server control examples in this section can be accessed from the page ServerCon-trols\WebForms1.aspx. (As usual, you should use IIS to configure the folder ServerControls as an application.) The top-level page gives you a choice of three examples,

  • HTML Controls
  • Validation
  • Calendar

Follow the link to HTML Controls, and you will come to a login page, as illustrated in Figure 14-34.

Figure 14-34Figure 14-34 Alogin page illustrating HTML server controls.

There is a textbox for entering a user ID and a password control for entering a password. Both of these controls are HTML INPUT controls, as shown previously. The textbox runs at the server, and the password is an ordinary HTML control. Clicking the Login button (implemented as a Windows Forms Button control) results in very simple action. There is one legal password, hardcoded at "77." The button event handler checks for this password. If legal, it displays a welcome message; otherwise, an error message.

Private Sub btnLogin_Click(ByVal sender As Object, _
  ByVal e As EventArgs) Handles btnLogin.Click
       If Request.Params("txtPassword") = "77" Then
           lblMessage.Text = "Welcome, " & txtUserId.Value
       Else
           lblMessage.Text = "Illegal password"
       End If 
End Sub 

Since the password control is not a server control, no server control variable is available for accessing the value. Instead, we must rely on a more fundamental technique, such as using the Params collection.10

HTML CONTROLS IN VISUAL STUDIO

It is easy to work with HTML controls in Visual Studio.11 The Toolbox has a palette of HTML controls, which you can access through the HTML tab. Figure 14–35 shows some of the HTML controls in the Visual Studio Toolbox.

Figure 14-35Figure 14-35 HTML controls in the Visual Studio Toolbox.

You can drag HTML controls onto a form, just as we have done with Web Forms controls. You have the option of using FlowLayout or GridLayout. The default is GridLayout, which enables absolute positioning of controls on a form. FlowLayout is the simplest layout, resulting in elements positioned in a linear fashion. You can set the layout mode through the pageLayout property of the form. In our example we used FlowLayout for the two INPUT controls and their associated labels.

The default choice for HTML controls is not to run at the server. To make an HTML control into a server control, right-click on it in the Form Designer. Clicking on Run As Server Control toggles back and forth between running on the server and not running on the server. You can inspect the runat property in the Properties panel, but you cannot change it there.

Validation Controls

The rest of our discussion of server controls will focus on Web controls. A very convenient category of control is the group of validation controls. The basic idea of a validation control is very simple. You associate a validation control with a server control whose input you want to validate. Various kinds of validations can be performed by different kinds of validation controls. The validation control can display an error message if the validation is not passed. Alternatively, you can check the IsValid property of the validation control. If one of the standard validation controls does not do the job for you, you can implement a custom validation control. The following validation controls are available:

  • RequiredFieldValidator
  • RangeValidator
  • CompareValidator
  • RegularExpressionValidator
  • CustomValidator

There is also a ValidationSummaryControl that can give a summary of all the validation results in one place.

An interesting feature of validation controls is that they can run on either the client or the server, depending on the capabilities of the browser. With an upscale browser such as Internet Explorer, ASP.NET will emit HTML code containing JavaScript to do validation on the client.12 If the browser does not support client-side validation, the validation will be done only on the server.

REQUIRED FIELD VALIDATION

A very simple and useful kind of validation is to check that the user has entered information in required fields. Our second server control demonstration page provides an illustration. Back on the top-level ServerCon-trols\WebForms1.aspx page, follow the link to "Validation" (or click the Register button from the Login page). You will be brought to the page Regis-terNewUser.aspx, as illustrated in Figure 14–36. The screenshot shows the result of clicking the Register button after entering a UserId, a Password, and a First Name, but leaving Last Name blank. You will see an error message displayed next to the Last Name textbox, because that is where the validator control is on the form.

Figure 14-36Figure 14-36 Register New User page illustrates ASP.NET validation controls.

The textboxes for First Name and Last Name both have an associated RequiredFieldValidator control. In Visual Studio you can simply drag the control to a position next to the associated control. You have to set two properties of the validator control:

  • ControlToValidate must be set to the ID of the control that is to be validated.

  • ErrorMessage must be specified.

Then, when you try to submit the form, the validator control will check whether information has been entered in its associated control. If there is no data in the control, the designated error message will be displayed.

Internet Explorer supports client-side validation using JavaScript. You can verify that ASP.NET generates suitable JavaScript by looking at the generated source code in the browser (View | Source).

This form also requires that the UserId field not be blank. Since the primary validation of this field is done by a regular expression validator, as discussed shortly, we will use another technique for the required field validation. Figure 14–37 shows the location of the various validator controls in the Visual Studio Form Designer.

Figure 14-37Figure 14-37 Layout of validation controls for Register New User page.

We assign the ID vldUserId to the required field validator control associated with the UserId control, and we clear the error message. We also set the EnableClientScript property to False, to force a postback to the server for the validation. The event handler for the Register button then checks the IsValid property of vldUserId.

private void cmdRegister_Click(object sender,
                                                     System.EventArgs e)
{
     if (vldUserId.IsValid)
         lblMessage.Text = "Welcome, " + txtFirstName.Text;
     else
         lblMessage.Text = "UserId must not be blank"; 
} 

If the control is valid, we display the welcome message; otherwise, an error message. Note that we won't even reach this handler if other validation is false.

REGULAR EXPRESSION VALIDATION

The RegularExpressionValidator control provides a very flexible mechanism for validating string input. It checks whether the string is a legal match against a designated regular expression. Our example illustrates performing a regular expression validation of UserId. The requirement is that the ID consist only of letters and digits, which can be specified by the regular expression

[ A-Za-z0-9]+

The following properties should normally be assigned for a RegularExpressionValidator control:

  • ValidationExpression (the regular expression, not surrounded by quotes)

  • ControlToValidate

  • ErrorMessage

You can try this validation out on our Register New User page by entering a string for UserId that contains a non-alphanumeric character.

Rich Controls

Another category of Web Forms controls consists of "rich controls," which can have quite elaborate functionality. The Calendar control provides an easy-to-use mechanism for entering dates on a Web page. Our third sample server control page provides an illustration, as shown in Figure 14–38.

The user can select a date on the Calendar control. The SelectedDate property then contains the selected date as an instance of the DateTime structure. You can work with this date by handling the SelectionChanged event. In our example page, the event handler displays the date as a string in a textbox.

Figure 14-38Figure 14-38 Using the Calendar control to select a date.

Private Sub Calendar1_SelectionChanged( _
  ByVal sender As Object, ByVal e As EventArgs) _
  Handles Calendar1.SelectionChanged
       txtDate.Text = _
           Calendar1.SelectedDate.ToShortDateString()
End Sub 
  • + Share This
  • 🔖 Save To Your Account