Tutoriel : Maitrisez les validators ASP.NET 2.0 en C#

Date de publication : 27/05/2008 , Date de mise à jour : 27/05/2008

Cet article a pour but de présenter les principes et l'utilisation de la validation des saisies utilisateurs d'une page web à travers le framework de validation d'ASP.NET 2.0.

1.Introduction
2.Le besoin de valider les informations saisies
3.Principe des validateurs d'ASP.NET
3.1.Classe de base
3.2.Afficher un message d'erreur
3.2.1.Propriété Text
3.2.2.Propriété ErrorMessage
3.2.3.Message personnalisé entre les balises
3.3.Les différents mode d'affichage d'une erreur
4.Comment valider ? Et que valider ?
4.1.Comment valider ?
4.2.Que valider ?
5.Les validateurs d'ASP.NET
5.1.RequiredFieldValidator
5.2.RangeValidator
5.3.CompareValidator
5.3.1.Comparer à une valeur
5.3.2.Comparer à un autre champ
5.3.3.Vérifier la validité d'un type
5.4.RegularExpressionValidator
5.5.CustomValidator
5.5.1.Côté serveur
5.5.2.Coté client
5.6.ValidationSummary
5.7.Combiner les validateurs
6.Un peu plus loin avec les validateurs
6.1.Les groupes de validations
6.2.Manipuler les validateurs pour afficher un message d'erreur personnalisé
6.2.1.Coté serveur
6.2.2.Coté client
6.2.3.Remarque
6.3.Afficher un MessageBox après un retour serveur
6.4.Désactiver la validation coté client
6.5.Vérifier coté Javascript que la validation est active
6.6.Utilisation avancée du CustomValidator
6.6.1.Passer des valeurs à la fonction javascript
6.6.2.Utiliser le CustomValidator pour valider un RadioButton
6.6.3.Valider deux contrôles avec le même validator / Changer le message d'erreur du validateur :
6.6.4.1.Coté client
6.6.4.2.Coté serveur
6.6.4.3.Remarques
6.6.4.Utiliser un CustomValidator pour afficher des images en fonction du résultat de la validation
6.7.Réflexion sur le passage de paramètres
7.Créer son propre validator
8.Validator et ajax
8.1.Validator et UpdatePanel
8.2.Un validateur amélioré avec l'AJAX Control Toolkit
10.Conclusion
Remerciements
Contact

1.Introduction

Vous êtes un développeur ASP.NET utilisant le C# et vous souhaitez apprendre à utiliser les validateurs (ou validators) ou approfondir vos connaissances pour faire une utilisation avancée des validators et comprendre les mécanismes du framework de validation d'ASP.NET ?
Alors ce tutoriel est pour vous.

Vous apprendrez dans ce cours à utiliser les différents validators, à comprendre l'importance de la validation des saisies utilisateurs et à mettre à profit la richesse et les possibilités d'ASP.NET pour rendre la validation efficace.
Tout au long de ce tutoriel, j'ai utilisé le logiciel Visual Studio 2008 et j'ai créé des projets de type "Web Application".

2.Le besoin de valider les informations saisies

La collecte d'informations via un formulaire est une des nombreuses taches que peut effectuer une page d'un site web.
Vous pouvez par exemple avoir besoin de saisir les coordonnées d'un client, des informations sur une commande, etc ...

Les pages web disposent de toute une série de contrôles qui permettent d'obtenir des saisies de l'utilisateur. Champ de texte, radio boutons, case à cochée, liste déroulante, etc ...

Mais qui dit "utilisateur" dit "risque d'erreur".
Par exemple, la page web réclame un nombre pour indiquer un nombre de jour, et l'utilisateur se trompe en saisissant une chaîne de caractères qui n'a rien à voir avec le nombre attendu.
Et encore, ceci correspond juste à une erreur ... Que dire d'un utilisateur malveillant qui tente de pénétrer les secrets de vos pages webs ...

La solution : la validation des saisies utilisateurs.

Votre champ texte attend un nombre à trois chiffres et uniquement ceci ? Alors, notre tache va consister à vérifier la saisie de l'utilisateur et à l'informer s'il s'est trompé ou pas.

C'est ici qu'interviennent les validators. Ce sont des contrôles ASP.NET qui intègrent la logique permettant de vérifier la saisie des utilisateurs. Ils vont grandement nous simplifier la tache pour vérifier qu'un champ obligatoire est correctement saisi ou qu'une valeur correspond bien à ce qu'on attend, etc ...
Ils permettent de contrôler la saisie coté client si le navigateur le supporte, ce qui améliore l'interaction avec l'utilisateur.
Ils permettent également de valider les saisies du coté du server, ce qui est une étape OBLIGATOIRE. En effet, la validation coté client peut avoir été désactivée ou altérée par du code malveillant. La seule façon fiable de vérifier la validité d'une saisie est de la faire coté serveur.

Les validators nous facilitent grandement la tache en disposant d'un moyen puissant de contrôler la saisie et d'afficher des messages d'erreurs pour avertir de la saisie incorrecte.

La validation des contrôles apparait à un moment précis du cycle de vie d'une page, entre la fin des événements d'initialisation par le code utilisateur et les événements des contrôles, comme vous pouvez le voir dans ce tutoriel.
Forcément, cela se passe après le chargement des valeurs du postback par la page... et avant les événements des contrôles. Cela permet de savoir au moment du click sur un bouton si la page est correcte et dans ce cas, rediriger vers la bonne page.
Il est important de comprendre l'ordre d'enchainement des événements, si l'on a à faire des traitements en cas d'erreur, ou en cas de succès de validation.

3.Principe des validateurs d'ASP.NET

Les validators sont des contrôles ASP.NET au même titre qu'un TextBox. Leur particularité de validator se remarque au fait qu'ils implémentent IValidator (ou dérivent de BaseValidator)

3.1.Classe de base

Tous les validators d'ASP.NET héritent de la classe BaseValidator.
Cette classe contient le coeur de l'implémentation des validators. Elle contient beaucoup de propriétés, dont certaines particulièrement intéressantes :

ControlToValidate : Permet d'associer à un validateur le contrôle qu'il doit valider. Il est requis pour tous les validators, sauf pour le CustomValidator où il est optionnel. Nous verrons son utilisation plus loin dans le tutoriel.
Display : Permet de définir la façon dont vont s'afficher les messages d'erreurs des validators. Nous verrons son utilisation plus loin dans le tutoriel.
EnableClientScript : Permet d'indiquer si l'on souhaite utiliser une validation cliente ou non. (Vrai par défaut)
ErrorMessage : Permet d'indiquer le message d'erreur qui sera affiché. Cette propriété est utilisée notamment pour le contrôle ValidationSummary. Nous verrons son utilisation dans le paragraphe suivant.
SetFocusOnError : Met le focus sur le champ indiqué par ControlToValidate en cas d'erreur.
Text : Permet d'indiquer le message d'erreur qui sera affiché. Nous verrons son utilisation dans le paragraphe suivant.
ValidationGroup : Permet de grouper les contrôles pour que ne soient validés que les contrôles qui font parti du même groupe. Cela permet de définir plusieurs zones de validation dans une page.

3.2.Afficher un message d'erreur

Prenons l'exemple du RequiredFieldValidator, nous y reviendrons en détail plus tard.
Ce validator, comme vous l'avez sans doute compris, sert à vérifier (grâce à ControlToValidate) que le textBox "LeTextBox" doit être saisi (Required).

<div>
	<asp:TextBox runat="server" ID="LeTextBox" />
</div>
<asp:RequiredFieldValidator runat="server" ControlToValidate="LeTextBox" Text="Le champ doit être saisi" />

<asp:Button runat="server" Text="Valider" />

En voyant cette écriture, on devine qu'il va afficher l'erreur "Le champ doit être saisi" si le champ est vide.
Il existe plusieurs façons d'afficher un message d'erreur, nous allons les observer.

3.2.1.Propriété Text

Lorsqu'on utilise la propriété Text, le message s'affiche en rouge par défaut. Comme ci-dessous :

3.2.2.Propriété ErrorMessage

<asp:RequiredFieldValidator runat="server" ControlToValidate="LeTextBox" ErrorMessage="Le champ doit être saisi" />

L'utilisation de la propriété ErrorMessage semble produire le même effet que la propriété Text. Il y a cependant une différence, et nous le verrons plus tard, le fait de définir la propriété ErrorMessage permettra au contrôle ValidationSummary de réutiliser le message d'erreur.

3.2.3.Message personnalisé entre les balises

Une autre façon d'afficher un message est de le définir entre les balises de RequiredFieldValidator, ce qui permet de faire un peu ce qu'on veut. Mettre des couleurs, des images, etc ...

<asp:RequiredFieldValidator runat="server" ControlToValidate="LeTextBox">
	Le message doit être saisi <img src="erreur.jpg" alt="erreur de saisie" />
</asp:RequiredFieldValidator>

3.3.Les différents mode d'affichage d'une erreur

Display="None" : Permet de ne pas afficher de message d'erreur. Le fait de ne pas afficher de message d'erreur peut être utile lorsqu'on utilise un ValidationSummary, comme on le verra plus tard.
Display="Dynamic" : Affiche le message d'erreur "dynamiquement", le message apparaitra à l'emplacement du validator en décalant les autres contrôles de la page.
Display="Static" : Affiche le message d'erreur "statiquement", c'est à dire que l'emplacement du message d'erreur est réservé. On voit un "trou" à l'emplacement ou sera affiché le message s'il y a une erreur. On utilise cette option lorsqu'on a besoin que l'affichage ou l'absence du message ne casse pas la présentation, dans des cellules d'un tableau par exemple.

4.Comment valider ? Et que valider ?

4.1.Comment valider ?

La validation de champs de formulaire se fait lorsqu'on "POST" la page, typiquement une action de type form.submit(). C'est à dire qu'une validation est possible pour des contrôles particuliers.
C'est le cas des <asp:Button>, des <asp:LinkButton>, <asp:ImageButton> et des <asp:BulletedList>
On les utilise ainsi :

<asp:Button runat="server" Text="Valider" />
<asp:LinkButton runat="server" Text="Valider" PostBackUrl="page2.aspx" />
<asp:ImageButton runat="server" ImageUrl="valider.jpg" PostBackUrl="page2.aspx" />
<asp:BulletedList CausesValidation="true" BulletStyle="Disc" DisplayMode="LinkButton" runat="server">
	<asp:ListItem Value="Element 1"/>
	<asp:ListItem Value="Element 2"/>
	<asp:ListItem Value="Element 3"/>
</asp:BulletedList>

NB : on remarque pour le contrôle BulletedList qu'il y a une propriété CausesValidation="true", en fait, elle vaut vraie par défaut pour tous les autres, c'est pour ça que je ne l'indique pas.

Lorsque cette propriété vaut true (par défaut dans presque tous les cas), ASP.NET va lancer la validation de la page lorsque l'utilisateur cliquera sur ces composants.
Lorsque cette propriété vaut false, ASP.NET ignorera la validation et la page sera postée normalement.

La validation de notre page se fait par défaut coté client (si le navigateur le supporte) et coté serveur. Lorsque la validation coté client n'est pas bonne, la page n'est pas postée. Le cycle de la page est donc interrompu.
La validation coté serveur est également automatique lorsque CausesValidation vaut true, la page est postée et le cycle de vie est classique.
Ce qui fait que lorsqu'un événement, par exemple l'événement Click du bouton, est levé, il faudra tester le résultat de la validation dans cet événement :

protected void ClickButton(object sender, EventArgs e)
{
	if (Page.IsValid)
	{
		// la validation est bonne ...
	}
}

4.2.Que valider ?

Les contrôles serveur que l'on peut valider sont :

TextBox
ListBox
DropDownList
RadioButtonList
HtmlInputText
HtmlTextArea
HtmlSelect

Certains contrôles ne peuvent pas être validés directement, c'est le cas par exemple du RadioButton ou de la CheckBox
Typiquement, on peut valider tous les contrôles qui prennent en charge l'attribut ValidationProperty.
Ainsi, on peut créer son contrôle pour qu'il soit sujet à la validation. Par exemple, ici je crée un contrôle qui affiche un <input type="text"> :

[ValidationProperty("Valeur")]
public class MonControl : WebControl
{
	private string _valeur;
	public string Valeur
	{
		get { return _valeur; }
		set { _valeur = value; }
	}

	protected override void Render(HtmlTextWriter writer)
	{
		writer.WriteBeginTag("input");
		writer.WriteAttribute("id", ID);
		writer.WriteAttribute("type", "text");
		writer.WriteAttribute("value", _valeur);
		writer.Write(HtmlTextWriter.SlashChar);
		writer.Write(HtmlTextWriter.TagRightChar);
	}
}

Ici je définis la propriété Valeur comme étant la propriété à tester pour la validation grâce à l'attribut ValidationProperty.
Je pourrais l'utiliser de cette façon :

<Exemple:MonControl runat="server" id="monControl" Valeur="Une valeur" />
<asp:RequiredFieldValidator runat="server" ControlToValidate="monControl" ErrorMessage="La valeur doit être saisi" />

NB : pour que l'attribut ValidationProperty fonctionne, il doit mapper l'attribut html value du contrôle (ici l'input type="text"), c'est pour cela que le contrôle CheckBox ne peut pas être validé, il ne possède pas d'attribut value.
Pour qu'un contrôle complexe qui ne peut pas mapper d'attribut html value puisse être validé, on utilisera un CustomValidator, comme on le verra plus tard.
Plus d'infos sur la création de custom controls dans la faq ASP.NET.

5.Les validateurs d'ASP.NET

5.1.RequiredFieldValidator

Le RequiredFieldValidator, comme son nom le suggère, permet de tester si un champ est rempli ou non.

<asp:TextBox runat="server" ID="LeTextBox" />
<asp:RequiredFieldValidator runat="server" ControlToValidate="LeTextBox" Display="dynamic" ErrorMessage="Vous devez saisir la valeur" />
<asp:Button runat="server" Text="Valider" />

Ici le RequiredFieldValidator va vérifier que le contrôle LeTextBox (précisé dans ControlToValidate) soit bien saisi. Si ce n'est pas le cas, il affichera la valeur de ErrorMessage.

Il peut arriver des fois qu'un contrôle possède une valeur par défaut. La propriété InitialValue permet de valider le contrôle uniquement si la valeur du contrôle est différente de celle saisie dans InitialValue. On peut l'appliquer par exemple pour une DropDownList :

<asp:DropDownList id="DropDownList1" runat="server">
	<asp:ListItem Selected="True">Sélectionnez une valeur</asp:ListItem>
	<asp:ListItem>Valeur 1</asp:ListItem>
	<asp:ListItem>Valeur 2</asp:ListItem>
	<asp:ListItem>Valeur 3</asp:ListItem>
</asp:DropDownList>
<asp:RequiredFieldValidator Display="Dynamic" runat="server" ErrorMessage="N'oubliez pas de saisir une valeur" 
	ControlToValidate="DropDownList1" InitialValue="Selectionnez une valeur"/>

PS : n'oubliez pas de toujours tester la validation coté serveur, même lorsqu'il s'agit d'un simple RequiredFieldValidator.
En effet, une personne peut très bien avoir désactivé le javascript (ou provoqué un résultat similaire) et dans ce cas, la validation coté client va passer, il faut donc toujours tester la validation coté serveur, c'est le seul moyen fiable de contrôler les saisies.

Imaginons un bouton qui comporte un événement Click, et dans lequel on redirige vers une page web :

<asp:TextBox runat="server" ID="LeTextBox" />
<asp:RequiredFieldValidator runat="server" ControlToValidate="LeTextBox" Display="dynamic" ErrorMessage="Vous devez saisir la valeur" />
<asp:Button runat="server" Text="Valider" OnClick="ButtonClick" />

protected void ButtonClick(object sender, EventArgs e)
{
	Response.Redirect("http://www.developpez.com");
}

Si le javascript est désactivé, peu importe qu'une valeur soit saisie ou non, on sera dans tous les cas redirigé vers la page de developpez.com.

La bonne façon de faire la redirection est :

protected void ButtonClick(object sender, EventArgs e)
{
	if (Page.IsValid)
	{
		// la page est valide
		Response.Redirect("http://www.developpez.com");
	}
}

5.2.RangeValidator

Le RangeValidator vérifie si la valeur d'un contrôle d'entrée se trouve dans une plage de valeurs spécifiée.
On peut comparer des Integer, Double, Date, String et Currency. Pour préciser quel type on attend, on va utiliser la propriété Type. Les bornes à valider seront saisies grâce aux propriétés MinimumValue et MaximumValue.

<asp:TextBox runat="server" ID="LeTextBox" />
<asp:RangeValidator runat="server" ControlToValidate="LeTextBox" Type="currency" MinimumValue="100" 
		MaximumValue="200" Display="dynamic" ErrorMessage="Saisissez un montant entre 100 et 200 €" />

NB : si le contrôle est vide, la validation sera toujours bonne. Si cette valeur doit obligatoirement être saisie, on combinera le RangeValidator avec un RequiredFieldValidator comme on le verra plus tard.

5.3.CompareValidator

Le CompareValidator permet de comparer la valeur entrée par l'utilisateur avec une valeur ou avec la valeur d'un autre contrôle.
On peut également se servir de ce contrôle pour vérifier qu'une donnée saisie est d'un type particulier. (on utilisera l'opérateur DataTypeCheck).
On peut comparer des Integer, Double, Date, String et Currency. Pour préciser quel type on attend, on va utiliser la propriété Type.
Pour effectuer la comparaison, on utilisera un opérateur qui permettra de spécifier le type de l'opération.
On pourra effectuer une comparaison d'égalité (Equal), d'inégalité (NotEqual), de supériorité (GreaterThan), de supériorité ou d'égalité (GreaterThanEqual), d'infériorité (LessThan) et enfin d'infériorité ou d'égalité (LessThanEqual).

5.3.1.Comparer à une valeur

<asp:TextBox runat="server" ID="LeTextBox" />
<asp:CompareValidator runat="server" ControlToValidate="LeTextBox" Type="Integer" Operator="NotEqual" ValueToCompare="0" 
		ErrorMessage="L'entier saisi doit être différent de 0" />
<asp:TextBox runat="server" ID="LeTextBoxDate" />
<asp:CompareValidator ID="CompareValidator1" runat="server" ControlToValidate="LeTextBoxDate" Type="Date" 
	Operator="GreaterThan" ValueToCompare="01/01/2000" ErrorMessage="Vous devez être né après l'an 2000 pour bénéficier de cette promotion" />

NB : si la valeur du contrôle ne peut pas être convertie, la validation échouera.

5.3.2.Comparer à un autre champ

<asp:TextBox runat="server" ID="Email1" />
<asp:TextBox runat="server" ID="Email2" />
<asp:CompareValidator runat="server" ControlToValidate="Email1" Type="String" Operator="Equal" 
	ControlToCompare="Email2" ErrorMessage="Les emails saisis doivent être identiques !" />

Attention, dans la comparaison à un contrôle, si le type du ControlToCompare ne correspond pas à la valeur saisie, la validation peut passer.
En effet, l'exemple suivant qui compare 2 dates:

<asp:TextBox runat="server" ID="Date1"/>
<asp:TextBox runat="server" ID="Date2"/>
<asp:CompareValidator runat="server" ControlToValidate="Date1" Type="Date" Operator="LessThanEqual" 
	ControlToCompare="Date2" ErrorMessage="La date doit être inférieure !" />

est malheureusement valide si je saisi les valeurs ci-dessous.

Il faudra effectuer également une validation sur le contrôle identifié par ControlToCompare.

5.3.3.Vérifier la validité d'un type

L'exemple ci-dessous permet de vérifier qu'on a bien saisi un entier.

<asp:TextBox runat="server" ID="LeTextBox" />
<asp:CompareValidator runat="server" ControlToValidate="LeTextBox" Type="Integer" Operator="DataTypeCheck" 
	ErrorMessage="Veuillez saisir un entier" Display="Dynamic" />

5.4.RegularExpressionValidator

Le RegularExpressionValidator permet de vérifier une entrée à partir d'une expression régulière.
Par exemple, pour vérifier un email :

<asp:TextBox runat="server" ID="LeTextBox" />
<asp:RegularExpressionValidator runat="server" ControlToValidate="LeTextBox" ErrorMessage="L'email saisi n'est pas correct" Display="dynamic"
	ValidationExpression="^[_a-zA-Z0-9-]+(\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.(([0-9]{1,3})|([a-zA-Z]{2,3})|(aero|coop|info|museum|name))$" />

Plus d'infos sur les expressions régulières : http://lgmorand.developpez.com/dotnet/regex/.
Un annuaire d'expressions régulières très utile : http://regexlib.com/.

5.5.CustomValidator

Le CustomValidator permet de créer sa propre fonction de validation, coté client et coté serveur.
On utilisera ServerValidate pour fournir sa propre méthode de validation coté serveur.
A noter que la propriété ControlToValidate n'est pas obligatoire, on pourra effectivement utiliser directement les contrôles de la page pour faire notre validation.
Pour faire une validation coté client, il faudra créer une fonction javascript dont le nom sera passé à la propriété ClientValidationFunction. On utilisera également les paramètres pour donner le résultat de la validation et connaitre la valeur de l'objet associé à ControlToValidate.
On pourra utiliser ValidateEmptyText pour indiquer si un texte vide devra être soumis à validation. Cela ne nous dispense pas de devoir tester si la valeur est vide ou non, cela signifie que lorsqu'un contrôle est vide, on passera dans la fonction de validation.

5.5.1.Côté serveur

Si la propriété ControlToValidate est définie, on pourra utiliser la propriété Value du paramètre ServerValidateEventArgs pour récupérer la valeur du contrôle.
On utilisera la propriété IsValid de l'objet ServerValidateEventArgs pour stocker le résultat de la validation, qui sera utilisée dans l'évaluation de la propriété Page.IsValid.
Le prototype de la fonction qui servira à la validation sera :

protected void NomFonction(object source, ServerValidateEventArgs args)
{
}

Ainsi, on pourra par exemple valider qu'un utilisateur existe de cette façon :

<asp:TextBox runat="server" ID="TextBoxLogin"/>
<asp:CustomValidator runat="server" ControlToValidate="TextBoxLogin" ErrorMessage="Cet utilisateur est inconnu" 
	ValidateEmptyText="true" OnServerValidate="ValiderLogin" Display="dynamic"/>

<asp:Button runat="server" Text="Valider" OnClick="ButtonClick" />

protected void ValiderLogin(object source, ServerValidateEventArgs args)
{
	args.IsValid = UserExist(args.Value); // args.Value contient la valeur saisie dans le contrôle identifié par ControlToValidate
}

private bool UserExist(string value)
{
	return value == "nico" || value == "test";
}

protected void ButtonClick(object sender, EventArgs e)
{
	if (Page.IsValid)
	{
		// la page est valide, continuer
	}
}

Notez que la propriété ValidateEmptyText m'empêche ici d'avoir une valeur vide, car ma méthode UserExist renvoi faux pour une valeur vide.

En général, lorsqu'on fait une validation qui a besoin de plusieurs contrôles, on n'utilisera pas la propriété ControlToValidate et on utilisera directement les objets représentant les contrôles.
On pourra également utiliser le CustomValidator pour valider des contrôles qui ne sont pas prévu pour, comme la checkbox.

<asp:CheckBox runat="server" ID="NewUser" Text="Etes vous déjà client chez nous ?" />
<asp:TextBox runat="server" ID="TextBoxLogin"/>
<asp:CustomValidator runat="server" ErrorMessage="Cet utilisateur est inconnu" ValidateEmptyText="true" 
	OnServerValidate="ValiderLogin" Display="dynamic"/>

protected void ValiderLogin(object source, ServerValidateEventArgs args)
{
	if (!NewUser.Checked)
	{
		CreerNouvelUtilisateur(TextBoxLogin.Text);
		args.IsValid = true;
	}
	else
		args.IsValid = UserExist(TextBoxLogin.Text);
}

Dans cet exemple, si la case n'est pas cochée, alors la validation est bonne (et on crée l'utilisateur), si elle est cochée, le résultat de la validation dépend de l'existence de l'utilisateur.

5.5.2.Coté client

Comme vu au paragraphe précédent, le CustomValidator procède à la vérification coté serveur. On peut améliorer l'interactivité avec l'utilisateur en proposant également une validation coté client, ce qui permettra d'éviter éventuellement un aller-retour server inutile.

On va créer une méthode javascript, qui aura la signature suivante :

function NomMethode(sender, args)
{
}

et de la même façon que coté serveur, on utilisera les objets passés en paramètres pour récupérer les éventuelles valeurs passées par ControlToValidate ou pour récupérer la valeur du contrôle.

<script type="text/javascript">
function ValideNombrePair(sender, args)
{
	if (args.Value == '')
		args.IsValid = false;
	else
		args.IsValid = (args.Value % 2 == 0);
}
</script>

<asp:TextBox runat="server" ID="NombrePair"/>
<asp:CustomValidator runat="server" ControlToValidate="NombrePair" ErrorMessage="Le nombre doit être pair" ValidateEmptyText="true" 
	ClientValidationFunction="ValideNombrePair" OnServerValidate="ValiderNombrePair" Display="dynamic"/>
<asp:Button runat="server" Text="Valider" OnClick="ButtonClick" />

N'oubliez pas qu'il faut absolument faire une validation coté serveur, la validation coté client pouvant être désactivée.

protected void ButtonClick(object sender, EventArgs e)
{
	if (Page.IsValid)
	{
		// la page est valide, continuer
	}
}

protected void ValiderNombrePair(object source, ServerValidateEventArgs args)
{
	int nombre;
	if (int.TryParse(args.Value, out nombre))
	{
		args.IsValid = nombre%2 == 0;
		return;
	}
	args.IsValid = false;
}

5.6.ValidationSummary

Le contrôle ValidationSummary n'est pas un validator comme les autres, il n'effectue pas de validation mais propose de récapituler les différentes erreurs survenues lors de la validation de la page.
Il se base uniquement sur le contenu des propriétés ErrorMessage de chaque validator qui n'a pas passé la validation.
On a plusieurs possibilités pour avoir un récapitulatif des erreurs.
On peut dans un premier temps les voir dans un alert Javascript coté client, il faut utiliser la propriété ShowMessageBox et la mettre à true.

Nom : <asp:TextBox runat="server" ID="Nom" />
<asp:RequiredFieldValidator runat="server" ControlToValidate="Nom" ErrorMessage="Le nom doit être saisi" Display="none" />
<br />
Email : <asp:TextBox runat="server" ID="Email" />
<asp:RegularExpressionValidator runat="server" ControlToValidate="Email" ErrorMessage="L'email saisi n'est pas correct" Display="none"
	ValidationExpression="^[_a-zA-Z0-9-]+(\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.(([0-9]{1,3})|([a-zA-Z]{2,3})|(aero|coop|info|museum|name))$" />
<br />
<asp:ValidationSummary runat="server" ShowMessageBox="true" ShowSummary="false" />
<asp:Button runat="server" Text="Valider" />

Dans l'exemple précédent, j'ai mis la propriété Display à none pour chaque validator et j'ai mis la propriété ShowSummary à false du ValidationSummary. Ce qui a pour effet d'afficher uniquement une alert javascript.
Vous l'aurez compris, la propriété ShowSummary permet de dire si on veut voir un résumé dans la page html ou non (par défaut à true).
Les différentes propriétés ne sont pas exclusive, on peut combiner l'affichage d'une alert javascript et l'affichage de l'erreur dans la page.
Il existe différentes façons d'avoir notre résumé dans la page, il faut utiliser la propriété DisplayMode et ses différentes valeurs : SingleParagraph, List et BulletList.

<asp:ValidationSummary ID="ValidationSummary1" runat="server" DisplayMode="BulletList" />
<asp:ValidationSummary ID="ValidationSummary2" runat="server" DisplayMode="List" />
<asp:ValidationSummary ID="ValidationSummary3" runat="server" DisplayMode="SingleParagraph" />

Sur l'image ci-dessous, vous pouvez voir les trois types de résumé possible

Il est également possible de saisir un entête, grâce à la propriété HeaderText :

<asp:ValidationSummary runat="server" DisplayMode="BulletList" HeaderText="<b>Voici la liste des erreurs :</b>" />

5.7.Combiner les validateurs

Pour satisfaire aux contraintes de nos sites, nous avons en général plusieurs conditions qui font qu'un champ sera validé. Par exemple, un email obligatoire doit être saisi et valide.
On pourra combiner un RequiredFieldValidator et un RegularExpressionValidator. Comme ci-dessous :

Email : <asp:TextBox runat="server" ID="Email" />
<asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" ControlToValidate="Email" 
	ErrorMessage="N'oubliez pas de saisir votre email" Display="dynamic" />
<asp:RegularExpressionValidator runat="server" ControlToValidate="Email" ErrorMessage="L'email saisi n'est pas correct" Display="dynamic"
	ValidationExpression="^[_a-zA-Z0-9-]+(\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.(([0-9]{1,3})|([a-zA-Z]{2,3})|(aero|coop|info|museum|name))$" />

<asp:Button runat="server" Text="Valider" />

Il suffira de faire pointer à chaque fois la propriété ControlToValidate vers le TextBox Email.

6.Un peu plus loin avec les validateurs

Vous venez de voir les bases de la validation. L'utilisation des différents contrôles simplifie grandement l'approche de la validation.
On peut encore aller plus loin, comme nous allons le voir tout de suite.