Validando las entradas de usuario

Validación de entrada de datos de
usuario
Índice
Descripción 1
Lección: Descripción de la validación de
entrada de datos del usuario 2
Lección: uso de los controles de validación 8
Lección: validación de páginas 30

Validación de entrada de datos de usuario 1
Descripción
„ Descripción de la validación de entrada de datos de
usuario
„ Uso de controles de validación
„ Validación de páginas
***************************** use******************************
Al crear un control de entrada de datos, como un control TextBox, podemos
tener ciertas expectativas del tipo de entrada que el usuario introducirá en ese
control. Una entrada de datos incorrecta, como mínimo, retrasará al usuario, y
puede incluso terminar nuestra aplicación Web. Para verificar que la entrada de
datos cumple nuestras expectativas, debemos compararlo con el valor, intervalo
o formato que esperamos recibir del usuario. Para crear esta comprobación,
enlazamos al menos un control de validación de entrada de datos con el control
de entrada de datos y comparamos la entrada de datos de los usuarios con
nuestras expectativas.
En este módulo, estudiaremos los controles de validación de entrada de datos
disponibles en Microsoft® ASP.NET. También estudiaremos cómo aplicar de
forma eficaz estos controles a un formulario Web Form con ASP.NET
utilizando Microsoft Visual Studio® .NET.
En este módulo, aprenderemos a:
„ Identificar cuándo es apropiada la validación de entrada de datos en los
formularios Web Forms.
„ Utilizar controles de validación de entrada de datos para verificar los datos
introducidos por el usuario en un formulario Web Form.
„ Verificar que todos los controles de validación de una página son válidos.
Introducción
Objetivos

2 Validación de entrada de datos de usuario
Lección: validación de entrada de datos del usuario
„ ¿Qué es es la validación de entrada de datos?
„ Validación del lado del cliente y del lado del servidor
„ Controles de validación ASP.NET
***************************** use******************************
En esta lección, estudiaremos cómo la validación de entrada de datos verifica
que el usuario ha cumplimentado correctamente los controles de entrada de
datos en un formulario Web Form, antes de que una petición sea procesada en
el servidor. También estudiaremos los tipos de controles de validación de
entrada de datos disponibles en ASP.NET.
En esta lección, aprenderemos a:
„ Explicar el concepto de validación.
„ Explicar la diferencia entre validación del lado del cliente y validación del
lado del servidor.
„ Combinar los tipos apropiados de controles de validación ASP.NET para
determinados requerimientos de entrada.
Introducción
Objetivos de la lección

¿Qué es la validación de entrada de datos?
„ Verifica que el usuario ha introducido correctamente el
valor de un control
„ Bloquea el procesamiento de una página hasta que
todos los controles son válidos
„ Evita el spoofing
o añadir
código mal
intencionado
***************************** use******************************
La validación de entrada de datos es el proceso de verificar que la entrada de
datos de un usuario en un formulario Web Form concuerda con el valor,
intervalo o formato de datos previsto. La validación de la entrada de datos
mejora la experiencia del usuario en el sitio Web reduciendo el tiempo de
espera de mensajes de error y la probabilidad de envíos incorrectos o caídas del
sitio Web debido a problemas con la entrada de datos del usuario. Cuando se
combinan con mensajes de error comprensibles y útiles, los controles de
validación de entrada de datos pueden mejorar enormemente el uso de una
aplicación Web, mejorando por tanto la percepción de usuario de la calidad
global del sitio Web.
Los controles de validación de entrada de datos actúan para verificar que el
usuario ha cumplimentado correctamente un control de entrada de datos, como
un control TextBox, antes de que la solicitud sea procesada en el servidor. Los
controles de validación de entrada de datos de un formulario Web Form actúan
como filtros de datos antes de que la página o la lógica de servidor sea
procesada.
En ASP.NET, la validación de entrada de datos siempre se ejecuta en el lado
del servidor, y puede ejecutarse en el lado del cliente si el navegador cliente
soporta la validación. Si el navegador soporta la validación del lado del cliente,
los controles de validación de entrada de datos realizan la comprobación de
errores en el cliente antes de enviar los datos al servidor. El usuario recibe
información inmediata sobre si los datos que ha introducido son válidos o no.
Por motivos de seguridad, toda validación de entrada de datos que se ejecute en
el lado del cliente se repite a continuación en el lado del servidor.
La validación de entrada funciona comparando la entrada de datos del usuario
con el formato de entrada de datos predeterminado. Estos formatos
predeterminados de entrada de datos pueden incluir el número de caracteres, el
uso de dígitos y/o letras, el intervalo del valor, una cadena específica de
caracteres, o una fórmula matemática.
Introducción
Verificar valores de
control

Por ejemplo, un control de entrada de datos que solicita al usuario que
introduzca su número de teléfono podría tener un control de validación de
entrada de datos adjunto que verificara que el usuario únicamente introduce
números en un formato basado en el número de teléfono. Introducir letras o
muy pocos números activaría el control de validación de entrada de datos para
validar la entrada de datos.
La entrada de usuario que concuerda con el formato predeterminado es
procesada por el formulario Web Form. La entrada de usuario que no concuerda
con el formato predeterminado provoca un mensaje de error que detiene el
procesamiento por parte del formulario Web hasta que la entrada de usuario se
corrige para cumplir con el formato previsto y la página haya sido reenviada
para su procesamiento.
Los controles de validación protegen los formularios Web Forms de dos
importantes peligros: spoofing y código mal intencionado. Ejecutando todos los
controles de validación en el lado del servidor, con independencia de la
validación del lado del cliente, ASP.NET protege de las siguientes amenazas:
„ Spoofing
Spoofing es cuando un usuario modifica la página HTML (Hypertext
Markup Language) que se le ha enviado, y devuelve valores que hacen que
parezca que ha introducido datos válidos o pasado una comprobación de
autorización. La validación únicamente es susceptible de spoofing en el lado
del cliente, porque el usuario puede deshabilitar scripts del lado del cliente
cambiando las opciones del navegador y no ejecutar el código de validación
del lado del cliente, lo que crea un falso nivel de autorización.
Con ASP.NET, la validación de entrada de datos del lado del cliente
siempre se repite en el lado del servidor, donde los usuarios no pueden
modificar o deshabilitar el control de validación.
„ Código mal intencionado
Cuando un usuario puede agregar texto ilimitado a una página Web
mediante controles de entrada de datos de usuario que no dispongan de
validación de entrada de datos, puede introducir código mal intencionado.
Cuando el usuario envía la siguiente solicitud al servidor, este código
añadido podría ser muy perjudicial para el servidor Web y las aplicaciones
conectadas.
Por ejemplo, si decidimos no validar un campo UserName porque tenemos
clientes internacionales y no podemos pensar en un formato de nombres
universal para la validación, un usuario mal intencionado podría explotar
esta falta de validación para provocar varios problemas, incluyendo:
• Generar un error de tipo buffer overrun y una caída del servidor
introduciendo un nombre con varios miles de caracteres.
• Crear y autenticar una nueva cuenta de usuario.
• Agregar privilegios a su propia cuenta, y eliminar privilegios de otras
cuentas.
• Enviar una consulta SQL a nuestra base de datos de clientes y descargar
todos los datos presentes, incluyendo nombres de usuario, direcciones,
contraseñas y números de tarjetas de crédito.
Procesamiento de
bloque de errores
Spoofing y código mal
intencionado

Validación del lado del cliente y del lado del servidor
„ ASP.NET puede generar
validación del lado del cliente y
del lado del servidor
„ Validación del lado del cliente
z Dependiente de la versión del
navegador
z Respuesta inmediata
z Reduce los ciclos de postback
„ Validación del lado del servidor
z Repite toda la validación del lado
del cliente
z Puede validar contra datos
almacenados
El usuario
introduce datos
¿Válido?
¿Válido?
No
No
Sí
Sí
Mensaje
de error
Cliente
Servidor
Aplicación Web
procesada
***************************** use******************************
La validación de entrada de datos puede tener lugar tanto en el servidor como
en el cliente. Aunque ASP.NET siempre requiere validación del lado del
servidor, la validación del lado del cliente es una opción con algunos
navegadores.
Los controles de validación de ASP.NET disponen de soporte tanto del lado del
cliente como del lado del servidor. La validación del lado del cliente utiliza
JavaScript y scripts DHTML (HTML Dinámico). La validación del lado del
servidor puede ser desarrollada en cualquier lenguaje basado en Microsoft
.NET, y se compila a Microsoft Intermediate Language (MSIL). Tanto la
validación del lado del cliente como la validación del lado del servidor utilizan
el mismo modelo de programación, aunque algunas variaciones entre los
lenguajes pueden crear pequeñas diferencias en las funciones de validación.
La validación del lado del cliente mejora el uso del formulario Web Form
comprobando la entrada de datos del usuario mientras se produce. Al
comprobar si se generan errores mientras se introducen, la validación del lado
del cliente permite detectar errores antes de que el formulario Web Form sea
enviado, evitando así el viaje de ida y vuelta necesario para la validación del
lado del servidor.
Escribir múltiples versiones de código de validación para soportar tanto el
servidor como los diferentes navegadores puede exigir mucho tiempo al
desarrollador. Los controles de validación ASP.NET eliminan este problema ya
que la lógica de validación se encapsula en los controles. Los controles crean
código específico para los navegadores de forma que los usuarios con soporte
de scripts del lado del cliente tendrán validación de entrada de datos. Los
navegadores que no soporten scripts no recibirán los scripts de validación en el
lado del cliente.
En versiones de navegador que soporten la validación de entrada de datos,
como Microsoft Internet Explorer 4 o posterior, la validación del lado del
cliente se produce cuando el usuario hace clic en el botón Submit. La página no
se publicará de nuevo en el servidor hasta que toda la validación del lado del
Introducción
Validación del lado del
cliente

cliente sea correcta. En Internet Explorer 5 o posterior, el uso de la tecla
TABULADOR para moverse de un control de entrada de datos al siguiente
ejecuta la validación del lado del cliente para el control de entrada de datos
completo. Esta validación utilizando el TABULADOR ofrece al usuario
información inmediata sobre los datos que ha introducido.
Todos los controles de validación de entrada de datos se ejecutan en el lado del
servidor. Las validaciones del lado del cliente se repiten en el lado del servidor
cuando la página se envía de nuevo al servidor. Esta repetición evita el spoofing
de usuarios que no ejecutan el script del lado del cliente e intentan introducir
datos no válidos.
Los controles de validación del lado del servidor pueden escribirse en cualquier
lenguaje basado en .NET, y se compilan en MSIL antes de ser ejecutados en el
servidor.
Además de validar el formato de los datos introducidos, los controles de
validación del lado del servidor pueden utilizarse para comparar la entrada de
datos del usuario con datos almacenados. Esta funcionalidad permite validación
contra diversos elementos, como contraseñas previamente almacenadas o
restricciones geográficas, incluyendo las leyes y los impuestos locales.
servidor

Controles de validación ASP.NET
ASP.NET proporciona controles de validación para:
„ Comparar valores
„ Comparar con una fórmula personalizada
„ Comparar con un intervalo
„ Comparar con un modelo de expresión habitual
„ Requerir entrada de datos por parte del usuario
„ Resumir los controles de validación de una página
***************************** use******************************
ASP.NET incluye los controles de validación que se muestran en la siguiente
tabla.
Control de validación Función
CompareValidator Compara un control de entrada de datos con otro, un valor fijo,
un tipo de datos o un archivo. Por ejemplo, este control puede
utilizarse para campos de verificación de contraseñas.
CustomValidator Nos permite escribir nuestro propio código para crear la
expresión de validación. Por ejemplo, este control puede
utilizarse para verificar que el valor es un número primo.
RangeValidator Similar al control CompareValidator, pero este control puede
verificar que la entrada de datos de usuario está entre dos
valores o los valores de otros controles de entrada de datos.
Por ejemplo, este control puede utilizarse para verificar que la
entrada el usuario coincide con el intervalo de edad esperado.
RegularExpression
Validator
Verifica que la entrada coincide con un modelo definido por
una expresión habitual. Este control de validación permite
comprobar secuencias predecibles de caracteres, como
números de la seguridad social, direcciones electrónicas,
números de teléfono y códigos postales. Visual Studio .NET
proporciona modelos predefinidos para expresiones habituales
como números de teléfono.
RequiredFieldValidator Comprueba si se ha introducido un valor en un control. Es el
único control de validación que requiere un valor. El resto de
controles de validación de entrada de datos aceptarán un
control vacío como respuesta válida.
ValidationSummary Muestra un resumen de todos los errores de validación para
todos los controles de validación de la página. Este control se
ubica normalmente cerca del botón Submit para proporcionar
respuesta inmediata sobre el estado de entrada de datos de la
página.
Controles de validación

Lección: uso de los controles de validación
„ Agregar controles de validación a un formulario Web
Form
„ Posicionar controles de validación en un formulario
Web Form
„ Combinar controles de validación
„ Controles de validación para la entrada de datos
„ Uso del control RegularExpressionValidator
„ Demostración: uso de controles de validación
„ Uso del control CustomValidator
„ Demostración: uso del control CustomValidator
***************************** use******************************
En esta lección, estudiaremos cómo aplicar controles de validación a controles
de entrada de datos en un formulario Web Form ASP.NET.
Validar los datos introducidos por el usuario solía ser un proceso difícil. Para
cada control de entrada de datos, era necesario escribir primero código de
validación para el servidor en un determinado lenguaje. A continuación, si se
realizaba validación en el lado del cliente, necesitábamos escribir la validación
equivalente en el lado del cliente en un script diferente para cada navegador.
ASP.NET y Visual Studio .NET han hecho más fácil la validación de la entrada
de usuario al proporcionar controles de validación que proporcionan código en
el lado del servidor y en el lado del cliente al agregarlos a nuestro formulario
Web Form.
„ Agregar un control de validación a un formulario Web Form y asociarlo a
un control de entrada de datos.
„ Posicionar los controles de validación en una página Web para soportar el
uso correcto del control de entrada de datos asociado.
„ Utilizar los controles de validación RequiredInputValidator,
CompareValidator y RangeValidator para validar datos introducidos por
el usuario.
„ Utilizar el control RegularExpressionValidator para validar datos
introducidos por el usuario.
„ Utilizar el control CustomValidator para validar datos introducidos por el
usuario.
„ Asociar múltiples controles de validación a un único control de entrada de
datos.
Introducción

Agregar controles de validación a un formulario Web Form
1. Agregar un control de validación
2. Seleccionar el control de entrada de datos para validar
3. Establecer propiedades de validación
1 1
2 2
3 3
<<aasspp::TTeexxttBBooxx iidd==""ttxxttNNaammee"" rruunnaatt==""sseerrvveerr"" //>>
<asp:Type_of_Validator
id="Validator_id"
runat="server"
ControlToValidate="txtName"
ErrorMessage="Message_for_error_summary"
Display="static|dynamic|none"
Text="Text_to_display_by_input_control">
</asp:Type_of_Validator>
<asp:Type_of_Validator
id="Validator_id"
runat="server"
ErrorMessage="Message_for_error_summary"
</asp:Type_of_Validator>
***************************** use******************************
Como todos los controles de validación de entrada de datos comparten un
modelo de objetos común, el proceso de agregar controles de validación a una
página es el mismo para todos los controles. En Visual Studio .NET,
simplemente arrastramos el control de validación de entrada a una página,
seleccionamos el control de entrada a validar y establecemos las propiedades.
Para agregar un control de validación, abrimos el cuadro de herramientas del
formulario Web Form, seleccionamos uno de los controles de validación
disponibles y lo arrastramos junto al control de entrada de datos que deseamos
validar.
Seleccionamos el control de entrada de datos para validar abriendo la ventana
Propiedades y seleccionando el ID de control de entrada de datos apropiado en
la lista desplegable que se encuentra junto a la propiedad ControlToValidate.
Podemos adjuntar múltiples controles de validación a un único control de
entrada de datos. Todos los controles de validación adjuntos deben estar en
True antes de que ese control de entrada de datos sea aceptado y el formulario
Web Form ASP.NET pueda ser procesado.
Una vez el control de validación de entrada de datos está ubicado en la página,
utilizamos la ventana Propiedades para introducir las propiedades específicas
del control, como la expresión de validación, el mensaje de error y mensaje de
texto.
La sintaxis compartida para los controles de validación de entrada de datos es la
siguiente:
<asp:type_of_validator id="validator_id" runat="server"
ControlToValidate="control_id"
ErrorMessage="error_message_for_error_summary"
</asp:type_of_validator>
Introducción
Agregar un control de
validación
Seleccionar el control de
entrada de datos para
validar
Establecer las
propiedades de
validación

Cada control de validación tiene propiedades únicas adicionales que definen el
modo de funcionamiento. Dos de las propiedades que comparten todos los
controles de validación, a excepción del control ValidationSummary, son
Type y EnableClientScript:
„ Type
La propiedad Type es el tipo de datos que se validará. Visual Studio .NET
ajustará automáticamente el tipo de datos para que coincida con el control
de entrada de datos adjunto al seleccionar ControlToValidate.
Entre los tipos de datos disponibles se incluyen String, Integer, Double,
Date y Currency.
„ EnableClientScript
La propiedad EnableClientScript indica si realizamos o no la validación
del lado del cliente. El valor predeterminado de esta propiedad es true.
ASP.NET crea procedimientos de validación en el lado del cliente en
Microsoft JScript® .NET, y crea procedimientos de validación del lado del
servidor en C# y Microsoft Visual Basic® .NET. Esta diferencia de lenguaje
puede provocar pequeñas diferencias entre las implementaciones de
controles de validación en el lado del cliente y en el lado del servidor.

Posicionar controles de validación en un formulario Web Form
„ Crear mensajes de error
„ Seleccionar modo de presentación
z Estático
z Dinámico
***************************** use******************************
Los controles de validación de entrada de datos pueden mostrar un mensaje de
error cuando se produce una violación en la entrada de datos. Es importante
posicionar los controles de validación de entrada de datos de modo que el
usuario vea claramente qué control contiene la entrada de datos incorrecta. En
Visual Studio .NET, debemos posicionar el control de validación en la página
donde debe aparecer el mensaje de error.
El código HTML estándar para un control de validación de entrada de datos es
el siguiente:
<asp:type_of_validator id="validator_id" runat="server"
ControlToValidate="control_id"
ErrorMessage="error_message_for_error_summary"
Los controles de validación de entrada de datos ASP.NET contienen dos
propiedades de mensajes de error: una propiedad ErrorMessage y una
propiedad Text, pudiéndose mostrar ambas en la ubicación del control de
validación de entrada de datos. La diferencia entre ambas propiedades de
mensajes de error es la siguiente:
„ Propiedad ErrorMessage
La propiedad ErrorMessage es el mensaje de error que se muestra en la
ubicación de un control de validación cuando éste se dispara, si no está
establecida la propiedad Text. Este mensaje también se incluirá en un
control ValidationSummary si se utiliza uno en el formulario Web Form.
Introducción
Mensajes de error

„ Propiedad Text
La propiedad Text es el texto alternativo que se mostrará en la ubicación del
control de validación cuando se utilizan las propiedades ErrorMessage y
Text, y se dispara el control de validación. Si se utiliza un control
ValidationSummary para capturar mensajes de error, normalmente se
utiliza un asterisco (*) rojo a la derecha del control de entrada de datos no
válido para indicar dónde se encuentra el error.
En Visual Studio .NET, el script predeterminado para la propiedad Text es
imprimir el contenido de Text entre las etiquetas de inicio y final del control
de validación, como muestra el siguiente código:
<asp:type_of_validator…>Text</asp:type_of_validator>
En este módulo, observarmos la propiedad Text declarada explícitamente,
como muestra el siguiente código:
<asp:type_of_validator…Text="Text">
La propiedad Display establece el espacio de mensajes de error desde múltiples
controles de validación cuando se muestra el formulario Web Form en
FlowLayout. La propiedad Display únicamente afecta a mensajes de error en la
ubicación del control de validación. Los mensajes que se muestran en
ValidationSummary no se ven afectados por la propiedad Display.
La siguiente tabla describe las diversas opciones de la propiedad Display.
Opciones Descripción
Static Define una presentación prefijada para el mensaje de error, con cada
control de validación ocupando un espacio, aunque no haya texto de
mensaje de error visible. Esta opción permite definir una presentación
fija para la página, como se muestra en la ilustración anterior.
De forma predeterminada, Visual Studio .NET utiliza
Display="static" para posicionar el texto del mensaje de error.
Dynamic Permite que los controles de validación se representen en la página
como parte del flujo de texto. El uso de esta opción evita que se
muestren espacios en blanco en la página cuando no se invocan los
controles de validación de entrada de datos, como se muestra en la
ilustración anterior. En ocasiones, esta opción hace que los controles
tengan movimiento en el formulario Web Form cuando se muestran
mensajes de error.
None Bloquea la visualización de mensajes de error en la ubicación del
control de validación.
Establecer la propiedad
Display

Combinar controles de validación
„ Pueden existir múltiples controles de validación en un único
control de entrada de datos
„ Únicamente RequiredFieldValidator comprueba los controles
vacíos
***************************** use******************************
En ocasiones, una única función o control de validación no es suficiente para
verificar que el usuario ha introducido correctamente los datos en un control de
entrada.
Por ejemplo, un control TextBox con números de teléfono puede requerir una
entrada, ajustarse a uno o varios modelos de número de teléfono y ser verificada
contra una base de datos que almacena números de teléfono. En este escenario,
TextBox debería estar enlazado a un control RequiredFieldValidator, un
control RegularExpressionValidator con varios patrones y un control
CustomValidator con acceso a una base de datos.
Podemos asociar múltiples controles de validación a un único control de
entrada de datos. Esta asociación muchos-a-uno de los controles de validación
permite la introducción de datos del usuario para más de un requerimiento de
validación.
El siguiente código de ejemplo muestra un único control de entrada de datos
para un número de teléfono. El contenido del control de entrada de datos se
comprueba utilizando un control RequiredFieldValidator, y el formato
correcto se comprueba utilizando un control RegularExpressionValidator:
„ Control de entrada de datos
El siguiente código define el control TextBox que se está validando:
<asp:TextBox id="txtPhone1" runat="server" >
</asp:TextBox>
Introducción
Múltiples controles de
validación en un único
control de entrada
Ejemplo

„ Control RequiredFieldValidator
El siguiente código define el control RequiredFieldValidator que verifica
que hay una entrada en txtPhone1:
<asp:RequiredFieldValidator
id="RequiredtxtPhone1Validator1"
runat="server"
ErrorMessage=
"A telephone number is required"
ControlToValidate="txtPhone1"
Text="*">
</asp:RequiredFieldValidator>
„ Control RegularExpressionValidator
El siguiente código define el control RegularExpressionValidator que
verifica que la entrada en txtPhone1 coincide con el modelo de número de
teléfono de Estados Unidos:
<asp:RegularExpressionValidator
id="RegulartxtPhone1Validator1"
runat="server"
ErrorMessage=_
"This telephone number is not formatted correctly"
ValidationExpression=
"(((d{3}) ?)|(d{3}-))?d{3}-d{4}"
Text="*">
</asp:RegularExpressionValidator>
„ Control CustomValidator
El siguiente código define el control CustomValidator que invoca la
función MyServerValidation, que compara la entrada en txtPhone1 con
una base de datos de números de teléfono:
<asp:CustomValidator
id="CustomValidator1"
OnServerValidate = "MyServerValidation"
runat="server"
ErrorMessage="This telephone number is not recognized"
Text="*">
</asp:CustomValidator>

Controles de validación de entrada de datos
„ RequiredFieldValidator
z InitialValue
„ CompareValidator
z ValueToComparar o ControlToComparar
z Type
z Operator
„ RangeValidator
z MinimumValue
z MaximumValue
z Type
Código de ejemplo
***************************** use******************************
Los controles de validación más sencillos son los controles
RequiredFieldValidator, CompareValidator y RangeValidator. Todos ellos
validan contra valores fijos o contra un segundo control de entrada de datos.
Utilizamos el control RequiredFieldValidator para obligar a un usuario a
introducir datos en un control de entrada de datos. Cualquier carácter es una
respuesta válida con este control de validación. Únicamente la nula entrada de
datos (en blanco), o espacios, constituye una entrada no válida con este control.
El control RequiredFieldValidator se utiliza normalmente sólo en controles de
entrada de datos necesarios para completar un proceso solicitado. Por ejemplo,
un control RequiredFieldValidator se utilizaría para los campos
nombre_usuario y contraseña en una página de inicio de sesión, pero no para
información secundaria, como una oferta para convertirse en visitante favorito
de un determinado sitio Web.
Una opción para el control RequiredFieldValidator es tener un valor inicial
que no sea una cadena vacía (en blanco). Resulta útil tener un valor inicial
cuando tenemos un valor predeterminado para un control de entrada de datos y
deseamos que el usuario introduzca otro valor. Para requerir un cambio del
valor inicial del control de entrada de datos asociado, establecer la propiedad
InitialValue para que coincida con el valor inicial del control de entrada de
datos.
En el siguiente ejemplo, un control RequiredFieldValidator verifica que el
valor txtName del control TextBox no es el valor inicial de Enter your name:
Introducción
Control
RequiredFieldValidator

<asp:TextBox id="txtName" runat="server">
Enter your name</asp:TextBox>
<asp:RequiredFieldValidator id="txtNameValidator"
runat="server"
InitialValue="Enter your name"
ErrorMessage="You must enter your name"
Display="dynamic"
Text="*">
</asp:RequiredFieldValidator>
Únicamente el control RequiredFieldValidator requiere que se
Nota
introduzca un valor en un control. El resto de controles de validación aceptarán
un control vacío o un espacio como respuesta válida.
Utilizamos el control CompareValidator para probar la entrada de datos del
usuario contra un valor específico o contra un segundo control de entrada de
datos. El control CompareValidator a menudo se utiliza donde el riesgo de
errores tipográficos es alto, como campos de contraseña que no muestran la
entrada real de usuario.
El control CompareValidator mostrará como válido un control de entrada de
datos vacío.
El control CompareValidator utiliza las siguientes propiedades:
„ ValueToCompare
La propiedad ValueToCompare se utiliza para establecer un valor
constante con el que realizar la comparación. Utilizamos un carácter tubería
(|) para separar varios valores. Esta propiedad se utiliza especialmente para
validar contra valores inalterables, como un límite de edad mínima.
Utilizamos el control CustomValidator para comparar contra valores que
pueden cambiar.
„ ControlToCompare
La propiedad ControlToCompare se utiliza para identificar otro control
con el que realizar la comparación. Esta propiedad puede utilizarse para
buscar errores tipográficos haciendo que el usuario introduzca los mismos
datos en dos campos adyacentes.
Si establecemos ambas propiedades, ValueToCompare y
ControlToCompare, la propiedad ControlToCompare tiene prioridad.
„ Type
La propiedad Type se utiliza para especificar el tipo de datos. Utilizamos
esta propiedad cuando deseamos comparar el valor de un control de entrada
de datos contra un DataType.
„ Operator
La propiedad Operator especifica el operador de comparación a utilizar.
Los operadores se especifican con el nombre de los operadores de
comparación, como Equal, NotEqual, GreaterThan y
GreaterThanEqual.
Uso del control
CompareValidator

En el siguiente ejemplo, un control CompareValidator verifica que los valores
de los controles TextBox, txtPassword1 y txtPassword2, coinciden:
<asp:TextBox id="txtPassword1" runat="server">
Enter your password </asp:TextBox>
<asp:TextBox id="txtPassword2" runat="server" >
Enter your password again </asp:TextBox>
<asp:CompareValidator id="CompareValidator1" runat="server"
ErrorMessage="These fields do not match"
ControlToCompare="txtPassword1"
ControlToValidate="txtPassword2"
Text="*">
</asp:CompareValidator>
El control RangeValidator se utiliza para comprobar si el valor introducido
está dentro de un determinado intervalo. El intervalo de medida es inclusivo y
los valores mínimo y máximo se consideran válidos. El control
RangeValidator se utiliza normalmente para verificar que el valor introducido
(por ejemplo, edad, estatura, salario o número de hijos) coincide con un
intervalo previsto.
El control RangeValidator mostrará como válido un control de entrada de
datos vacío.
El control RangeValidator tiene las siguientes propiedades:
„ MinimumValue
La propiedad MinimumValue especifica el valor mínimo del intervalo
válido para variables numéricas, o la longitud mínima de la cadena de
caracteres para variables de cadena.
„ MaximumValue
La propiedad MaximumValue especifica el valor máximo del intervalo
válido para variables numéricas, o la longitud máxima de la de caracteres
cadena para variables de cadena.
„ Type
La propiedad Type se utiliza para especificar el tipo de datos de los valores
a comparar. Los valores a comparar se convierten en este tipo de datos antes
de que se realice alguna comparación.
En el siguiente ejemplo, un control RangeValidator verifica que el control
TextBox denominado txtAge tiene un valor entre 18 y 50:
Uso del control
RangeValidator

<asp:textbox id="txtAge" runat="server">
Enter your age</asp:textbox>
<asp:RangeValidator id="txtAgeValidator" runat="server"
ControlToValidate="txtAge"
Type="Integer"
MinimumValue="18"
MaximumValue="50"
ErrorMessage="Applicants must be between 18 and 50"
Display="dynamic"
Text="*">
</asp:RangeValidator>

Uso del control RegularExpressionValidator
„ Se utiliza cuando la entrada debe ajustarse a un
modelo predefinido
„ Visual Studio .NET incluye modelos para:
z Números de teléfono
z Códigos postales
z Direcciones electrónicas
<asp:RegularExpressionValidator …
<asp:RegularExpressionValidator …
ControlToValidate="ControlToValidate="US_US_PhoneNumber"…
PhoneNumber"…
ValidationExpression="(((d{3}) ?)|(d{3}-))?d{3}-d{4} "
…>*</asp:RegularExpressionValidator >
d{3}) ?)|(d{3}-))?d{3}-d{4} "
…>*</asp:RegularExpressionValidator >
Código de ejemplo
***************************** use******************************
Cuando debemos verificar que los datos introducidos por un usuario coinciden
con un modelo predefinido, como un número de teléfono, un código postal o
una dirección electrónica, utilizamos el control RegularExpressionValidator.
Este control de validación compara el modelo de caracteres, dígitos y símbolos
introducidos por el usuario con uno o más modelos en el control.
Cuando hacemos clic en ValidationExpression en la ventana Propiedades,
Visual Studio .NET proporciona una serie de modelos de expresiones
habituales preestablecidas. Estos modelos incluyen direcciones electrónicas y
Web, números de teléfono y códigos postales. Para crear un nuevo modelo,
seleccionar la plantilla Custom. El último modelo utilizado estará disponible
para ser modificado. Esta característica del último utilizado ofrece una base a
partir de la cual crear nuestro propio modelo.
Introducción

Generamos nuestras propias expresiones habituales personalizadas utilizando el
conjunto de caracteres de control que se muestran en la siguiente tabla.
Carácter Definición
a Debe utilizar la letra en minúscula. Las letras que no estén precedidas
por una barra invertida (), o parte de un intervalo, son un
requerimiento para ese valor literal.
1 Debe utilizar el número 1. Cualquier número que no esté precedido de
una barra invertida (),o parte de un intervalo, es un requerimiento para
ese valor literal.
? Elemento 0 ó 1.
* Elementos 0 a N.
+ Elementos 1 a N (1 como mínimo).
[0-n] Intervalo de valores enteros de 0 a n.
{n} La longitud debe ser n caracteres.
| Separa múltiples modelos válidos.
El siguiente carácter es un carácter comando.
w Debe tener un carácter.
d Debe tener un dígito.
. Debe tener un periodo.
Para más información sobre los caracteres de control, leer la
“Introducción a las expresiones regulares,” en la documentación en línea de
Referencia de JScript.
El siguiente código de ejemplo muestra cómo podemos utilizar un control
RegularExpressionValidator para comprobar si un usuario ha introducido una
dirección electrónica válida:
<asp:TextBox id="txtEmail" runat="server" />
<asp:RegularExpressionValidator id="txtEmail_validation"
runat="server"
ControlToValidate="txtEmail"
ErrorMessage="Use the format username@organization.xxx"
ValidationExpression="w+@w+.w+"
Text="*">
</asp:RegularExpressionValidator>
Caracteres de
expresiones habituales
Nota
Ejemplo de una
expresión simple

Este control de validación RegularExpression comprueba un modelo
específico, como muestra la siguiente tabla.
Caracteres Definición
w+ Una cadena de un carácter como mínimo.
@ Un signo (@).
. Un periodo.
Una dirección electrónica válida para este control es: alguien@ejemplo.com.
Una dirección electrónica no válida para este control es: alguien.com, o
alguien@.com.
La expresión predeterminada de correo electrónico de Visual Studio .NET es
más compleja que el ejemplo anterior. El modelo predeterminado de correo
electrónico también limita la separación de términos antes y después del signo
(@) a xx.xx o xx-xx.
La expresión regular predeterminada para direcciones electrónicas es:
w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
Este control de validación RegularExpression comprueba un modelo
específico, como muestra la siguiente tabla.
Caracteres Definición
([-+.]w+)* Puede tener uno o más guiones o un punto, y una cadena de un
carácter como mínimo.
@ Un signo (@).
([-.]w+)* Puede tener un guión o un punto, y una cadena de un carácter como
mínimo.
. Un punto.
([-.]w+)* Puede tener un guión o un punto, y una cadena de un carácter como
mínimo.
Una dirección electrónica válida para este control es: algu-ien@
ejemplo.empresa.com.
Una dirección electrónica no válida para este control es:
algu,ien@ejemplo..empresa.com.
Ejemplo de una
expresión compleja

Demostración: uso de los controles de validación
„ Crear un formulario Web Form ASP.NET
con controles TextBox y Button
„ Agregar un control
„ Agregar un control RangeValidator
„ Agregar un control
RegularExpressionValidator
***************************** use******************************
En esta demostración, veremos cómo puede utilizarse un control
RequiredFieldValidator para verificar que un control TextBox se ha rellenado
antes de que un formulario Web Form sea procesado.
Ë Ejecutar esta demostración
1. Crear un nuevo proyecto de aplicación Web denominado ValidationTst1.
2. Cambiar a FlowLayout.
3. Arrastrar los siguientes controles Web desde el Cuadro de herramientas a
WebForm1: TextBox y Button.
4. Agregar un control RequiredFieldValidator junto al control de entrada de
datos TextBox.
5. Establecer las propiedades del control RequiredFieldValidator en la
ventana Propiedades, como muestra la siguiente tabla.
Propiedad Valor
ControlToValidate TextBox1
ErrorMessage Texto del mensaje de error
Text Se requiere entrada de datos
6. Mostrar que la propiedad Display de RequiredFieldValidator está
establecida en Static de forma predeterminada.
7. Guardar, generar y examinar la página.
8. Dejar el control en blanco y hacer clic en Button1.
Se obtiene el mensaje de error Text, y no el mensaje ErrorMessage.
Crear un formulario Web
Form ASP.NET con
controles TextBox y
Button
Agregar un control

9. Agregar un control RangeValidator al formulario Web Form junto a
RequiredFieldValidator.
10. Establecer las propiedades del control RangeValidator en la ventana
Propiedades, como muestra la siguiente tabla:
Propiedad Valor
ControlToValidate TextBox1
ErrorMessage Texto del mensaje de error
Text Fuera del intervalo
MaximumValue 100
MinimumValue 16
Type Entero
12. Dejar el valor en blanco y hacer clic en Button.
Se debería obtener el mensaje Se requiere entrada de datos del control
RequiredFieldValidator.
13. Escribir un valor mayor que 100 o menor que 16, y hacer clic en Button. Se
debería obtener el mensaje Fuera del intervalo del control
RangeValidator.
El mensaje de texto Fuera del intervalo no está directamente junto al
control de entrada de datos. Debido a que la página está en modo de
presentación estático, el control RequiredFieldValidator guarda un espacio
para su mensaje de texto.
14. Volver a abrir el formulario Web Form, seleccionar el control
RequiredFieldValidator y cambiar la propiedad Display a Dynamic.
16. Introducir un valor mayor que 100 o menor que 16, y hacer clic en Button.
Se debería obtener el mensaje Fuera del intervalo del control
RangeValidator.
Esta vez, el mensaje de texto Fuera del intervalo está directamente junto al
control de entrada de datos debido a que RequiredFieldValidator no
guarda el espacio para su mensaje de texto (modo de presentación
dinámico).
17. Agregar un segundo control TextBox y un control
RegularExpressionValidator junto a él.
18. Hacer clic con el botón derecho en el control RegularExpressionValidator
y clic en Propiedades, o clic en el control RegularExpressionValidator si
la ventana Propiedades sigue abierta, e introducir las siguientes propiedades:
a. En la propiedad ErrorMessage, escribir Dirección electrónica no
válida.
b. En la propiedad ControlToValidate, seleccionar TextBox2.
c. En la propiedad ValidationExpression, seleccionar Internet E-mail
Address.
Agregar un control
RangeValidator
Agregar un segundo
control TextBox y un
control Regular
ExpressionValidator

Escribir una dirección electrónica incorrecta en el segundo cuadro de texto y
hacer clic en Button. Se debería obtener el mensaje de texto Dirección
electrónica no válida del control RegularExpressionValidator.
20. Seleccionar Ver fuente y mostrar la validación del lado del cliente HTML.

Uso del control CustomValidator
„ Es posible validar en lado del cliente, en el lado del
servidor, o en ambos
z ClientValidationFunction
z OnServerValidate
„ Validar con:
z Fórmula
z Datos
z Objetos COM
z Servicio Web
Código de ejemplo
***************************** use******************************
Utilizamos el control CustomValidator cuando deseamos utilizar nuestra
propia lógica de validación personalizada para comprobar los datos
introducidos por el usuario contra una variable, fórmula, o la entrada desde una
segunda fuente. El control CustomValidator se utiliza a menudo para
situaciones como la verificación de contraseñas, en las que los datos
introducidos por el usuario se comparan con una contraseña almacenada en una
base de datos de usuarios.
El control CustomValidator valida en el lado del servidor, y puede validar en
el lado del cliente si el navegador soporta la validación. A diferencia de otros
controles de validación, donde ASP.NET crea los scripts de validación de
cliente y servidor, debemos escribir explícitamente los scripts de validación
para el control CustomValidator. Establecemos el control CustomValidator
como válido o no válido utilizando la propiedad args.IsValid.
Las propiedades del control CustomValidator incluyen:
„ ClientValidationFunction
La propiedad ClientValidationFunction es el script que deseamos que
ejecute el control CustomValidator en el lado del cliente. Debido a que
escribimos nuestro propio script en el cliente, es importante comprobar que
existe coherencia lógica con el código del lado del servidor.
„ OnServerValidate
La propiedad OnServerValidate es el script que deseamos que ejecute el
control CustomValidator en el lado del servidor. Debido a que escribimos
nuestro propio código en el servidor, es importante comprobar que existe
coherencia lógica con el script del lado del cliente.
Introducción
cliente y del lado del
servidor

El siguiente código de ejemplo muestra procedimientos del lado del servidor y
del lado del cliente para un control CustomValidator y verificará que un
número introducido en un control de entrada de datos es un número par:
<asp: CustomValidator…
ClientValidationFunction = "MyClientFunction"
OnServerValidate = "MyServerFunction" />
„ Procedimiento del lado del cliente
El siguiente código JScript está pensado para ejecutarse en Internet Explorer
6, y verificará que un número es par:
<script language = "Jscript">
function MyClientFunction(source, arguments) {
alert("Ejecución en el cliente");
var intValue = arguments.Value;
if (intValue % 2 == 0) {
arguments.IsValid = true;
} else {
arguments.IsValid = false;
}
}
</script>
„ Procedimiento del lado del servidor
El siguiente código está diseñado para ejecutarse en un servidor .NET, y
verificará que un número es par:
Sub MyServerFunction(objSource as Object, _
args as ServerValidateEventArgs)
Dim intValue As Integer = args.Value
If intValue mod 2 = 0 Then
args.IsValid = True
Else
args.IsValid = False
End If
End Sub
private void MyServerFunction(object objSource,
ServerValidateEventArgs args)
{
int intValue = Convert.ToInt16(args.Value);
if (intValue%2 == 0)
{
args.IsValid = true;
}
else
{
args.IsValid = false;
}
}
Ejemplo
Visual Basic .NET
C#

Demostración: uso del control CustomValidator
„ Agregar un control CustomValidator
„ Escribir el código del lado del servidor
„ Escribir el script en el lado del cliente
„ Probar el resultado
***************************** use******************************
En esta demostración, veremos cómo utilizar un control CustomValidator.
El código para esta demostración se encuentra en el proyecto Demo06VB o
Demo06CS que se pueden encontrar dentro del fichero demos06.zip
1. Abrir el formulario Web Form denominado CustomValidator.aspx en
Visual Studio .NET.
El formulario Web Form ya dispone de un control TextBox y de un control
Button.
2. Agregar un control CustomValidator al formulario Web Form .
3. En la propiedad Text del control CustomValidator, escribir Es un número
impar.
4. Establecer la propiedad ControlToValidate en TextBox1.
5. Hacer doble clic en CustomValidator para abrir el procedimiento de evento
del lado del servidor y agregar el siguiente código:
Dim intValue As Integer = args.Value
If intValue mod 2 = 0 Then
args.IsValid = True
Else
args.IsValid = False
End If
Introducción
Agregar un control
CustomValidator
Escribir el código del
lado del servidor
Visual Basic .NET

int intValue = Convert.ToInt16(args.Value);
if (intValue % 2 == 0)
{
args.IsValid = true;
}
else
{
args.IsValid = false;
}
El procedimiento de eventos del lado del servidor que Visual Studio .NET
ha creado automáticamente debería tener el nombre
CustomValidator1_ServerValidate, y dos parámetros: source (tipo
Object) y args (tipo ServerValidateEventArgs).
6. En la propiedad ClientValidationFunction del control CustomValidator,
escribir MyClientValidation.
7. Abrir el código fuente HTML de la página CustomValidator.aspx (y no
CustomValidator.aspx.vb).
8. Quitar el comentario del siguiente código que se encuentra justo después de
la etiqueta <head>. Este ejemplo está en JScript:
function MyClientValidation(source, arguments)
{
alert("Ejecución en el cliente");
var intValue = arguments.Value;
if (intValue % 2 == 0)
{
arguments.IsValid = true;
} else {
arguments.IsValid = false;
}
}
Verificar que el navegador de destino es Internet Explorer 5. En la vista de
Diseño o la vista HTML, seleccionar Propiedades, y verificar que Target
Schema está establecido a Internet Explorer 5.0.
9. Establecer la propiedad EnableClientScript del control CustomValidator
a True.
El script del lado del cliente se ejecutará antes del código del lado del
servidor para evitar el viaje de ida y vuelta al servidor con la página si esta
propiedad está establecida a True y el navegador cliente es Internet
Explorer 4 o posterior.
C#
Escribir el script del
lado del cliente
Probar el resultado

10. Generar y examinar CustomValidator.aspx.
11. Escribir un número en el cuadro de texto.
12. Se debería obtener el cuadro de mensaje Ejecución en el cliente al hacer
clic en Button. Además, se debería obtener el mensaje Es un número
impar cuando el número sea impar.
13. Establecer la propiedad EnableClientScript del control CustomValidator
en False, de forma que únicamente se ejecute el código del lado del
servidor.
14. Generar y examinar la página.
15. En este momento no se debería obtener el cuadro de mensaje, ya que se está
ejecutando el código en el lado del servidor. Sin embargo, seguirá
apareciendo el mensaje Es un número impar cuando el número sea impar.

Lección: validación de páginas
„ Uso de la propiedad Page.IsValid
„ Uso del control ValidationSummary
„ Demostración: uso de la propiedad Page.IsValid y del
control ValidationSummary
***************************** use******************************
En esta lección, estudiaremos cómo utilizar la propiedad Page.IsValid y el
control ValidationSummary para verificar que todos los controles de
validación de un formulario ASP.NET Web Form son válidos antes de que se
inicie el proceso.
„ Utilizar la propiedad Page.IsValid para determinar si todos los controles de
validación de entrada de datos de una página son válidos.
„ Utilizar el control ValidationSummary para mostrar un resumen de
mensajes de error en una página.
Introducción

Uso de la propiedad Page.IsValid
Examina todos los controles de validación
Sub cmdSubmit_Click(s As Object, e As EventArgs)
Sub cmdSubmit_Click(s As Object, e As EventArgs)
If Page.IsValid Then
Message.Text = "Page is valid!"
' Perform database updates or other logic here
End If
End Sub
End If
End Sub
private void cmdSubmit_Click(object s, System.EventArgs e)
{ if (Page.IsValid)
{ if (Page.IsValid)
{ Message.Text = "Page is Valid!";
// Perform database updates or other logic here
}
}
{ Message.Text = "Page is Valid!";
}
}
***************************** use******************************
.NET permite verificar que todos los controles de una página son válidos antes
de que realicen alguna acción. Esta verificación puede llevarse a cabo en el
cliente o en el servidor, dependiendo del navegador que se esté utilizando. La
verificación del lado del cliente se realiza con el control ValidationSummary,
mientras que la verificación del lado del servidor se realiza con la propiedad
Page.IsValid.
Para determinar si todos los controles de validación de una página son válidos,
comprobamos la propiedad IsValid de la página en tiempo de ejecución. La
propiedad IsValid se vincula a los valores de todos los controles de validación
que se encuentran en la página (utilizando un AND lógico). Si algún control de
validación no es válido, la propiedad IsValid devuelve False. Esta propiedad
proporciona una forma sencilla de determinar si los controles de entrada de
datos en el formulario Web Form son válidos y si el formulario Web Form está
preparado para seguir con la lógica de negocio.
Los controles de validación verifican las entradas del usuario, establecen un
estado de error y producen mensajes de error. Sin embargo, los controles de
validación no cambian el flujo de procesamiento de páginas. Por ejemplo, los
controles de validación no evitan nuestro código si detectan un error en los
datos introducidos por el usuario. En lugar de ello, probamos el estado de los
controles en nuestro código antes de realizar lógica específica de aplicación. Si
detectamos un error, evitamos que nuestro código se ejecute; la página seguirá
procesándose y se devuelve al usuario con mensajes de error.
La información de validación no está disponible durante la inicialización
de una página o durante la fase de carga. Para obtener información sobre los
estados de página, examinar “Estados de procesamiento de páginas de
formularios Web Forms” en la documentación de Visual Studio .NET.
Introducción
Uso de la propiedad
Page.IsValid
Nota

El siguiente ejemplo muestra el controlador de eventos de un botón. El código
verifica la propiedad IsValid de toda la página. No es necesario para una
cláusula Else, ya que la página será enviada de vuelta automáticamente al
navegador y los controles de validación mostrarán sus propios mensajes de
error:
Sub cmdSubmit_Click (s As Object, e As EventArgs)
End If
End Sub
{
if (Page.IsValid)
{
Message.Text = "Page is Valid!";
}
}
Ejemplo
Visual Basic .NET
C#

Uso del control ValidationSummary
„ Recopila los mensajes de error de todos los controles
de validación de la página
„ Puede mostrar mensajes de texto y de error
„ Utilizar Text="*" para indicar la ubicación del error
<asp:ValidationSummary id="valSummary"
runat="server"
HeaderText="These errors were found:"
ShowSummary="True"
DisplayMode="List"/>
runat="server"
ShowSummary="True"
DisplayMode="List"/>
***************************** use******************************
El control ValidationSummary muestra cuando la propiedad Page.IsValid
devuelve False. Se contacta con cada control de validación de la página y el
control ValidationSummary reúne los mensajes de ErrorMessage.
El control ValidationSummary puede mostrar un cuadro de mensaje o un área
de texto, con un encabezado y una lista de errores, dependiendo del valor
DisplayMode, podemos mostrar la lista de errores como una lista de viñetas o
un único párrafo. Los controles ValidationSummary se ubican normalmente
cerca del botón Submit de forma que todos los mensajes de error sean
fácilmente visibles para el usuario cuando se disparen los controles de
validación de entrada de datos.
El siguiente código HTML muestra un control ValidationSummary típico:
runat="server"
ShowSummary="True"
DisplayMode="List" />
Cuando se utiliza el control ValidationSummary, la propiedad Text (si se
utiliza) se muestra en la ubicación del control de validación, mientras que la
propiedad ErrorMessage se muestra en la presentación del control
ValidationSummary.
Normalmente, se muestra una propiedad Text con un asterisco (*) rojo a la
derecha del control de entrada de datos para avisar al usuario de que el control
de entrada de datos no se ha cumplimentado correctamente. En el control
ValidationSummary, se muestra una propiedad ErrorMessage, con una
descripción del error de entrada de datos, que normalmente se ubica cerca del
evento que dispara el control.
Introducción
Muestra mensajes de
texto y de error
Uso de * para localizar
errores

La siguiente ilustración muestra un par de campos de contraseña con varios
controles de validación de entrada de datos y un control ValidationSummary.
Ejemplo

Demostración: uso de la propiedad Page.IsValid y del control
ValidationSummary
„ Abrir una página ASP.NET con múltiples
cuadros de texto y controles de
validación
„ Agregar un control ValidationSummary
„ Agregar un script que utilice la propiedad
Page.IsValid
***************************** use******************************
En esta demostración, veremos cómo utilizar el método Page.IsValid y el
control Validation Summary.
Los campos de esta demostración se encuentran en el proyecto Demo06VB o
Demo06CS que se pueden encontrar dentro del fichero demos06.zip
1. Abrir el formulario Web Form denominado ValidationSummary.aspx en
Visual Studio .NET.
La página ya contiene dos controles TextBox. Hay un control
RequiredFieldValidator y un control RangeValidator, que validan el
primer cuadro de texto. La página también contiene un control
RequiredFieldValidator y un control RegularExpressionValidator, que
validan el segundo cuadro de texto. Además, hay un botón Submit y un
Label.
2. Arrastrar el control ValidationSummary a la parte inferior de la página.
3. Hacer doble clic en el control Button para abrir el controlador de eventos
Click, y eliminar el comentario del siguiente código:
lblMessage.Text = "Page is valid!"
End If
Introducción
Abrir una página
ASP.NET
Agregar un control
Validation
Summary
Agregar código para
probar la validez de la
página
Visual Basic .NET
C#

if (Page.IsValid)
{
lblMessage.Text = "Page is valid!";
}
4. Guardar, generar y examinar la página ValidationSummary.aspx.
Deberíamos ver el mensaje Page is valid! cuando toda la página sea válida.

Validando las entradas de usuario

Más contenido relacionado

Destacado (11)

Similar a Validando las entradas de usuario (16)

Último (20)

Validando las entradas de usuario