Fonctionnalités côté client dans un contrôle serveur
En programmation Web, les fonctionnalités côté client relèvent habituellement de la responsabilité du développeur de pages Web et ne sont pas encapsulées dans les composants serveur. ASP.NET s'écarte de ce paradigme en permettant aux contrôles serveur d'émettre un script côté client ; les contrôles serveur peuvent ainsi combiner traitement côté client et traitement côté serveur.
Le cas le plus simple des fonctionnalités côté client apparaît quand un contrôle serveur Web effectue un rendu d'un gestionnaire d'événements pour un événement côté client par le biais de la propriété Attributes du contrôle. L'exemple suivant montre un contrôle (ClientClickButton) dérivé du contrôle serveur Web System.Web.UI.WebControls.Button et fournit un gestionnaire d'événements pour l'événement click côté client.
Remarque Un développeur de pages peut facilement fournir des gestionnaires d'événements côté client en utilisant la collection Attributes du contrôle serveur Web. Cet exemple illustre comment un contrôle peut lui-même encapsuler une telle fonctionnalité. Pour générer cet exemple, consultez les instructions fournies dans Exemples de contrôles serveur.
using System;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace CustomControls
{
public class ClientClickButton : Button
{
protected override void AddAttributesToRender(HtmlTextWriter writer)
{
base.AddAttributesToRender(writer);
writer.AddAttribute("onclick", "alert('Thanks');");
}
}
}
[Visual Basic]
Option Explicit
Option Strict
Imports System
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls
Namespace CustomControls
Public Class ClientClickButton
Inherits Button
Protected Overrides Sub AddAttributesToRender(writer As HtmlTextWriter)
MyBase.AddAttributesToRender(writer)
writer.AddAttribute("onClick", "alert('Thanks');")
End Sub
End Class
End Namespace
La page suivante utilise le contrôle personnalisé ClientClickButton. Pour vérifier que l'attribut onClick sur ClientClickButton est rendu sur le client, demandez la page dans votre navigateur et affichez la source.
<%@ Register TagPrefix="Custom" Namespace="CustomControls" Assembly = "CustomControls" %>
<html>
<body>
<form runat=server>
This button handles a client-side click event.
<Custom:ClientClickButton Id = "Button" BackColor = "Red" runat=server/> <br> <br>
</form>
</body>
</html>
L'exemple précédent est une illustration très simple des fonctionnalités côté client. ASP.NET permet à un contrôle de participer à des scénarios côté client plus complexes, tels que ceux qui figurent dans la liste suivante :
- Fourniture d'une bibliothèque de scripts côté client.
- Émission d'un script en haut ou en bas d'une page.
- Garantie qu'un bloc de script n'apparaît qu'une seule fois sur une page (même quand plusieurs instances du contrôle existent sur la page).
- Possibilité pour un contrôle d'associer un gestionnaire d'événements à l'événement d'envoi côté client du formulaire (si la page contient un formulaire).
- Ajout de l'élément côté client rendu par un contrôle à une variable tableau déclarée sur le client.
Ces scénarios sont activés par l'intermédiaire des méthodes exposées par la classe System.Web.UI.Page et sont accessibles à un contrôle serveur ASP.NET via sa propriété Page. Le tableau suivant énumère les méthodes de la classe Page qui fournissent des fonctionnalités côté client.
| Méthode | Description | Quand l'utiliser |
|---|---|---|
| Page.RegisterClientScriptBlock | Permet à un contrôle d'émettre un bloc de script (qui contient un script inline ou spécifie l'emplacement d'un fichier de script). Le bloc de script est rendu en haut de la page et est inscrit (au moyen d'une clé) auprès de la page de façon qu'il ne soit émis qu'une seule fois, même quand plusieurs instances du contrôle existent sur la page.
Remarque Un bloc de script émis en haut de la page est appelé bloc de script client dans une page ASP.NET. |
Lorsque vous voulez inclure une bibliothèque de scripts ou rendre un bloc de script contenant des fonctions générales (décrites plus loin dans la page). En particulier, les fonctions qui sont appelées pendant la phase de rendu doivent se trouver en haut de la page. |
| Page.RegisterStartupScript | Permet à un contrôle d'émettre un bloc de script (qui contient un script inline ou spécifie l'emplacement d'un fichier de script). Le bloc de script est rendu au bas de la page et est inscrit (au moyen d'une clé) auprès de la page de façon qu'il ne soit émis qu'une seule fois, même quand plusieurs instances du contrôle existent sur la page.
Remarque Un bloc de script émis au bas de la page est appelé bloc de script de démarrage sur une page ASP.NET. |
Utilisez cette méthode lorsque vous voulez émettre un script qui appelle des éléments situés sur la page ou dans le script devant s'exécuter au démarrage. Dans la mesure où ce script est émis au bas de la page, les éléments auxquels il fait référence existent forcément avant l'exécution du script. |
| Page.RegisterArrayDeclaration | Permet à un contrôle de s'ajouter lui-même à une variable tableau côté client à l'aide d'un nom spécifié. Le nom du tableau est inscrit auprès de la page conteneur (au moyen d'une clé) de façon qu'un seul tableau portant ce nom soit rendu dans le script côté client sur la page. | Utilisez cette méthode lorsque vous voulez que l'élément rendu par votre contrôle appartienne à une variable tableau dans le script client. Le tableau permet le regroupement d'éléments du même type afin d'en faciliter l'accès par le script client. Par exemple, les contrôles validateurs s'ajoutent eux-mêmes à un tableau nommé Page_Validators. |
| Page.RegisterOnSubmitStatement | Associe un gestionnaire d'événements à l'événement submit côté client du formulaire et l'inscrit (au moyen d'une clé) auprès de la page conteneur. Le gestionnaire est rendu en tant qu'attribut onSubmit de l'élément formulaire. L'inscription du gestionnaire permet d'éviter que des instances multiples du contrôle n'émettent plusieurs gestionnaires. | Utilisez cette méthode lorsque vous voulez qu'un gestionnaire côté client soit appelé quand le formulaire est envoyé.
Remarque Vous pouvez passer le script inline directement en tant qu'argument à cette méthode ou passer l'appel à un gestionnaire d'événements. Si vous passez un appel à un gestionnaire d'événements, le gestionnaire doit être défini de façon indépendante dans un bloc de script ou dans une bibliothèque de scripts. |
| Page.IsClientScriptBlockRegistered | Détermine si un bloc de script client avec la clé spécifiée est inscrit auprès de la page conteneur. | Utilisez la valeur de retour de cette méthode pour déterminer si Page.RegisterClientScriptBlock doit être appelé. |
| Page.IsStartupScriptRegistered | Détermine si un bloc de script de démarrage avec la clé spécifiée est inscrit auprès de la page conteneur. | Utilisez la valeur de retour de cette méthode pour déterminer si Page.RegisterStartupScript doit être appelé. |
| Page.RegisterHiddenField | Permet à un contrôle serveur d'inscrire un champ masqué sur sa page conteneur qui est émise lorsque la page est rendue. Ce champ est accessible par un script client ; lorsque le formulaire est publié sur le serveur, le champ masqué est disponible sur le serveur en tant que données de publication. | Utilisez cette méthode lorsqu'un contrôle serveur doit envoyer une variable masquée accessible dans un script côté client. (Cette méthode est utile lorsque la variable ne peut pas être rendue en tant qu'attribut du contrôle ou lorsque le traitement côté client exige une variable qui est indépendante du contrôle). Pour obtenir un exemple, consultez Persistance des modifications côté client dans un contrôle qui n'est pas un formulaire. |
Les contrôles validateurs sont les seuls contrôles serveur ASP.NET qui exploitent pleinement les fonctionnalités côté client fournies par ASP.NET. Dans la mesure où le modèle objet de document (DOM, Document Object Model) pris en charge par les différents navigateurs n'est pas homogène, la plupart des contrôles serveur fournis avec le Kit de développement .NET Framework SDK font un usage limité du script côté client et l'utilisent tout au plus pour l'auto-publication. (Pour plus d'informations sur l'utilisation d'un script à des fins de publication, consultez Génération d'un script côté client pour la publication). Cependant, si vous ciblez un navigateur spécifique ou des navigateurs qui sont compatibles avec un modèle objet de document spécifique, vous pouvez utiliser un script côté client dans vos contrôles afin de permettre une expérience plus riche côté client et de limiter les allers-retours au serveur chaque fois que c'est possible.
Utilisation des méthodes de script exposées par Page
Le fragment de code suivant extrait de l'exemple de contrôle validateur de base utilise plusieurs méthodes de script côté client exposées par la classe Page. Dans ce fragment, les appels des méthodes de script côté client apparaissent en gras. Le code initial dans le fragment définit les constantes de chaîne contenant le nom de fichier du fichier de script à inclure en haut de la page, une clé pour inscrire un bloc de script auprès de la page, un bloc de script à inclure au bas de la page et une chaîne qui fournit des informations de mise en forme.
private const string ValidatorFileName = "DomValidation.js";
// The key to register a script key. In this example, the same key
// is used for registering both the script at the top of the
// page (called the client-side script block) and the script
// that is rendered at the bottom of the page (called startup
// script).
private const string ValidatorIncludeScriptKey = "DomValidatorIncludeScript";
// The script block that is rendered at the bottom of the page.
private const string ValidatorStartupScript = @"
<script language=""javascript"">
<!--
var Page_ValidationActive = false;
if (typeof(Page_DomValidationVer) == ""undefined"")
alert(""{0}"");
else
ValidatorOnLoad();
function ValidatorOnSubmit() {{
if (Page_ValidationActive) {{
return ValidatorCommonOnSubmit();
}}
}}
// -->
</script>
";
// Provides formatting information for emitting the script
// block at the top of the page.
private const string IncludeScriptFormat = @"
<script language=""{0}"" src=""{1}{2}""></script>";
// This method is called from OnPrerender in the
// Base Validator Control Sample.
protected void RegisterValidatorCommonScript() {
string location = null;
if (!Page.IsClientScriptBlockRegistered(ValidatorIncludeScriptKey)) {
// Provide the location of the script file.
location = Page.Request.ApplicationPath + "/script/";
// Create client script block.
string includeScript = String.Format(IncludeScriptFormat, "javascript", location, ValidatorFileName);
Page.RegisterClientScriptBlock(ValidatorIncludeScriptKey, includeScript);
}
if (!Page.IsStartupScriptRegistered(ValidatorIncludeScriptKey)) {
if (location == null) location = Page.Request.ApplicationPath + "/script/";
// Provide error message, which is localized.
string missingScriptMessage = "Validation script is missing '" + location + ValidatorFileName + "'";
// Create startup script block.
string startupScript = String.Format(ValidatorStartupScript, new object [] {missingScriptMessage,});
Page.RegisterStartupScript(ValidatorIncludeScriptKey, startupScript);
}
Page.RegisterOnSubmitStatement("ValidatorOnSubmit", "return ValidatorOnSubmit();");
}
[Visual Basic]
Private Const ValidatorFileName As String = "DomValidation.js"
' The key to register a script key. In this example, the same key
' is used for registering both the script at the top of the
' page (called the client-side script block) and the script
' that is rendered at the bottom of the page (called startup
' script).
Private Const ValidatorIncludeScriptKey As String = "DomValidatorIncludeScript"
' The script block that is rendered at the bottom of the page.
Private Const ValidatorStartupScript As String = ControlChars.CrLf & _
"<script language=""javascript"">" & ControlChars.CrLf & _
"<!--" & ControlChars.CrLf & _
"var Page_ValidationActive = false;" & ControlChars.CrLf & _
"if (typeof(Page_DomValidationVer) == ""undefined"")" & ControlChars.CrLf & _
" alert(""{0}"");" & ControlChars.CrLf & _
"else" & ControlChars.CrLf & _
" ValidatorOnLoad();" & ControlChars.CrLf & ControlChars.CrLf & _
"function ValidatorOnSubmit() {{" & ControlChars.CrLf & _
" if (Page_ValidationActive) {{" & ControlChars.CrLf & _
" return ValidatorCommonOnSubmit();" & ControlChars.CrLf & _
" }}" & ControlChars.CrLf & _
"}}" & ControlChars.CrLf & _
"// -->" & ControlChars.CrLf & _
"</script>"
' Provides formatting information for emitting the script
' block at the top of the page.
Private Const IncludeScriptFormat As String = ControlChars.CrLf & _
"<script language=""{0}"" src=""{1}{2}""></script>"
' This method is called from OnPrerender in the
' Base Validator Control Sample.
Protected Sub RegisterValidatorCommonScript()
Dim location As String = Nothing
If Not Page.IsClientScriptBlockRegistered(ValidatorIncludeScriptKey) Then
' Provide the location of the script file.
' When using a script library, deployment can be
' a problem because the runtime is
' tied to a specific version of the script file.
' This sample takes the easy way out and insists that
' the file be placed in the /script subdirectory
' of the application.
' In other cases, you should place it where it
' can be shared by multiple applications and is placed
' in a separate directory so that different versions
' of a control library can run side by side.
' The recommended pattern is to put script files in the
' path /aspnet_client/<assembly name>/<assembly version>/".
location = Page.Request.ApplicationPath + "/script/"
' Create the client script block.
Dim includeScript As String = [String].Format(IncludeScriptFormat, "javascript", location, ValidatorFileName)
Page.RegisterClientScriptBlock(ValidatorIncludeScriptKey, includeScript)
End If
If Not Page.IsStartupScriptRegistered(ValidatorIncludeScriptKey) Then
If location Is Nothing Then
location = Page.Request.ApplicationPath + "/script/"
End If
' Provide an error message, which is localized.
Dim missingScriptMessage As String = "Validation script is missing '" & location & ValidatorFileName & "'"
' Create the startup script block.
Dim startupScript As String = [String].Format(ValidatorStartupScript, New Object() {missingScriptMessage})
Page.RegisterStartupScript(ValidatorIncludeScriptKey, startupScript)
End If
Page.RegisterOnSubmitStatement("ValidatorOnSubmit", "return ValidatorOnSubmit();")
End Sub
Le fragment de code suivant extrait de l'exemple de contrôle validateur de base montre comment appeler la méthode Page.RegisterArrayDeclaration (en gras dans le fragment), qui ajoute l'élément rendu par le contrôle à une variable tableau (Page_Validators) rendue dans le script client. L'inscription de la variable tableau auprès de la page (au moyen de la clé Page_Validators) garantit que seule une variable portant ce nom est créée sur la page.
// This method is called from Render in the
// Base Validator Control Sample.
protected virtual void RegisterValidatorDeclaration() {
string element = "document.getElementById(\"" + ClientID + "\")";
Page.RegisterArrayDeclaration("Page_Validators", element);
}
[Visual Basic]
' This method is called from Render in the
' Base Validator Control Sample.
Protected Overridable Sub RegisterValidatorDeclaration()
Dim element As String = "document.getElementById(""" & ClientID & """)"
Page.RegisterArrayDeclaration("Page_Validators", element)
End Sub
Accès à un contrôle dans un script client
La classe Control expose une propriété nommée ClientID, qu'elle rend (en code HTML) en tant qu'attribut ID de l'élément rendu. ASP.NET génère un ClientID pour un contrôle de façon dynamique et le ClientID de chaque contrôle sur une page est forcément unique. Un contrôle (à savoir, l'élément rendu par le contrôle) peut ainsi être accessible sur le client par l'utilisation de son ID dans un modèle objet de document. Un contrôle peut également utiliser le ClientID pour générer des noms uniques destinés à d'éventuels éléments supplémentaires qu'il pourrait rendre (des champs masqués, par exemple).
L'émission de la valeur de ClientID dans un script inline (ou dans le code dans une bibliothèque de scripts) peut être délicate, car ClientID doit être inséré à l'emplacement approprié dans une variable de chaîne. L'exemple suivant utilise des caractères d'échappement pour insérer un ClientID dans une chaîne constituant un script inline.
string element = "document.getElementById(\"" + ClientID + "\")";
Page.RegisterArrayDeclaration("Page_Validators", element);
[Visual Basic]
Dim element As String = "document.getElementById(""" & ClientID & """)"
Page.RegisterArrayDeclaration("Page_Validators", element)
Vous pouvez également utiliser les méthodes surchargées Format de la classe String pour composer un script côté client qui utilise le ClientID. Pour plus d'informations sur la mise en forme, consultez Mise en forme des types.
Déploiement d'un fichier de script
Le bloc de script émis par un contrôle activé pour les scripts peut contenir un script inline ou fournir l'emplacement d'un fichier de script. Les deux cas sont illustrés dans l'exemple décrit plus haut dans cette rubrique. Si le bloc indique l'emplacement d'un fichier de script, vous devez déployer le fichier de script d'une manière telle qu'il puisse être utilisé à partir d'autres applications sans créer de conflit de versioning. Dans l'exemple, le fichier de script est placé dans un sous-répertoire nommé script dans le répertoire racine virtuel de l'application Web.
// Provides the location of the script file.
location = Page.Request.ApplicationPath + "/script/";
[Visual Basic]
' Provides the location of the script file.
location = Page.Request.ApplicationPath & "/script/"
Si cet emplacement fonctionne pour l'exemple, l'emplacement recommandé pour un fichier de script destiné à être utilisé par d'autres applications est le suivant :
/aspnet_client/<your assembly name>/<your assembly version>/
Le répertoire aspnet_client est un répertoire racine virtuel d'application Web qui est créé sur votre ordinateur lorsque vous installez le Kit de développement .NET Framework SDK ou Visual Studio .NET. Par exemple, les fichiers de script livrés avec ASP.NET se trouvent à l'emplacement suivant :
/aspnet_client/system_web/<version of SDK installed>
Si vous avez installé plusieurs versions du Kit de développement SDK, plusieurs sous-répertoires apparaîtront sous aspnet_client/system_web. Dans la mesure où une bibliothèque de contrôles est liée à une version spécifique du fichier de script, le schéma de déploiement recommandé autorise l'exécution côte à côte de versions différentes d'une bibliothèque de contrôles.
Notez également qu'un répertoire aspnet_client est créé pour chaque site Web hébergé sur l'ordinateur. En principe, un serveur héberge un seul site Web. Cependant, il est possible d'utiliser plus d'un site, alors que des sites multiples se traduisent par plusieurs copies du répertoire aspnet_client.
Détermination du rendu d'un script
Un contrôle activé pour les scripts doit laisser à ses consommateurs la possibilité d'activer ou de désactiver le rendu d'un script côté client. Dans ASP.NET, les contrôles serveur Web du validateur exposent une propriété de type booléen nommée EnableClientScript qui détermine si le contrôle doit effectuer un rendu du script pour le client. Vous pouvez définir une propriété qui fournit cette fonctionnalité de la façon suivante :
public bool EnableClientScript {
get {
object o = ViewState["EnableClientScript"];
return((o == null) ? true : (bool)o);
}
set {
ViewState["EnableClientScript"] = value;
}
}
[Visual Basic]
Public Property EnableClientScript() As Boolean
Get
Dim o As Object = ViewState("EnableClientScript")
If o Is Nothing Then
Return True
Else
Return CBool(o)
End If
End Get
Set
ViewState("EnableClientScript") = value
End Set
End Property
Avant le rendu, un contrôle activé pour les scripts doit vérifier les fonctionnalités du client et déterminer aussi si l'utilisateur (le développeur de pages) a désactivé l'écriture de scripts. Ces contrôles sont généralement effectués lors des phases de pré-rendu et de rendu. Le fragment de code suivant extrait de l'exemple de contrôle validateur de base effectue des contrôles pendant la phase de pré-rendu.
private boolean renderUplevel;
protected override void OnPreRender(EventArgs e) {
base.OnPreRender(e);
...
// Work out uplevelness now.
renderUplevel = DetermineRenderUplevel();
if (renderUplevel) {
// Helper method that creates script blocks
// and registers them with the page.
RegisterValidatorCommonScript();
}
}
// Helper method to check whether script should be rendered.
protected virtual bool DetermineRenderUplevel() {
// Must be on a page.
Page page = Page;
if (page == null || page.Request == null) {
return false;
}
// Check whether the user has turned off scripting and
// check browser capabilities. This custom control
// needs the W3C DOM level 1 for control manipulation
// and at least ECMAScript 1.2.
return (EnableClientScript
&& page.Request.Browser.W3CDomVersion.Major >= 1
&& page.Request.Browser.EcmaScriptVersion.CompareTo(new Version(1, 2)) >= 0);
}
[Visual Basic]
Private _renderUplevel As Boolean
Protected Overrides Sub OnPreRender(e As EventArgs)
MyBase.OnPreRender(e)
_preRenderCalled = True
' Force a re-query of properties for render.
_propertiesChecked = False
' Work out uplevelness now.
_renderUplevel = DetermineRenderUplevel()
If _renderUplevel Then
RegisterValidatorCommonScript()
End If
End Sub
' Helper method to check whether script should be rendered.
Protected Overridable Function DetermineRenderUplevel() As Boolean
' Must be on a page.
Dim page As Page = Page
If page Is Nothing Or page.Request Is Nothing Then
Return False
End If
' Check the browser capabilities.
' This is how you can get automatic fallback to server-side
' behavior. These validation controls need
' the W3C DOM level 1 for control manipulation
' and need at least ECMAScript 1.2 for the
' regular expressions.
Return EnableClientScript AndAlso _
page.Request.Browser.W3CDomVersion.Major >= 1 AndAlso _
page.Request.Browser.EcmaScriptVersion.CompareTo(New Version(1, 2)) >= 0
End Function
Pour des contrôles effectués au cours de la phase de rendu, consultez la méthode Render dans l'exemple de contrôle validateur de base.
Script rendu sur le client
Pour voir comment le script encapsulé par le contrôle est rendu sur le client, compilez et déployez les exemples fournis dans Exemples de contrôle validateur, demandez la page fournie dans Page de test pour l'exemple de validateur et affichez la source de la page dans votre navigateur. Vous obtiendrez le code HTML et le script montrés dans l'exemple ci-après. (Le script émis par les contrôles apparaît en gras.) La page possède plusieurs contrôles qui émettent un script, tous dérivant du contrôle de base décrit dans l'exemple de contrôle validateur de base. Dès lors, la source inclut un script qui n'est pas décrit dans cette rubrique. Notez que lorsque vous affichez la source dans votre navigateur, le nom du répertoire de l'application (samples dans l'exemple) sera remplacé par le nom du répertoire virtuel de votre application.
<HTML>
<HEAD>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<meta content="Microsoft Visual Studio .NET" name=GENERATOR>
<meta content=C# name=CODE_LANGUAGE>
<meta content="JavaScript (ECMAScript)" name=vs_defaultClientScript>
<meta content="Internet Explorer 3.02 / Navigator 3.0" name=vs_targetSchema>
<title>DOM Validators Test</title>
</HEAD>
<body>
<form name="ValTest" method="post" action="valtest.aspx" language="javascript" onsubmit="return ValidatorOnSubmit();" id="ValTest">
<input type="hidden" name="__VIEWSTATE" value="dDwxOTkwOTM1MDA5O3Q8O2w8aTwxPjs+O2w8dDw7bDxpPDEzPjs+O2w8dDw7bDxpPDE+O2k8Mz47aTw1PjtpPDc+Oz47bDx0PHA8cDxsPFRleHQ7PjtsPElFOz4+Oz47Oz47dDxwPHA8bDxUZXh0Oz47bDw1LjU7Pj47Pjs7Pjt0PHA8cDxsPFRleHQ7PjtsPDEuMjs+Pjs+Ozs+O3Q8cDxwPGw8VGV4dDs+O2w8MS4wOz4+Oz47Oz47Pj47Pj47Pj47Pg==" />
<script language="javascript" src="/samples/script/DomValidation.js"></script>
<P><FONT face=Verdana size=5>DOM Validators Test</FONT></P>
<P>
<TABLE cellSpacing=1 cellPadding=1 width=602 border=0 height=131>
<TR>
<TD style="WIDTH: 82px">Name:</TD>
<TD style="WIDTH: 164px"><input name="txtName" type="text" id="txtName" /></TD>
<TD><span id="valRequired" controltovalidate="txtName" errormessage="Required." evaluationfunction="RequiredFieldValidatorEvaluateIsValid" initialvalue="" style="color:Red;visibility:hidden;">Required.</span></TD>
</TR>
<TR>
<TD style="WIDTH: 82px">Postal Code:</TD>
<TD style="WIDTH: 164px"><input name="txtPostcode" type="text" id="txtPostcode" /></TD>
<TD><span id="valRegex" controltovalidate="txtPostcode" errormessage="Postcode must be 9999." evaluationfunction="RegularExpressionValidatorEvaluateIsValid" validationexpression="\d{4}" style="color:Red;visibility:hidden;">Postcode must be 9999.</span></TD>
</TR>
</TABLE></P>
<P>
<input type="submit" name="cmdSubmit" value="Submit" onclick="if (typeof(Page_ClientValidate) == 'function') Page_ClientValidate(); " language="javascript" id="cmdSubmit" />
<input type="submit" name="cmdCancel" value="Cancel" id="cmdCancel" />
</P>
<div id="Panel1" style="border-color:#00C000;border-width:2px;border-style:Solid;height:55px;width:197px;">
<P>
Browser: <span id="lblBrowserName">IE</span><br>
Version: <span id="lblBrowserVersion">5.5</span><br>
Script Version: <span id="lblScriptVersion">1.2</span><br>
DOM Version: <span id="lblDomVersion">1.0</span><br>
Submit clicks: <span id="lblSubmitCount"> 0 </span><br>
Cancel clicks: <span id="lblCancelCount"> 0 </span><br>
</P>
</div>
<script language="javascript"><!-- var Page_Validators = new Array(document.getElementById("valRequired"), document.getElementById("valRegex")); // --></script><script language="javascript"><!--var Page_ValidationActive = false;if (typeof(Page_DomValidationVer) == "undefined") alert("Validation script is missing '/samples/script/DomValidation.js'");else ValidatorOnLoad();function ValidatorOnSubmit() { if (Page_ValidationActive) { return ValidatorCommonOnSubmit(); }}// --></script>
</form>
</body>
</HTML>
Voir aussi
Contrôle validateur de base, exemple | Exemples de contrôle validateur