ASP.NET Input Validation Controls

Submitted by Andrew Ma on Mon, 01/28/2008 – 17:09.

Back when we had only ASP, developers who had to write webpages for forms knew
that the most tedious part is writing code to validate the user input. User
input had to be validated so that malicious use of the pages couldn’t be
achieve. User input had to be validated so that an incorrect piece of
information would not be entered. User input had to be validated so that the
information stored was standardized. Yeah, some people had libraries of ASP
functions to validate common things such as postal codes (zip codes for you
Americans), e-mail addresses, phone numbers, etc. The developers of ASP.NET saw
the tedium in always having to check user input. They decided that to simplify
our life by including validation controls.

ASP.NET validation controls also provide two ways of
validation: Server-side or Client-side. The nice thing about these Validation
controls is that it will perform client-side validation when it detects the
browser is able (unless client-side validation has been disabled). Thus reducing
roundtrips. And it will perform server-side where necessary. This
client-side/server-side detection and validation is done without extra work by
the developer!

With ASP.NET, there are five(5) controls included. They

  • The RequiredFieldValidation Control
  • The CompareValidator Control
  • The RangeValidator Control
  • The RegularExpressionValidator Control
  • The CustomValidator Control

The validation controls

All of the validation controls inherit from the base class BaseValidator so they
all have a series of properties and methods that are common to all validation
controls. They are:

  • ControlToValidate – This value is which control the validator is
    applied to.
  • ErrorMessage – This is the error message that will be displayed in
    the validation summary.
  • IsValid – Boolean value for whether or not the control is valid.
  • Validate – Method to validate the input control and update the
    IsValid property.
  • Display – This controls how the error message is shown. Here are
    the possible options:

    • None (The validation message is never displayed.)
    • Static (Space for the validation message is allocated in the page
    • Dynamic (Space for the validation message is dynamically added to the
      page if validation fails.)

Now to the five controls themselves:

The RequiredFieldValidation Control

The first control we have is the RequiredFieldValidation Control. As it’s
obvious, it make sure that a user inputs a value. Here is how it’s used:

Required field: <asp:textbox id="textbox1" runat="server"/>
<asp:RequiredFieldValidator id="valRequired" runat="server"
ControlToValidate="textbox1" ErrorMessage="* Please enter a value" Display="dynamic">*

In this example, we have a textbox which will not be valid until the user
types something in. Inside the validator tag, we have a single *. The text in
the innerhtml will be shown in the controltovalidate if the control is not
valid. It should be noted that the ErrorMessage attribute is not what is
shown. The ErrorMessage tag is shown in the Validation Summary (see below).

The CompareValidator Control

Next we look at the CompareValidator Control. Usage of this CompareValidator is
for confirming new passwords, checking if a departure date is before the arrival
date, etc. We’ll start off with a basic example:

Textbox 1: <asp:textbox id="textbox1" runat="server"/><br />
Textbox 2: <asp:textbox id="textbox2" runat="server"/><br />
<asp:CompareValidator id="valCompare" runat="server"
   ControlToValidate="textbox1" ControlToCompare="textbox2"
   ErrorMessage="* You must enter the same values into textbox 1 and textbox 2"

Here we have an example where the two textboxes must be equal. The tags that are
unique to this control is the ControlToCompare attribute which is the
control that will be compared. The two controls are compared with the type of
comparison specified in the Operator attribute. The Operator
attribute can contain Equal, GreterThan, LessThanOrEqual, etc. Another usage of
the ComapareValidator is to have a control compare to a value. For example:

Field: <asp:textbox id="textbox1" runat="server"/>
<asp:CompareValidator id="valRequired" runat="server" ControlToValidate="textbox1"
   ErrorMessage="* You must enter a number greater than 50" Display="dynamic">*

The data type can be one of: Currency, Double, Date, Integer or String, string
being the default data type.

The RangeValidator Control

Range validator control is another validator control which checks to see if a
control value is within a valid range. The attributes that are necessary to this
control are: MaximumValue, MinimumValue, and Type.


Enter a date from 1998:
<asp:textbox id="textbox1" runat="server"/>
<asp:RangeValidator id="valRange" runat="server"
   ErrorMessage="* Date must be between 1/1/1998 and 12/13/1998" Display="static">

The RegularExpressionValidator Control

The regular expression validator is one of the more powerful features of
ASP.NET. Everyone loves regular expressions. Especially when you write those
really big nasty ones- and then a few days later, look at it and say to yourself:
what does this do?

Again, the simple usage is:

E-mail: <asp:textbox id="textbox1" runat="server"/>
<asp:RegularExpressionValidator id="valRegEx" runat="server"
   ErrorMessage="* Your entry is not a valid e-mail address."

Here is a service I like to use to check
my regular expressions
for validity.

The CustomValidator Control

The final control we have included in ASP.NET is one that adds great flexibility
to our validation abilities. We have a custom validator where we get to write
our own functions and pass the control value to this function.

Field: <asp:textbox id="textbox1" runat="server">
<asp:CustomValidator id="valCustom" runat="server"
   ErrorMessage="*This box is not valid" dispaly="dynamic">*

You’ll notice that there are two new attributes ClientValidationFunction
and OnServerValidate. These are to tell the validation control which
functions to pass the controltovalidate value to. ClientValidationFunction is
usually a JavaScript function included in the HTML of your webpage. OnServerValidate
is the function that is server-side to check for validation if client does not
support client-side validation.

Client Validation function:

<script language="Javascript">
   /* ... Code goes here ... */

Server Validation function:

Sub ServerValidate (objSource As Object, objArgs As ServerValidateEventsArgs)
   ' Code goes here
End Sub

Validation Summary

ASP.NET has provided an additional control that complements the validator
controls. This is the validation summary control which is used like:

<asp:ValidationSummary id="valSummary" runat="server"
   ShowSummary="true" DisplayMode="List" />

The validation summary control will collect all the error messages of all the
non-valid controls and put them in a tidy list. The list can be either shown on
the web page (as shown in the example above) or with a popup box (by specifying ShowMessageBox="True")

Now you know how to use the Validator Controls in ASP.NET! Have fun!

Acknoledgment: Professional ASP.NET (published by Wrox) was
used a reference. It’s a good book!

1 Comment »

  1. Wonderful goods from you, man. I have take note your stuff previous
    to and you are simply too great. I actually like what you’ve received here, certainly like
    what you are stating and the best way during which you assert it.
    You make it entertaining and you continue to take care of to stay it smart.

    I can not wait to read much more from you.
    This is actually a wonderful site.

RSS feed for comments on this post · TrackBack URI

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: