desarrollo de aplicaciones web.pdf

7/16/2019 Desarrollo de Aplicaciones Web.pdf

http://slidepdf.com/reader/full/desarrollo-de-aplicaciones-webpdf 1/302

Developing Web Applications

1

Contenido

1 INTRODUCCIÓN A LA PROGRAMACIÓN WEB....5 1.1 TIPOS DE APLICACIONES......................................................... 5

1.1.1 ¿Qué puede crear? ............................ ............................... ........ 5 1.1.2 Cómo funcionan las aplicaciones Web ....................................5 1.1.3 Lo que proporciona ASP.NET..................... ............................. 6 1.1.4 Ventajas de ASP.NET.. ................................. ............................ 6

1.2 USO DE ASP.NET................................................................... 7 1.2.1 Partes de una aplicación Web..................................................7 1.2.2 Componentes de formulario Web.............................................7 1.2.3 Marco de trabajo .NET............................ ................................. 8 1.2.4 Lenguajes de programación.............. ................................... ..10

1.3 VISUAL STUDIO.NET ........................................................... 11 1.3.1 Página de inicio......................................................................11 1.3.2 Ventanas de Visual Studio .NET.............................................11 1.3.3 Cuadro de herramientas.........................................................12 1.3.4 Editar documentos Web..........................................................12 1.3.5 Editar código..........................................................................12 1.3.6 Explorador de soluciones.......................................................13 1.3.7 Ejecutar un proyecto ..............................................................13 1.3.8 Establecer puntos de Interrupción e Inspeccionar

Variables................................................................................13 1.3.9 Ejecutar sentencias.................................................................13 1.3.10 Ayuda... ............................... ............................... ..................... 14

1.4 R ESUMEN.............................................................................. 14 1.5 PRÁCTICA: COMIENZO CON VISUAL STUDIO .NET.............. 14 1.5.1 Personalizar el Marco de Trabajo .NET................................15

1.5.2 Configurar una cuenta de alojamiento Web .......................... 15 1.5.3 Elegir un proveedor de servicio .............................. ............... 15 1.5.4 Explorar los tutoriales rápidos de ASP.NET......... ................ 16

1.6 R EPASO ................................................................................. 16

2 APLICACIONES DE FORMULARIO WEB............. 17 2.1 CREAR UN PROYECTO DE APLICACIÓN WEB ........................ 17

2.1.1 Crear una nueva aplicación Web...........................................17 2.1.2 Organizar su proyecto con IIS ...............................................17 2.1.3 Crear directorios virtuales para aplicaciones Web...............17 2.1.4 Añadir controles y escribir código.......................... ............... 18 2.1.5 Archivos de un proyecto de formulario Web...................... .... 19 2.1.6 Archivos en una aplicación Web............ ................................ 20

2.2 R ESPONDER A SUCESOS ........................................................ 20 2.2.1 Sucesos en el ciclo de vida de una aplicación Web ............... 20 2.2.2 Conservar datos en un formulario Web...... ........................... 20 2.2.3 Sucesos de aplicación y sesión...............................................21 2.2.4 Sucesos de formulario Web ............................... ..................... 22 2.2.5 Sucesos de controles de servidor............................................23

2.3 ¿DÓNDE SE HACE EL PROCESAMIENTO?............................... 24 2.3.1 Establecer los límites de aplicación.......................................24 2.3.2 Gestión de procesos................................................................25 2.3.3 Determinar cuando termina una aplicación .......................... 25

2.4 R ESUMEN.............................................................................. 26 2.5 PRÁCTICA: CREAR UNA APLICACIÓN WEB SENCILLA.......... 26

2.5.1 Crear el interface de usuario .................................................26 2.5.2 Crear una clase llamada FlashCardClass.............................27 2.5.3 Almacenar un objeto FlashCardClass en Session ................. 28 2.5.4 Utilizar FlashCardClass en los sucesos del formulario

Web.........................................................................................29 2.6 R EPASO ................................................................................. 30

3 TRABAJAR CON OBJETOS WEB ....................... .....31 3.1

FUNDAMENTOS DE LOS ESPACIOS DE NOMBRES ..................31

3.1.1 Comprender los espacios de nombres....................................31 3.1.2 Referencias Frente a Importaciones ............................ .......... 33 3.1.3 Clases y módulos ............................... ................................ ..... 34 3.1.4 Interfaces ............................ ................................ .................... 42

3.2 ESPACIOS DE NOMBRES EN UNA APLICACIÓN WEB ............. 43 3.2.1 Generalidades de los espacios de nombres Web ...................43 3.2.2 Uso del objeto Application.....................................................44 3.2.3 Uso del objeto Page................................................................45 3.2.4 Uso del objeto Request..... .................................. .................... 45 3.2.5 Uso del objeto Response.........................................................46

3.3 MANTENIMIENTO DE INFORMACIÓN DE ESTADO ................. 47 3.3.1 Niveles de estado........... ............................... .......................... 47 3.3.2 Uso de cadenas de consulta ...................................................47 3.3.3 Uso de cookies........................................................................47 3.3.4 Uso del estado de vista...........................................................48

3.4 R ESUMEN.............................................................................. 51 3.5 PRÁCTICA: USAR OBJETOS Y GRABAR DATOS ...................... 51

3.5.1

Crear el interface de usuario .................................................51

3.5.2 Crear una clase Translator.... ................................. ............... 51 3.5.3 Almacenar un objeto Translator en sesión............................. 53 3.5.4 Use el objeto TransClass en los sucesos del formulario

Web.........................................................................................53 3.6 R ESUMEN.............................................................................. 55

4 CREAR UN INTERFACE DE USUARIO...................57 4.1 USAR CONTROLES.................................................................57

4.1.1 Seleccionar una disposición ...................................................57 4.1.2 Elegir el control correcto........................................................58 4.1.3 Trabajar con texto...................................................................59 4.1.4 Trabajar con tablas y listas ....................................................60 4.1.5 Añadir elementos a una lista o tabla en diseño.... ..................60 4.1.6 Añadir elementos a una lista o tabla en ejecución.... .............60 4.1.7 Obtener el elemento seleccionado de una lista ......................61 4.1.8 Usar vinculación de datos sencilla con listas.........................62 4.1.9 Añadir elementos a DataGrid, DataList y Repeater ..............62 4.1.10 Ejecutar comandos..................................................................63 4.1.11 Leer y escribir opciones................ ............................... ...........65 4.1.12 Mostrar gráficos y avisos.................................. ......................65 4.1.13 Agrupar controles.............. ................................ .....................66 4.1.14 Obtener fechas ........................................................................67 4.1.15 Obtener archivos del cliente...................................................68

4.2 VALIDAR DATOS ...................................................................69 4.2.1 Usar validación.......................................................................69 4.2.2 Combinar validaciones......... .................................. ................70 4.2.3 Cancelar la validación............................................................70 4.2.4 Personalizar la validación......................................................70

4.3 NAVEGACIÓN ENTRE FORMULARIOS ....................................72 4.3.1 Formas de navegar ................................. ................................72 4.3.2 Uso de hiperenlaces y redirección......................... .................72 4.3.3 Método Transfer................................................. .....................72 4.3.4 Método Execute...................................... ................................ .73 4.3.5 Mostrar una página en una nueva ventana............... .............74

4.4 R ESUMEN ..............................................................................76 4.5 PRÁCTICA: EDITOR DE TEXTO BASADO EN WEB ..................76

4.5.1 Crear el formulario de registro ............................. .................76 4.5.2 Crear el formulario NewAccount...................................... ......78 4.5.3 Crear el formulario FileManager............................... ............80 4.5.4 Crear el formulario FileEditor...............................................82 4.5.5 Crear el formulario Web NonAuthorized ...............................84

4.6 R EPASO .................................................................................85

5 ADO.NET. ....................... ...................... ....................... ..87 5.1 ACCESO A DATOS CON ADO.NET........................................87

5.1.1 ADO.NET............................... ................................. ................87 5.1.2 Conectar con una base de datos ................................... ..........88 5.1.3 Crear un conjunto de datos.....................................................88 5.1.4 Mostrar un conjunto de datos.......... .................................. .....88 5.1.5 Cambiar registros en la base de datos .............................. .....89 5.1.6 Cómo hace referencia a objetos ADO.NET............................89 5.1.7 Añadir, cambiar y borrar filas.......................... ......................90 5.1.8 Actualizar la base de datos desde el conjunto de datos .........91 5.1.9 Crear una conexión en tiempo de ejecución...........................92 5.1.10 Actualizar una Conexión en tiempo de ejecución...................92

5.2 USAR CONJUNTOS DE DATOS EN FORMULARIOS WEB..........94 5.2.1 Mostrar un conjunto de datos en un DataGrid.......................94 5.2.2 Mostrar un conjunto de datos en un DataList ........................95 5.2.3 Mostrar datos en otros controles de lista................... ............96 5.2.4 Seleccionar registros concretos..............................................97 5.2.5 Ejecutar comandos sobre una base de datos..................... .....98 5.2.6 Devolver un valor desde una base de datos ...........................98 5.2.7 Cambiar registros directamente en la base de datos .............99 5.2.8 Recuperar registros directamente de la base de datos.........100

5.3 PROCESO DE TRANSACCIONES ............................................101 5.3.1 Transacciones .......................................................................101 5.3.2 Transacciones de conjunto de datos.....................................102 5.3.3 Transacciones de base de datos............................................103 5.3.4 Transacciones de empresa....................................................106

5.4 R ESUMEN ............................................................................106 5.5 PRÁCTICA: APLICACIÓN DE GESTIÓN DE CONTACTOS .......107

5.5.1 Inicie un proyecto y cree el formulario SwichtBoard...........107 5.5.2 Añadir componentes de base de datos............................... ...107 5.5.3 Crear el formulario AddContact............................. ..............108 5.5.4 Crear el formulario Calls .....................................................112 5.5.5 Crear los formularios DeleteContact y ContactTypes .........117

5.6 R EPASO ...............................................................................117 6 CAPTURAR Y CORREGIR ERRORES ..................119

6.1 USO DEL MANEJO DE EXCEPCIONES....................................119 6.1.1 Técnicas de control de excepciones......................................119 6.1.2 Usar bloques de control de excepciones...............................119 6.1.3 Causar excepciones...............................................................122 6.1.4 Definir nuevas excepciones.......................................... .........123 6.1.5 Uso de sucesos de error........................................................123 6.2 USAR PÁGINAS DE ERROR ...................................................125 6.2.1 Control de excepciones relacionadas con internet...............125 6.2.2 Páginas de error a nivel de aplicación.................................125 6.2.3 Páginas de error a nivel de página.......................................126



MCAD/MCSD

2

6.3 R EGISTRO DE EXCEPCIONES................................................127 6.3.1 Usar seguimiento para registrar errores..............................127 6.3.2 Activar y desactivar el seguimiento...................... ................127 6.3.3 Escribir mensajes en el registro de seguimiento ..................128 6.3.4 Leer el registro de seguimiento.............................................129

6.4 R ESUMEN ............................................................................129 6.5 PRÁCTICA: A ÑADIR CONTROL DE EXCEPCIONES A UNA

APLICACIÓN.........................................................................129 6.5.1 Ampliar el control de errores ...............................................129 6.5.2 Añadir un suceso de error...................................... ...............131 6.5.3 Crear y ver el registro de seguimiento ............................ .....132 6.5.4 Ampliar el control de excepciones a otros formularios

Web.......................................................................................132 6.6 R EPASO ...............................................................................132

7 PROGRAMACIÓN AVANZADA DEFORMULARIOS WEB ........................ ...................... 133 7.1 GUARDAR Y RECUPERAR INFORMACIÓN DEL USUARIO......133

7.1.1 Identificar usuarios de la aplicación Web............ ................133 7.1.2 Almacenar nformación de suario en el cliente.... .................133 7.1.3 Almacenar información de usuario en el servidor ...............136 7.1.4 Crear claves únicas para identificar usuarios .....................136 7.1.5 Crear un archivo para guardar información del usuario....136 7.1.6 Crear un archivo XML..........................................................137 7.1.7 Crear un esquema XML........................................................137 7.1.8 Especificar un campo clave .................................. ................137 7.1.9 Leer XML en un conjunto de datos...................... .................137 7.1.10 Guardar información del usuario en el servidor..................138 7.1.11 Recuperar información de usuario del DataSet.. .................139

7.2 E NVIAR CORREO .................................................................139 7.2.1 Enviar correo desde un cliente ............................. ................139 7.2.2 Enviar correo desde el servidor............................................140

7.3 USO DE MARCOS .................................................................141 7.3.1 Crear marcos en Visual Studio.............................................141 7.3.2 Crear un conjunto de marcos ...............................................141 7.3.3 Crear páginas y añadirlas al conjunto de marcos ...............141 7.3.4 Comprobar el soporte del navegador para marcos ....... ......141 7.3.5 Apuntar a un marco desde un enlace....................................142

7.4 SECUENCIAS DE COMANDOS DE CLIENTE ...........................142 7.4.1 Antes de usar secuencias de comandos ................................143 7.4.2 Seleccionar un lenguaje de secuencias de comandos...........144 7.4.3 DOM................................. ................................. ....................144 7.4.4 Añadir secuencias de comandos en línea .............................144 7.4.5 Respuesta a sucesos con secuencia de comandos ................145

7.5 CONSUMIR SERVICIOS WEB XML ......................................147 7.5.1 Encontrar servicios Web XML..............................................148 7.5.2 Usar un servicio Web XML...................................................148 7.5.3 Uso de servicios Web XML desde secuencias de comando

de cliente...............................................................................148 7.6 R ESUMEN ............................................................................150 7.7 PRÁCTICA: USO DE CARACTERÍSTICAS AVANZADAS..........150

7.7.1 Comprobar el soporte de características avanzadas ...........151 7.7.2 Almacenar información de usuario .................................. ....152 7.7.3 Crear un formulario Web para correo............ .....................153 7.7.4 Crear un interface de usuario basado en marcos ................155 7.7.5 Práctica extra con secuencias de comandos y cookies ........155

7.8 R EPASO ...............................................................................155 8 MANTENER LA SEGURIDAD...................... .......... 157

8.1 AUTENTICAR Y AUTORIZAR USUARIOS...............................157 8.1.1 Acceso por uuarios anónimos........................... ....................157 8.1.2 Acceso por usuarios autenticados ............................ ............157 8.1.3 Autenticación con archivos HTM y HTML...................... .....158

8.2 AUTENTICACIÓN DE WINDOWS ..........................................158 8.2.1 Activar la autenticación Windows............. ...........................158 8.2.2 Permitir o denegar el acceso a usuarios concretos..............159 8.2.3 Autorización basada en rol................... ................................160 8.2.4 Obtener la identidad del usuario..........................................160 8.2.5 Configuración de IIS y autenticación Windows ...................160

8.3 AUTENTICACIÓN POR FORMULARIOS..................................161 8.3.1 Activar la autenticación por formularios .............................161 8.3.2 Establecer el modo de autenticación por formulario...........161 8.3.3 Crear un formulario Web de conexión ............................ .....162 8.3.4 Autenticar usuarios con una base de datos ..........................163 8.3.5 Añadir usuarios a una base de datos....................................164 8.3.6 Autenticar usuarios contra una base de datos .....................165

8.4 AUTENTICACIÓN PASSPORT................................................166 8.4.1 Activar la autenticación Passport.........................................167

8.5 PROPORCIONAR COMUNICACIONES SEGURAS ....................168 8.5.1 Activar la comunicación segura ................................. ..........168 8.5.2 Generar una petición de certificado.....................................169 8.5.3 Solicitar un certificado .........................................................169 8.5.4 Instalar el certificado..................... ................................. ......169 8.5.5 Usar comunicaciones seguras ............................... ...............170

8.6 R ESUMEN ............................................................................170 8.7 PRÁCTICA: CREAR UNA APLICACIÓN SEGURA ....................170

8.7.1 Activar la autenticación por formularios .............................170

8.7.2 Crear el formulario Web LogIn...................................... ...... 171 8.7.3 Mostrar información de usuario ............................... ........... 175 8.7.4 Temas avanzados..................................................................176

8.8 R EPASO................................................................................176

9 GENERAR Y DESPLEGAR APLICACIONES.......177 9.1 GENERAR UNA APLICACIÓN WEB .......................................177

9.1.1 Configurar las opciones de generación ............................... 177 9.1.2 Identificar la aplicación .................................. ..................... 177 9.1.3 Configurar la aplicación................ ................................. ..... 179

9.2 DESPLEGAR UNA APLICACIÓN WEB....................................179 9.2.1 Uso de las herramientas desSubida ................................. .... 179 9.2.2 Alojamiento en su propio servidor............... ........................ 179 9.2.3 Configurar un directorio virtual ............................... ........... 180 9.2.4 Copiar la aplicación.................................. ........................... 180 9.2.5 Instalar componentes compartidos. ............................... ...... 180 9.2.6 Asignar privilegios de seguridad. ........................................ 181

9.3 MANTENER UNA APLICACIÓN .............................................181 9.3.1 Controlar el servidor...................... ................................. ..... 182 9.3.2 Reparar aplicaciones....................................... ..................... 183 9.3.3 Afinar aplicaciones desplegadas.......................................... 184 9.3.4 Configurar las opciones de Caché....................... ................ 184 9.3.5 Cambiar el nivel de protección ................................. ........... 185 9.3.6 Ajustar los atributos de processModel................................. 185 9.3.7 Ajustar los atributos de sessionState.................................... 185 9.3.8 Consejos de optimización.......................... ........................... 185

9.4 DESPLEGAR ENTRE VARIOS SERVIDORES ............................186 9.4.1 Crecer con varios procesadores..................................... ...... 186 9.4.2 Crecer con varios servidores ...............................................186 9.4.3 Compartir información de estado .................................. ...... 186 9.5 R ESUMEN.............................................................................187

9.6 PRÁCTICA: GENERAR Y DISTRIBUIR UNA APLICACIÓN

WEB 187 9.6.1 Preparar la aplicación....... .................................. ................ 188 9.6.2 Despliegue la aplicación..... .................................. ............... 188 9.6.3 Comprobar el rendimiento de la aplicación ........................ 188 9.6.4 Afinar la aplicación........................................ ...................... 188

9.7 R EPASO................................................................................189 10 PROBAR APLICACIONES WEB.............................191

10.1 CREAR PRUEBAS..................................................................191 10.1.1 Desarrollar un plan de pruebas.......... ................................. 191 10.1.2 Tipos de pruebas.............................................. ..................... 192 10.1.3 Pruebas de unidad.................... ................................... ......... 192 10.1.4 Pruebas de integración................................................ ......... 194 10.1.5 Pruebas de regresión............................................................195 10.1.6 Pruebas de carga.................................. ................................ 195 10.1.7 Pruebas de plataforma........ .................................. ............... 196 10.2 EJECUTAR PRUEBAS ............................................................196 10.2.1 Ejecutar pruebas con ACT .............................. ..................... 196 10.2.2 Ejecutar pruebas con ensamblados .NET ............................ 198 10.2.3 Compilaciones y pruebas desatendidas ...............................200

10.3 DEPURADO ..........................................................................202 10.3.1 Poner a trabajar los resultados de las pruebas. .................. 202 10.3.2 Clases Debug y Trace...........................................................204 10.3.3 Mostrar alertas y mensajes .................................................. 204 10.3.4 Registrar mensajes de Debug y Trace.................................. 205 10.3.5 Depurado remoto............................. ................................. .... 205

10.4 R ESUMEN.............................................................................206 10.5 PRÁCTICA: PRUEBAS Y DEPURADO .....................................206

10.5.1 Repasar un plan de pruebas................ ................................. 206 10.5.2 Escribir pruebas de unidad .................................. ................ 207 10.5.3 Crear una prueba de carga..................................................207 10.5.4 Recorrer un proceso remoto........................................... ...... 207

10.6 R EPASO................................................................................207 11 CREAR CONTROLES WEB.....................................209

11.1 CREAR CONTROLES DE USUARIO WEB................................209 11.1.1 Crear y usar controles de usuario.................................. ...... 209 11.1.2 Crear un control de usuario y dibujar su interface ............. 209 11.1.3 Escribir las propiedades, métodos y sucesos del control ....210 11.1.4 Agregar el control a un formulario Web.............................. 211 11.1.5 Usar el control en el código.................................................211 11.1.6 Añadir sucesos al control de usuario............................... .... 212 11.1.7 Activar el diseño en rejilla ................................................... 213

11.2 CREAR CONTROLES COMPUESTOS.......................................213 11.2.1 Crear y usar controles compuestos ................................ ...... 213 11.2.2 Crear el proyecto de control personalizado ........................ 214 11.2.3 Crear el proyecto de prueba .......................................... ...... 215 11.2.4 Agregar el control personalizado al proyecto de prueba.... 215 11.2.5 Crear el aspecto del control compuesto...............................217 11.2.6 Crear propiedades y métodos...............................................218 11.2.7 Control de sucesos...................................... .......................... 219 11.2.8 Lanzar sucesos..................................................... ................. 220 11.2.9 Cambio de tamaño del control .................................. ........... 221 11.2.10 Superclasificar controles de servidor.............................. .... 222

11.3 CREAR CONTROLES PERSONALIZADOS TRAZADOS .............222 11.3.1 Crear y usar controles trazados................................ ........... 222




3

11.3.2 Crear la apariencia del control............................................223 11.3.3 Guardar configuración de propiedad .................................. 224 11.3.4 Recuperar texto contenido................................ .................... 225 11.3.5 Responder a acciones de usuario...................... ................... 226 11.3.6 Obtener datos desde el usuario............................................229 11.3.7 Añadir controles personalizados a la caja de

herramientas..... ................................ ................................ ...231 11.3.8 Establecer el icono y TagPrefix para controles

personalizados ................................. ................................. ...231 11.4 R ESUMEN............................................................................ 232 11.5 PRÁCTICA: CREAR CONTROLES PERSONALIZADOS ............232

11.5.1 Ejercicio 1: Crear un control de usuario AddressBox.........232 11.5.2 Ejercicio 2: Crear el control personalizado compuesto DigitPad.................. ................................ ............................. 232

11.5.3 Ejercicio 3: Cree el control personalizado trazado BartChar ................................. .................................. ........... 233

11.6 R EPASO ............................................................................... 233 12 TRABAJAR CON MULTIMEDIA............................235

12.1 I NTERPRETAR AUDIO .......................................................... 235 12.1.1 Formas de interpretar audio ............................. ................... 235 12.1.2 Interpretar sonidos de fondo .............................. .................. 235 12.1.3 Incrustar sonidos.................... ................................ .............. 236 12.1.4 Sonido como objetos ActiveX ............................. .................. 236

12.2 MOSTRAR VIDEO ................................................................ 240 12.2.1 Formas de mostrar video......................................................240 12.2.2 Elemento img........................................................................240 12.2.3 Incrustar videos................. ................................ ................... 240 12.2.4 Videos como objetos ActiveX................................................241 12.2.5 Objetos ActiveX en Netscape Navigator .............................. 242 12.2.6 Versiones de Windows Media Player...................................242

12.3 A NIMAR PÁGINAS WEB ...................................................... 243 12.3.1 Formas de mostrar animaciones..........................................243 12.3.2 Animar Texto ............................ ................................ ............ 243 12.3.3 Animar gráficos sencillos....... ................................. ............. 244 12.3.4 Mostrar animaciones como objetos o plugins...................... 245 12.3.5 Animar con secuencias de comandos de cliente ..................245 12.3.6 Animar con HTML+TIME.................................. .................. 246 12.3.7 Uso de HTML+TIME.......... ............................... .................. 246 12.3.8 Crear líneas de tiempo .........................................................247 12.3.9 Contenedores de tiempo ............................... ........................ 248 12.3.10 Animar atributos.................... ................................... ........... 249 12.3.11 Controlar audio, video y otros medios ................................ 249

12.4 R ESUMEN............................................................................ 250 12.5 PRÁCTICA: CREAR UNA APLICACIÓN MULTIMEDIA ........... 250

12.5.1 Ejercicio 1: Usar sonido y movimiento................................250 12.5.2 Ejercicio 2: Mostrar una presentación de diapositivas.......250

12.6 R EPASO ............................................................................... 251 13 DAR FORMATO A SALIDA DE APLICACIÓN

WEB..............................................................................253 13.1 HOJAS DE ESTILO EN CASCADA .......................................... 253

13.1.1 Cómo funcionan los estilos...................................................253 13.1.2 Usar hojas de estilo con formularios Web...........................254 13.1.3 Modificar estilos........................... ................................. ....... 254 13.1.4 Añadir estilos.......................... ................................ .............. 254 13.1.5 Usar clases de estilo.............................................................255 13.1.6 Crear estilos para elementos concretos...............................255 13.1.7 Crear estilos anidados..........................................................255 13.1.8 Cambiar la hoja de estilo en ejecución................................256 13.1.9 Comportamientos..................................................................257

13.2 TRANSFORMACIONES XSL................................................. 258 13.2.1 Cómo funcionan las transformaciones XSL.........................258 13.2.2 Crear un archivo XML .........................................................258 13.2.3 Crear un archivo XSL...........................................................259 13.2.4 Cambiar el diseño.................................................................260 13.2.5 Incluir otras plantillas..... .................................. ................... 260

13.2.6 Repetir tareas......................... .................................. .............261 13.2.7 Insertar enlaces y otros elementos HTML........ ....................262 13.2.8 Ordenar elementos................................................................263 13.2.9 Tareas condicionales.. .................................. ........................263

13.3 R ESUMEN ............................................................................264 13.4 LAB: CREAR EL LIBRO DE RECETAS....................................264

13.4.1 Ejercicio 1: Crear y anexar una hoja de estilo ........... .........264 13.4.2 Ejercicio 2: Proporcionar hojas de estilo alternativas........265 13.4.3 Ejercicio 3: Transformación XSL.........................................265 13.4.4 Ejercicio 4: Por si mismo .....................................................266

13.5 R EPASO ...............................................................................266 14 PROPORCIONAR AYUDA .................... ...................267

14.1 A ÑADIR AYUDA A APLICACIONES WEB..............................267 14.1.1 Etiquetas de ayuda (ToolTip)................................................267 14.1.2 Mostrar ayuda como formulario Web o HTML....................267 14.1.3 Mostrar ayuda HTML .................................. .........................268

14.2 HTML HELP WORKSHOP ...................................................269 14.2.1 Crear ayuda HTML...............................................................269 14.2.2 Opciones de proyecto............................................................270 14.2.3 Tablas de contenido... ................................... ........................270 14.2.4 Índice....................... ............................... ...............................272 14.2.5 Referencias cruzadas .............................. ..............................273 14.2.6 Búsqueda................. ................................. .............................274 14.2.7 Compilar y previsualizar ......................................................274

14.3 E NLAZAR AYUDA HTML CON FORMULARIOS WEB...........275 14.3.1 Mostrar el visor de ayuda HTML ................................. ........275 14.3.2 Mostrar ayuda HTML en el navegador................. ...............275 14.3.3 Ayuda sensible a contexto............. ................................ ........275

14.4 R ESUMEN ............................................................................276 14.5 LAB: CREAR Y USAR UN ARCHIVO DE AYUDA HTML........277 14.5.1 Ejercicio 1: Crear un proyecto de ayuda .............................277 14.5.2 Ejercicio 2: Activar contenidos, índice y búsqueda .............277 14.5.3 Ejercicio 3: Añadir palabras clave al índice.................... ....277 14.5.4 Ejercicio 4: Enlazar ayuda con un formulario Web.............278

14.6 R EPASO ...............................................................................278 15 GLOBALIZAR APLICACIONES WEB...................279

15.1 SELECCIONAR UN MÉTODO.................................................279 15.1.1 Formas de globalizar aplicaciones Web ..............................279 15.1.2 Detectar la cultura del usuario............................... ..............279 15.1.3 Redirigir a una aplicación específica de cultura..................280 15.1.4 Ajustar a la cultura actual en tiempo de ejecución ..............281 15.1.5 Ensamblados satélite.............................................................284

15.2 CREAR Y USAR ENSAMBLADOS SATÉLITE ..........................284 15.2.1 Cómo funcionan los ensamblados satélite............................284 15.2.2 Preparar los elementos HTML para recursos......................285 15.2.3 Crear archivos de recursos...................................................285 15.2.4 Cargar archivos de recursos ................................................286 15.2.5 Leer y configurar la cultura del interface de usuario ..........286 15.2.6 Mostrar cadenas de recurso .................................................287

15.3 TEMAS DE GLOBALIZACIÓN ................................................288 15.3.1 Temas de programación general .................................... ......288 15.3.2 Codificación de caracteres ............................... ....................288

15.4 R ESUMEN ............................................................................290 15.5 PRÁCTICA: CONVERSOR DE MONEDA .................................290

15.5.1 Ejercicio 1: Crear el formulario Web del conversor demoneda .................................................................................290

15.5.2 Ejercicio 2: Crear los archivos de recurso del interfacede usuario.............................................................................291

15.5.3 Ejercicio 3: Cargar recursos según la cultura.....................291 15.5.4 Ejercicio 4: Conversión dependiente de cultura ..................292

15.6 R EPASO ...............................................................................293 16 PREGUNTAS Y RESPUESTAS.................................295



MCAD/MCSD

4




5

1 Introducción a la programación WebEn este capítulo aprenderá sobre las aplicaciones Internet y las herramientas que usará para crearlas. Este ca-

pítulo introduce los conceptos y términos utilizados en el libro, incluyendo las cómo funcionan las aplicacionesWeb, las partes de una aplicación Web, cómo está organizado el marco de trabajo .NET y cómo usar el entorno de programación Visual Studio .NET. Las secciones de este capítulo proporcionarán un vistazo de alto nivel de concep-tos que se explicarán con más detalle en capítulos posteriores.

Para completar este capítulo necesitará:

• Tener instalado Visual Studio .NET• Acceso a Internet por medio de una red de área local, banda ancha o módem

1.1 Tipos de aplicacionesLas aplicaciones Web son uno de los cuatro tipos de aplicaciones Internet que puede crear usando Visual

Studio .NET y ASP.NET. En esta lección aprenderá un poco sobre los diferentes tipos de aplicaciones Internet yverá como funciona una aplicación Web.

1.1.1 ¿Qué puede crear?Hablando estrictamente, una aplicación Internet es cualquier aplicación que usa Internet de cualquier forma.

Esto significa que aplicaciones que piden a los usuarios que se registren en Internet o que proporcionen ayuda enInternet son, en cierto grado, aplicaciones Internet.

Esta definición es demasiado amplia para ser el tema de un solo libro. Para centrar un poco el tema vamos aidentificar cuatro tipos de aplicaciones Internet:

• Aplicaciones Web. Proporcionan contenido desde un servidor a máquinas cliente en Internet. Los usuariosven la aplicación Web a través de un navegador.

• Servicios Web. Estos componentes proporcionan servicios de procesamiento desde un servidor a otras apli-caciones en Internet.

• Aplicaciones preparadas para Internet. Son aplicaciones independientes que incorporan aspectos de Inter-net para proporcionar registro en línea, ayuda, actualizaciones u otros servicios.

• Aplicaciones de igual a igual. Son aplicaciones independientes que usan Internet para comunicarse conotros usuarios que ejecutan sus propias instancias de la aplicación.

Puede usar Visual Studio.NET para crear todos estos tipos de aplicaciones. El primer tipo, aplicaciones Web,es el tema de este libro.

1.1.2 Cómo funcionan las aplicaciones WebLas aplicaciones Web usan una arquitectura cliente-servidor. La aplicación Web reside en un servidor y res-

ponde a las peticiones de múltiples clientes a través de Internet.

En el lado cliente, la aplicación Web es alojada por un navegador. El interface de usuario de la aplicacióntoma la forma de páginas HTML interpretadas y mostradas por el navegador cliente.

En el lado servidor la aplicación corre bajo Microsoft IIS. IIS administra la aplicación, pasa peticiones de losclientes a la aplicación, y devuelve las respuestas de la aplicación a los clientes. Estas peticiones y respuestas se pasan sobre Internet usando el protocolo HTTP. Un protocolo es un conjunto de reglas que describe cómo se comu-nican dos o más elementos sobre un medio, como Internet.

La aplicación Web compone las respuestas a las peticiones a partir de recursos encontrados en el servidor.Estos recursos incluyen el código ejecutable en ejecución en el servidor (lo que tradicionalmente denominamos“aplicación” en programación Windows), formularios Web, páginas HTML, archivos de imagen y otros medios quecomponen el contenido de la aplicación.

Las aplicaciones son muy similares a los sitios Web tradicionales, salvo que ejecutan el contenido presentadoal usuario en realidad lo compone dinámicamente un ejecutable, en lugar de servirlos a partir de una página estáticaalmacenada en el servidor.

La parte ejecutable de la aplicación Web permite hacer muchas cosas que no se pueden hacer con un sitioWeb estático, como:

• Reunir información del usuario y almacenarla en el servidor • Realizar tareas para el usuario, como hacer un pedido de un producto, realizar cálculos complejos o recuperar

información de una base de datos.• Identificar a un usuario concreto y mostrar un interface personalizado para él.• Presentar contenido altamente volátil, como inventario, pedidos pendientes e información de envíos.



MCAD/MCSD

6

Esta es solo una lista parcial. Básicamente, puede hacer con una aplicación Web todo lo que imagine hacer con una aplicación cliente/servidor. Lo que hace especial a una aplicación Web es que la interacción cliente/servidor tiene lugar sobre Internet.

1.1.3 Lo que proporciona ASP.NETASP.NET es la plataforma que se usa para crear aplicaciones Web y servicios Web que se ejecutan bajo IIS.

ASP.NET no es la única forma de crear una aplicación Web. Otras tecnologías, notablemente CGI, también permi-ten crear aplicaciones Web. Lo que hace especial a ASP.NET es su estrecha integración con el servidor Microsoft,

programación, acceso a datos y herramientas de seguridad.

ASP.NET proporciona un alto nivel de coherencia en el desarrollo de aplicaciones Web. En cierto sentido essimilar al nivel de coherencia que proporciona Microsoft Office al desarrollo de aplicaciones de sobremesa.ASP.NET es parte del marco de trabajo .NET y se compone de varios componentes diferentes.

• Herramientas de desarrollo Web Visual Studio .NET: Incluye las herramientas visuales para diseño de páginas Web y plantillas de aplicación, gestión de proyectos y herramientas de despliegue para aplicacionesWeb.

• Espacios de nombres System.Web: Son parte del marco de trabajo .NET e incluye las clases que se ocupande temas específicos de Web como peticiones y respuestas HTTP, navegadores y correo electrónico.

• Controles de servidor y HTML: Son los componentes de interface de usuario que se usan para obtener in-formación de y proporcionar respuestas a los usuarios.

Además de los componentes anteriores, ASP.NET también usa los siguientes componentes de programacióny herramientas Windows más generales. Estos elementos no son parte de ASP.NET, pero son claves para la progra-mación ASP.NET.

• Servicios de Información Internet (IIS) de Microsoft: Como se mencionó en la sección anterior, IIS alojalas aplicaciones Web en un servidor Windows.

• Lenguajes de programación Visual Basic .NET, Visual C# y JScript: Estos tres lenguajes tienen soporteintegrado en Visual Studio .NET para crear aplicaciones Web.

• El marco de trabajo .NET: Es el conjunto completo de clases de programación Windows; incluyen las cla-ses ASP.NET así como clases para otras tareas como acceso a archivos, conversión de tipos de datos, mani- pulación de arrays y cadenas, etc.

• Clases y herramientas ADO.NET para bases de datos: Estos componentes proporcionan acceso a bases dedatos SQL Server y ODBC. El acceso a datos a menudo es un componente clave de las aplicaciones Web.

• Centro de Pruebas de Aplicaciones (Application Center Text, ACT): Este componentes de Visual Studio.NET proporciona una forma automatizada para hacer pruebas de stress a aplicaciones Web.

ASP.NET es la plataforma más completa para desarrollar aplicaciones Web que corren bajo IIS. Sin embar-go, es importante recordar que ASP.NET no es independiente de plataforma. Como está alojado en IIS, ASP.NETdebe correr en servidores Windows. Para crear aplicaciones Web que corran en servidores que no sean Win-dows/IIS, debe usar otras herramientas – por lo general CGI.

1.1.4 Ventajas de ASP.NETASP.NET tiene muchas ventajas sobre otras sobre otras plataformas cuando se trata de crear aplicaciones

Web. Probablemente la más significativa sea su integración con el servidor y herramientas de programación Win-dows. Las aplicaciones Web creadas con ASP.NET son más fáciles de crear, depurar y desplegar porque todas estastareas se pueden realizar desde un solo entorno – Visual Studio.NET.

ASP.NET proporciona estas otras ventajas a los desarrolladores de aplicaciones Web:

• Las partes ejecutables de una aplicación Web están compiladas de modo que se ejecutan más deprisa que lassecuencias de comandos interpretadas.

• Actualizaciones sobre la marcha de aplicaciones Web desplegadas sin reiniciar el servidor.• Acceso al marco de trabajo .NET, que amplía el API de Windows.• Uso del ampliamente conocido lenguaje de programación Visual Basic, que se ha mejorado para que soporte

completamente la programación orientada a objetos.• Introducción del lenguaje C#, que proporciona una versión con tipos seguros y orientada a objetos de C.• Gestión de estado automática para los controles de una página Web (llamados controles de servidor) de

forma que se comportan de una manera más similar a los controles Windows.• Capacidad de crear nuevos controles de usuario a partir de los existentes.• Seguridad integrada mediante el servidor Windows u otros métodos de autorización/autenticación.• Integración con ADO.NET para proporcionar acceso a bases de datos y herramientas de diseño de base de

datos desde Visual Studio.NET• Soporte completo de XML, CSS y otros estándares Web nuevos y establecidos.




7

• Características integradas para caché de páginas Web solicitadas con frecuencia, localización de contenido para lenguajes concretos y detección de capacidades del navegador.

1.2 Uso de ASP.NETEn esta lección aprenderá cómo organiza ASP.NET una aplicación Web en partes y aprenderá las funciones y

nombres de estas partes. Se mostrarán los formularios Web, que son el elemento central del interface de usuario delas aplicaciones Web.

ASP.NET es parte de un marco de trabajo .NET mayor, de modo que esta lección también discutirá cómo es-tá organizado el marco de trabajo .NET y cómo corren las aplicaciones .NET a diferencia de de las aplicacionesWindows tradicionales que puede estar acostumbrado a usar.

Finalmente esta lección termina con una discusión de los lenguajes de programación que puede usar paracrear aplicaciones Web. ASP.NET no está ligado a ningún lenguaje de programación, y al final e esta lección seindican algunos otros lenguaje disponibles y se explican algunas de las diferencias principales entre los dos lenguajes tratados en este libro: Visual Basic .NET y C#.

1.2.1 Partes de una aplicación WebUna aplicación Web consta de tres partes: contenido, lógica del programa e información de configuración

Web. La tabla 1.1 resume estas partes y da ejemplos de donde residen en una aplicación Web ASP.NET:

Tabla 1. 1: Partes de una Aplicación Web ASP.NET

Parte Tipos de Archivos DescripciónContenido Formularios Web, HTML,

imágenes, audio, video, otrosdatos

Los archivos de contenido determinan la apariencia de una aplicación Web. Pue-den contener texto e imágenes estáticos así como elementos compuestos sobre lamarcha por la lógica del programa (como una consulta a una base de datos).

Lógica deprograma

Archivos ejecutables,secuencias de comandos

La lógica del programa determina cómo responde la aplicación a las acciones delusuario. Las aplicaciones Web ASP.NET tienen un archivo DLL que corre en elservidor, y también pueden incluir secuencias de comandos que corren en lamáquina cliente.

Configuración Archivo de configuraciónWeb, hojas de estilo,opciones IIS

Los archivos y opciones de configuración determinan cómo corre la aplicación enel servidor, quién tiene acceso, cómo se manejan los errores y otros detalles.

El formulario Web es el elemento clave de una aplicación Web. Un formulario Web es un cruce entre una

página Web ordinaria y un formulario Windows. Tiene el mismo aspecto y un comportamiento similar a una páginaHTML, pero también tiene controles que responden a sucesos y ejecutan código, como un formulario Windows.

En una aplicación Web terminada la parte ejecutable del formulario Web está almacenada en un ejecutableque corre en el servidor bajo el control de IIS. La parte de contenido del formulario Web reside en un directorio decontenido en el servidor Web.

Cuando un usuario navega a una página de formulario Web en su navegador se produce esta secuencia:

1. IIS arranca el ejecutable de la aplicación Web si no está ya en ejecución2. El ejecutable compone una respuesta al usuario en base al contenido de la página de formularios Web que ha

solicitado y a la lógica de programa que proporciona contenido dinámico.3. IIS devuelve la respuesta al usuario en forma de HTML.

Una vez que el usuario obtiene el formulario Web solicitado puede introducir datos, seleccionar opciones,

pulsar botones y usar cualquier control que aparezca en la página. Algunos controles, como los botones, hacen quela página se envíe de vuelta al servidor para procesar el suceso, y la secuencia se repite.

El ciclo de sucesos se describe en mayor detalle en el apartado 2.2, Crear Aplicaciones de Formulario Web.

1.2.2 Componentes de formulario WebLos formularios Web pueden contener varios tipos de componentes, como resume la tabla 1.2.

Tabla 1. 2: Componentes en un Formulario WebComponente Ejemplos DescripciónControles deServidor

TextBox, Label, Button, ListBox,DropDownList, DataGrid

Responden a sucesos de usuario ejecutando procedimientos en elservidor. Tienen características incorporadas para grabar datosintroducidos por el usuario entre presentaciones de la página. Seusan para definir el interface de usuario de un formulario Web.

Controles HTML Text Area, Table, Image, Submit Button,Reset Button Representan los elementos visuales estándar que proporcionaHTML. Son útiles cuando no se necesitan las características másavanzadas de los controles de servidor.



MCAD/MCSD

8

Componente Ejemplos DescripciónControles deDatos

SqlConnection, SqlCommand,OleDbConnection, OleDbCommand,DataSet

Proporcionan una forma para conectar con, ejecutar comandossobre y recuperar datos desde bases de datos SQL y OLE y archi-vos de datos XML.

Componentes deSistema

FileSystemWatcher, EventLog,

MessageQueue Proporcionan acceso a los diferentes sucesos a nivel de sistemaque se producen en el servidor.

Los controles de servidor y HTML se usan para crear el interface de usuario de un formulario Web. Los con-

troles de datos y componentes de sistema aparecen en el formulario Web solo en tiempo de diseño para proporcio-nar una forma visual para configurar sus propiedades y manejar sus sucesos. En tiempo de ejecución los controles dedatos y componentes de sistema no tienen representación visual.

El Capítulo 4, Crear un Interface de Usuario, proporciona mayor detalle sobre el uso de controles de servi-dor y HTML en un formulario Web.

1.2.3 Marco de trabajo .NETASP.NET es una parte importante del marco de trabajo .NET, pero es solo una parte. Comprender lo que

proporciona el marco de trabajo .NET le ayudará a programar su aplicación con eficacia y le evitará escribir nuevocódigo para realizar tareas que ya están implementadas dentro del marco de trabajo .NET.

Primero, un pequeño trasfondo. El marco de trabajo .NET es la nueva plataforma de programación de Micro-soft para desarrollar software Windows y Web. Se compone de dos partes:

• Un motor de ejecución llamado sistema de ejecución de lenguaje común (common language runtime, CLR).• Una librería de clases que proporciona funciones centrales de programación, como aquellas de las que ante-

riormente se disponía solo por medio del API Windows, y funciones a nivel de aplicación usadas para desa-rrollo Web (ASP.NET), acceso a datos (ADO.NET), seguridad y gestión remota.

Las aplicaciones .NET no se ejecutan de la misma formaque las aplicaciones tradicionales que puede estar acostumbradoa crear. En lugar de compilarse en un ejecutable que contienecódigo nativo, el código .NET se compila en lenguaje interme-dio de Microsoft (MSIL) y se almacena en un archivo llamadoun ensamblado. En tiempo de ejecución el ensamblado se compila a su estado final mediante el CLR. Durante la ejecución elCLR proporciona gestión de memoria, comprobaciones de segu-ridad de tipos y otras tareas de tiempo de ejecución para la apli-cación. La figura 1-1 muestra como funciona.

Las aplicaciones que se ejecutan bajo el CLR se denomi-nan código administrado porque el CLR se preocupa de mu-chas de las tareas que anteriormente tendría que realizar el eje-cutable de la aplicación. El código administrado resuelve el problema de registro y versiones de componentes en la progra-mación Windows (el infierno de las DLL), porque el ensambla-do contiene toda la información de versiones y tipos que necesi-ta el CLR para ejecutar la aplicación. El CLR maneja el registrodinámicamente en tiempo de ejecución, en lugar de estáticamen-te mediante el registro del sistema como se hace con las aplica-

ciones basadas en COM.La librería de clases .NET proporciona acceso a todas las características del CLR. La librería de clases .NET

está organizada en espacios de nombres. Cada espacio de nombres contiene un grupo de clases funcionalmente rela-cionadas. La tabla 1-3 resume los espacios de nombres .NET que son de más interés para los programadores deaplicaciones Web.

Tabla 1. 3: Resumen de la Librería de Clases del Marco de Trabajo .NETComponente Ejemplos DescripciónTipos Comunes System Todos los tipos de datos comunes, incluyendo cadenas,

arrays y tipos numéricos. Estas clases incluyen métodospara convertir tipos, manipular cadenas y arrays y tareasmatemáticas.

Acceso a Datos System.Data, System.Data.Common,

System.Data.OleDb, System.Data.SqlClient,System.Data.SqlTypes

Acceso a bases de datos. Estas clases incluyen métodos

para conectar con bases de datos, ejecutar comandos,recuperar datos y modificar datos.

Depurado System.Diagnostics Depurado y seguimiento de ejecución de aplicaciones

Fig. 1- 1: Cómo se Ejecuta una Aplicación.NET




9

Componente Ejemplos Descripción Acceso a Archivos

System.IO, System.IO.IsolatedStorage,System.DirectoryServices

Acceso al sistema de ficheros. Incluyen métodos para leery escribir archivos y obtener rutas y nombres de archivo.

ComunicacionesRed

System.NET, System.Net.Sockets Comunicación sobre Internet usando protocolos de bajonivel como TCP/IP. Estas clases se usan cuando se creanaplicaciones de igual a igual.

Seguridad System.Security, System.Security.Cryptography,

System.Security.Permissions,

System.Security.Policy, System.Web.Security

Proporcionan autenticación y autorización de usuarios yencriptación de datos.

AplicacionesWeb

System.Web, System.Web.Caching,

System.Web.Configuration,System.Web.Hosting, System.Web.Mail,System.Web.SessionState, System.Web.UI,System.Web.UI.Design,

System.Web.UI.WebControls,System.Web.UI.HtmlControls

Creación de aplicaciones cliente – servidor que corrensobre Internet. Son las clases principales usadas para crearaplicaciones ASP.NET.

Servicios Web System.Web.Services,System.Web.Services.Configuration,System.Web.Services.Description,

System.Web.Services.Discovery,System.Web.Services.Protocols

Crear y publicar componentes que se pueden usar sobreInternet. Son las clases centrales que se usan para crearservicios Web ASP.NET.

AplicacionesWindows

System.Windows.Forms,System.Windows.Forms.Design

Creación de aplicaciones usando componentes de interfacede usuario de Windows. Proporcionan formularios y contro-les Windows y la capacidad de crear controles propios.

Datos XML Sytem.XML, System.Xml.Schema,System.Xml.Serialization, System.Xml.Xpath,System.Xml.Xsl

Crear y acceder archivos XML.

Puesto que los espacios de nombres .NET organizan las clases por funciones, puede usarlos para localizar lasclases y miembros de clase que proporcionan las características del CLR que quiere utilizar. Por ejemplo, el espaciode nombres System es uno de los que se usan más normalmente porque contiene las clases para todos los tipos dedatos fundamentales. En cualquier momento en que declare una variable con un tipo numérico, de cadena o de array,está usando el espacio de nombres System.

Esta aproximación permite que el marco de trabajo .NET proporcione métodos integrados para convertir ti-

pos de datos y manipular cadenas y arrays. Por ejemplo, las siguientes líneas de código usan los métodos integradosde las clases String y Array para ordenar una lista.

Visual Basic .NET‘Declara e inicializa una cadenaDim strFruta As String = “naranjas manzanas melocotones kiwis nectarinas mangos”‘Declara un arrayDim arrFruta As String()‘Pone cada fruta en un elemento del arrayarrFruta = strFruta.Split(“ “)‘Ordena el arraySystem.Array.Sort(arrFruta)‘Pone el array ordenado en la cadenastrFruta = String.Join(“ “, arrFruta)

Visual C#//Declara e inicializa una cadenastring strFruta = “naranjas manzanas melocotones kiwis nectarinas mangos”;//Declara un arraystring[] arrFruta;//Pone cada fruta en un elemento del arrayarrFruta = strFruta.Split(“ “.ToCharArray());//Ordena el arraySystem.Array.Sort(arrFruta)//Pone el array ordenado en la cadenastrFruta = System.String.Join(“ “, arrFruta)

Muchos de los métodos de clase del espacio de nombres System se pueden usar directamente sin crear prime-ro un objeto a partir de la clase. Estos métodos se llaman miembros compartidos (shared) en Visual Basic .NET ymiembros estáticos (static) en Visual C#. Los miembros compartidos y estáticos se pueden llamar desde el propio

nombre de la clase, como en la línea System.Array.Sort del código anterior. Otro ejemplo de clase con miembroscompartidos/estáticos es la clase Math, como se muestra en los siguientes métodos Pi y Pow.



MCAD/MCSD

10

Visual Basic .NET‘Obtiene el área de un círculodblAreaCirculo = System.Math.Pi * System.Math.Pow(intRadio, 2)

Visual C#//Obtiene el área de un círculodblAreaCirculo = System.Math.Pi * System.Math.Pow(intRadio, 2);

1.2.4 Lenguajes de programaciónASP.NET e, indudablemente, todo el marco de trabajo .NET, son independientes del lenguaje de programa-

ción. Esto significa que puede elegir cualquier lenguaje que tenga implementado un compilador conforme al CLR.Además de desarrollar sus propios lenguajes de programación, Microsoft ha formado alianzas con muchos provee-dores de lenguajes para proporcionar soporte .NET para Perl, Pascal, Eiffel, Cobol, Python, Smalltalk y otros len-guajes de programación.

Este libro trata la creación de aplicaciones Web con los lenguajes de programación Visual Basic .NET y Vi-sual C#. Estos dos lenguajes son funcionalmente equivalentes, lo que significa que ambos proporcionan las mismascapacidades para crear aplicaciones Web. Las diferencias entre ambos lenguajes son de sintaxis y de estilo.

La mayoría de los programadores elegirán el lenguaje con el que estén familiarizados. Los programadores deVisual Basic estarán más cómodos desarrollando aplicaciones Web en Visual Basic .NET. Los programadores C oC++ estarán más cómodos con C#.

Si es nuevo en la programación o si está pensando ampliar sus habilidades de programación a nuevos lenguajes, aprender ambos lenguajes es un objetivo práctico. Esto es cierto en particular cuando se crean aplicaciones Web, puesto que la mayoría de las tareas se ejecutan por medio de clases del marco de trabajo .NET, lo que significa queel código Visual Basic .NET y C# son prácticamente idénticos.

La tabla 1.4 resume algunas diferencias significativas entre los dos lenguajes. Esta información es útil si estáeligiendo un lenguaje de programación por primera vez o si está pensando cambiar entre lenguajes.

Tabla 1. 4: Diferencias entre Visual Basic .NET y Visual C#Característica Visual Basic .NET Visual C# .NETDiferenciación demayúsculas

No diferencia mayúsculas

response.write(“Yo”) ‘correcto

Diferencia mayúsculas

response.write(“Yo”) //errorResponse.Write(“Yo”) //correcto

Bloques

funcionales

Utiliza sentencias de comienzo y final para delimitar

Sub Muestra(strX As String)Response.Write(strX)

End Sub

Utiliza llaves para delimitar

void Muestra(string strX){

Response.Write(strX)}

Conversión detipos

De forma predetermina se permite la conversiónimplícita:

Dim intX as IntegerintX = 3.14 ‘Permitido

Puede limitar las conversiones incluyendo unasentencia Option Strict On al inicio del módulo

Las conversiones de tipos se realizan explícitamentemediante moldeo:

int intX;intX = 3.14; // ErrorintX = (int)3.14 //Moldeo, correcto

O usando métodos de conversión de tipos

String strX;strX = intX.ToString();

Arrays Los elementos se especifican mediante paréntesisarrFruta(1) = “Manzana”

Los elementos se especifican usando corchetesarrFruta[1] = “Manzana”;

Métodos Puede omitir los paréntesis tras el nombre demétodo si no hay argumentos.

strX = objX.ToString

Hay que incluir los paréntesis tras todos los métodos

strX = objX.ToString();

Terminación desentencias

Las sentencias terminan por retorno de carro

Response.Write(“Hola”)

Las sentencias terminan con punto y coma

Response.Write(“Hola”);

Continuación desentencias

Las sentencias se continúan con un carácter desubrayado

intX = System.Math.Pi * _intRadio

Las sentencias continúan hasta el punto y coma ypueden abarcar todas las líneas necesarias

intX = System.Math.Pi *intRadio;




11

Característica Visual Basic .NET Visual C# .NETOperador decadena

Usa el ampersand (&) o el signo de suma (+) paraunir cadenas

strFruta = “Manzanas” & _“ Naranjas”

Utiliza el signo de suma (+) para unir cadenas

strFruta = “Manzanas” +“ Naranjas”;

Operadores decomparación

Utiliza =, >, <, >=, <=, <> para comparar valores

If intX > 5 Then

Utiliza ==, >, <, >=, <=, != para comparar valores

if(intX >= 5)

Negación Utiliza la palabra clave Not para expresar negaciónlógica

If Not IsPostBack Then

Usa el operador ! para expresar negación lógicaif(!IsPostBack)

Comparación deobjetos

Usa la palabra clave Is para comparar variablesobjeto,

If objX Is objY Then

Usa == para comparar variables objeto

if(objX == objY)

Existencia deobjetos

Usa la palabra clave Nothing o la función IsNothing para comprobar si existe un objeto.

If IsNothing(objX) Then

Usa la palabra clave null para comprobar si existe unobjeto.

if(objX == null)

Además de las diferencias que se ven en la tabla hay diferencias significativas en las palabras clave entre losdos lenguajes. Los ejemplos de código en este libro muestran estas diferencias.

1.3 Visual Studio.NETEl entorno de programación Visual Studio .NET presenta nuevos tipos de ventanas, nuevas formas de gestio-

nar estas ventanas y nueva integración de contenido Internet. Esta lección ofrece un recorrido de estas nuevas carac-terísticas, así como un vistazo a algunas de las características más antiguas de depurado y ayuda de Visual Studio.NET desde el punto de vista de la programación de aplicaciones Web.

Si ha programado con versiones anteriores de Visual Studio .NET y se salta esta lección tenga en cuenta queya no puede hacer cambios a una aplicación a la vez que depura sin reiniciar la aplicación. Esta característica deVisual Studio .NET, llamada edita-y-continúa, ya no está disponible en Visual Basic .NET o Visual C#.

1.3.1 Página de inicioCuando se arranca Visual Studio .NET lo primero que se ve es la página de inicio. La página de inicio con-

tiene varios paneles para hacer más fácil encontrar la información y ayudar a simplificar algunas tareas como abrir un archivo reciente.

El panel Proyectos muestra los cuatro proyectos más recientes en forma de enlaces. Para abrir uno de estos proyectos pulse sobre su nombre. Para crear un proyecto nuevo o abrir un proyecto existente no mostrado en la listade proyectos recientes pulse el botón correspondiente en este panel.

A la izquierda de la página de inicio hay una lista de temas que contienen información sobre Visual Studio.NET, otros productos de Microsoft, programación, alojamiento de sitios Web y otra información. Esta informaciónes dinámica, mucha de ella procedente de Internet. Esto asegura que esta información es actual; es una buena ideacomprobarla ocasionalmente para ver las últimas noticias.

De especial interés para los desarrolladores de aplicaciones Web es el panel Alojamiento Web. Este panel en-laza con sitios Web que pueden alojar sus aplicaciones ASP.NET en Internet.

Algunos de estos sitios, como Brinkster, ofrecen alojamiento gratuito limitado. Estos servicios de alojamientoson extremadamente útiles cuando se está aprendiendo ASP.NET ya que permiten compartir su trabajo con el mun-do sin el esfuerzo y el gasto de configurar su propio servidor Web.

El panel Mi Perfil permite configurar sus preferencias para Visual Studio .NET. Estas opciones le permitencambiar el diseño de ventanas, configurar el lenguaje de programación que use con más frecuencia, y determinar sila ayuda se muestra en los paneles de diseño de Visual Studio .NET o en una ventana como aplicación separada. Laventana de ayuda puede estar un poco sobrecargada cuando se muestra dentro de Visual Studio .NET, de modo quesalvo que tenga un monitor de 19 pulgadas es una buena idea seleccionar la opción Ayuda Externa.

1.3.2 Ventanas de Visual Studio .NETVisual Studio .NET tiene dos tipos de ventana: de documentos y de herramientas. Las ventanas de documen-

tos muestran el contenido de su aplicación: los formularios, páginas Web y código aparecen todos en las ventanas dedocumentos. Puede tener varias ventanas de documentos abiertas a la vez, y puede cambiar entre ellas pulsando suslengüetas cerca de la parte superior de la pantalla.

Las ventanas de herramientas muestran los componentes que se usan para crear la aplicación. Estos compo-nentes incluyen los controles, conexiones con bases de datos, clases y propiedades que se usan en el proyecto. Las



MCAD/MCSD

12

ventanas de herramientas se muestran a izquierda y derecha de las ventanas de documentos y se pueden mostrar yocultar pulsando sus lengüetas.

Para que una ventana de herramientas con lengüeta permanezca en pantalla pulse el icono Auto Ocultar en la parte superior derecha de la ventana, que tiene la imagen de una chincheta. Pulse de nuevo la chincheta para que laventana vuelva de nuevo a la presentación con lengüetas. Puede usar la presentación con lengüetas para ocultar lasventanas a ambos lados de la ventana de documentos para tener más espacio para editar el contenido de sus aplica-ciones.

La presentación con lengüetas para las ventanas es la opción predeterminada para Visual Studio .NET. Puededesactivar esta característica seleccionado Opciones en el menú Herramientas y seleccionando sus preferencias en elcuadro de diálogo.

1.3.3 Cuadro de herramientasEl cuadro de herramientas muestra los controles y componentes que se pueden añadir a una ventana de do-

cumento. El contenido del cuadro de herramientas cambia dependiendo del tipo de documento que se esté editando.Cuando se está editando un formulario Web, por ejemplo, el cuadro de herramientas muestra los controles de servi-dor, controles HTML, controles de datos y otros componentes que se pueden añadir a un formulario Web.

Los componentes en el cuadro de herramientas están categorizados. Cuando se pulsa sobre una categoría semuestran los elementos de la categoría. Puede recorrer los elementos del cuadro de herramientas pulsando las fle-chas de la parte superior e inferior de la lista de componentes.

Cuando el documento actual es código el cuadro de herramientas contiene solo el Anillo del Portapapeles. Elanillo del portapapeles registra los últimos 20 elementos que se han cortado o copiado, de modo que se pueden vol-ver a pegar en un documento.

Para pegar un elemento del anillo del portapapeles pulse y arrastre el elemento al lugar donde quiere insertar-lo. Cuando se mueve el puntero del ratón sobre un elemento Visual Studio lo expande para mostrar más del textoque contiene.

1.3.4 Editar documentos WebPuede editar formularios Web y documentos HTML visualmente usando las mismas técnicas de arrastrar y

soltar que se usan en formularios Windows, o como archivos de texto. Para cambiar entre los modos de edición pulse las lengüetas Diseño y HTML en la parte inferior de la ventana de documento.

Hay tareas que no es posible realizar visualmente, por lo que a menudo tendrá que editar documentos Webcomo texto. También puede ser más conveniente usar el modo HTML en lugar de las herramientas visuales si yaestá familiarizado con HTML. La tecnología IntelliSense de Visual Studio .NET proporciona ayuda para completar elementos HTML.

Puede volver al modo diseño para ver los cambios hechos en el modo HTML sencillamente pulsando la len-güeta Diseño en la parte inferior de la ventana de documentos.

1.3.5 Editar códigoLas páginas de formularios Web tienen archivos de código subyacente asociados. Estos archivos se crean au-

tomáticamente cuando se crea un nuevo formulario Web. Tienen el mismo nombre base que el formulario Web conla extensión .vb o .cs añadida tras la extensión .aspx.

Visual Studio .NET genera una definición de clase, procedimiento de inicialización y procedimiento de suce-

so Page_Load para cada archivo de código subyacente de un formulario Web. No debería cambiar el código de lasregiones marcadas Código Generado por el Diseñador Web Forms, porque este código puede ser modificado másadelante por Visual Studio .NET y sus cambios se podrían sobrescribir.

Puede ocultar el código generado pulsando el signo menos (-) a la izquierda de la directiva #Region. Al pul-sar el signo menos la región se colapsa en una sola línea y el signo menos cambia a más (+), que se puede pulsar para expandir la región de nuevo. Puede usar esta misma característica de esquematización para colapsar o expandir bloques de código como definiciones de clase y procedimientos.

El editor de código de Visual Studio .NET también proporciona el completado mediante IntelliSense para pa-labras clave y miembros de clase que se usen en código.

Si está programando en Visual Basic la característica de auto completar también corregirá la capitalizaciónde palabras clave y nombres de miembros cuando se complete una línea. Si está usando C# , Visual Studio .NET noreconocerá una palabra clave o nombre de miembro si no está correctamente capitalizado. Esto se debe a que VisualBasic .NET no diferencia mayúsculas y minúsculas y C# si.




13

El editor de código destaca los errores sintácticos y las variables no declaradas cuando se completa cada lí-nea. Estos errores se subrayan con una línea quebrada, y si se coloca el puntero sobre un error se muestra una des-cripción del error.

Puede activar y desactivar la mayoría de las opciones del editor de código mediante el cuadro de diálogo Op-ciones. También puede usar este cuadro de diálogo para cambiar el indentado automático, completado de bloques decódigo y otras opciones propias del lenguaje.

1.3.6 Explorador de solucionesVisual Studio .NET organiza las aplicaciones en proyectos y soluciones. Un proyecto es una colección de ar-

chivos que compondrán últimamente un único ejecutable. Una solución es un grupo de proyectos que componenuna única unidad funcional. Los archivos que componen una solución se ven usando el Explorador de Soluciones.

El proyecto que se muestra en negrita es el proyecto de inicio. El proyecto de inicio es el proyecto que seejecuta cuando se pulsa Iniciar. Cuando se están desarrollando varios proyectos como parte de una solución el pro-yecto de inicio normalmente llama a los otros proyectos de la solución.

La información sobre una solución se almacena en un archivo de solución (.sln), que de forma predeterminase coloca en la carpeta Mis Documentos. Puede abrir la solución usando este archivo o puede abrir directamente los proyectos usando sus archivos de proyecto (.vbproj o .csproj), que se encuentran en las carpetas de proyecto. Si seabre un archivo de proyecto Visual Studio .NET crea un nuevo archivo de solución cuando se guarda el proyecto.

1.3.7 Ejecutar un proyectoPuede ejecutar un proyecto dentro de Visual Studio .NET pulsando Iniciar en la barra de herramientas, selec-cionando Iniciar en el menú Depurar o pulsando F5. Cuando se ejecuta un proyecto Visual Studio .NET genera losarchivos del proyecto y muestra los errores que se produzcan en la ventana Lista de Tareas, en la parte inferior de laventana de documento.

Pulsando dos veces sobre la descripción del error en la lista de tareas se selecciona la línea donde está el error en la ventana de documento de modo que se puede corregir.

Si no se producen errores durante la generación Visual Studio .NET inicia la aplicación en modo de depura-ción y, en el caso de una aplicación Web, inicia Internet Explorer y muestra la página de inicio de la aplicación. Sise produce un error mientras se ejecuta la aplicación en modo de depurado, Visual Studio .NET muestra el error enel navegador.

En este punto tiene dos opciones:• Si sabe qué ha causado el error, puede detener la aplicación cerrando el navegador y volviendo a Visual Stu-

dio para corregirlo.• Si no está seguro de qué ha causado el error, puede pulsar Atrás en el navegador, cambiar a Visual Studio pa-

ra colocar un punto de interrupción en una posición en el código antes de que ocurra el error, y volver al na-vegador para repetir la tarea. Visual Studio detendrá la aplicación en el punto de interrupción de modo que se podrá recorrer el código paso a paso para localizar el origen del error.

Una vez localizado el error deberá detener la aplicación antes de poder corregirlo.

1.3.8 Establecer puntos de Interrupción e Inspeccionar VariablesPuede detener un proyecto en una línea de código concreta estableciendo un punto de interrupción. Cuando

Visual Studio .NET ejecuta el proyecto lo detiene y muestra la línea que contiene el punto de interrupción en el

editor de código antes de que se ejecute esta línea.Para establecer un punto de interrupción pulse en el margen gris a la izquierda donde quiere romper, o selec-

cione la línea y pulse F9. El punto de interrupción se representa mediante un círculo rojo en el margen gris a la iz-quierda de la línea.

Una vez que Visual Studio .NET se detiene en un punto de interrupción puede ver el valor de las variablesactivas colocando el puntero sobre la variable. Si la variable es de tipo complejo, como un objeto o un array, puedever sus datos añadiéndola a una ventana de Inspección.

Para añadir un elemento a una ventana de inspección seleccione el elemento y arrástrelo a la ventana de ins- pección. Pulse en el signo más junto al elemento en la ventana de inspección para ver sus subelementos, como ele-mentos del array o propiedades del objeto.

1.3.9 Ejecutar sentenciasTras detenerse en un punto de interrupción puede continuar la ejecución de la aplicación pulsando Continuar

en la barra de herramientas o pulsando F5. Puede ejecutar una línea cada vez pulsando F10 o F11.



MCAD/MCSD

14

F10 ejecuta cada llamada a procedimiento como una sentencia única. En otras palabras, paso a paso sobre elprocedimiento, ejecutándolo y deteniéndose en la siguiente línea del procedimiento actual. F11 ejecuta las llamadaspaso a paso por instrucciones, entrando dentro del procedimiento y deteniéndose en su primera línea. Para ejecutar una única línea de código fuera del contexto del proyecto escriba el código en la ventana de comando. Los resulta-dos de las sentencias escritas en la ventana de comando se dirigen a la siguiente línea de la ventana.

1.3.10 AyudaVisual Studio. NET contiene una colección combinada de ayuda para el entorno de programación, lenguajes,

marco de trabajo .NET, soporte técnico y artículos de la red del desarrollador. La ayuda se muestra en una ventanade documento o fuera de Visual Studio en una ventana separada, dependiendo de las preferencias configuradas en la página de inicio o en la caja de diálogo Opciones.

El sistema de ayuda incluye tres formas de localizar temas: la ventana Contenido, la ventana Índice y la ven-tana Buscar. Estas ventanas actúan como caja de herramientas, se pueden “acoplar” y después ocultar o mostrar usando lengüetas.

Cada una de las ventanas de navegación proporciona una lista desplegable Filtrado por: que le permite selec-cionar un lenguaje de programación o tema concreto en el que buscar. Esta característica es especialmente útil en lasventanas Buscar e Índice porque la colección de ayuda combinada es muy amplia. Los filtros Visual Basic y TemasRelacionados y Visual C# y Temas Relacionados incluyen la mayoría de los temas necesarios en este libro.

Los temas que incluyen ejemplos sintácticos o de código tienen en la parte superior de cada página un icono

de filtro de lenguaje que parece un embudo. Pulse sobre el icono para cambiar el lenguaje de programación mostra-do en el tema o ver los ejemplos para todos los lenguajes.

Además de la ayuda incluida con Visual Studio .NET Microsoft aloja el sitio Web GotDotNet enwww.gotdotnet.com. Este sitio Web incluye tutoriales sobre el uso de ASP.NET y enlaces con muchos otros sitiosWeb relacionados.

1.4 Resumen• Hay cuatro tipos de aplicaciones Internet: las aplicaciones Web, servicios Web, aplicaciones adaptadas para

Internet y aplicaciones igual a igual.• Las aplicaciones Web corren en un servidor, procesando peticiones de usuario para páginas y componen estas

páginas usando código ejecutable y recursos estáticos en el servidor.• Las aplicaciones Web pueden proporcionar contenido dinámico en base a recursos dinámicos del servidor,

como una base de datos, y en base a entradas del usuario, como la creación de una tabla de amortización dehipoteca a partir de información del usuario.• ASP.NET es una plataforma para crear aplicaciones Web que se ejecutan sobre servidores Windows usando

IIS y el marco de trabajo .NET.• Las aplicaciones Web se componen de contenido, un ejecutable y archivos de configuración.• El contenido de una aplicación Web se muestra mediante formularios Web. Los formularios Web usan com-

ponentes HTML como páginas HTML convencionales; sin embargo, como los formularios Windows, puedenresponder a sucesos de usuario como pulsaciones de ratón.

• El ejecutable de una aplicación Web se almacena en un archivo dll llamado ensamblado. Los ensamblados secompilan en un estado intermedio, y la compilación final la hace el CLR justo antes de ejecutar la aplicación.

• El marco de trabajo .NET lo componen el CLR y la librería de clases .NET. La librería de clases .NET haceque las tareas de tiempo de ejecución del CLR estén disponibles para los programadores.

• Las clases .NET están agrupadas en espacios de nombres por tareas de programación. Estos agrupamientos le

ayudan a localizar la clase, método o propiedad que necesita para cumplir una tarea.• Use la página de inicio de Visual Studio .NET para ver información actual del producto, para abrir proyectos

nuevos o existentes, configurar preferencias de entorno y registrarse en servicios de alojamiento Web.• Edite páginas de formulario Web y HTML visualmente usando el modo de Diseño de la ventana de docu-

mentos; edítelas como texto usando el modo HTML de la misma ventana.• Configure el filtro de lenguaje de la ayuda para ver los ejemplos de código en un único lenguaje de progra-

mación o en varios.• Modifique las características del entorno Visual Studio .NET usando la caja de diálogo Opciones.

1.5 Práctica: comienzo con Visual Studio .NETEn esta práctica se familiarizará con el entorno de programación Visual Studio .NET, se registrará en un alo-

jamiento de aplicaciones Web y verá los tutoriales rápidos de ASP.NET. Estos ejercicios establecen una base para

las habilidades específicas de programación que aprenderá en los siguientes capítulos.




15

1.5.1 Personalizar el Marco de Trabajo .NETEn este ejercicio personalizará la presentación de ventanas en Visual Studio .NET para maximizar el área de

diseño. También cambiará las opciones para ver la ayuda en una ventana externa, separada, y especificará un filtrode lenguaje en la ayuda.

Cuando se arranca Visual Studio .NET por primera vez el diseño de ventana predeterminado muestra las ven-tanas del Explorador de Servidores y del Cuadro de Herramientas como lengüetas en el lado izquierdo de la pantallay las ventanas del Explorador de Soluciones y de Propiedades en el lado derecho.

►Para maximizar el espacio de pantalla para edición de documentos Web y código Seleccione Ocultar Todo Automáticamente, o

Pulse Ocultar Automáticamente en la esquina superior derecha de las ventanas del Explorador de Solu-ciones y de Propiedades. El botón Ocultar Automáticamente tiene el aspecto de una chincheta.

Cuando se activa la opción de ocultar automáticamente la ventana desaparece cuando el puntero del ratón sa-le de ella. La ventana reaparece cuando el puntero se mueve sobre la lengüeta en el borde de la ventana.

Otra opción predeterminada de Visual Studio .NET es mostrar la ventana de ayuda dentro de una ventana dedocumento. La propia ayuda tiene unas cuantas ventanas, de modo que esta presentación de ventana dentro de ven-tana puede quedar un poco saturada.

►Para mostrar la ayuda en su propia ventana

1. En el menú Herramientas seleccione Opciones. Visual Studio .NET muestra el diálogo Opciones2. En la caja de diálogo Opciones pulse Ayuda en la carpeta Entorno. Visual Studio .NET muestra las op-ciones de ayuda.

3. Marque la opción Ayuda externa y pulse Aceptar.

Si experimenta con el diseño de ventanas de Visual Studio .NET y no le gustan los resultados puede restable-cer las opciones de ventana predeterminadas.

►Para restablecer las opciones de ventana predeterminadas1. En el menú Herramientas seleccione Opciones. Visual Studio .NET muestra el diálogo Opciones.2. En el cuadro de diálogo Opciones, carpeta Entorno, seleccione General.3. Pulse el botón Restablecer diseño de ventana. Visual Studio .NET muestra una advertencia pidiendo con-

firmación de que quiere restablecer el diseño de ventanas a su valor predeterminado.4. Pulse Aceptar para cerrar la advertencia y de nuevo para cerrar el cuadro de diálogo Opciones. Visual

Studio .NET restablece el diseño previo de las ventanas.

1.5.2 Configurar una cuenta de alojamiento WebEn este ejercicio va a configurar una cuenta de alojamiento Web que le permitirá desplegar aplicaciones Web

para prueba y evaluación públicas en Internet. No necesita tener una cuenta de alojamiento Web para completar laslecciones de este libro, puesto que puede ejecutar y depurar aplicaciones localmente. Sin embargo, tener una cuentade alojamiento Web le permite probar cómo gestiona su aplicación múltiples usuarios simultáneos y también le permite compartir sus logros en programación con otros, una buena diversión.

►Para configurar el alojamiento Web1. Seleccione un proveedor de servicio de alojamiento2. Regístrese con el servicio3. Conecte con el servicio y suba la información

4. Para mostrar el panel Alojamiento Web en Visual Studio .NET seleccione la ventana de documento de la página de inicio y pulse la lengüeta Alojamiento Web.

Las siguientes secciones describen con más detalle los pasos para configurar una cuenta de alojamiento Web.

1.5.3 Elegir un proveedor de servicioEl panel de alojamiento Web recoge una serie de proveedores de servicio de alojamiento que soportan aplica-

ciones ASP.NET. Cada uno de estos proveedores ofrece una combinación diferente de servicios gratuitos y de pago.Para evaluar cuál de estos proveedores es el que le conviene visite su página Web pulsando sobre su enlace en la página de inicio de Visual Studio. Además del coste debe considerar:

• Nivel de Asistencia: ¿Proporciona un foro de usuarios u otro área donde se pueda responder a sus pregun-tas?. Si lo hace, compruebe lo que dicen otros usuarios.

• Capacidad para Migrar: ¿Podrá pasar con facilidad las aplicaciones de la etapa de pruebas a despliegue

completo? ¿Proporciona el servicio de alojamiento el almacenamiento y prestaciones que necesita?• Soporte de Base de Datos: La mayor parte de servicios proporcionan alojamiento de Base de Datos, pero

cada uno cobra una tarifa diferente por este servicio.



MCAD/MCSD

16

►Para registrarse con un proveedor de servicioNota: Regístrese con el servicio para crear su propia cuenta. El procedimiento exacto varía para cada

proveedor, pero todos siguen estos pasos básicos.

1. En el panel de alojamiento Web pulse el enlace pulse el enlace Registrar Con del proveedor de servicioque ha elegido. Visual Studio .NET muestra el procedimiento de registro en una ventana de documento.

2. Siga las instrucciones del proveedor de servicio, que normalmente pedirá información de nombre, direc-ción y correo electrónico. Cuando la información esté completa el proveedor de servicio le enviará por

correo electrónico una contraseña para proporcionar acceso a la nieva cuenta.Los proveedores de servicio mostrados en el panel de alojamiento Web proporcionan alojamiento en un paso,

lo que significa que puede subir sus aplicaciones completas directamente desde el panel de alojamiento Web deVisual Studio.

►Para subir una aplicación al servicio de alojamiento1. Desde el panel de alojamiento Web de Visual Studio .NET pulse el enlace Subir Directamente a su Cuen-

ta en el proveedor de servicio con el que se haya registrado. Visual Studio .NET muestra la página de co-nexión del servicio en una ventana de documento.

2. En la página de conexión, escriba el nombre de usuario y contraseña para su cuenta (normalmente se laenviarán por correo electrónico). Una vez conectado, el proveedor de servicio mostrará una página de subida en una ventana de documento.

3. En la lista de la izquierda, seleccione la carpeta que contiene la aplicación a subir. En la lista de la dere-

cha, seleccione una carpeta del servidor a la que subir la aplicación. Pulse Subir para subir el proyecto alalojamiento Web.

Tras subir la aplicación, Vd. y otros pueden verla navegando a su situación en Internet. Los proveedores dealojamiento de servicio Web no piden que los usuarios se registren para ver una aplicación, solo para subirla.

1.5.4 Explorar los tutoriales rápidos de ASP.NETEn este ejercicio va a instalar los tutoriales rápidos del SDK de .NET y verá los tutoriales rápidos para

ASP.NET. Los tutoriales rápidos contienen información sobre los diferentes aspectos del marco de trabajo .NET yson uno de los mejores recursos para aprended a programar usando ASP.NET.

►Para instalar y ver los tutoriales rápidos1. En el menú de Inicio de Windows seleccione Programas, Microsoft .NET Framework SDK, Ejemplos y

Tutoriales. Windows muestra la página de instalación de Tutoriales rápidos, tutoriales y ejemplos de Mi-

crosoft Framework SDK.2. Pulse el paso 1 para instalar las bases de datos utilizadas en los ejemplos de los tutoriales.3. Pulse el paso 2 para instalar y configurar los sitios Web usados en los ejemplos de los tutoriales.4. La siguiente vez que acceda a los tutoriales rápidos Internet Explorer se saltará la página de instalación y

le llevará directamente a la página tutoriales rápidos, tutoriales y ejemplos5. Pulse el enlace Tutorial Rápido ASP.NET para ver la página del tutorial.

La página del tutorial rápido de ASP.NET muestra cómo realizar diferentes tareas de programación en VisualBasic .NET, Visual C# y JScript. Presenta los formularios Web en modo HTML en lugar de modo Diseño, comohace este libro en gran medida.

1.6 RepasoLas siguientes preguntas están pensadas para reforzar información clave mostrada en este capítulo. Si no es

capaz de contestar a una pregunta repase la lección correspondiente e intente de nuevo. Las respuestas se puedenencontrar en el capítulo 16.

1. De tres ejemplos de en que se diferencia una aplicación Web de una aplicación Windows tradicional.

2. ¿Cuáles son las dos partes del marco de trabajo .NET?

3. ¿Cómo se restablecen las opciones de ventana predeterminadas en Visual Studio .NET?

4. ¿Por qué no completa automáticamente el editor de código la siguiente línea de código parcial (sólo usuariosde Visual C#)?int intX = system.math

5. ¿Cuándo no puede usar ASP.NET para crear una aplicación?




17

2 Aplicaciones de Formulario WebEn este capítulo aprenderá cómo crear una aplicación Web usando Microsoft Visual Studio .NET y

ASP.NET. Aprenderá cómo iniciar un nuevo proyecto, crear un interface de usuario básico, escribir código pararesponder a sucesos y preservar datos dentro de la aplicación. Como ASP.NET está integrado con los servicios deinformación Internet (IIS) de Microsoft, también aprenderá cómo usarlo para organizar su aplicación Web.

Antes de completar las lecciones deberá:

• Haber instalado Visual Studio .NET, IIS y las extensiones de servidor de FrontPage en su ordenador.• Estar familiarizado con los aspectos básicos de uso de Visual Studio .NET, incluyendo cómo añadir controles

a un formulario Windows, cómo añadir código a controles, y como ejecutar una aplicación dentro de VisualStudio .NET. Puede ver instrucciones para estas tareas en los tutoriales rápidos.

2.1 Crear un proyecto de aplicación WebLos formularios Web son objetos de aplicación que definen el interface de usuario de su aplicación Web. El

texto y controles que se colocan en un formulario Web determinan lo que ve un usuario cuando ejecuta la aplica-ción. En este aspecto los formularios Web son similares a una aplicación Windows.

A diferencia de las aplicaciones Windows, sin embargo, las aplicaciones Web corren en un servidor y se dis-tribuyen a los clientes sobre Internet. Sin embargo, la forma en que se crea y organiza un proyecto de aplicaciónWeb tiene diferencias significativas frente al trabajo con aplicaciones Windows en Visual Studio .NET. Estas dife-

rencias se explican en la siguiente sección.2.1.1 Crear una nueva aplicación Web

El primer paso en la creación de una aplicación de formularios Web es comenzar un nuevo proyecto. VisualStudio .NET proporciona plantillas para cada tipo de aplicación que puede crear. La plantilla para una nueva aplica-ción Web se denomina Aplicación Web ASP.NET. Cuando crea un nuevo proyecto creando esta plantilla VisualStudio .NET crea un archivo de proyecto, un formulario Web en blanco y otros archivos de apoyo usados por laaplicación.

Para crear una aplicación Web desde Visual Studio .NET siga estos pasos:

1. En la página de inicio de Visual Studio .NET pulse Nuevo Proyecto. Visual Studio .NET muestra la caja dediálogo Nuevo Proyecto. Visual Studio .NET pone las aplicaciones Web en el directorio virtual localhost.

2. En la caja de diálogo Nuevo Proyecto seleccione la plantilla Aplicación Web ASP.NET, escriba el nombre

del nuevo proyecto en la caja de texto Ubicación y pulse Aceptar Cuando se crea un proyecto de aplicación Web en Visual Studio .NET el entorno de programación crea una

nueva carpeta y genera un conjunto de archivos para el proyecto. Visual Studio .NET da a la carpeta el mismo nombre del proyecto y la pone en el directorio raíz del sitio Web predeterminado que aloja IIS en su ordenador. Estaubicación se muestra se muestra en la caja de texto Ubicación de la caja de diálogo Nuevo Proyecto comohttp://localhost/nombreproyecto.

2.1.2 Organizar su proyecto con IISEs importante tener en cuenta que las aplicaciones Web solo pueden existir en una ubicación que IIS ha pu-

blicado como directorio virtual. Un directorio virtual es un recurso compartido identificado por un alias que repre-senta una situación física en un servidor. Si intenta seleccionar una carpeta física como C:\MisArchivos en el cuadrode diálogo Nuevo Proyecto Visual Studio .NET desactiva el botón Aceptar. No se puede crear una aplicación Web

aquí.La carpeta virtual //localhost es la carpeta raíz Web en su ordenador. IIS determina la ubicación física de su

carpeta raíz Web local. De forma predeterminada IIS la instala en su disco de arranque en \Inetpub\wwwroot. Enlugar de usar esta opción predeterminada y dejar que se sature con proyectos de ejemplo, código de producción yotros estorbos organice sus proyectos creando carpetas separadas para ejemplos, pruebas y código de producción.Comparta estas carpetas en la Web antes de crear nuevos proyectos. Recuerde que Visual Studio .NET crea unanueva carpeta para cada nuevo proyecto, de modo que cree solo las carpetas para organizar los tipos de proyectosque va a crear.

2.1.3 Crear directorios virtuales para aplicaciones WebUse IIS para crear nuevos directorios virtuales y para administrar los sitos Web alojados en su ordenador.

Crear un directorio virtual para usar con Visual Studio .NET precisa dos tareas principales:

• Crear el directorio virtual: Los directorios virtuales especifican donde se almacenan físicamente los pro-yectos, de modo que úselos para ayudar a organizar sus proyectos durante el desarrollo.



MCAD/MCSD

18

• Añadir las Extensiones FrontPage al directorio virtual para crear una subweb . Una subweb es simple-mente un directorio virtual que contiene un sitio Web. Al añadir las Extensiones FrontPage a un directoriovirtual se permite que Visual Studio .NET cree y mantenga las aplicaciones Web en este directorio.

Para añadir un directorio virtual en IIS siga estos pasos.

1. Pulse con el botón derecho sobre el icono Sitio Web Predeterminado en IIS y en el menú Nuevo pulse Di-rectorio Virtual.

2. IIS inicia el asistente de creación de nuevo directorio virtual para guiarle. Puse Siguiente en la página de

título del asistente para ver la página Alias del directorio virtual.3. Escriba un alias para la capeta. El alias es el nombre que usará para identificar el recurso en esta carpeta.

En Visual Studio .NET este es el nombre que usará para especificar la ubicación de su proyecto. Pulse Si-guiente. El asistente mostrará la página Directorio de contenido del sitio Web.

4. Escriba la ruta del directorio físico asociado con el directorio virtual. Este el directorio base donde se al-macenarán los archivos del proyecto. Pulse Siguiente; el asistente muestra la página Permisos de acceso.

5. Mantenga los permisos predeterminados (Lectura y Ejecutar secuencias de comandos). Pulse Siguiente yFinalizar para crear el directorio virtual y terminar el asistente.

Crear una SubwebPara añadir las extensiones FrontPage a un directorio virtual:

1. Pulse con el botón derecho en el icono localhost en IIS y seleccione Nuevo Æ Web de Extensiones deServidor

2. IIS inicia el asistente para nuevo subweb para guiarle a la hora de añadir las extensiones FrontPage a sudirectorio virtual. Pulse siguiente en la pantalla de título del asistente para mostrar la página Nombre desubweb.

3. Escriba el nombre del directorio virtual en la caja de texto Nombre de directorio. Este nombre correspon-de al alias que se introdujo en el paso 3 del procedimiento anterior. Escriba una descripción para el direc-torio en la caja de texto Título, o déjela en blanco. Pulse Siguiente. El asistente muestra la página Controlde acceso.

4. Acepte las opciones predeterminadas de control de acceso pulsando siguiente, y pulse finalizar para crear la nueva subweb.

Crear un nuevo proyecto en el directorio virtualDespués de crear un nuevo directorio virtual y añadirle las extensiones de servidor puede usarlo desde Vi-

sual Studio .NET para crear nuevos proyectos. Para crear un proyecto de aplicación Web en su nuevo directorio

virtual seleccione Nuevo Proyecto en el menú Archivo y especifique el nombre del directorio virtual en la cajade diálogo Nuevo Proyecto.

La ubicación especificada en la caja de diálogo tiene la forma http://nombreservidor/directoriovirtual. Elnombre de servidor localhost indica que el servidor corre en la máquina de desarrollo. El nombre directoriovir-tual es el alias que se creó para el directorio virtual en las tareas anteriores.

2.1.4 Añadir controles y escribir códigoCuando Visual Studio .NET crea una aplicación muestra un nuevo formulario Web en la ventana central.

Arrastre controles desde la caja de herramientas al formulario Web como haría con un formulario Windows.

Para añadir código que responda a sucesos en el formulario Web pulse dos veces sobre el control. VisualStudio .NET. muestra la ventana Código. Añada su código al procedimiento de suceso que se proporciona para elcontrol. Por ejemplo, el siguiente código muestra “¡Hola Web!” en Internet Explorer cuando se pulsa un botón:

Visual Basic .NETPrivate Sub Button1_Click(ByVal sender as System.Object, _

ByVal e as System.EventArgs) Handles Button1.ClickResponse.Write(“¡Hola Web!<br>!)

End Sub

Visual C#private void Button1_Click(object sender, System.EventArgs e){

Response.Write(“¡Hola Web!<br>”);}

Para ejecutar la aplicación pulse F5. Visual Studio .NET genera la aplicación y muestra la página en el nave-gador. Cuando se pulsa Button1 el navegador muestra “¡Hola Web!”. Al cerrar el navegador termina la aplicación.

Como puede ver en este ejemplo las aplicaciones de formularios Web son similares a las aplicaciones deWindows. Sin embargo, las aplicaciones de formularios Web tienen las siguientes diferencias significativas:

• Herramientas. Los formularios Web no pueden usar controles Windows estándar. En su lugar usan controlesde servidor, controles HTML, controles de usuario o controles creados especialmente para formularios Web.




19

• Interface de usuario. La apariencia de un formulario Web la determina el navegador en el que se muestra.Diferentes navegadores (y versiones diferentes del mismo navegador) soportan diferentes características deHTML, lo que puede cambiar el aspecto y el comportamiento de sus formularios Web. Pero no se alarmedemasiado, los controles web manejan la mayor parte de estas diferencias de forma elegante, como verá en elcapítulo 4, Crear un Interface de Usuario.

• Tiempo de vida. Los formularios Windows se instancian, existen durante el tiempo necesario y se destruyen.Los formularios Web parecen comportarse de esta misma forma, pero de hecho se instancian, se envían alnavegador y se destruyen inmediatamente. Esto significa que todas las variables y objetos declarados en un

formulario Web se destruyen tan pronto como se muestra el formulario. Para poder hacer algo interesante ne-cesita guardar información en objetos especiales de estado que proporciona ASP.NET. Verá más sobre obje-tos de estado en el capítulo 3, Trabajar con Objetos Web.

• Ejecución. Las partes ejecutables de una aplicación Web residen en un servidor Web. De esta forma, lasaplicaciones Web son de algún modo la aplicación cliente/Servidor definitiva: el único software instalado enel lado cliente es el navegador, y todo el interface de usuario y lógica de negocios corren en el servidor. Todala comunicación entre el cliente y el servidor se producen mediante HTML. Esto significa que incluso lasaplicaciones Web sofisticadas representan un riesgo de seguridad escaso para el cliente y por tanto pasan através de los firewall sin problemas. La estructura física de una aplicación Web y donde se produce el proce-samiento se explican en el apartado 3 de este capítulo.

2.1.5 Archivos de un proyecto de formulario WebEl formulario Web es solo uno de los once archivos que genera Visual Studio .NET cuando crea un nuevo

proyecto de formulario Web. La tabla 2-1 describe el cometido de cada uno de estos archivos. Visual Studio .NETcrea estos archivos para cada nuevo proyecto. Solo los archivos en negrita se ven en el explorador de soluciones.

Tabla 2. 1: Archivos de proyecto Web FormsNombre de Archivo Contiene

AssemblyInfo, AssembyInfo.csvb

Todas las opciones de generación del proyecto, incluyendo versión, nombre de la compañía,GUID, opciones del compilador, etc.

Global.asax Sucesos globales que se producen en la aplicación Web, como al iniciar o detener la aplicación.Solo puede haber uno por proyecto y debe estar en el directorio raíz del mismo.

Global.asax.vb, Global.asax.cs Código utilizado en Global.asax. Este archivo no se muestra en el explorador de soluciones.

Styles.css Definiciones de estilos para utilizar en el HTML generado por el proyecto

Web.config Opciones que utiliza el servidor Web cuando procesa este proyecto. Estas opciones determinancómo se informa de los errores, qué tipo de identificación de usuario utilizar, etc. Solo puedehaber uno por proyecto y se encuentra en la raíz del mismo.

Nombreproyecto.disco Descripción de servicios Web que proporciona este proyecto

WebForm1.aspx Descripción visual de un formulario Web.

WebForm1.aspx.vb,WebForm1.aspx.cs

Código que responde a los sucesos en el formulario Web. De forma predeterminada, estearchivo no se muestra en el explorador de soluciones.

WebForm1.aspx.resx Recursos XML que utiliza el formulario Web. No se muestra en el explorador de soluciones.

Nombreproyecto.vbproj,Nombreproyecto.csproj

Archivo de proyecto que recoge los archivos y opciones usados en tiempo de diseño. No semuestra en el explorador de soluciones

Nombreproyecto .vbproj.webinfo,Nombreproyecto .csproj.webinfo

Preferencias Web para el proyecto en tiempo de diseño. No se muestra en el explorador desoluciones.

Además de los archivos de la tabla 2.1 los proyectos de aplicación Web pueden contener cualquier otro tipode archivo. Los tipos principales de archivos que se añadirán a un proyecto de aplicación Web se muestran en latabla 2.2. Los proyectos de aplicación Web a menudo incluirán estos diferentes tipos de archivos fuente:

Tabla 2. 2: Tipos de archivo para proyectos de Formulario WebExtensión Elemento de Proyecto Descripción

.asxp Formulario Web Cada formulario Web constituye una página Web ASP.NET. Las aplicaciones puedentener uno o más formularios Web. Los formularios Web tienen archivos de códigoasociados con la extensión .aspx.vb (Visual Basic) o .aspx.cs (Visual C#)

.htm Página HTML Las páginas Web que no tienen código de servidor aparecen como páginas HTML.

.vb o .cs Clase o módulo El código que define los objetos de la aplicación se almacena en clases

.ascx Control de usuario Los controles de usuario construidos a partir de otros formularios Web y controles deservidor en Visual Studio .NET

.xsd DataSet Crea un esquema XML con las clases DataSet .



MCAD/MCSD

20

2.1.6 Archivos en una aplicación WebCuando se genera un proyecto de formularios Web Visual Studio .NET compila todo el código fuente en un

ejecutable (DLL) y lo coloca en un directorio /bin. La parte visual de la aplicación permanece como archivos aspx yhtml, como se ve en la figura 2.1.

En la figura, cuando un navegador solicita la página deinicio (http://www.mysite.com/Hello.aspx) de la aplicación, IISarranca el ejecutable de la aplicación (Hello.dll) y genera una

respuesta. En este caso la respuesta consiste en mostrar la pági-na definida en Hello.dll. Si se produce un suceso, como la pul-sación del ratón, en la página, se envía de vuelta al servidor,donde es manejada por la DLL de la aplicación.

Los dos apartados siguientes tratan los detalles de manejo de los sucesos y donde se produce el procesamiento.

2.2 Responder a sucesosEn esta lección aprenderá sobre los sucesos en el ciclo de vida de una aplicación Web y en qué se diferencia

este ciclo de vida del de una aplicación Windows. Los sucesos de aplicación Web se producen a nivel aplicación, página y control de servidor. La secuencia de estos sucesos y cómo se ejecutan afecta a cómo se responde a ellos enel código.

2.2.1 Sucesos en el ciclo de vida de una aplicación WebUna aplicación Web vive mientras tiene sesiones activas, mientras que los formularios Web viven escasa-

mente un momento. La vida de una aplicación Web comienza cuando un navegador solicita su página de inicio. Eneste momento entra en acción el servidor Web, arrancando el ejecutable (DLL) que responde a la petición. El ejecu-table crea una instancia del formulario Web solicitado, genera el HTML para responder a la petición y envía la respuesta al navegador. Entonces destruye la instancia del formulario Web.

Cuando el navegador tiene el HTML generado el usuario puede escribir en cajas de texto, seleccionar boto-nes de opción y realizar otras tareas hasta que lance un suceso de reenvío, como pulsar un botón. Los sucesos dereenvío hacen que el navegador envíe los datos de la página (estado de vista) al servidor para procesar el suceso.Cuando el servidor recibe el estado de vista crea una nueva instancia del formulario Web, rellena los datos del esta-do de vista y procesa el suceso que ha ocurrido. Tan pronto como el servidor termina envía el HTML resultante al

navegador y destruye la instancia del formulario Web.Cuando el usuario termina y cierra el navegador o va a otro sitio Web, la sesión de usuario termina; si no hay

sesiones de otros usuarios, la aplicación termina. Esto no siempre funciona bien. ASP.NET gestiona la memoriamediante recolección de basura en lugar de cuenta de referencias, como hace OLE. La recolección de basura signifi-ca que periódicamente el servidor recorre las referencias entre objetos. Cuando localiza un objeto que no está en usose deshace del objeto y recupera la memoria. Esto significa que no se sabe exactamente cuándo se va a producir elsuceso Application_End .

2.2.2 Conservar datos en un formulario WebComo los formularios Web tienen tiempos de vida muy cortos ASP.NET realiza unos pasos especiales para

preservar los datos introducidos en controles de un formulario Web. Los datos introducidos en cada control se enví-an con cada petición y se restauran a los controles en Page_Init . Los datos en estos controles están entonces dispo-nibles en el suceso Page_Load .

Los datos que ASP-NET preserva entre llamadas forman el estado de vista del formulario Web. El estado devista de un formulario Web está disponible solo dentro del mismo formulario. Para que los datos introducidos en unformulario estén disponibles para otros formularios de la aplicación es necesario grabar los datos en una variable deestado en los objetos Application o Session. Estos objetos proporcionan dos niveles de alcance:

• Variables de estado Application . Están disponibles para todos los usuarios de una aplicación. Puede pensar en el estado Application como datos globales multiusuario. Todas las sesiones pueden leerlas y escribirlas.

• Variables de estado Session . Están disponibles solo para una sesión (usuario). El estado Session es como losdatos globales en una aplicación Windows estándar. Solo la sesión actual tiene acceso a su estado Session.

Las variables de estado Application y Session no se declaran de la misma forma que las variables ordinarias,sino que se crean en código sobre la marcha. Por ejemplo, el siguiente código graba el número de pulsaciones de botón en el estado Session:

Fig. 2. 1: Archivos en una Aplicación Web




21

Visual Basic .NETPrivate Sub Button1_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles Button1.Click‘Graba el número de pulsaciones en el estado de sesiónSession(“Clicks”) = Session(“Clicks”) + 1‘Muestra el número de pulsacionesResponse.Write(“Número de pulsaciones: ” & session(“Clicks”))

End Sub

Visual C#//En Global.asax.csprotected void Session_Start(Object sender, EventArgs e){

//Inicializa la variable de estado de sesión ClicksSession[“Clicks”] = 0;

}

private void Button1_Click(Object sender, System.EventArgs e){//Graba el número de pulsaciones en el estado de sesiónSession[“Clicks”] = (int)Session[“Clicks”] + 1;//Muestra el número de pulsacionesResponse.Write(“Número de pulsaciones: “ + Session[“Clicks”] + “<br>”);

}

Puede guardar cualquier tipo de datos en un variable de estado, desde un entero a objetos completos. Como

las variables de estado son datos globales necesita desarrollar estrategias para trabajar con ellas en su aplicación. Elmanejo de variables de estado en su aplicación se trata en profundidad en el capítulo 3, Trabajar con Objetos Web.

Importante: En Visual C# hay que inicializar las variables de estado Application antes de poder rea-lizar la mayoría de operaciones sobre ellas. Por ejemplo, hay que asignar un valor a lavariable de estado Clicks antes de poder realizar el moldeo a entero. En caso contrario serecibirá un error en tiempo de ejecución, ya que su estado es nulo.

2.2.3 Sucesos de aplicación y sesiónPuede escribir código para responder a los sucesos de Application y Session en el archivo Global.asax. Utili-

ce los sucesos de Application para inicializar objetos y datos que quiere tener disponibles para todas las sesionesactuales de la aplicación Web. Use los sucesos de Session para inicializar datos que quiere mantener a lo largo desesiones individuales, pero que no quiere compartir entre sesiones. La tabla 2.3 indica los manipuladores de suceso

de Application y describe cuando se producen.Tabla 2. 3: Manipuladores de Suceso de AplicaciónNombre del manipulador Se produce cuando:

Application_Start El primer usuario visita la página inicial de la aplicación

Application_End No hay más usuarios en la aplicación

Application_BeguinRequest Al comienzo de cada petición al servidor. Un petición se produce cada vez que un navegador entraen alguna de las páginas de la aplicación.

Application_EndRequest Al final de cada petición al servidor.

Session_Start Un nuevo usuario visita la página de inicio de la aplicación.

Session_End Un usuario abandona la aplicación, ya sea cerrando su navegador o por exceso de tiempo.

En formularios Web una sesión es una instancia única del navegador. Un único usuario puede tener variasinstancias del navegador corriendo en su propia máquina. Si varias instancias visitan la aplicación, cada una tiene su propia sesión.

Para ver cómo se producen los sucesos de Application y Session añada el siguiente código al archivo Glo- bal.asax de un proyecto de formulario Web.

Visual Basic .NETSub Application_Start(ByVal Sender As Object, ByVal e as EventArgs)

‘Registra el inicio de la aplicaciónApplication(“CuentaAplicacion”) = Application(“CuentaAplicacion”) + 1

End Sub

Sub Session_Start(ByVal Sender As Object, ByVal e as EventArgs)‘Cuenta sesiones

Application(“CuentaSesion”) = Application(“CuentaSesiones”) + 1



MCAD/MCSD

22

‘Muestra la cuenta de aplicacionesResponse.Write(“Número de Aplicaciones: “ & _

Application(“CuentaAplicacion”) & “<br>”)‘Muestra la cuenta de sesionesResponse.Write(“Número de Sesiones: “ & _

Application(“CuentaSesion”) & “<br>”)End Sub

Sub Session_End(ByVal Sender As Object, ByVal e as EventArgs)

‘Decrementa las sesionesApplication(“CuentaSesiones”) = Application(“CuentaSesiones”) - 1End Sub

Visual C#protected void Application_Start(Object sender, EventArgs e){

//Crea las variables de estado de la aplicaciónApplication[“CuentaAplicacion”] = 0;Application[“CuentaSesion”] = 0;//Registra el inicio de la aplicaciónApplication[“CuentaAplicacion”] = (int)Application[“CuentaAplicacion”] + 1;

}

protected void Session_Start(Object sender, EventArgs e){//Cuenta sesionesApplication[“CuentaSesion”] = (int)Application[“CuentaSesion”] + 1;//Muestra la cuenta de aplicacionesResponse.Write(“Número de aplicaciones: “ + Application[“CuentaAplicacion”] +

“<br>”;//Muestra la cuenta de aplicacionesResponse.Write(“Número de sesiones: “ + Application[“CuentaSesion”] + “<br>”;

}

protected void Session_End(Object sender, EventArgs e){//Decrementa las sesionesApplication[“CuentaSesion”] + (int)Application[“CuentaSesion”];

}

Para comprobar estos sucesos ejecute el código anterior, inicie una nueva instancia del navegador y vayaa la dirección. Cada nueva instancia del navegador incremente la cuenta de sesiones, pero la cuenta de aplicacio-nes siempre es 1.

Es importante darse cuenta de que los objetos intrínsecos como Session y Response no están disponiblesen Application_Start . Para usar estos objetos debe esperar a que se produzca el suceso de creación.

2.2.4 Sucesos de formulario WebLos sucesos de formulario Web se usan para procesar y mantener datos utilizados en una página Web, para

responder a la vinculación de datos y para manejar excepciones en una página Web. Los sucesos de la tabla 2-4 se producen en el orden mostrado. Los procedimientos de suceso con los que más trabajará en su código son Pa-ge_Load y Page_Error .

Tabla 2. 4: Sucesos de Formulario WebNombre del manipulador Se produce cuando:

Page__Init Los controles de servidor se cargan e inicializan a partir del estado de vista. Es el primer paso en el

ciclo de vida del formulario Web.Page_Load Los controles de servidor se cargan en el objeto Page . En este punto está disponible la información

de estado de vista, de modo que es donde se pone el código para cambiar la configuración decontroles o mostrar texto en la página.

Page_PreRender La aplicación está a punto de mostrar el objeto Page .

Page_Unload Se descarga la página de memoria.

Page_Error Se produce una excepción no controlada.

Page_AbortTransaction Se aborta una transacción.

Page_CommitTransaction Se acepta una transacción.

Page_DataBinding Un control de servidor en la página se vincula con un origen de datos.

Page_Disposed Se libera el objeto Page en memoria. Es el último suceso en el ciclo de vida del objeto Page .

Puede combinar el suceso Page_Load con la propiedad IsPostBack para inicializar datos la primera vez queun usuario visita un formulario Web. Es similar a un suceso Session_Start , pero se produce a nivel de página en




23

lugar de a nivel aplicación. El siguiente código inicializa un objeto y lo almacena en el estado de sesión la primeravez que se visita una página:

Visual Basic .NET‘Declara un nuevo objetoDim FlashCard as New FlashCardClass()

Private Sub Page_Load(ByVal Sender As System.Object, _ByVal e As System.EventArgs) Handles MyBase.Load

‘Si es la primera vez que se visita la páginaIf Not Page.IsPostback Then‘Baraja las tarjetasFlashCard.Baraja()‘Almacena el objeto en una variable de sesiónSession(“FlashCard”) = FlashCard

End If‘Recupera la variable de sesiónFlashCard = Session(“FlashCard”)RefreshDisplay;

End Sub

Visual C#//Declara un nuevo objeto FlashCardFlashCardClass FlashCard = new FlashCardClass();

private void Page_Load(object sender, System.EventArgs e){if(!isPostBack){

//Baraja las tarjetasFlashCard.Baraja();//Almacena el objeto en una variable de sesiónSession[“FlashCard”] = FlashCard;

}//Recupera la variable de sesiónFlashCard = (FlashCardClass)Session[“FlashCard”];RefreshDisplay();

}

Los otros sucesos de página permiten modificar la apariencia de la página y responder a sucesos de datos.Vinculación de datos, procesamiento de transacciones y trazado se tratan en mayor detalle en capítulos posteriores.

2.2.5 Sucesos de controles de servidor Los controles de servidor, como Button, TextBox, y DropDownList tienen sus propios conjuntos de sucesos

que se producen en respuesta a acciones del usuario. Sin embargo, no todos los sucesos de control de servidor secrean igual. Hay tres tipos de sucesos de control de servidor:

• Sucesos de reenvío: Estos sucesos hacen que se envíe la página Web al servidor para procesamiento inmediato.Los sucesos de reenvío afectan a las prestaciones aparen-tes porque lanzan una ida y vuelta al servidor.

• Sucesos en caché: Estos sucesos se almacenan en el es-tado de vista de la página para ser procesados cuando se produzca un suceso de reenvío.

•

Sucesos de validación: Estos sucesos se manejan en la página sin envío o almacenamiento en caché. Los contro-les de validación de servidor usan este tipo de sucesos

La figura 2.2 muestra la secuencia de sucesos de control de servidor en un formulario Web. Los controles devalidación se evalúan antes de enviar la página al servidor. Cuando se envía la página se gestionan Page_Init y Pa-ge_Load , después los sucesos en caché y finalmente el suceso que causó el envío de la página.

Los controles Button, LinkButton e ImageButton causan sucesos de reenvío. Los controles TextBox, Drop-DownList, ListBox, RadioButton y CheckBox proporcionan sucesos en caché; sin embargo puede cambiar estecomportamiento cambiando su propiedad AutoPostBack a True.

Para ver cómo interactúan los sucesos de validación, en caché y de reenvío cree un formulario con controlesde servidor TextBox, RequiredFieldValidator y Button. De a la propiedad ControlToValidate del RequiredFieldVa-lidator el valor TextBox1 y añada el siguiente código a los manipuladores de suceso del TextBox y el Button.

Fig. 2. 2: Secuencia de Sucesos en un FormularioWeb



MCAD/MCSD

24


ByVal e as System.EventArgs) Handles Button1.ClickResponse.Write(“Pulsado el botón <br>”)

End Sub

Private Sub TextBox1_TextChanged(ByVal sender As System.Object, _ByVal e as System.EventArgs) Handles TextBox1.TextChanged

Response.Write(“Texto cambiado <br>”)

End SubVisual C#private void Button1_Click(object sender, System.EventArgs e){

Response.Write(“Pulsado el botón <br>”);}

private void TextBox1_TextChanged(object sender, System.EventArgs e){Response.Write(“Texto cambiado <br>”);

}

Si deja la caja de texto en blanco y pulsa el botón se muestra el RequiredFieldValidator – no se procesa nin-gún otro suceso en la página y la página no se envía al servidor. Si escribe en la caja de texto y pulsa el botón la página se envía al servidor, y se procesa el suceso TextChanged antes que el suceso Click .

2.3 ¿Dónde se hace el procesamiento?Como sabe por la lección anterior, las aplicaciones Web corren en un servidor. Pero las aplicaciones Web noson como las aplicaciones Windows, que se inician cuando un usuario arranca un ejecutable y terminan cuando elusuario cierra la aplicación. En cambio, las aplicaciones Web se inician cuando un navegador pide una página Weby terminan cuando no se hacen más peticiones.

Para manejar esta diferencia las aplicaciones Web usan IIS para gestionar sus procesos en el servidor. En estalección aprenderá cómo determina IIS qué páginas Web son parte de una aplicación concreta, cómo se ejecutan lasDLL de las aplicaciones en el servidor, y cómo determina IIS cuando cerrar una aplicación.

2.3.1 Establecer los límites de aplicaciónIIS define una aplicación Web como cualquier archivo que se ejecuta dentro de un conjunto de directorios de

un sitio Web. Los límites de la aplicación los determina su estructura de directorios. El límite de la aplicación co-

mienza en un directorio que contiene la página de inicio de la aplicación y termina en su último directorio subordi-nado.

Cuando Visual Studio .NET crea un nuevo proyecto de aplicación Web crea un nuevo directorio para el pro-yecto e identifica el primer formulario Web creado en el proyecto (Webform1.aspx) como página de inicio. Unapágina de inicio es la página designada por Visual Studio como primera página a mostrar en la aplicación. Todoslos directorios subordinados, como /bin, son parte de la aplicación.

Si el diseño de la aplicación cambia durante el desarrollo o si quiere ejecutar rápidamente la página actual du-rante el depurado, puede que quiera cambiar la página de inicio de la aplicación.

Para designar un formulario Web o página HTML diferente como página de inicio siga estos pasos.

1. En la ventana Proyecto seleccione el formulario Web o página HTML que quiere indicar como página deinicio de la aplicación.

2. En el menú Proyecto seleccione Proyecto Web y Establecer como Página de Inicio. Visual Studio .NETusará la página seleccionada como primera a mostrar de la aplicación.

Cada proyecto que se crea tiene su propia página de inicio, y por tanto es una única aplicación. Si quierecombinar varios proyectos en una aplicación Web puede organizarlos usando IIS.

Para incluir una aplicación Web subordinada como parte de una aplicación única mayor siga estos pasos:

1. En IIS, seleccione la aplicación subordinada que se va a incluir como parte de la aplicación contenedor.2. En el menú Acción seleccione Propiedades. IIS muestra el diálogo de propiedades de la aplicación.3. Pulse Quitar. Esto elimina el punto inicial de la aplicación y por tanto la incluye como parte de la aplica-

ción que se encuentra en el nivel inmediato superior de la jerarquía. Pulse Aceptar para confirmar el cambio y volver a IIS.

Igualmente, en ocasiones querrá romper una aplicación grande, con varios directorios, en aplicaciones meno-

res debido a cambios de diseño.Para romper una aplicación con varios directorios en aplicaciones menores siga estos pasos:

1. En IIS, seleccione el directorio subordinada que se convertirá en nueva aplicación Web.




25

2. En el menú Acción seleccione Propiedades. IIS muestra el diálogo de propiedades de la aplicación.3. Pulse Crear para que el directorio se convierta en punto de inicio de aplicación. Pulse Aceptar para con-

firmar el cambio y volver a IIS.

El cambio en los límites de la aplicación puede afectar a las variables de estado Application. Es importantedarse cuenta de que todas las DLL dentro de los límites de una aplicación tienen acceso al mismo estado Applica-tion. Esto puede causar interacciones inadvertidas entre DLL,s si no se desarrollan teniéndolo en cuenta.

2.3.2 Gestión de procesosEs importante establecer los límites de aplicación porque IIS los usa para determinar cómo se ejecuta la apli-

cación en el servidor. IIS le da tres opciones para la forma de ejecutar la aplicación Web.

• En proceso con IIS (Inetinfo.exe): Esta opción mejora las prestaciones porque todas las llamadas se hacendentro del proceso; sin embargo, no ofrece protección. Si una aplicación falla, puede corromper la memoria yafectar a Inetinfo.exe, así como a otras aplicaciones que corren en el proceso.

• Agrupada con otros procesos de aplicación Web en DLLHost.exe: Es la opción predeterminada y propor-ciona un equilibrio entre protección y prestaciones. Si una aplicación falla puede afectar a otra aplicación delgrupo, pero no a Inetinfo.exe.

• Aislada en su propia instancia de DLLHost.exe: Las aplicaciones aisladas no afectan a otras aplicacionesni son afectadas por ellas. Sin embargo, las llamadas a otras aplicaciones deben cruzar límites de proceso, yesto afecta a las prestaciones.

Para establecer la forma en que IIS ejecuta su aplicación siga estos pasos:1. En IIS seleccione el directorio que contiene el punto de inicio de la aplicación2. En el menú Acción seleccione Propiedades. IIS muestra el diálogo de propiedades de la aplicación3. Seleccione la opción adecuada en la lista desplegable Permisos de ejecución. Pulse Aceptar para confir-

mar el cambio volver a IIS.

Para asegurar la fiabilidad del servidor ejecute las aplicaciones con protección agrupada o aislada. La opciónen proceso es principalmente un artefacto de versiones anteriores de IIS, que solo proporcionaba este modelo de proceso.

La opción agrupada es la predeterminada para nuevas aplicaciones, y es la que se usará para la mayor partede las aplicaciones Web porque permite que las aplicaciones accedan a otros componentes en el proceso de agrupa-miento en lugar de necesitar que se clasifiquen las llamadas para acceso fuera de proceso.

La opción aislada proporciona la mayor protección contra aplicaciones erráticas; sin embargo, precisa que lasllamadas a otras aplicaciones sean clasificadas, lo que daña las prestaciones. Hay un límite práctico de 10 procesosaislados por servidor, de modo que solo se debe usar esta opción para aplicaciones críticas.

2.3.3 Determinar cuando termina una aplicaciónCuando un usuario solicita una página por primera vez IIS inicia la aplicación Web, si no está corriendo ya, y

crea una sesión para este usuario. Todas las peticiones posteriores hechas por el usuario son parte de la misma se-sión. Las sesiones son importantes por dos razones:

• Permiten que ASP.NET mantenga datos específicos del usuario llamados estado Session. Los estados Session y Application se trataron en el apartado 2 de este capítulo.

• Determinan cuando termina la aplicación. Cuanto termina la última sesión, IIS finaliza la aplicación.

La duración de una sesión viene determinada por un valor de tiempo límite establecido en el archivoweb.config del proyecto, con un valor predeterminado de 20 minutos. Esto significa que 20 minutos después de queel usuario haga su última petición a una aplicación, la sesión de usuario termina. Cuando no hay más sesiones, laaplicación termina.

Recuerde que IIS define una aplicación Web como cualquier archivo que se ejecuta dentro de un conjunto dedirectorios en un sitio Web. De modo que si un usuario solicita cualquier de los archivos .aspx o .htm del conjuntode directorios de la aplicación dentro del plazo de 20 minutos, se mantiene la sesión de usuario.

Nota: Solo se tiene un control indirecto sobre el momento de finalización de la aplicación mediante eltiempo límite de sesión. Es importante comprender esto porque controla el ciclo de vida de laaplicación en el servidor.

La reducción del valor del tiempo límite de sesión puede liberar recursos en el servidor porque los datos desesión expiran más rápidamente. Sin embargo, establecer un valor demasiado bajo puede hacer que las sesionesterminen mientras están en uso, lo que probablemente causará errores en la aplicación.

Para cambiar el valor de tiempo límite de sesión siga estos pasos:



MCAD/MCSD

26

1. Abra el proyecto en Visual Studio .NET2. Abra el archivo Web.config pulsando sobre el en la ventana del Explorador de Soluciones3. Edite el valor de la variable timeout en la siguiente línea del archivo;

<sessionState mode=”InProc” stateConnectionString=”tcpip=127.0.0.1:42424”sqlConnectionString=”data source=127.0.0.1:user id=sa;password=”cookieless=”false” timeout=”20” />

4. Grabe el archivo

2.4 Resumen• Las aplicaciones Web usan formularios Web para crear un interface de usuario que se presenta por medio de

un navegador Internet en el ordenador del usuario• El código y recursos que responden a sucesos y realizan tareas útiles reside y corre en el servidor Web que

aloja la aplicación.• Como las aplicaciones Web están distribuidas entre un cliente y un servidor, hay cuatro diferencias significa-

tivas entre programación para la Web y programación para Windows.o Las aplicaciones Web usan controles de servidor y controles HTML en lugar de controles Windowso Las aplicaciones Web se muestran en un navegador Web en lugar de su propia ventanao Los formularios Web no son persistentes mientras se muestran. Debe preservar los datos persistentes en

una variable de estado durante los sucesos de página y control.o El procesamiento se produce en el servidor y los datos se intercambian mediante un ciclo de peticiones y

respuestas• Las aplicaciones Web están controladas por sucesos y los sucesos se producen a nivel aplicación, página y

control de servidor.• Los sucesos de controles de servidor son de tres tipos, y se producen en el siguiente orden

o Los sucesos de validación se producen antes de enviar la página al servidor o Los sucesos en caché se recogen mientras se muestra la página y se procesan una vez que la página envía

una petición al servidor.o Los sucesos de reenvío hacen que la página envíe una petición al servidor, pero su procedimiento de suce-

so se procesa en último lugar entre todos los sucesos.• Los límites de una aplicación Web los determina su estructura de directorios.• Los límites de la aplicación afectan al alcance de los datos almacenados en el estado Application y permiten

especificar el proceso en el que el servidor ejecuta la aplicación.• Para crear el directorio raíz de la aplicación, configurar los límites de aplicación y determinar el proceso en

que se ejecuta se utiliza IIS.2.5 Práctica: Crear una aplicación Web sencilla

En esta práctica creará la aplicación FlashCards. FlashCards es una aplicación sencilla, con un solo formula-rio, que muestra problemas matemáticos y evalúa el resultado introducido – como las tarjetas de cálculo rápido usa-das en una clase de matemáticas en una escuela elemental1.

Para completar la aplicación FlashCards creará un formulario Web, añadirá controles de servidor al formula-rio y controlará estos controles desde el procedimiento de suceso Page_Load .

2.5.1 Crear el interface de usuarioEn este ejercicio iniciará el proyecto FlashCards y creará el interface de usuario añadiendo controles de ser-

vidor al formulario Web.

►Para Crear un Nuevo Proyecto de Aplicación Web1. Abra un nuevo proyecto de aplicación ASP.NET. En la caja de diálogo Nuevo Proyecto escriba el nombreFlashCards y pulse aceptar

2. En la ventana Propiedades cambie el nombre de WebForm1.aspx a FlashCards.aspx

►Para Añadir los Controles al Interface de UsuarioAñada controles de servidor al formulario Web y defina las siguientes propiedades:

Control Tipo de Control Propiedad ValorLabel1 Label ID lblFeedBack

Font Arial, Bold, XXLText Flash Cards

Label2 Label ID lblFirst

Font Arial, Bold, XXL

1 Están locos estos yanquis. (N del T).




27

Label3 Label ID LblSecondFont Arial, Bold, XXL

<HR> Horizontal Rule Size 4Color #000000

TextBox1 TextBox ID txtAnswer AutoPostBack TrueFont Arial, Bold, XXL

Consejo: Si quiere crear varios controles con propiedades similares cree el primer control,configure sus propiedades y copie y pegue para crear nuevos controles. En formula-rios Web, esto no crea un array de controles como en formularios Windows.

2.5.2 Crear una clase llamada FlashCardClassEn este ejercicio creará una clase que contendrá la lógica y los datos que usa la aplicación FlashCards. Un

clase es una definición de un objeto usado para realizar una tarea en un programa. En el capítulo 3, Trabajar conObjetos Web hay más información sobre programación orientada a objetos.

La clase FlashCardClass creada aquí genera problemas matemáticos aleatorios que se mostrarán en el formu-lario Web. Esta es la lógica que usa la aplicación. En esta aplicación, y en la mayoría, la lógica ( FlashCardClass)está separada del interface de usuario (formulario Web).

►Para Crear una Clase1. En el menú Proyecto seleccione Agregar Clase. Visual Studio .NET muestra la caja de diálogo Agregar

Nuevo Elemento. Llame a la clase FlashCardClass y pulse Abrir.2. En la ventana de código, añada el siguiente:

Visual Basic .NETPublic Class FlashCardClass

Dim mintFirstNumber, mintSecondNumber As IntegerDim mstrOp As String = "+"Dim mrndNumber As Random

Public Sub New()' Inicializa el objeto generador de números aleatorios.mrndNumber = New Random()

End Sub

Public Sub Shuffle(Optional ByVal Min As Integer = 1, _Optional ByVal Max As Integer = 12)

' Obtiene los números aleatoriosmintFirstNumber = mrndNumber.Next(Min, Max)mintSecondNumber = mrndNumber.Next(Min, Max)

End Sub

Public ReadOnly Property FirstNumber()Get

FirstNumber = mintFirstNumberEnd Get

End Property

Public ReadOnly Property SecondNumber()

GetSecondNumber = mintSecondNumberEnd Get

End Property

Public Property Operation() As StringGet

Operation = mstrOpEnd GetSet(ByVal Value As String)

mstrOp = ValueEnd Set

End Property



MCAD/MCSD

28

' Calcula la respuesta según la operación actual.Public Function Answer() As Integer

Select Case mstrOpCase "+"

Answer = mintFirstNumber + mintSecondNumberCase "x", "*"

Answer = mintFirstNumber * mintSecondNumberCase "-"

Answer = mintFirstNumber - mintSecondNumber

End SelectEnd Function

End Class

Visual C#public class FlashCardClass{

int mintFirstNumber, mintSecondNumber;string mstrOp = "+";Random mrndNumber;

public FlashCardClass(){// Inicializa el objeto generador de números aleatorios.mrndNumber = new Random();

}

public void Shuffle(int Min, int Max){// Obtiene los números aleatorios.mintFirstNumber = mrndNumber.Next(Min, Max);mintSecondNumber = mrndNumber.Next(Min, Max);

}

// Baraja sin parámetros, predeterminados Min = 0, Max = 12.public void Shuffle(){

// Obtiene los números aleatorios.mintFirstNumber = mrndNumber.Next(0, 12);mintSecondNumber = mrndNumber.Next(0, 12);

}

public int FirstNumber{get{return mintFirstNumber;}

}

public int SecondNumber{get{return mintSecondNumber;}

}

public string Operation{get{return mstrOp;}set{mstrOp = value;}

}

// Calcula la respuesta en base a la operación actual.public int Answer(){

switch(mstrOp){case "+": return mintFirstNumber + mintSecondNumber;case "x": return mintFirstNumber * mintSecondNumber;case "*": return mintFirstNumber * mintSecondNumber;

case "-": return mintFirstNumber - mintSecondNumber;default : return 0;

}}

}

2.5.3 Almacenar un objeto FlashCardClass en SessionEn este ejercicio añadirá al archivo Global.asax código para inicializar una variable de estado de sesión que

contenga un objeto FlashCardClass que utilizará el formulario Web. El archivo Global.asax contiene los sucesosque se producen cuando se inicia la aplicación y cuando se inician nuevas sesiones. El objeto FlashCardClass sealmacena en una variable de sesión de modo que se mantiene durante toda la sesión de usuario.

►Para crear una variable de estado de sesión1. En la ventana Proyecto, pulse dos veces sobre el archivo Global.asax y pulse el enlace haga click aquí

para cambiar a vista de códigos.2. En la ventana de código, añada el siguiente procedimiento de suceso Session_Start .




29

Visual Basic .NETSub Session_Start(ByVal Sender As Object, ByVal e As EventArgs)

‘Crea un nuevo objeto FlashCardDim FlashCard As New FlashCardClass()‘Almacena el objeto en una variable de sesiónSession(“FlashCard”) = FlashCard

End Sub

Visual C#

protected void Session_Start(Object sender, EventArgs e){//Crea un nuevo objeto FlashCardFlashCardClass FlashCard = new FlashCardClass();//Almacena el objeto en una variable de sesiónSession[“FlashCard”] = FlashCard;

}

2.5.4 Utilizar FlashCardClass en los sucesos del formulario WebEn este ejercicio añadirá código al formulario Web para utilizar el objeto FlashCardClass almacenado en la

variable de estado de sesión. De esta forma se enlaza la lógica (FlashCardClass) con la interface de usuario (Flash-Card.aspx).

►Para Usar el Objeto FlashCardClass En los Procedimientos de Suceso del Formulario Web1. Abra el módulo de código del formulario Web en la ventana de código pulsando dos veces sobre cual-

quier parte del formulario Web.2. Declare a nivel módulo una variable que recibirá el objeto del estado de sesión.Visual Basic .NETDim FlashCard As FlashCardClass

Visual C#FlashCardClass FlashCard;

3. En el procedimiento del suceso Page_Load añada el siguiente código para asignar la variable de estado desesión a la variable FlashCard que acaba de crear.Visual Basic .NETPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.Load‘Recupera la variable de sesiónFlashCard = Session(“FlashCard”)RefreshDisplay

End Sub

Visual C#private void Page_Load(object sender, System.EventArgs e){

//Recupera la variable de sesiónFlashCard = (FlashCardClass)Session[“FlashCard”];RefreshDisplay();

}

4. Añada el siguiente código al procedimiento de suceso TextChanged del cuadro de textoVisual Basic .NETPrivate Sub txtAnswer_TextChanged(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles txtAnswer.TextChangedIf txtAnswer.Text = FlashCard.Answer Then

lblFeedback.Text = “Correcto”‘Obtiene otro par de númerosFlashCard.Shuffle()‘Renueva la salida para mostrar los nuevos númerosRefreshDisplay()‘Borra la respuestatxtAnswer.Text = “”

ElselblFeedback.Text = “Error, pruebe otra vez”

End IfEnd Sub

Visual C#private void txtAnswer_TextChanged(object sender, System.EventArgs e){

if(txtAnswer.Text == FlashCard.Answer().ToString()){lblFeedback.Text = “Correcto”;//Obtiene otro par de númerosFlashCard.Shuffle();



MCAD/MCSD

30

//Renueva la salida para mostrar los nuevos númerosRefreshDisplay();//Borra la respuestatxtAnswer.Text =””;

}else

lblFeedback.Text = “Error, pruebe otra vez”;}

5. Escriba el siguiente procedimiento auxiliar para refrescar la pantallaVisual Basic .NETPrivate Sub RefreshDisplay()

lblFirst.Text = FlashCard.FirstNumberlblSecond.Text = FlashCard.Operation & FlashCard.SecondNumber

End Sub

Visual C#private void RefreshDisplay(){

lblFirst.Text = FlashCard.FirstNumber.ToString();lblSecond.Text = FlashCard.Operation + FlashCard.SecondNumber.ToString();

}

6. Ejecute y pruebe la aplicación

(N del T: es necesario pulsar Enter tras escribir la respuesta para provocar el suceso TextChanged )

Consejo: El uso de una variable a nivel de formulario para contener los datos almacenados en variables de estado de sesión o aplicación ayuda a capturar los errores. Visual Studio .NET noimpone que se declaren las variables de estado. Escribir mal una variable de estado creaotra nueva, vacía.

2.6 RepasoLas siguientes preguntas están pensadas para reforzar información clave presentada en este capítulo. Si no es

capaz de contestar a una pregunta repase la lección correspondiente e intente de nuevo. Las respuestas a estas pre-guntas se encuentran en el capítulo 16.

1. Explique donde guarda Visual Studio .NET los proyectos de aplicación Web.

2.

Indique las cuatro diferencias principales entre aplicaciones Web y Windows.3. Describa el ciclo de vida de una aplicación Web: ¿Cuándo se instancian los formularios Web y durante

cuanto tiempo existen?

4. ¿Cómo se conservan los datos persistentes, como variables sencillas, en una aplicación Web?

5. ¿Qué determina los límites de una aplicación Web?




31

3 Trabajar con objetos webEn este capítulo aprenderá cómo crear y organizar objetos en Microsoft Visual Studio .NET, usar los objetos

que proporciona ASP.NET y guardar objetos y datos entre peticiones a formularios Web. Visual Basic .NET, C# yASP.NET comparten un marco de trabajo común, de modo que todas las técnicas de programación orientada a obje-tos que aprenda aquí se aplican a todos los aspectos de la programación de aplicaciones de formularios Web.

Para completar las lecciones de este capítulo deberá:

• Estar familiarizado con los aspectos básicos de los lenguajes de programación Visual Basic, C# o C++. Estoincluye familiaridad con los conceptos de variables, procedimientos, estructuras de decisión y alcance. Parauna introducción a Visual Basic .NET y C# vea la ayuda de Visual Studio

• Comprender los sucesos en el ciclo de vida de una aplicación Web tal como se trató en la lección 2 del capí-tulo 2, Crear Aplicaciones de Formulario Web

3.1 Fundamentos de los espacios de nombresVisual Basic .NET y C# proporcionan un conjunto completo de conceptos de programación orientada a obje-

tos, incluyendo clases abstractas, interfaces y sobrecarga o sustitución de miembros de clase. Estas característicasson fundamentales en el lenguaje y se usan a todo lo ancho del marco de trabajo .NET. Aprendiendo a usar estascaracterísticas por si mismo comprenderá cómo está implementado el marco de trabajo .NET y será más capaz deusarlas en sus aplicaciones.

3.1.1 Comprender los espacios de nombresEn el capítulo anterior vio en el archivo Global.asax código generado que tenía este aspecto:

Visual Basic .NETImports SystemImports System.Web

Visual C#using System;using System.Web;

Estas sentencias permiten usar código de los espacios de nombres System y System.Web sin especificar losnombres completos. Sin estas sentencias una llamada a un simple método del espacio de nombres System sería así:

Visual Basic .NETSystem.Array.Sort(strArray)

Visual C#System.Array.Sort(strArray);

Al incluir el espacio de nombres System al comienzo del código este método de Array se reduce a:

Visual Basic .NETArray.Sort(strArray) Visual C#Array.Sort(strArray);

• Los espacios de nombres son una forma de organizar el código. Proporcionan protección frente a nombresconflictivos, llamados a veces colisiones de espacio de nombres. Esta protección es especialmente necesariaen grandes proyectos donde es muy fácil que dos elementos tengan accidentalmente el mismo nombre. Orga-nizando el código en espacios de nombres se reduce la posibilidad de estos problemas. Para crear un espaciode nombres encierre un Class o Module en un bloque Namespace ... End Namespace o namespace{...}

• Para añadir más de una clase o módulo a un espacio de nombres, especifique el mismo nombre de espacio denombres para todos.

La parte en negrita de este código crea un espacio de nombres para el módulo Strings:

Visual Basic .NET' Nombre de Proyecto: Wombat. Namespace Utils

Public Module StringsPublic Function Sort(ByVal strText As String, _

Optional ByVal bAlphaOrder As Boolean = True) As String' Declara e inicializa un array de cadenas.Dim strArray As String() = {""}' Convierte la cadena en un array usando System.String.strArray = strText.Split(" ")' Usa System.Array para ordenar.System.Array.Sort(strArray)' Si no está en orden alfabético, invierte el array.If Not bAlphaOrder Then

' Usa System.Array para invertir.System.Array.Reverse(strArray)

End If



MCAD/MCSD

32

' Devuelve la cadena ordenada.Sort = System.String.Join(" ", strArray)

End FunctionEnd Module

End Namespace

Visual C#// Project name: Wombat.namespace Utils{

class Strings{// Coge una cadena, la ordena y devuelve una cadena.public static string Sort(string strText , bool bAlphaOrder){

// Declara e inicializa un array de cadena.string[] strArray = {""};char[] strSep = {' '};// Convierte la cadena en un array usando System.String.strArray = strText.Split(strSep);// Usa System.Array para ordenar.System.Array.Sort(strArray);// Si no es orden alfabético, invierte el array.if (!bAlphaOrder){

// Usa System.Array para invertir.System.Array.Reverse(strArray);

}

// Devuelve la cadena.return System.String.Join(" ", strArray);

}

// El mismo método con un parámetro.public static string Sort(string strText){

return Sort(strText, true);}

}}

Importante: El ejemplo anterior también usa dos espacios de nombres .NET: System.Array y Sys-tem.String. Los espacios de nombres System son la nueva forma de acceder a funcionesa las que anteriormente se accedía mediante el API de Windows por medio de sentencias Declare. Ahora es incluso más fácil porque Visual Basic .NET, C# y el marco de trabajo

.NET usan los mismos tipos de datos escalares y convenciones de paso de parámetros. Adiferencia del API de Windows los espacios de nombres System proporcionan un inter-face orientado a objetos para loas funciones Windows. Si está familiarizado con el APIde Windows puede que le lleve tiempo acostumbrarse, pero las ventajas del motor deejecución común para lenguajes y del código administrado son enormes.

Como los espacios de nombres son una herramienta de organización para el código que querrá usar en cual-quier parte, son públicos por definición. Cuando se usan en el código la referencia tiene la forma:

NombreProyecto.NombreEspacio.NombreModulo.NombreMiembro

Puede usar código de espacios de nombres en su aplicación de dos formas.

• Usando el nombre completamente cualificado del miembro. La parte en negrita del siguiente código llama ala función Sort del espacio de nombres Wombat.Util.


ByVal e As System.EventArgs) Handles Button1.Click‘Ordena el textoTextBox1.Text = Wombat.Utils.Strings.Sort(TextBox1.Text)

End Sub


TextBox1.Text = Wombat.Utils.Strings.Sort(TextBox1.Text);}

• Añadir una sentencia Imports en Visual Basic .NET o using en C# al comienzo de la clase o módulo. Estasentencia proporciona un atajo para el nombre de miembro – ya no es necesario usar el nombre completo. La

parte en negrita del siguiente código usa el espacio de nombres Util en el proyecto Wombat




33

Visual Basic .NET‘Importa el espacio de nombres del proyecto WombatImports Wombat.Utils

Public Class WebForm1‘Se omiten las declaraciones y código de inicialización

Private Sub Button1_Click(ByVal sender as System.Object, _ByVal e As System.EventArgs) Handles Button1.Click

‘Ordena el textoTextBox1.Text = Strings.Sort(TextBox1.Text)

End SubEnd Class

Visual C#//Importa el espacio de nombres Utils del proyecto Wombatusing Wombat.Utils;namespace csNamespaces{

public class WebForm1 : System.Web.UI.Page{//Se omiten las declaraciones y el código de inicializaciónprivate void Button1_Click(object sender, System.EventArgs e){

TextBox1.Text = Strings.Sort(TextBox1.Text);}

}}

Los espacios de nombres utilizan notación de punto (.) para especificar jerarquía. Considere la siguiente de-claración:

Visual Basic .NET‘Nombre de proyecto: WombatNamespace Utils

Namespace TypesNamespace Digits

Public Enum NumericZero

:Nine

End EnumEnd Namespace

End NamespaceEnd Namespace

Visual C#//Nombre de Proyecto: Wombatnamespace Utils{

namespace Types{namespace Digits{

public Enum Numeric{Zero, ..., Nine

}}

}}

Esta declaración es equivalente a:

Visual Basic .NET‘Nombre de proyecto: WombatNamespace Utils.Types.Digits

Public Enum NumericZero

:Nine

End EnumEnd Namespace

Visual C#//Nombre de Proyecto: Wombatnamespace Utils.Types.Digits{

public Enum Numeric{Zero, ... ,Nine

}}

Para usar cualquiera de las dos declaraciones de espacio de nombres anteriores pede usar el nombre comple-tamente cualificado:

Visual Basic .NETDim numVar As Wombat.Utils.Types.Digits.Numeric

Visual Basic C#Wombat.Utils.Types.Digits.Numeric numVar;

O puede usar sentencias Imports y Using:

Visual Basic .NETImports Wombat.Utils.Types.DigitsDim numVar as Numeric

Visual C#using Wombat.Utils.Types.DigitsNumeric numVar

3.1.2 Referencias Frente a ImportacionesSe añaden referencias de proyecto para usar espacios de nombres que están fuera del proyecto actual. Use

sentencias Imports o using para proporcionar una abreviatura para el espacio de nombres. La sentencia Imports ousing sencillamente proporciona una forma abreviada para hacer referencia al espacio de nombres en código.



MCAD/MCSD

34

Para añadir una referencia a un proyecto:

1. En el menú Proyecto seleccione Agregar Referencia. Visual Studio .NET muestra el cuadro de diálogoAgregar Referencia.

2. Seleccione la referencia que quiere añadir de la lista de componentes .NET, COM o Proyecto. PulseAceptar.

3. Visual Studio añade las referencias a la ventana de proyecto.

3.1.3 Clases y módulosLos proyectos de Visual Studio almacenan el código en clases y módulos. Versiones anteriores de Visual Ba-

sic introdujeron el concepto de clases y cómo se diferencian de los módulos de código. Este concepto es el mismoen Visual Basic .NET: se usan las clases para elementos que definen su propio almacenamiento y los módulos paracódigo que no tiene datos persistentes. Además, se instancias clases para crear objetos antes de usarlos, mientras quese llama al código de los módulos directamente.

En C#, sin embargo, todo el código está contenido en una clase. Si quiere crear métodos o propiedades que se puedan llamar sin tener que crear un objeto declare estos elementos como estáticos. El método Sort de la clase Utils creado en la sección anterior muestra el equivalente C# de un módulo Visual Basic .NET.

Visual Basic .NET y C# usan cuatro conceptos clave para trabajar con módulos y clases. Estos conceptos sonnuevos en Visual Basic .NET y, lógicamente, en C#, puesto que es un lenguaje completamente nuevo. Sin embargolos programadores de C++ estarán familiarizados con estos conceptos. La tabla 3.1 describe estos conceptos en

ambos lenguajes.Tabla 3. 1: Conceptos clave de orientación a objetosConcepto En Visual Basic .NET En Visual C#Definición Se define una clase o módulo usando bloques

Class...End Class o Module...End Module . En versionesanteriores esto estaba implícito en el tipo de archivo ysolo se podía tener una clase o módulo por archivo.

Las clases se definen con la palabra clave class . Todoel código ejecutable es parte de una clase.

Acceso Hay cinco niveles de acceso a las clases, módulos ysus miembros: Public , Protected , Friend , Protected

Friend y Private . El acceso está explícito en la decla-ración del elemento en lugar de oculto en las propie-dades del archivo.

Hay cinco niveles de acceso a las clases y sus miem-bros: public , protected , internal , protected internal y

private .

Herencia Las clases pueden heredar miembros de otra y susti-

tuir, ensombrecer o sobrecargar miembros de la claseheredada.

Las clases pueden heredar miembros de clases base y

sustituir o sobrecargar miembros de la clase hereda-da.

Constructores yDestructores

Las clases tienen métodos New y Finalize a los que sellama cuando se crea o destruye un objeto basado enla clase.

Las clases tienen constructores o destructores a losque se llama cuando se crea o destruye un objetobasado en la clase. Los métodos constructores tienenel mismo nombre que la clase y los destructores usanel nombre de clase precedido por una tilde (~)

Clases Abstractase Interfaces

Puede crear interfaces y clases, métodos y propiedades abstractos. Los interfaces definen los nombres demiembro y listas de parámetros para las clases que usan el interface. Los miembros abstractos proporcionanlos elementos que serán heredados por las clases derivadas de ellos.

Crear clases/módulos y proporcionar accesoEn Visual Basic, use bloques Class…End Class y Module…End Module para definir clases y módulos. En

Visual C# use la palabra clave class para definir clases. Puede tener uno o más clases/módulos en un solo archi-vo. Use las palabras clave de acceso usadas en la tabla 3.2 para definir qué otras clases o módulos pueden usar los miembros de la clase o módulo actual.

Tabla 3. 2: Niveles de acceso para clases y módulos Visual Basic Visual C# Disponible paraPublic public Todos los miembros de todas las clases y proyectosFriend internal Todos los miembros del proyecto actualProtected protected Todos los miembros de la clase actual y derivadas en cualquier proyecto. Se puede

usar solo en definiciones de miembros, no de clases o módulosProtected Friend protected internal Todos los miembros de la clase actual y derivadas en el proyecto actual. Se puede

usar solo en definiciones de miembros, no de clases o módulos.Private private Disponible solo en la clase actual.

Por ejemplo, la siguiente clase solo está disponible en el proyecto actual.

Visual Basic .NETFriend Class TranslatorPrivate mstrText As String




35

' Controla el acceso a las variables a nivel de módulo.Public Property Text() As String

GetText = mstrText

End GetSet(ByVal Value As String)

mstrText = ValueEnd Set

End Property

' Traduce el valor de la propiedad Text.Public Sub Translate()

Dim strWord As String, intCount As IntegerDim arrWords() As StringDim bCaps As Boolean' Convierte la cadena en un array usando System.String.arrWords = mstrText.Split(" ")For intCount = 0 To UBound(arrWords)

' Comprueba si la palabra usa mayúsculas.If LCase(arrWords(intCount)) <> arrWords(intCount) Then

bCaps = TruearrWords(intCount) = LCase(arrWords(intCount))

End IfstrWord = arrWords(intCount)

' Hace la traducción.If strWord <> "" Then

strWord = Right(strWord, Len(strWord) - 1) & _Left(strWord, 1) & "ay"' Vuelve a poner mayúscula si es necesarioIf bCaps Then

strWord = UCase(Left(strWord, 1)) & _Right(strWord, Len(strWord) - 1)

End IfEnd If' Vuelve a poner en el array.arrWords(intCount) = strWord' Restablece el indicador de mayúsculas.bCaps = False

Next' Reconstruye la cadena a partir del array.mstrText = String.Join(" ", arrWords)

End SubEnd Class

Visual C#internal class Translator{

string mstrText;

// Controla el acceso a las variables a nivel de módulo.public string Text {

get{return mstrText;}set{mstrText = value;}

}

/// Traduce el valor en la propiedad Textpublic void Translate(){string strWord;string[] arrWords;bool bCaps = false;

// Convierte la cadena en un array usando System.String.arrWords = mstrText.Split(' ');for(int intCount = 0; intCount <= arrWords.GetUpperBound(0); intCount++){

// Cambia a minúsculas.strWord = arrWords[intCount].ToLower();// Comprueba si la palabra usa mayúscula.if(!arrWords[intCount].Equals(strWord)) bCaps = true;



MCAD/MCSD

36

// Hace la traducción.if(strWord != ""){

strWord = strWord.Substring(1,strWord.Length - 1) +strWord.Substring(0,1) + "ay";// Vuelve a poner mayúscula si es necesario.if(bCaps)

strWord = strWord.Substring(0,1).ToUpper() +strWord.Substring(1, strWord.Length - 1);

}

// Coloca la palabra en el array.arrWords[intCount] = strWord;// Restablece el indicador de mayúscula.bCaps = false;

}// Reconstruye la cadena a partir del array.mstrText = String.Join(" ", arrWords);

}}

Puede acceder a la propiedad Text y al método Translate de la anterior clase Translator desde dentro del proyecto donde está incluida, pero no desde otros proyectos. La parte en negrita del siguiente código muestra eluso de estos miembros desde un formulario Web.

Visual Basic .NETPrivate Sub butTranslate_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butTranslate.Click‘Crea un nuevo objeto TranslatorDim TranslateText As New Translator()‘Pone el texto original en el traductorTranslateText.Text = txtInput.Text‘Hace el trabajoTranslateText.Translate()‘Muestra el resultadotxtOutput.Text = TranslateText.Text

End Sub

Visual C#private void butTranslate_Click(object sender, System.EventArgs e){

//Crea un nuevo objeto Translator

Translator TranslateText = new Translator();//Pone el texto original en el traductorTranslateText.Text = txtInput.Text;//Hace el trabajoTranslateText.Translate();//Muestra el resultadotxtOutput.Text = TranslateText.Text;

}

Cuando se examina el código que genera Visual Studio para un formulario Web se observa que los con-troles de servidor se declaran como protegidos. De forma predeterminada los objetos control de servidor se con-figuran de modo que solo estén disponibles en el formulario Web actual y el los formularios Web derivados deéste.

Herencia: ¿quién deriva?La herencia es el proceso de basar una clase en otra. En este proceso una clase base proporciona méto-

dos, propiedades y otros miembros a una clase derivada. La ventaja de la herencia es que puede escribir y man-tener el código una sola vez en la clase base y reutilizarlo una y otra vez en clases derivadas. Cómo esté de fami-liarizado con la herencia depende del lenguaje de programación que haya estado utilizando.

• Visual Basic .NET introduce la herencia en la programación Visual Basic. Es un enorme paso adelante para el lenguaje y el motivo de que muchas cosas tengan que cambiar entre versiones. Los formulariosWindows y los tipos de datos ahora se heredan del marco de trabajo .NET en lugar de ser implementadosmediante el motor “Ruby” de las versiones anteriores de Visual Basic. Ahora encontrará mucha mayor coherencia entre Visual Basic .NET y Windows

• Los programadores C# que estén familiarizados con C++ probablemente estén muy familiarizados con elconcepto de herencia. Sin embargo, C# añade refinamientos que no se encuentran en la sintaxis C++, in-cluyendo las palabras clave interface, abstract y virtual.

Cómo se especifique la herencia depende también del lenguaje de programación. En Visual Basic .NETse usa la sentencia Inherits para que una nueva clase esté basada en una existente. En C# se usa la definición declase. Las siguientes líneas muestran las diferentes sintaxis en ambos lenguajes.




37

Visual Basic .NETPublic Class ClaseDerivada

Inherits ClaseBaseEnd Class

Visual C#public class ClaseDerivada : ClaseBase{}

Visual Studio utiliza las palabras clave de la tabla 3.3 para crear clases base y derivar nuevas clases a par-tir de ellas. Las siguientes secciones explican como usar cada una de ellas.

Tabla 3. 3: Generalidades de las palabras clave de herencia

Visual Basic Visual C# Usada paraInherits ClaseDerivada: ClaseBase Basar una clase en otra, heredando los miembros de la clase base.Overridable virtual Declarar que un miembro de la clase base se puede sustituir en la derivadaOverrides override Declarar que un miembro de la clase derivada sustituye a uno del mismo

nombre en la clase base.Shadows new Declarar que un miembro de la clase derivada oculta a uno del mismo nombre

en la clase base.MustInherit abstract Declarar que una clase proporciona una plantilla para clases derivadas, Este tipo

de clase se llama clase abstracta y no se puede instanciar.MustOverride abstract Declarar que un miembro de una clase proporciona una plantilla para miembros

derivados. Este tipo de miembro se denomina miembro abstracto y no se lepueden hacer llamadas.

MyBase base Llamar a un miembro de la clase base desde dentro de la clase derivada.Me this Llamar a un miembro de la instancia actual de la clase.Interface interface Crear un interface que define los miembros que debe proporcionar una clase.Implements NombreClase : NombreInterface Usar una definición de interface en una clase.

Antes de poder aprender sobre la herencia con más detalle debe comprender las dos cosas que no puedehacer con ella:

• No puede heredar de más de una clase base en la definición de una clase derivada. El concepto de heren-cia múltiple existe en muchos lenguajes de programación orientada a objetos, pero en la práctica no esmuy utilizado. Las clases base, sin embargo, se pueden derivar unas de otras de modo jerárquico.

• No puede derivar una clase formulario Web de una base formulario Web. Incluso aunque los formulariosWeb se definen como clases, Visual Studio no permite derivar nuevos formularios de los existentes.

Sustituir, sobrecargar y ocultar miembrosUna clase derivada hereda los miembros de su clase base. Si la clase derivada define un miembro con la

misma firma, el miembro derivado sustituye al miembro base. La firma de un miembro incluye su nombre, listade parámetros, tipos de parámetros y tipo de devolución.

Si una clase derivada define un miembro con el mismo nombre, pero una lista de parámetros, tipos de pa-rámetros o tipo de devolución diferentes, el miembro derivado sobrecarga u oculta el miembro base. Un miembro sobrecarga a otro miembro si el miembro base sigue estando disponible. Un miembro oculta a otro miembro si el miembro derivado reemplaza al miembro base.

En el siguiente ejemplo la clase Sphere está basada en la clase Circle. En Visual Basic .NET los miembros que se pueden sustituir se deben declarar como Overridable (1), En visual C# se deben declarar como vir-tual (1), Esta es la clase Circle:

Visual Basic .NETPublic Class Circle

Private sxCenter, syCenter As SinglePrivate sRadius As Single

Public Property Top() As SingleGetTop = sxCenter - sRadius

End GetSet(ByVal Value As Single)

sxCenter = Value + sRadiusEnd Set

End Property

Public Property Left() As SingleGet

Left = syCenter - sRadiusEnd GetSet(ByVal Value As Single)

syCenter = Value + sRadius

End SetEnd Property



MCAD/MCSD

38

Public Overridable Function Area() As Single ' (1)Area = System.Math.PI * (sRadius ^ 2)

End Function

Public Function Perimeter() As SinglePerimeter = 2 * sRadius * System.Math.PI

End Function

Public Property Radius() As SingleGet

Radius = sRadiusEnd GetSet(ByVal Value As Single)

sRadius = ValueEnd Set

End Property

Public Overridable Sub Center(ByVal X As Single, ByVal Y As Single) ' (1)sxCenter = XsyCenter = Y

End SubEnd Class

Visual C#public class Circle{

float fxCenter, fyCenter, fRadius;// Constructor.public Circle(){

// Inicializa variables internas.fxCenter = 0;fyCenter = 0;fRadius = 0;

}

public float Top{get{return fxCenter - fRadius;}set{fxCenter = value + fRadius;}

}

public float Left{get{return fyCenter - fRadius;}set{fyCenter = value + fRadius;}

}

public virtual float Area(){ // (1)return (float)(System.Math.PI * Math.Pow((double)fRadius, 2));

}

public float Perimeter(){return 2 * fRadius * (float)System.Math.PI;

}

public float Radius{get{return fRadius;}set{fRadius = value;}

}

public virtual void Center(float X, float Y){ // (1)fxCenter = X;fyCenter = Y;

}}

La clase Sphere hereda todos los métodos y propiedades definidos en Circle (1). Sphere sustituye elmétodo Area (2) porque la esfera utiliza una fórmula diferente para su cálculo. Sphere oculta el método Cen-ter porque las esferas tienen una coordenada adicional (z) y no queremos que los usuarios accidentalmenteden valores a X e Y sin dárselo a Z. Observe que Sphere utiliza las palabras clave MyBase de Visual Basic obase de C# (4) para llamar al método Center de la clase base desde el método que lo oculta.

Visual Basic .NETPublic Class Sphere

Inherits Circle ' (1)Private sCenter As Single




39

Public Overrides Function Area() As Single ' (2)Area = 4 * System.Math.PI * (MyBase.Radius ^ 2)

End Function

Public Shadows Sub Center(ByVal X As Single, _ByVal Y As Single, ByVal Z As Single) ' (3)

MyBase.Center(X, Y) ' (4)sCenter = Z

End Sub

Public Function Volume() As SingleVolume = (4 / 3) * System.Math.PI * (Radius ^ 3)

End Function

Public Property Front() As SingleGet

Depth = sCenter - RadiusEnd GetSet(ByVal Value As Single)

sCenter = Value + MyBase.RadiusEnd Set

End PropertyEnd Class

Visual C#

public class Sphere : Circle{ // (1)float fCenter;

// Constructor.public Sphere(){

// Inicializa variable interna.fCenter = 0;

}

public override float Area(){ // (2)return (float)(4 * Math.PI * Math.Pow((double)base.Radius, 2));

}

public new void Center(float X, float Y){ // (3)this.Center(X, Y, 0);

}

public void Center(float X, float Y, float Z){base.Center(X, Y); // (4)fCenter = Z;

}

public float Volume(){return (float)((4 / 3) * System.Math.PI * Math.Pow((double)base.Radius, 3));

}

public float Front{get{return fCenter - base.Radius; }set{fCenter = value + base.Radius; }

}}

Para ver como funciona la herencia, cree un nuevo objeto de cada tipo y llama a los métodos y propieda-des de ambos. El siguiente código muestra las clases Sphere y Circle mostrando los valores que calculan en unformulario Web.

Visual Basic .NETPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.LoadDim MyCircle As New Circle()MyCircle.Radius = 2MyCircle.Center(10, 2)Response.Write("Área del Círculo: " & MyCircle.Area & "<br>")Response.Write("Circunferencia del círculo: " & _

MyCircle.Perimeter & "<br>")



MCAD/MCSD

40

Dim MySphere As New Sphere()MySphere.Radius = 10MySphere.Center(10, 20, 25)Response.Write("Esfera Arriba: " & MySphere.Top & "<br>")Response.Write("Esfera Izquierda: " & MySphere.Left & "<br>")Response.Write("Esfera Delante: " & MySphere.Front & "<br>")Response.Write("Volumen Esfera: " & MySphere.Volume & "<br>")Response.Write("Área superficial Esfera: " & MySphere.Area & "<br>")Response.Write("Circunferencia Esfera: " & MySphere.Perimeter & "<br>")

End Sub


Circle MyCircle = new Circle();MyCircle.Radius = 2;MyCircle.Center(10, 2);Response.Write("Área del Círculo: " + MyCircle.Area() + "<br>");Response.Write("Circunferencia del círculo: " + MyCircle.Perimeter() +

"<br>");

Sphere MySphere = new Sphere();MySphere.Radius = 10;MySphere.Center(10,20,25);Response.Write("Esfera Arriba: " + MySphere.Top + "<br>");

Response.Write("Esfera Izquierda: " + MySphere.Left + "<br>");Response.Write("Esfera Delante: " + MySphere.Front + "<br>");Response.Write("Volumen Esfera: " + MySphere.Volume() + "<br>");Response.Write("Área superficial Esfera: " + MySphere.Area() + "<br>");Response.Write("Circunferencia Esfera: " + MySphere.Perimeter() + "<br>");

}

En lo abstractoVisual Studio también permite definir clases abstractas. Una clase abstracta es una clase que define un

interface para clases derivadas. Una clase abstracta esencialmente es un contrato que dice que todas las clases basadas en él deben proporcionar ciertos métodos y propiedades. No puede crear objetos a partir de clases abs-tractas – solo puede derivar nuevas clases de ellas.

Las clases abstractas se declaran con las palabras clave MustInherit de Visual Basic o abstract de C#. Losmétodos y propiedades que debe implementar la clase derivada se declaran como MustOverride en Visual Basic

o abstract en C#. La clase Shape es un ejemplo de clase abstracta:

Visual Basic .NET' Definición de clase abstracta.Public MustInherit Class Shape

Public MustOverride Property Top() As SinglePublic MustOverride Property Left() As SinglePublic MustOverride Function Area() As SinglePublic MustOverride Function Perimeter() As Single

End Class

Visual C#// Definición de clase abstracta.public abstract class Shape{

public Shape(){}

public abstract float Top{get; set;}public abstract float Left{get; set;}public abstract float Area();public abstract float Perimeter();

}

Observe que los miembros MustOverride en Visual Basic o abstract en C# son solo definiciones – no haycuerpo de procedimiento porque estos procedimientos se definirán (sustituirán) en la clase derivada.

La siguiente clase Circle demuestra cómo se hereda de una clase abstracta. En Visual Basic .NET la palabra clave Inherits declara que esta clase está basada en la clase base Shape (1). La palabra clave Overrides (2) esnecesaria en cada una de las definiciones de miembros que sustituyen a miembros de la clase base. En C# la de-finición de clase (1) declara que esta clase se basa en la clase base abstracta Shape. La palabra clave override (2)es necesaria en la declaración de cada miembro que sustituye a un miembro de la clase base abstracta.




41

Visual Basic .NETPublic Class Circle

Inherits Shape ' (1)Private sxCenter, syCenter As SinglePrivate sRadius As Single

Public Overrides Property Top() As Single ' (2)Get

Top = sxCenter - sRadius

End GetSet(ByVal Value As Single)sxCenter = Value + sRadius

End SetEnd Property

Public Overrides Property Left() As SingleGet

Left = syCenter - sRadiusEnd GetSet(ByVal Value As Single)

syCenter = Value + sRadiusEnd Set

End Property

Public Overrides Function Area() As SingleArea = 2 * System.Math.PI * (sRadius ^ 2)

End Function

Public Overrides Function Perimeter() As SinglePerimeter = 2 * sRadius * System.Math.PI

End Function

Public Property Radius() As SingleGet

Radius = sRadiusEnd GetSet(ByVal Value As Single)

sRadius = ValueEnd Set

End Property

Public Overridable Sub Center(ByVal X As Single, ByVal Y As Single)sxCenter = XsyCenter = Y

End SubEnd Class

Visual C#public class Circle : Shape{ // (1)

float fxCenter, fyCenter, fRadius;

// Constructor.public Circle(){

// Inicializa variables internas.fxCenter = 0;fyCenter = 0;

fRadius = 0;}

public override float Top{ // (2)get{return fxCenter - fRadius; }set{fxCenter = value + fRadius; }

}

public override float Left{get{return fyCenter - fRadius; }set{fyCenter = value + fRadius; }

}

public override float Area(){return (float)(2 * System.Math.PI * Math.Pow((double)fRadius, 2));

}

public override float Perimeter(){return 2 * fRadius * (float)System.Math.PI;

}



MCAD/MCSD

42

public float Radius{get{return fRadius; }set{fRadius = value; }

}

public virtual void Center(float X, float Y){fxCenter = X;fyCenter = Y;

}

}

3.1.4 InterfacesLos interfaces son similares a las clases abstractas en que ambos proporcionan una plantilla que se puede usa

para crear nuevas clases. La diferencia es que los interfaces no proporcionan la implementación de ningún miembro base, mientras que las clases abstractas pueden implementar miembros comunes a todas las clases derivadas.

Los interfaces se parecen más a tipos que a clases. Cuando se implementa un interface concreto en una clase,las instancias de esta clase se pueden usar en lugar de cualquier argumento o variable declarado como del tipo delinterface2. Por ejemplo, el siguiente código declara un interface para los objetos forma creados anteriormente:

Visual Basic .NET‘Interface para todas las formas.Public Interface IFigure

Property Top() As SingleProperty Left() As SingleFunction Area() As SingleFunction Perimeter() As Single

End Interface

Visual C#//Interface para todas las formaspublic interface IFigure{

float Top{get; set;}float Left{get; set;}float Area();float Perimeter();

}

Para usar el interface impleméntelo en una clase como se muestra aquí en negrita

Visual Basic .NET' Definición de clase abstracta.Public MustInherit Class Shape

Implements IFigurePublic MustOverride Property Top() As Single Implements IFigure.TopPublic MustOverride Property Left() As Single Implements IFigure.LeftPublic MustOverride Function Area() As Single Implements IFigure.AreaPublic MustOverride Function Perimeter() As Single Implements

IFigure.PerimeterEnd Class

Visual C#public abstract class Shape : IFigure{

// Constructor.public Shape(){}public abstract float Top{get; set; }public abstract float Left{get; set; }public abstract float Area();public abstract float Perimeter();

}

Como la clase abstracta Shape de este ejemplo implementa el interface IFigure, todas las clases derivadas deShape heredan también la implementación de IFigure. Esto significa que todos los objetos de los tipos Circle ySphere, que derivan de Shape, se pueden usar como argumentos del tipo IFigure, como muestran las siguientesllamadas a procedimientos:


ByVal e As System.EventArgs) Handles MyBase.Load' Crea un círculo.Dim MyCircle As New Circle()MyCircle.Radius = 2MyCircle.Center(10, 2)' Crea una esfera.Dim MySphere As New Sphere()MySphere.Radius = 10MySphere.Center(10, 20, 25)

2 Que yo sepa, esto sucede también cuando se hereda de una clase base. Desde siempre, una clase es un tipo. (N. del T.)




43

' Muestra información sobre las formas.ShowShapeInfo(MySphere)ShowShapeInfo(MyCircle)

End Sub

' Muestra la información de forma en el formulario Web.Sub ShowShapeInfo(ByVal Shape As IFigure)

Response.Write("Arriba: " & Shape.Top & "<br>")Response.Write("Izquierda: " & Shape.Left & "<br>")

Response.Write("Volumen: " & Shape.Volume & "<br>")Response.Write("Superficie: " & Shape.Area & "<br>")Response.Write("Perímetro: " & Shape.Perimeter & "<br>")

End Sub


// Crea un círculo.Circle MyCircle = new Circle();MyCircle.Radius = 2;MyCircle.Center(10, 2);// Crea una esfera.Sphere MySphere = new Sphere();MySphere.Radius = 10;MySphere.Center(10,20,25);

// Muestra información sobre cada esfera.ShowShapeInfo(MySphere);ShowShapeInfo(MySphere);

}

// Muestra información de la forma en el formulario Web.private void ShowShapeInfo(IFigure Shape){

// Como el argumento Shape es un IFigure sabemos que tiene estos miembros.Response.Write("Arriba: " + Shape.Top + "<br>");Response.Write("Izquierda: " + Shape.Left + "<br>");Response.Write("Perímetro: " + Shape.Perimeter() + "<br>");Response.Write("Superficie: " + Shape.Area() + "<br>");

}

La clave es que todos los elementos definidos en el interface deben existir en cualquier clase que implemente

el interface. Si se omite cualquier miembro Visual Studio genera un error en compilación.3.2 Espacios de nombres en una aplicación Web

En esta lección aprenderá como recorrer los espacios de nombres ASP.NET para encontrar los objetos que seusan para crear una aplicación Web. También verá como usar los objetos Application, Page, Request y Response enel código. Estos cuatro objetos forman el núcleo de la programación de aplicaciones Web.

3.2.1 Generalidades de los espacios de nombres WebLas definiciones de clase para los objetos usados en aplicaciones Web residen en el espacio de nombres Sys-

tem.Web. La tabla 3.4 muestra la jerarquía del espacio de nombres y describe los tipos de definiciones de clase quese encuentran en cada uno. Use esta tabla como guía para buscar los objetos que realizan tareas concretas.

Tabla 3. 4: Jerarquía de espacios de nombres WebEspacio de Nombres Contiene clases para

System.Web Objetos Application , Browser , Cache , Cookies , Exception , Request , Response , Server y Trace . Estasclases se usan en la mayoría de las tareas de programación Web. El objeto Application definido enGlobal.asax se basa en la clase Application .

System.Web.SessionState Objeto Session . Use esta clase para grabar y recuperar elementos en el estado de sesión.System.Web.Services Objeto WebService . Use esta clase para crear y usar servicios Web.System.Web.UI Objetos Control y Page . Use estas clases dentro de un formulario Web para crear y controlar el

interface de usuario de la aplicación Web. Los formularios Web están basados en la clase Page .System.Web.UI.WebControls Todos los objetos control de servidor. Use estas clases dentro de formularios Web.System.Web.UI.HTMLControls Todos los objetos control HTML. Use estas clases dentro de formularios WebSystem.Web.Caching Objeto Cache . Use esta clase para controlar el caché de lado cliente para mejorar las prestaciones

de las aplicaciones.System.Web.Mail Objetos MailMessage , MailAttachment y SmtpMail . Use estas clases para enviar mensajes de

correo desde su aplicación.System.Web.Security Objetos y módulos de autenticación. Use estas clases para autenticar usuarios y proporcionar

seguridad dentro de su aplicación.

Cuando se programa una aplicación web se trata directamente con dos tipos de objetos derivados de clases delos espacios de nombres Web:



MCAD/MCSD

44

• Objeto Application: Derivado de la clase HttpApplication. En la aplicación, esta definición reside en el ar-chivo Global.asax.

• Objetos formulario Web: derivados de la clase Page, En la aplicación, esta definición reside en los módulosde formulario Web.

El siguiente código muestra las declaraciones que genera Visual Studio para las clases Global y WebForm1.Estas clases las instancia automáticamente el motor de ejecución de ASP.NET.

Visual Basic .NETPublic Class Global

Inherits System.Web.HttpApplicationEnd Class

Public Class WebForm1Inherits System.Web.UI.Page

End Class

Visual C#public class Global : System.Web.HttpApplication {}

public class WebForm1 : Sytem.Web.UI.Page {}

Estos objetos Global y WebForm1 son los puntos de entrada que se usan parallegar a otros objetos Web en una aplicación. Estos objetos, junto con Request y Response son los que se usan con mayor frecuencia en el código. Las siguientessecciones explican cómo usar los objetos Application, Page, Request y Response para moverse entre otros objetos.

3.2.2 Uso del objeto ApplicationEl objeto Application es un objeto de más alto nivel en la jerarquía de objetos

de la aplicación Web. Use el objeto Application para configurar su aplicación y paraguardar información de estado. El objeto Application tiene propiedades y métodosque proporcionan a otros objetos de la aplicación, como muestra la figura 3.1.

Cuando ASP.NET arranca una aplicación instancia automáticamente el objetoGlobal definido en Global.asax. Use los sucesos del objeto Global para configurar suaplicación y para inicializar variables de estado a nivel de aplicación.

La clase base HttpApplication proporciona las propiedades y métodos para acceder a objetos subordinadosdel objeto Global. Estas propiedades y métodos se muestran en la tabla 3.5. Use estas propiedades y métodos paraobtener otros objetos desde el objeto Application.

Tabla 3. 5: Propiedades y métodos del objeto ApplicationPropiedad/ Método

Se usa para

Application Grabar elementos de datos en el estado de aplicaciónContext Obtener Trace , Cache , Error y otros objetos para el contexto actualModules Acceso a módulos HTTP.Request Leer una petición y obtener objetos Browser , ClientCertificates , Cookies y Files para la petición actual.Response Escribir texto o datos en una respuesta y obtener objetos Cache , Cookies y Output de la respuesta actual.Server Procesar peticiones y respuestas. El objeto Server proporciona métodos auxiliares para codificar y decodificar URL,s.Session Grabar elementos de datos en el estado de sesión.User Obtener información de autenticación sobre el usuario que está haciendo la petición actual. De forma

predeterminada, las aplicaciones Web permiten acceso anónimo.El siguiente código usa los objetos Request y Browser disponibles desde el objeto Application para determi-

nar si el navegador que hace la petición es de versión 4.0 o posterior.

Visual Basic .NETSub Application_BeginRequest(ByVal sender as Object, ByVal e as EventArgs)

‘Se dispara al comienzo de cada peticiónIf Request.Browser.MajorVersion < 4 Then

‘Desactiva características avanzadasEnd If

End Sub

Visual C#protected void Application_BeginRequest(Object sender, EventArgs e){

//Se dispara al comienzo de cada peticiónif(Request.Browser.MajorVersion < 4){

//Desactiva características avanzadas}

}

Fig 3. 1: Objeto Application




45

3.2.3 Uso del objeto PageEl objeto Page controla el interface de la aplicación. Este objeto tiene propiedades y métodos que proporcio-

nan acceso a otros objetos en el interface de usuario, como muestra la figura 3.2.

Cuando un usuario solicita una página de la aplicación ASP.NET instancia automáticamente el formularioWeb y muestra la página. Se añaden procedimientos de suceso al formulario para controlar el interface e interactuar con el usuario.

La clase base Page proporciona los métodos y propiedades centrales que se usan cuando se programan for-mularios Web. Estas propiedades y métodos se muestran en la tabla 3.6.

Tabla 3.6: Propiedades y métodos del objeto Page

El siguiente código añade un nuevo control al formulario Web en tiempo de ejecu-ción.


ByVal e As System.EventArgs) Handles MyBase.Load‘Crea un nuevo controlDim txtNew As New TextBox()‘Establece el texto que se muestra en el controltxtNew.Text = “Un poco de texto”‘Añade el control entre los elementos <form></form>FindControl(“Form1”).Controls.Add(txtNew)

End Sub


//Crea un nuevo controlTextBox txtNew = New TextBox();//Establece texto para mostrar en el controltxtNew.Text = “Un poco de texto”;//Añade el control entre los elementos <form></form>.FindControl[“form1”].Controls.Add(txtNew);

}

3.2.4 Uso del objeto RequestEl objeto Request contiene la información enviada por el navegador cliente

cuando se solicita una página de la aplicación. El objeto Request tiene propiedades y

métodos que proporcionan acceso a los otros objetos que componen la petición, comomuestra la figura 3.3.

El objeto Request proporciona los métodos y propiedades que se muestran en latabla 3.7 para acceder a los objetos subordinados.

Tabla 3. 7: Propiedades y métodos del objeto RequestPropiedad /Método

Se usa para

Browser Determina las posibilidades del navegador que hace la petición. Las propiedades del navegador proporcionan elnúmero de versión, determinan si es AOL, si soporta cookies, y otra información

ClientCertificates Autentifica el cliente.Cookies Obtiene información procedente del cliente en forma de cookiesFiles Obtiene los archivos subidos por el clienteInputStream Lee y escribe los datos en bruto enviados al cliente

El siguiente código usa el objeto Request para comprobar si el navegador soporta cookies y si existe una coo-kie concreta antes de grabar el valor de una cookie en el estado de sesión.

Propiedad/ Método

Se usa para

Application Grabar elementos de datos en el estado de aplicaciónCache Controlar la forma en que se guardan en caché las respuestas en el servidor.Controls Obtener los controles de la páginaRequest Leer una petición y obtener los objetos Browser , ClientCertificates , Cookies y Files de

la petición actualResponse Escribir texto o datos en la respuesta y obtener los objetos Cache , Cookies y Output

de la respuesta actualServer Procesar peticiones y respuestas. El objeto Server proporciona métodos auxiliares

para codificar y decodificar URL,sSession Grabar elementos de datos en el estado de sesiónTrace Activar o desactivar el seguimiento de traza y escribir en el registro e traza

Fig 3. 3: Objeto Request

Fig 3. 2: Objeto Page



MCAD/MCSD

46


ByVal e As System.EventArgs) Handles MyBase.Load‘Se ejecuta la primera vez que se muestra la páginaIf Not IsPostBack Then

‘Comprueba si el navegador soporta cookiesIf Request.Browser.Cookies Then

‘Comprueba si existe la cookie UNameIf Not IsNothing(Request.Cookies(“UName”)) Then

‘Graba el valor de la cookieSession(“User”) = Request.Cookies(“UName”).Value

End IfEnd If

End IfEnd Sub


//Se ejecuta la primera vez que se muestra la páginaif(!IsPostBack)

//Comprueba si el navegador soporta cookiesif(Request.Browser.Cookies)

//Comprueba si existe la cookie UNameif(Request.Cookies[“UName”] != null)

//Obtiene el valor de la cookieSession[“User”] = Request.Cookies[“UName”].Value;

}

3.2.5 Uso del objeto ResponseUse el objeto Response para dar forma a la respuesta enviada desde el servidor

al navegador cliente. El objeto Response tiene propiedades y métodos que proporcio-nan acceso a otros objetos que componen la respuesta, como muestra la figura 3.4.

El objeto Response proporciona los métodos y propiedades que se muestran enla tabla 3.8:

Tabla 3. 8: Propiedades y Métodos del Objeto ResponsePropiedad

/ Método

Se usa para

Cache Determina cómo almacena el servidor en caché las respuestas antes de enviarlas al clienteCookies Configura el contenido de las cookies que se envían al clienteOutput Obtiene o establece los datos en bruto enviados al cliente como respuesta.

El siguiente código crea una cookie y la envía al cliente como parte de la respuesta.


ByVal e As System.EventArgs) Handles MyBase.Load' Se ejecuta la primera vez que se muestra la página.If Not IsPostBack Then

' Si el navegador soporta cookies.If Request.Browser.Cookies Then

' Crea una cookie.

Dim cookUname As New HttpCookie("UName")cookUname.Value = "Wombat"' Añade la cookie.Response.Cookies.Add(cookUname)

End IfEnd If

End Sub


if(!IsPostBack)// Si el navegador soporta cookies.if (Request.Browser.Cookies){

// Crea una cookie.HttpCookie cookUname = new HttpCookie("UName");

cookUname.Value = "Wombat";

Fig 3. 4: Objeto Response




47

// Añade la cookie.Response.Cookies.Add(cookUname);

}}

3.3 Mantenimiento de información de estadoEn esta lección aprenderá cómo retener datos en un formulario Web entre peticiones. ASP.NET proporciona

diferentes mecanismos para guardas datos de formularios, dependiendo de la naturaleza y alcance de la información.

3.3.1 Niveles de estadoComo se explicó en el Capítulo 2, Crear Aplicaciones de Formulario Web, los formularios Web se crean y se

destruyen cada vez que un navegador cliente hace una petición. Debido a esto las variables declaradas dentro de unformulario Web no mantienen su vale tras mostrar la página. Para resolver este problema ASP.NET proporciona lassiguientes formas de mantener variables entre peticiones:

• Cadenas de Consulta: Se usan para pasar información en peticiones y respuestas como parte de una direc-ción Web. Las cadenas de consulta son visibles para el usuario, por lo que no deben contener informaciónsensible, como contraseñas.

• Cookies: Use las cookies para almacenar pequeñas cantidades de información en un cliente. Los clientes po-drían rechazar las cookies, por lo que el código tiene que anticipar esta posibilidad.

• Estado de Vista: ASP.NET almacena los elementos añadidos a la propiedad ViewState como campos ocultos

en la página.• Estado de Sesión: Use las variables Session para almacenar elementos que quiere mantener locales a la se-

sión (usuario) actual.• Estado de Aplicación: Use las variables Application para almacenar elementos que quiere que estén dispo-

nibles para todos los usuarios de la aplicación.

3.3.2 Uso de cadenas de consultaLas cadenas de consulta permiten enviar información adicional junto con una dirección. En HTML las cade-

nas de consulta aparecen tras un interrogante en un hiperenlace, en la forma:

<A HREF=”WebForm1.aspx?UName=Wombat”>Ejemplo de cadena de consulta</A>

Para enviar una cadena de consulta en el código añádala a la dirección de un método Redirect . El siguiente procedimiento de suceso Click es equivalente al HTML anterior:


ByVal e As System.EventArgs) Handles Button1.Click‘Vuelve a mostrar esta página con una cadena de consultaServer.Redirect(“WebForm1.aspx?UName=Wombat”)

End Sub


//Vuelve a mostrar esta página con una cadena de consultaServer.Redirect(“WebForm1.aspx?UName=Wombat”);

}

Para recuperar una cadena de consulta en el código use el método QueryString del objeto Response. El si-

guiente código muestra el elementoUName

de la cadena de consulta creada en los ejemplos anteriores.Visual Basic .NETPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.Load‘Muestra la cadena de consultaResponse.Write(Request.QueryString(“UName”))

End Sub


//Muestra la cadena de consultaResponse.Write(Request.QueryString(“UName”))

}

3.3.3 Uso de cookiesUse cookies para almacenar pequeñas cantidades de información en la máquina del cliente. Los sitios Web

las usan a menudo para almacenar las preferencias del cliente u otra información específica del cliente. Como lascookies pueden ser rechazadas es importante comprobar que el navegador las admite antes de intentar crearlas.



MCAD/MCSD

48

El siguiente código comprueba si un navegador permite cookie y si lo hace graba las preferencias del usuario.



‘Si el navegador soporta cookiesIf Request.Browser.Cookies Then

‘Crea una CookieDim cookUPrefs As New HttpCookie(“UPrefs”)cookUPrefs.Value = “Español”‘Añade la cookieResponse.Cookies.Add(cookUPrefs)

End IfEnd If

End Sub


//Se ejecuta la primera vez que se muestra la páginaIf(!IsPostBack)

//Si el navegador soporta cookiesIf(Request.Browser.Cookies){

//Crea una cookieHttpCookie cookUPrefs = new HttpCookie(“UPrefs”);cookUPrefs.Value = “Español”;//Añade la cookieResponse.Cookies.Add(cookUPrefs);

}}

El siguiente código comprueba la existencia de una cookie y la lee si existe:



‘Comprueba si el navegador soporta cookiesIf Request.Browser.Cookies Then‘Comprueba si existe la cookie UPrefsIf Not IsNothing(Request.Cookies(“UPrefs”)) Then

‘Graba el valor de la cookieSession(“Lang”) = Request.Cookies(“UPrefs”).Value

End IfEnd If

End IfEnd Sub


//Se ejecuta la primera vez que se muestra la páginaif(!IsPostBack)

//Comprueba si el navegador soporta cookiesif(Request.Browser.Cookies)

//Comprueba si existe la cookie UPrefsif(Request.Cookies[“UPrefs”] != null)

//Graba el valor de la cookieSession[“Lang”] = Request.Cookies[“UPrefs”].Value;

}

3.3.4 Uso del estado de vistaUse la propiedad ViewState para guardar datos en un campo oculto en una página. Como ViewState guarda

los datos en la página, está limitado a elementos que se puedan serializar. Si quiere guardar elementos más complejos tendrá que convertirlos a y de una cadena.

Por ejemplo, el siguiente código añade texto de una caja de texto a celdas de una tabla en la página. Como no

se pueden almacenar directamente objetos en ViewState es necesario almacenar las cadenas en el procedimiento Button1_Click y después crear los controles fila de tabla a partir de las cadenas, como muestra el procedimientoPage_Load :




49


ByVal e As System.EventArgs) Handles Button1.Click' Añade texto a ViewStateViewState.Add(ViewState.Count, TextBox1.Text)

End Sub

Private Sub Page_Load(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles MyBase.Load

Dim iCount As Integer' Para cada elemento del estado de vistaFor iCount = 0 To ViewState.Count

Dim rowNew As New TableRow()Dim celNew As New TableCell()' Configura el texto de la celda.celNew.Text = ViewState(iCount)' Añade la celda a la fila.rowNew.Cells.Add(celNew)' Añade la fila a la tablaTable1.Rows.Add(rowNew)

NextEnd Sub

Visual C#

private void Button1_Click(object sender, System.EventArgs e){// Añade texto al estado de vista.ViewState.Add(ViewState.Count.ToString(), TextBox1.Text);

}

private void Page_Load(object sender, System.EventArgs e){if (IsPostBack)

// Para cada elemento en ViewStateforeach(StateItem staItem in ViewState.Values) {

TableRow rowNew = new TableRow();TableCell celNew = new TableCell();// Configura el texto de la celda.celNew.Text = staItem.Value.ToString();// Añade la celda a la fila.rowNew.Cells.Add(celNew);

// Añade la fila a la tabla.Table1.Rows.Add(rowNew);}

}

ASP.NET codifica los datos ocultos que se almacenan en la página de forma que no son inteligibles para losusuarios. Si añade unos cuantos elementos a la tabla usando el código anterior y después selecciona Ver Fuente ensu navegador, el HTML para el campo oculto es algo como esto:

</HEAD><body MS_POSITIONING="GridLayout"><form name="Form1" method="post" action="WebForm1.aspx" id="Form1"><input type="hidden" name="__VIEWSTATE" value="dDwtMTMwNzIzMzU0Mzt0PHA8bDwwOzE7MjszOzQ7PjtsPFxlO1RoaXMgaXMgc29tZSB0ZXh0O1RoaXMgaXMgc29tZSB0ZXh0O1RoaXMgaXMgc29tZSB0ZXh0O1RoaXMgaXMgc29tZSB0ZXh0Oz4+Ozs+Oz4=" />

Usar los estados de aplicación y de sesiónUse Application y Session para guardar datos que quiera mantener durante el tiempo de vida de la aplica-

ción o de una sesión respectivamente. Puede almacenar cualquier tipo de datos en Application o Session, inclu-yendo objetos. Sin embargo, antes de usarlo debe considerar los siguientes puntos:

• Las variables de estado Application y Session se crean sobre la marcha, sin comprobación de nombre o tipo.Debe limitar sus puntos de acceso a estas variables.

• El mantenimiento de estado de sesión afecta a las prestaciones. Se puede desactivar a niveles de aplicación y página.

• Las variables de estado de aplicación están disponibles en el proceso actual, pero no entre procesos. Si sehace crecer una aplicación para que corra en varios servidores o en varios procesadores dentro de un servidor,cada proceso tiene su propio Application.

• Los límites de aplicación establecidos por IIS determinan el alcance de Application.



MCAD/MCSD

50

Estructurar el acceso a variables de estadoLas variables de estado Application y Session son potentes y, por tanto, amedrentadoras. Es fácil introdu-

cir en el código errores al estilo de Basic si se usan de una forma no estructurada. Por ejemplo, el siguiente códi-go crea dos variables distintas en Application:

Visual Basic .NETApplication(“Uname”) = “Wombat”Response.Write(Application(“Unamme”))

Visual C#Application[“Uname”] = “Wombat”;Response.Write(Application[“Unamme”]);

La primera línea crea una variable y le asigna un texto. La segunda línea recupera una nueva variable, va-cía y no muestra nada, sencillamente porque el nombre de variable está mal escrito. Aquí el problema es obvio, pero si ocurre en las profundidades de una estructura de decisión puede ser muy difícil de encontrar.

Para mejorar este problema estructure su acceso a las variables de Application y Session. La forma másfácil de hacerlo es declarar una variable a nivel de página para cada elemento que necesite, recupere los valoresde Application y Session en el procedimiento de suceso Page_Load y grábelos en el procedimiento de sucesoPage_Unload . Puede ser conveniente que la recuperación y grabación de variables de estado en un lugar cohe-rente sea parte de sus normas de codificación.

El siguiente código muestra la estructuración del acceso a sus variables de estado.

Visual Basic .NETPublic Class WebForm1

' Declara una variable a nivel de página.Dim mstrUname As String


' Lee la variable de estado.mstrUname = Application("Uname")' Modifica la variablemstrUname = "Wombat"' Usa la variable.Response.Write(mstrUname)

End Sub

Private Sub Page_Unload(ByVal sender As Object, _ByVal e As System.EventArgs) Handles MyBase.Unload

' Graba las variables de estado.Application("Uname") = mstrUname

End SubEnd Class

Visual C#string mstrUname = "";

private void Page_Load(object sender, System.EventArgs e){// Comprueba si existe la variable de estado.if(Application["Uname"] != null)

// Obtiene la variable de estado.mstrUname = Application["Uname"].ToString();// Modifica la variablemstrUname = "Wombat";// Usa la variable.Response.Write(mstrUname);

}

private void Page_UnLoad(object sender, System.EventArgs e){// Graba las variables de estado.Application["Uname"] = mstrUname;

}

Importante: En Visual C# asegúrese de comprobar si la variable de estado es null antes de llamar a cual-quiera de sus métodos, como ToString(). Si no lo hace recibirá un error en tiempo deejecución si la variable no contiene un valor.

Desactivar el estado de sesiónASP.NET mantiene de forma predeterminada el estado de sesión para cada página de la aplicación. Si una

página no precisa información de estado a nivel de sesión puede desactivarlo para mejorar las prestaciones.




51

Para desactivar el estado de sesión para un formulario Web, en la ventana de propiedades del formularioWeb de el valor False a EnableSessionState.

Para desactivar el estado de sesión para toda una aplicación, en el archivo Web.config de el valor False ala etiqueta <sessionstate mode=>, de la forma <sessionstate mode=false>.

3.4 Resumen• Los espacios de nombres organizan el código y proporcionan acceso al código del marco de trabajo .NET.

Para usar un espacio de nombres desde fuera del proyecto establezca una referencia a él usando el diálogoReferencias del menú Proyecto. Añada una sentencia Imports (Visual Basic) o using (C#) en el archivo fuen-te para proporcionar una forma abreviada de nombrar a los miembros del espacio de nombres en el código.

• Las clases definen objetos dentro de un espacio de nombres. Puede basar una clase en otra usando herencia.Cuando se usa herencia la clase base proporciona sus miembros a la clase derivada, donde pueden ser susti-tuidos, sobrecargados u ocultados.

• Las aplicaciones Web usan los espacios de nombres System.Web y System.Web.UI . Estos espacios de nombres definen la mayoría de los objetos que se usan en una aplicación Web, incluyendo Application, Page, Re-quest y Response. Estos cuatro objetos proporcionan acceso a la mayoría de los objetos subordinados en unaaplicación Web.

• Como las variables ordinarias definidas en un formulario Web no son persistentes necesita grabar los datosvolátiles entre peticiones. ASP.NET permite grabar elementos de datos mediante cadenas de consulta, coo-kies, ViewState, Session y Application.

3.5 Práctica: Usar objetos y grabar datosEn esta práctica creará la aplicación Translator. Creará un formulario Web y un módulo de clase. Creará una

instancia de un objeto en el módulo Global, grabará la instancia en Session y en el estado de vista desde el formula-rio Web.

3.5.1 Crear el interface de usuarioEn este ejercicio creará el interface de usuario añadiendo controles de servidor al formulario Web.

►Para crear un nuevo proyecto de aplicación Web1. Abra un nuevo proyecto de aplicación Web ASP.NET. En la caja de diálogo Nuevo Proyecto escriba el

nombre Translator y pulse Aceptar.2. En la ventana de propiedades cambie el nombre del archivo WebForm1.aspx a Translator.aspx.

►Para añadir controles al interface de usuarioAñada los controles de la siguiente tabla, con las propiedades indicadas:

Control Tipo de Control Propiedad ValorLabel1 Label Text Traductor Universal

Font Bold, Large

TextBox1 Text Box ID txtSourceTextMode Multicine

Button1 Button ID butTranslateText Traducir

3.5.2 Crear una clase Translator

En este ejercicio creará una clase Friend para contener la lógica y los datos de la aplicación.►Para añadir controles al interface de usuario

1. En el menú Proyecto, seleccione Agregar Clase. Visual Studio muestra la caja de diálogo Agregar NuevoElemento. Llame a la clase TranslatorClass y pulse Aceptar.

2. En la ventana de código añada el siguiente:

Visual Basic .NETFriend Class TranslatorClass

Private mstrText As StringPrivate mstrOriginal As String

' Controla el acceso a las variables a nivel de móduloPublic Property Text() As String

Get

Text = mstrTextEnd Get



MCAD/MCSD

52

Set(ByVal Value As String)mstrText = Value' Mantiene una copia del original para restaurar.mstrOriginal = Value

End SetEnd Property

' Restaura el texto traducido al original.Public Sub Restore()

mstrText = mstrOriginalEnd Sub

' Traduce el valor de la propiedad Text.Public Sub Translate()

Dim strWord As String, intCount As IntegerDim arrWords() As StringDim bCaps As Boolean' Convierte la cadena en array usando System.String.arrWords = mstrText.Split(" ")For intCount = 0 To UBound(arrWords)

' Comprueba si la palabra tiene mayúscula.If LCase(arrWords(intCount)) <> arrWords(intCount) Then

bCaps = TruearrWords(intCount) = LCase(arrWords(intCount))

End IfstrWord = arrWords(intCount)' Hace la traducción.If strWord <> "" Then

strWord = Right(strWord, Len(strWord) - 1) & _Left(strWord, 1) & "ay"

' Vuelve a mayúscula si es necesario.If bCaps Then

strWord = UCase(Left(strWord, 1)) & _Right(strWord, Len(strWord) - 1)

End IfEnd If' Vuelve a almacenar en el array.arrWords(intCount) = strWord' Restaura el indicador de mayúscula.

bCaps = FalseNext' Reconstruye la cadena a partir del array.mstrText = String.Join(" ", arrWords)

End SubEnd Class

Visual C#internal class TranslatorClass{

string mstrText, mstrOriginal;

// Controla el acceso a las variables a nivel de clase.public string Text {

get{return mstrText; }set{

mstrText = value;// Mantiene una copia del original para restaurar.mstrOriginal = value;

}}

// Restablece el texto traducido al original.public void Restore(){mstrText = mstrOriginal; }




53

// Traduce el valor de la propiedad Text.public void Translate(){

string strWord;string[] arrWords;bool bCaps = false;// Convierte la cadena en array usando System.String.arrWords = mstrText.Split(' ');for(int intCount = 0; intCount <= arrWords.GetUpperBound(0); intCount++){

// Cambia a minúsculas.

strWord = arrWords[intCount].ToLower();// Comprueba si la palabra lleva mayúsculas.if(!arrWords[intCount].Equals(strWord))

bCaps = true;// Hace la traducción.if(strWord != "") {

strWord = strWord.Substring(1,strWord.Length - 1) +strWord.Substring(0,1) + "ay";

// Vuelve a poner mayúsculas si es necesario.if(bCaps)

strWord = strWord.Substring(0,1).ToUpper() +strWord.Substring(1, strWord.Length - 1);

}// Vuelve a almacenar la palabra en el array.arrWords[intCount] = strWord;// Restablece el indicador de mayúsculas.bCaps = false;

}// Reconstruye la cadena a partir del array.mstrText = String.Join(" ", arrWords);

}}

3.5.3 Almacenar un objeto Translator en sesiónEn este ejercicio añadirá al archivo Global.asax el código para inicializar una variable de estado de sesión

que contenga el objeto TranslatorClass que usará el formulario Web.

►Para crear una variable de estado de sesión1. En la ventana de proyecto pulse dos veces sobre el archivo Global.asax y después pulse el enlace haga

click aquí para cambiar a la vista de códigos.2. En la ventana de código añada el siguiente procedimiento Session_Start :

Visual Basic .NETSub Session_Start(ByVal sender As Object, ByVal e As EventArgs)

‘Crea un nuevo objeto TranslatorDim TransClass As New TranslatorClass()‘Almacena el objeto en una variable de estado de sesiónSession(“TransClass”) = TransClass;

End Sub

Visual C#protected void Session_Start(Object sender, EventArgs e){

//Crea un nuevo objeto TranslatorTranslatorClass TransClass = new TranslatorClass();//Almacena el objeto en una variable de estado de sesiónSession[“TransClass”] = TransClass;

}

3.5.4 Use el objeto TransClass en los sucesos del formulario WebEn este ejercicio añadirá al formulario Web el código para usar el objeto TransClass almacenado en la varia-

ble de estado de sesión. También usará una variable booleana guardada en el estado de vista de la página para cambiar la función del botón de Traducir a Restablecer .

►Para crear una variable de estado de sesión1. Abra el módulo de código del formulario en la ventana de código2. Declare una variable para guardar el objeto del estado de sesión.Visual Basic

Dim TransClass As TranslatorClassVisual C#TranslatorClass TransClass;



MCAD/MCSD

54

3. Añada el siguiente código en el procedimiento de suceso Page_Load para asignar la variable de estadode sesión a la variable declarada en el punto anterior.

Visual BasicPrivate Sub Page_Load(ByVal sender As Sytem.Object, _

ByVal e as System.EventArgs) Handles MyBase.Load‘Lee la variable de sesión TransClassTransClass = Session(“TransClass”)

End Sub

Visual C#private void Page_Load(Object sender, System.EventArgs e){//Se asegura de que existe la variable de sesiónif(Session[“TransClass”] != null)

//Lee la variable de sesiónTransClass = (TranslatorClass)Session[“TransClass”];

}

4. Añada el siguiente código al procedimiento de suceso but_Translate.Click :Visual Basic .NETPrivate Sub butTranslate_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butTranslate.Click' Declara un indicador booleano.Dim bSwitch As Boolean' Lee el valor de ViewState y lo invierte.bSwitch = Not Viewstate("bSwitch")' Guarda el nuevo valor en ViewState.ViewState("bSwitch") = bSwitch' Usa el indicador para traducir o restablecer el texto.If bSwitch Then

TransClass.Text = txtSource.Text ' Lee el texto.TransClass.Translate() ' Lo traducetxtSource.Text = TransClass.Text ' Muestra el texto.butTranslate.Text = "Restablecer" ' Cambia el texto del botón.

ElseTransClass.Restore() ' Restablece el texto original.txtSource.Text = TransClass.Text ' Muestra el texto.butTranslate.Text = "Traducir" ' Cambia el texto del botón.

End If

End SubVisual C#private void butTranslate_Click(object sender, System.EventArgs e){

// Declara un indicador booleano.bool bSwitch;// Comprueba si existe la variable en ViewState.if(ViewState["bSwitch"] != null)

// Lee el valor de ViewState y lo invierte.bSwitch = !(bool)ViewState["bSwitch"];

else// Configura el indicador.bSwitch = true;

// Graba el nuevo valor en ViewState.ViewState["bSwitch"] = bSwitch;

// Usa el indicador para traducir o restablecer el texto.if (bSwitch){

TransClass.Text = txtSource.Text; // Lee el texto.TransClass.Translate(); // Lo traduce.txtSource.Text = TransClass.Text; // Muestra el texto.butTranslate.Text = "Restablecer"; // Cambia el texto del botón.

}else{

TransClass.Restore(); // Restablece el texto original.txtSource.Text = TransClass.Text; // Muestra el texto.butTranslate.Text = "Traducir"; // Cambia el texto del botón.

}}

5. Ejecute y pruebe la aplicación




55

3.6 ResumenLas siguientes preguntas están pensadas para reforzar información clave presentada en este capítulo. Si no es

capaz de contestar una pregunta, repase la lección apropiada e intente contestar de nuevo. Las respuestas a estas preguntas se pueden encontrar en el Capítulo 16.

1. ¿Cómo organiza el marco de trabajo .NET sus clases?

2. En Visual Basic .NET ¿Cuál es la diferencia entre un módulo de clase y un módulo de código?

3. En Visual C#, ¿Cómo se declara un método para que esté disponible sin tener que instanciar un objeto dela clase?

4. ¿Cómo se llama a un miembro de la clase base desde dentro de una clase derivada?

5. ¿Cuáles son los cuatro objeto principales usados en la programación de aplicaciones Web?

6. ¿Dónde grabaría los siguientes elementos de datos de modo que sean persistentes entre peticiones a unformulario Web?

• Un control creado en tiempo de ejecución

• Un objeto que proporciona servicio a todos los usuarios

• Preferencias de usuario



MCAD/MCSD

56




57

4 Crear un interface de usuarioEn este capítulo aprenderá cómo usar los controles ASP.NET para crear un interface de usuario para aplica-

ciones de formularios Web con varias páginas. Aprenderá sobre los diferentes estilos de formularios Web, cómoelegir controles según la tarea que quiera que ejecuten, cómo validar campos de datos y cómo desplazarse entre páginas Web en su aplicación.

Antes de comenzar deberá estar familiarizado con los elementos básicos de HTML y comprender el ciclo devida de los formularios Web tal como se explica en el capítulo 2, Crear Aplicaciones de Formulario Web.

4.1 Usar controlesLos controles son las herramientas para todas las tareas que se realizan sobre un formulario Web. Definen el

aspecto del formulario y proporcionan una forma para obtener información y realizar tareas en beneficio del usuario.

Visual Studio .NET incluye dos tipos diferentes de controles y dos formas de colocar estos controles en elformulario. En esta lección aprenderá sobre estas diferencias y cómo se relacionan con las tareas de programación principales.

4.1.1 Seleccionar una disposiciónCuando se colocan controles en un formulario Web hay dos opciones para la forma en que se ordenan:

• Disposición en Rejilla: Es la predeterminadas. Los controles se colocan exactamente donde se les pone y

tienen posiciones absolutas en la página. Use esta disposición para aplicaciones estilo Windows, en la que nose mezclan los controles con grandes cantidades de texto.• Disposición de Flujo: Coloca los controles en relación con otros elementos de la página. Si se añaden ele-

mentos en tiempo de ejecución los controles que se encuentran tras el nuevo se mueven hacia abajo. Use estadisposición para aplicaciones tipo documento, en las que el texto y los controles están entremezclados.

Para establecer cómo se colocan los controles en una página:

1. Seleccione el formulario Web en la ventana de diseño2. En la ventana de propiedades seleccione el objeto DOCUMENT 3. En la propiedad pageLayout de DOCUMENT seleccione el valor FlowLayout para disposición de flujo o

GridLayout para disposición en rejilla.

La opción GridLayout se usa en formularios que tienen un aspecto fijo. FlowLayout se usa para formularios

Web que incorporan texto y controles.Cuando se crean controles con GridLayout Visual Studio añade a cada control atributos de estilo que fijan su

posición, como muestra, en negrita, en la siguiente definición de formulario:

<form action="webform1.aspx" method="post"enctype="multipart/form-data" runat="server" ID="Form1"><h2>Upload and View Files on Server</h2><INPUT id="filUpload" style="Z-INDEX: 101; LEFT: 86px; WIDTH: 347px;POSITION: absolute; TOP: 20px; HEIGHT: 27px" runat="server"

type="file" size="38"><asp:Button id="butUpload" style="Z-INDEX: 102; LEFT: 357px;

POSITION: absolute; TOP: 60px" runat="server" Text="Upload"Width="74px" Height="31px"></asp:Button>

<asp:ListBox id="lstServerFiles" style="Z-INDEX: 103; LEFT: 86px;POSITION: absolute; TOP: 79px" runat="server" Height="140px"Width="168px"></asp:ListBox>

<asp:Button id="butView" style="Z-INDEX: 104; LEFT: 268px;POSITION: absolute; TOP: 178px" runat="server" Height="31px"Width="76px" Text="View"></asp:Button>

<asp:Image id="imgView" style="Z-INDEX: 106; LEFT: 441px;POSITION: absolute; TOP: 24px" runat="server"Height="132px" Width="162px"></asp:Image>

</form>

Cuando se crean controles con FlowLayout Visual Studio omite el atributo de estilo. Además, puede crear controles pulsando dos veces sobre ellos en la caja de herramientas en lugar de usando arrastrar y soltar. Usar Flow- Layout simplifica la mezcla de controles y texto en un formulario Web, especialmente cuando se edita el fuente delHTML, como muestra la siguiente definición de formulario.



MCAD/MCSD

58

<form id="Form1" method="post" runat="server"><h2>File Manager</h2><p>To create a new file, type the name of the file below and click New.</p><asp:Literal id="litNoFile" runat="server"></asp:Literal><asp:TextBox id="txtNewFile" runat="server" width="191px"> </asp:TextBox><asp:Button id="butNew" runat="server" Width="62px" Height="29px"

Text="New"></asp:Button><p>To edit a file, select the file from the list below and click Edit.

Click Delete to delete the selected file. </p>

<asp:Literal id="litNoneSelected" runat="server"></asp:Literal><asp:ListBox id="lstFiles" runat="server" Width="252px"

Height="161px"></asp:ListBox><br><asp:Button id="butEdit" runat="server" Width="62" Height="29"

Text="Edit"></asp:Button> <asp:Button id="butDelete" runat="server" Width="62px" Height="29px"

Text="Delete"></asp:Button></form>

4.1.2 Elegir el control correctoEn un formulario Web puede elegir controles de servidor o controles HTML. ¿Cuál es la diferencia? Básica-

mente, los controles de servidor son un súper conjunto de los controle HTML, y ofrecen las ventajas que muestra la

tabla 4.1:Tabla 4. 1: Controles de servidor frente a controles HTMLCaracterística Controles de servidor Controles HTML

Sucesos deservidor

Lanzan sucesos específicos en el servidor Sólo pueden lanzar sucesos de servidor a nivel de página(reenvío)

Gestión deestado

Los datos introducidos en el control se mantienenentre peticiones.

Los datos no se mantienen, hay que grabarlos y restaurarlosusando secuencias de comandos a nivel de página.

Adaptación Detectan automáticamente el navegador y adaptansu presentación de forma acorde.

No hay adaptación automática. Hay que detectar el navega-dor mediante código o usar el mínimo común denominador.

Propiedades El marco de trabajo .NET proporciona un conjuntode propiedades para cada control. Las propiedadespermite n cambiar el aspecto del control y sucomportamiento desde código del servidor.

Solo atributos HTML

Entonces ¿por qué usar otra cosa?. Porque los controles HTML tienen una correspondencia uno a uno con loselementos HTML estándar y proporcionan un control más directo sobre lo que aparece en una página. Los controlesHTML se usan por los siguientes motivos:

• Migración desde versiones anteriores de ASP. Puede cargar una aplicación ASP en Visual Studio y revi-sarla gradualmente en lugar de rescribirla completamente. Versiones previas de ASP solo soportaban elemen-tos HTML, y estos elementos se convierten en controles HTML cuando se carga el proyecto en Visual Studio.NET

• No todos los controles precisan sucesos de servidor o control de estado. Esto es particularmente ciertocuando se hace vinculación de datos. Los elementos vinculados normalmente se refrescan a partir del origende datos con cada petición en cada petición, por lo que es más eficiente no mantener información de estado para controles vinculados. Esto significa que puede usar controles HTML o desactivar la gestión de estado para los controles vinculados.

• Con controles HTML tiene control completo sobre la presentación. ASP.NET ajusta el aspecto de loscontroles según el navegador que hace la petición. Los controles HTML no se ajustan, por lo que tiene con-trol directo sobre su aspecto.

Los controles de servidor y HTML proporcionan funcionalidades que se solapan. Por lo general es más fáciltrabajar con controles de servidor. La tabla 4.2 recoge los controles de servidor y HTML según tareas.

Tabla 4. 2: Controles de Servidor Frente a Controles HTMLTarea Controles de servidor Controles HTML

Mostrar texto Label, TextBox, Literal Label, Text Field, Text Area, Password FieldMostrar tablas Table, DataGrid TableSeleccionar de listas DropDownList, ListBox, DataList, Repeater List Box, DropdownEjecutar comandos Button, LinkButton, ImageButton Button, Reset Button, Submit ButtonEstablecer valores CheckBox, CheckBoxList, RadioButton, RadioButtonList Checkbox, Radio ButtonMostar imágenes Image, ImageButton ImageNavegación Hyperlink Ninguno (etiqueta <a> en texto)

Agrupar controles Panel, Placeholder Flow Layout, Gris LayoutTrabajar con fechas Calendar NingunoMostrar anuncios AdRotator NingunoMostrar regla horizontal Literal Horizontal Rule




59

Tarea Controles de servidor Controles HTML

Obtener nombres deficheros del cliente

Ninguno File Field

Guardar datos en la página (lo proporciona la gestión de estado) Input Hidden Validar datos RequiredFieldValidator, CompareValidator,

RangeValidator, RegularExpressionValidator,CustomValidator, ValidationSummary

Ninguno (a nivel página)

Las siguientes secciones describen las tareas de programación principales que se ejecutan con controles para

crear un interface de usuario.4.1.3 Trabajar con texto

Hay muchas formas de mostrar texto en una página. Para texto de solo lectura, puede escribir directamente enel objeto Response, como en Response.Write(“Un texto”); puede usar un control Label; puede usar un controlTextBox y dar a su propiedad ReadOnly el valor True; o puede usar un control Literal y componer el texto enHTML como haría con el método Response.Write.

Para mostrar texto modificable, en cambio, puede usar un control de servidor TextBox. El control TextBoxtiene las propiedades clave de la tabla 4.3.

Tabla 4. 3: Propiedades del Control TextBoxPropiedad Se usa para

Text Leer o escribir los datos del TextBoxTextMode Mostrar texto en una sola línea (SingleLine ), varias líneas (MultiLine ) o de contraseña (Password ). Cuando tiene el

valor Password la caja de texto muestra puntos en lugar de los caracteres escritos.ReadOnly Impedir que el usuario cambie el texto

AutoPostBack Cuando vale True la caja de texto lanza un suceso de envío TextChanged cuando el usuario sale de ella despuésde cambiar su contenido. De forma predeterminada su valor es False y el suceso TextChanged se guarda encaché hasta que se produce otro suceso de envío.

Para ver los controles de texto en acción siga estos pasos para crear una página de conexión:

1. Inicie una nueva aplicación Web con dos formularios llamados Webform1 y Webform2.2. En Webform1 coloque los controles de la siguiente tabla, con los valores de propiedad que se indican:

Control Propiedad ValorLabel1 Text Nombre de UsuarioLabel2 Text ContraseñaTextBox1 ID txtUser

TextBox2 ID txtPasswordTextMode PasswordButton1 ID butOK

Text Aceptar 3. Añada el siguiente código al procedimiento del suceso butOK_Click .

Visual Basic .NETPrivate Sub butOK_Click(ByVal sender As System.Object _

ByVal e As System.EventArgs) Handles butOk.ClickIf txtUser.Text = “Invitado” And txtPassword.Text = “Amigo” Then

Response.Redirect(“Webform2.aspx”)Else

txtPassword.Text = “”End If

End SubVisual C#private void butOK_Click(object sender, System.EventArgs e){

if((txtUser.Text = ”Invitado”) && (txtPassword.Text == “Amigo”))Response.Redirect(“Webform2.aspx”);

elsetxtPassword.Text = “”;

}

4. Ejecute la aplicación. Cuando entre el nombre de usuario y contraseña especificados en el código se muestraWebform2.aspx. Observe que el valor Password en la propiedad TextMode hace que los caracteres introduci-dos sean reemplazados por un símbolo.

Desde luego, normalmente no es una buena idea poner los nombres de usuario y contraseñas en el código. En

el capítulo 8 Mantener la Seguridad se mostrará la forma de grabar y recuperar contraseñas en un archivo seguro enel servidor.



MCAD/MCSD

60

4.1.4 Trabajar con tablas y listasEl texto que se muestra en etiquetas y cajas de texto se coloca en un solo bloque. Para colocar el texto en filas

y columnas necesita usar un control de tablas o de listas descritos en la tabla 4.4. Use los controles ListBox, Drop-DownList y Table para tablas dinámicas sencillas. Use controles DataGrid, DataList y Repeater para tablas y listascomplejas que contienen otros controles o están vinculadas con datos.

Tabla 4. 4: Controles de Lista y de Tabla de ASP.NETPropiedad Se usa para

ListBox Muestra texto de solo lectura en una formato de lista desplazable sencillaDropDownList Muestra texto de solo lectura en una lista desplegable sencillaTable Muestra texto y controles en filas y columnas. Los controles tabla permite construir tablas dinámicamente median-

te código usando colecciones TableRows y TableCells .DataGrid Muestra texto en filas y columnas usando una plantilla para controlar su aspecto. Los controles DataGrid tienen

capacidades de formato, ordenación y paginación incorporadas.DataList Muestra filas de texto y controles usando una plantilla para controlar la apariencia. Los controles DataList tienen

capacidades de formato y selección incorporadas.Repeater Muestra filas de otros controles usando una plantilla para controlar la apariencia. Los controles Repeater no inclu-

yen las capacidades incorporadas en los controles DataGrid y DataList.

4.1.5 Añadir elementos a una lista o tabla en diseñoLos controles ListBox, DropDownList y Table permiten que se añadan elementos estáticos en tiempo de di-

seño usando la caja de diálogo Editor de Colección:

• Para añadir elementos estáticos a un control ListBox o DropDownList seleccione la propiedad Items en laventana de propiedades y pulse el botón junto a (Colección).

• Para añadir elementos estáticos a un control Table seleccione la propiedad Rows en la ventana de propiedadesy pulse el botón junto a (Colección).

4.1.6 Añadir elementos a una lista o tabla en ejecuciónPara añadir elementos a una lista en tiempo de ejecución use el método Add de la colección Items. Por ejem-

plo, el siguiente código añade a un control ListBox y un control DropDownList elementos introducidos en un Text-Box.

Visual Basic .NETPrivate Sub butAdd_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butAdd.Click

ListBox1.Items.Add(txtSource.Text)DropDownList1.Items.Add(txtSource.Text)End Sub

Visual C#private void butAdd_Click(object sender, System.EventArgs e){

ListBox1.Items.Add(txtSource.Text);DropDownList1.Items.Add(txtSource.Text);

}

Tanto el ListBox como el DropDownList almacenan automáticamente los elementos que se les añaden entiempo de ejecución. Sin embargo, el control Table solo almacenará automáticamente los datos para las celdas detabla creadas en tiempo de diseño en el editor de colecciones. Para crear tablas y celdas adicionales en tiempo deejecución necesita reconstruir la tabla a partir de información almacenada en una variable de estado. Por ejemplo, elsiguiente código muestra elementos delimitados por coma introducidos en una caja de texto como celdas en una

tabla, añadiendo filas a la tabla cada vez que el usuario pulsa el botón.Visual Basic .NETPrivate Sub butAdd_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butAdd.Click‘Añade texto al ViewState de la páginaViewState.Add(ViewState.Count, txtSource.Text)‘Reconstruye la tablaRebuildTable()

End Sub

Private Sub RebuildTable()Dim iCount1, iCount2 As IntegerDim arrWords As String()Dim strWords As String




61

' Para cadena guardada en ViewState.For iCount1 = 0 To ViewState.Count - 1

Dim rowNew As New TableRow() ' Crea una nueva fila de tabla.strWords = ViewState(iCount1) ' Lee la cadena del ViewState.arrWords = Split(strWords, ",") ' Divide la lista en un array.For iCount2 = 0 To UBound(arrWords) ' Para cada elemento del array.

Dim celNew As New TableCell() ' Crea una nueva celda de tabla.celNew.Text = arrWords(iCount2) ' Establece el texto de la celda.rowNew.Cells.Add(celNew) ' Añade la celda a la fila de tabla.

NextTable1.Rows.Add(rowNew) ' Añade la fila a la tabla.

NextEnd Sub


ListBox1.Items.Add(txtSource.Text);DropDownList1.Items.Add(txtSource.Text);// Añade texto al ViewState de la página.ViewState.Add(ViewState.Count, txtSource.Text);RebuildTable();

}

private void RebuildTable(){

string[] arrWords;string strWords;TableRow rowNew;TableCell celNew;// Para cada cadena guardada en ViewState.for (int iCount1 = 0; iCount1 < ViewState.Count; iCount1++){

rowNew = new TableRow(); // Crea una nueva fila de tablastrWords = ViewState(iCount1); // Lee la cadena del ViewState.arrWords = Split(strWords, ","); // Divide la lista en un array.// Para cada elemento del array.for (int iCount2 = 0; iCount2 <= arrWords.GetUpperBound; iCount2++){

celNew = new TableCell(); // Crea una nueva celda de tabla.celNew.Text = arrWords[iCount2]; // Establece el texto de la celda.rowNew.Cells.Add(celNew); // Añade la celda a la fila de tabla.

}Table1.Rows.Add(rowNew); // Añade la fila a la tabla.

}}

4.1.7 Obtener el elemento seleccionado de una listaPara obtener la selección actual en una lista use la propiedad SelectedItem. Por ejemplo, el siguiente código

muestra los elementos seleccionados de una caja de lista en una etiqueta en un formulario Web:


ByVal e As System.EventArgs) Handles MyBase.Load' Comprueba si hay un elemento seleccionado.If Not IsNothing(ListBox1.SelectedItem) Then

' Muestra el elemento seleccionado.Label1.Text = "El elemento seleccionado es: " & _

ListBox1.SelectedItem.TextElse

Label1.Text = "No hay ningún elemento seleccionado."End If

End Sub


// Comprueba si hay un elemento seleccionado.if (ListBox1.SelectedItem == null)

Label1.Text = "No hay elemento seleccionado.";else

// Muestra el elemento seleccionado.

Label1.Text = "El elemento seleccionado es: " ListBox1.SelectedItem.Text;}

La propiedad SelectedItem devuelve un objeto; asegúrese de comprobar si existe antes de intentar usarlo.



MCAD/MCSD

62

4.1.8 Usar vinculación de datos sencilla con listasLos controles pueden obtener sus valores de cualquier origen de datos de la aplicación. Los orígenes de datos

pueden ser cualquier dato público – sea una tabla de base de datos, un array una propiedad o un objeto, o una expre-sión que combina varios elementos. A su nivel más sencillo esto proporciona una forma fácil de inicializar los valo-res de cajas de lista y listas desplegables en un formulario Web.

Para ver cómo funciona la vinculación sencilla siga estos pasos:

1. Cree un formulario Web con una lista desplegable y este código:Visual Basic .NET' Elemento de datos público para DropDownList.Public arrData As String() = {"Este", "ese", "y", "el", "otro"}


' Vincula datos y controles en esta página.Page.DataBind()

End Sub

Visual C#public string[] arrData = {"Este", "ese", "y", "el", "otro"};

private void Page_Load(object sender, System.EventArgs e){Page.DataBind()

}

2. Seleccione la lista desplegable y pulse el botón junto a su propiedad DataBindings en la ventana de propie-dades. Visual Studio muestra la caja de diálogo DataBindings. Esta caja de diálogo se utiliza para cargar elementos de cualquier origen de datos público en un control de tabla o de lista.

3. En la lista Propiedades enlazables seleccione la propiedad DataSource y marque la opción Expresión de en-lace predeterminada; escriba arrData en la caja de texto de la expresión. Cuando ejecute la aplicación loselementos del array se mostrarán en la lista desplegable.

Cuando se usa vinculación de datos con un control de servidor, puede desactivar la gestión de estado para es-te control. Esto mejora las prestaciones porque el método DataBind remplaza la gestión de estado automática que proporciona ASP.NET.

Para desactivar la gestión de estado para un control de servidor de el valor False a su propiedad Enable-

ViewState.4.1.9 Añadir elementos a DataGrid, DataList y Repeater

Use la vinculación de datos para añadir elementos a los controles DataGrid, DataList y Repeater. Estos trescontroles usan plantillas para definir su aspecto en tiempo de ejecución. Una plantilla es un conjunto de elementosHTML, controles de servidor o ambos que se repetirán para cada elemento del control.

Para añadir elementos a un control DataGrid, DataList o Repeater siga estos pasos:

1. Defina el origen de datos2. Coloque el control DataGrid, DataList o Repeater y vincúlelo con el origen de datos3. Edite las plantillas en el control para añadir elementos HTML o controles de servidor que se repetirán dentro

de la lista o rejilla4. Configure las propiedades del control de servidor contenido en la lista o rejilla para vincular con los elemen-

tos de datos en el origen de datos del contenedor.El siguiente ejemplo muestra cómo añadir columnas plantilla a un DataGrid y cómo vincular los controles de

estas columnas con un origen de datos sencillo.

1. Cree un origen de datos público en su aplicación como hizo en el ejemplo anterior. Por ejemplo, este códigocrea un array para probar un origen de datos sencillo.Visual Basic .NET‘Elemento de datos público para un DataGridPublic arrData As String() = {"This", "that", "and", "the", "other"}

Visual C#public string[] arrData= {"This", "that", "and", "the", "other"};

2. Coloque un control DataGrid en un formulario Web

3. Añada columnas plantilla al control seleccionándolo y pulsando en el enlace Generador de Propiedades bajola ventana de propiedades. Visual Studio muestra la caja de diálogo Propiedades.




63

4. En la caja de diálogo Propiedades seleccione Columnas, en la lista Columnas disponibles seleccione Colum-na plantilla y pulse el botón Agregar (>) para añadir una columna plantilla al control DataGrid. Para esteejemplo, añada dos columnas plantilla y pulse Aceptar.

5. En la ventana de propiedades seleccione la propiedad DataSource y especifique el origen de datos para elcontrol. Para este ejemplo, escriba arrData, el array creado en el paso 1.

6. Cree la plantilla que se usará para mostrar datos en el control: pulse con el botón derecho sobre el control Da-taGrid, seleccione Editar plantilla y Columna(0). El aspecto del control cambia a modo de edición.

7. Arrastre otros controles al formulario Web y colóquelos en la plantilla para agregarlos al DataGrid. Para este

ejemplo coloque un TextBox y arrástrelo a la columna 0.8. En la ventana de propiedades, seleccione la propiedad DataBindings del control que acaba de añadir a la

plantilla y pulse sobre el botón que aparece. Visual Studio muestra la caja de diálogo DataBindings.9. En la lista Propiedades enlazables seleccione la propiedad que recibirá el elemento de datos. Para este ejem-

plo seleccione Text . Seleccione Enlace simple, despliegue Container y pulse DataItem para especificar quéelemento de datos se pondrá en la propiedad seleccionada. Pulse Aceptar para cerrar la caja de diálogo.

10. Edite la segunda plantilla de columna. Para ello pulse con el botón derecho sobre el control DataGrid, selec-cione Editar plantilla y Columna (1).

11. Repita los pasos 4 a 7 para Columna(1). Para este ejemplo, coloque un botón en la plantilla Columna(1) delDataGrid.

12. Cuanto termine cierre la plantilla. Para ello pulse con el botón derecho sobre la plantilla y seleccione terminar edición de plantilla. Visual Studio muestra los controles contenidos. Para cambiar cualquiera de las propieda-des del control contenido edite la plantilla como se hizo en los ejemplos anteriores.

4.1.10 Ejecutar comandosLos controles Button, LinkButton e ImageButton lanzan todos ellos sucesos de envío para ejecutar coman-

dos. Un suceso de envío comienza una petición desde el navegador, haciendo que el servidor procese los sucesos dela página. El procedimiento de suceso Click de un botón control se procesa después de los sucesos de validación yen caché de la página.

Para ver el orden de los sucesos de una página coloque un TextBox, un ListBox y un Button en un formularioWeb y añada este código.


ByVal e As System.EventArgs) Handles MyBase.LoadResponse.Write("Carga de página.<br>")

' Añade elementos a la caja de lista la primera vez que se carga la página.If Not IsPostBack Then

ListBox1.Items.Add("Este")ListBox1.Items.Add("Ese")ListBox1.Items.Add("El otro")

End IfEnd Sub

Private Sub TextBox1_TextChanged(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles TextBox1.TextChanged

Response.Write("Texto cambiado.<br>")End Sub

Private Sub ListBox1_SelectedIndexChanged(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles ListBox1.SelectedIndexChanged

Response.Write("Elemento seleccionado.<br>")End Sub

Private Sub Button1_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles Button1.Click

Response.Write("Botón pulsado.<br>")End Sub


Response.Write("Carga de página.<br>");// Añade elementos a la caja de lista la primera vez que se carga la página.

if (!IsPostBack){ListBox1.Items.Add("Este");ListBox1.Items.Add("Eso");ListBox1.Items.Add("El otro");

}}



MCAD/MCSD

64

private void TextBox1_TextChanged(object sender, System.EventArgs e){Response.Write("Texto cambiado.<br>");

}

private void ListBox1_SelectedIndexChanged(object sender, System.EventArgs e){Response.Write("Elemento seleccionado.<br>");

}

private void Button1_Click(object sender, System.EventArgs e){Response.Write("Botón pulsado.<br>");

}

Cuando se ejecuta el código anterior la página muestra el orden de ejecución de los sucesos. El procedimien-to de suceso Click es el último suceso de control que se procesa en la página.

El uso del procedimiento de suceso Click de Button y LinkButton es directo. El control ImageButton propor-ciona una capacidad adicional. El argumento de suceso Click para un control incluye coordenadas X e Y del lugar donde ha pulsado el usuario en el control. La respuesta de imagen depende de donde se ha pulsado. Las imágenesque responden a pulsaciones de esta forma se denominan mapas de imagen.

El siguiente código usa los argumentos X e Y para calcular en que círculo se ha pulsado.

Visual Basic .NETPrivate Sub ImageButton1_Click(ByVal sender As System.Object, _

ByVal e As System.Web.UI.ImageClickEventArgs) Handles ImageButton1.Click

Dim xOffset, yOffset, X, Y, Radius As SingleDim strMessage As String' Calcula el radio del punto de pulsación según X e Y.xOffset = CSng(sender.width.value) / 2yOffset = CSng(sender.height.value) / 2X = System.Math.Abs(CSng(e.X) - xOffset)Y = System.Math.Abs(CSng(e.Y) - yOffset)Radius = System.Math.Sqrt((X ^ 2) + (Y ^ 2))' Configura el mensaje a mostrar.Select Case CInt(Radius)

Case 0 To 21strMessage = "en el círculo central."

Case 22 To 42strMessage = "en el segundo círculo."

Case 43 To 64strMessage = "en el tercer círculo."

Case 65 To 86strMessage = "en el cuarto círculo."

Case ElsestrMessage = "fuera del círculo."

End Select' Muestra el mensaje.Label1.Text = "Ha pulsado " & strMessage

End Sub

Visual C#private void ImageButton1_Click(System.Object sender,

System.Web.UI.ImageClickEventArgs e){double xOffset, yOffset, X, Y, Radius;

string strMessage;// Calcula el radio del punto de pulsación a partir de X e Y.xOffset = Convert.ToDouble(ImageButton1.Width.Value) / 2;yOffset = Convert.ToDouble(ImageButton1.Height.Value) / 2;X = Math.Abs(Convert.ToDouble(e.X) - xOffset);Y = Math.Abs(Convert.ToDouble(e.Y) - yOffset);Radius = Math.Sqrt(Math.Pow(X, 2) + Math.Pow(Y, 2));if (Radius < 22) strMessage = "en el circulo central.";else if ((Radius >= 22) && (Radius <= 42)) strMessage = "en Segundo círculo.";else if ((Radius > 42) && (Radius <= 64)) strMessage = "en tercer círculo.";else if ((Radius > 64) && (Radius <= 86)) strMessage = "en cuarto círculo.";else strMessage = "fuera del círculo.";// Muestra el mensaje.Label1.Text = "Ha pulsado " + strMessage;

}




65

4.1.11 Leer y escribir opcionesUse los controles RadioButton, RadioButtonList, CheckBox o CheckBoxList para obtener valores de opcio-

nes booleanas del usuario. Como con ListBox y DropDownList, use el editor de colecciones para añadir elementos aun RadioButtonList o CheckBoxList. Pulse la propiedad Items para mostrar el editor de propiedades para un control.

Use la propiedad Checked para leer el estado de un CheckBox o RadioButton. Por ejemplo, el siguiente códi-go muestra si el control CheckBox1 está seleccionado.

Visual Basic .NETPrivate Sub Button1_Click(ByVal sender AS System.Object _ByVal e as System.EventArgs) Handles Button1.Click

Response.Write(“CheckBox1 está “ & Checkbox1.Checked.ToString)End Sub


Response.Write(“CheckBox1 está “ + CheckBox1.Checked.ToString());}

Cuando se coloca inicialmente un RadioButton en un formulario Web no interactúa automáticamente con losotros RadioButton del formulario en la forma en que lo hacen los controles OptionButton en un formulario Win-dows. Para que los controles interactúen necesitar dar un valor a la propiedad GroupName de los botones. Cuandovarios RadioButton tienen el mismo valor en la propiedad GroupName al seleccionar uno se elimina la selección de

los demás.Para leer o modificar los valores de un control CheckBoxList o RadioButtonList use un bucle For Each para

comprobar cada control de la lista. Los controles contenidos en un CheckBoxList no son CheckBox, como se podríaesperar. Tanto CheckBoxList como RadioButtonList contienen elementos ListControl. Para determinar el estado deun ListControl use la propiedad Selected , como muestra el siguiente código.


ByVal e As System.EventArgs) Handles Button1.ClickDim lstItem As ListItemFor Each lstItem In RadioButtonList1.Items

If lstItem.Selected ThenResponse.Write(lstItem.Text & " está seleccionado.<br>")

End IfNext

End Sub


foreach (ListItem lstItem in RadioButtonList1.Items)if (lstItem.Selected)

Response.Write(lstItem.Text + " está seleccionado.<br>");}

4.1.12 Mostrar gráficos y avisosHay varias formas de mostrar gráficos en un formulario Web:

• Como fondo: Use la propiedad Background del formulario Web para mostrar una imagen en toda la página.

Use la propiedad BackgroundUrl del control Panel para mostrar una imagen de fondo en una zona de una pá-gina en lugar de la página completa.• Como primer plano: Use el control Image para mostrar imágenes en primer plano• Como botón: Use el control ImageButton para mostrar imágenes que respondan a sucesos de usuario. Vea la

sección Ejecutar Comandos, más atrás, para un ejemplo de respuesta a sucesos de pulsación en una imagen.• Como anuncio: Use el control AdRotator para mostrar imágenes de una lista. Los anuncios mostrados por el

control AdRotator contienen hiperenlaces con el sitio Web del anunciante.

El control Image no responde a sucesos de usuario, pero permite mostrar gráficos dinámicamente según laentrada de otros controles de usuario. Para mostrar una imagen en un control Image en tiempo de ejecución use la propiedad ImageUrl. Por ejemplo, el siguiente código muestra una imagen cuando se pulsa un botón.


ByVal e As System.EventArgs) Handles Button.ClickImage1.ImageUrl = “gondola.jpg”

End Sub



MCAD/MCSD

66

Visual C#private void Button1_Click(object sender, System.EventArgs){

Image1.ImageUrl = “gondola.jpg”;}

Un uso habitual de los gráficos es para anuncios – la mayoría de los anuncios en Internet se guardan comoarchivos .gif. Visual Studio incluye el control AdRotator para manejar las tareas asociadas con la presentación deeste tipo de anuncios. El control AdRotator usa un archivo XML para planificar los archivos que se mostrarán. Elarchivo XML almacena el URL de las imágenes de anuncio, el URL de la página que se mostrará si el usuario pulsa

el anuncio, la prioridad del anuncio, y otras propiedades. En tiempo de ejecución, el AdRotator selecciona uno delos anuncios indicados en este archivo y lo muestra en la página.

Para usar el control AdRotator siga los pasos siguientes:

1. Coloque un control AdRotator en un formulario Web2. Añada un archivo XML al proyecto actual y ábralo3. En la ventana de propiedades, seleccione la propiedad TargetSchema y seleccione AdRotator Schedule File.

Visual Studio añade al archivo XML las siguientes líneas:<Advertisements xmlns="http://schemas.microsoft.com/AspNet/

AdRotator-Schedule-File"></Advertisements>

4. Añada una etiqueta < Ad > a la sección < Advertisements> por cada anuncio que quiera mostrar.5. Grabe el archivo XML y cambie al formulario Web en modo diseño

6. Seleccione el control AdRotator y configure la propiedad AdvertisementsFile con el archivo XML reciéncreado.

Ahora edite el archivo XML para mostrar la información deseada. Por ejemplo, el siguiente archivo XMLmuestra dos anuncios diferentes

<?xml version="1.0" encoding="utf-8" ?><Advertisements xmlns="http://schemas.microsoft.com/AspNet/

AdRotator-Schedule-File"><Ad>

<ImageUrl>../ads/sponsorad.gif</ImageUrl><NavigateUrl>/ads/sponsorad.htm</NavigateUrl><AlternateText>Click here to visit our sponsor.</AlternateText><Keyword></Keyword><Impressions>1</Impressions>

</Ad><Ad>

<ImageUrl>../ads/net.gif</ImageUrl><NavigateUrl>//www.gotdotnet.com</NavigateUrl><AlternateText> ASP.NET tutorials and more.</AlternateText><Keyword>ASP</Keyword><Keyword>.NET</Keyword><Impressions>5</Impressions>

</Ad></Advertisements>

Las etiquetas del esquema XML de AdRotator son las de la tabla 4.5

Tabla 4. 5: El Esquema AdRotatorPropiedad Se usa para

Ad Comenzar la definición de un anuncio.ImageUrl Dirección del anuncio que se muestra.NavigateUrl Dirección a la que se va si el usuario pulsa sobre el anuncio. AlternateText Texto que se muestra en una etiqueta de ayuda cuando el usuario detiene el ratón sobre el anuncio. Si no se

puede mostrar ImageUrl se muestra este texto en su lugar.Keyword Nombre de categoría que se usa para filtrar los anuncios que se muestranImpressions Número que representa la posibilidad de que se muestre un anuncio. Los anuncios con un número más alto tienen

mayor posibilidad de verse.

4.1.13 Agrupar controlesColoque los controles en un grupo cuando quiera manipular una zona concreta de su formulario Web median-

te código. Por ejemplo, si quiere permitir que los usuario conecten con un sistema desde una región de su página, ydespués ocultar o desactivar esta zona cuando se hayan conectado.

Use el control Panel para agrupar controles en un formulario Web. El uso del control Panel en un formularioWeb es diferente de su uso en un formulario Windows. Por un lado, no puede colocar directamente controles en uncontrol Panel; primero se colocan en el formulario Web y después se arrastran al Panel. Por otra parte, el control




67

Panel de formulario Web usa disposición en flujo en lugar de rejilla; esto significa que no puede colocar un controlen una posición exacta en un panel.

Nota: No es necesario colocar los RadioButton en un panel para que funcionen juntos, en cambio esnecesario darles el mismo valor en su propiedad GroupName. Vea la sección Leer y Escribir Opciones.

Para colocar controles en un control Panel siga estos pasos:

1. Coloque los controles en el formulario Web2. Arrastre los controles al control Panel en el orden en que quiera mostrarlo. Visual Studio colocará cada con-trol inmediatamente tras el otro en secuencia.

3. Use retornos de carro y espacios para colocar los controles.

El siguiente ejemplo utiliza un panel con dos controles de texto y un botón para pedir los datos de un usuario.Cuando el usuario se conecta, el panel se oculta.

Visual Basic .NETPrivate Sub butOK_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butOK.Click' Si nombre/contraseña coinciden, oculta el panel y muestra el mensaje.If txtName.Text = "Invitado" And txtPassword.Text = "Amigo" Then

pnlLogon.Visible = False‘Esta etiqueta no está en el panellblWelcome.Text = "Bienvenido " & txtName.Text

ElsetxtPassword.Text = ""vldPassword.Validate()

End IfEnd Sub

Visual C#private void butOK_Click(object sender, System.EventArgs e){

// Si nombre/contraseña coinciden, oculta el panel y muestra el mensaje.if ((txtName.Text == "Invitado") && (txtPassword.Text == "Amigo")){

pnlLogon.Visible = False;//Esta etiqueta no está en el panellblWelcome.Text = "Bienvenido " + txtName.Text;

}else{txtPassword.Text = "";vldPassword.Validate();

}}

4.1.14 Obtener fechasPara mostrar y obtener información de fechas use el control Calendar. Utilice su procedimiento de suceso Se-

lectionChanged y las propiedades SelectedDate o SelectedDates. SelectionChanged es un suceso con envío, de mo-do que el siguiente código muestra la fecha o fechas seleccionadas en cuanto cambia la selección:


ByVal e As System.EventArgs) Handles MyBase.Load' Muestra los datos actuales en la etiqueta para empezar.lblDate.Text = "Fecha actual: " & Date.Now.Date

End Sub

Private Sub calSource_SelectionChanged(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles calSource.SelectionChanged

If calSource.SelectedDates.Count = 1 Then' Si se ha seleccionado una fecha la muestra en una etiqueta.lblDate.Text = "Fecha seleccionada: " & calSource.SelectedDate

Else' Si se han seleccionado varias fechas, las muestra.lblDate.Text = "Fechas seleccionadas: " & calSource.SelectedDates(0) & _

" a " & calSource.SelectedDates(calSource.SelectedDates.Count - 1)End If

End Sub



MCAD/MCSD

68


// Muestra la fecha actual.lblDate.Text = "Fecha actual: " + calSource.TodaysDate;

}

private void calSource_SelectionChanged(object sender, System.EventArgs e){// Muestra la fecha actual.lblDate.Text = "Fecha actual: " + calSource.TodaysDate;

if (calSource.SelectedDates.Count == 1)// Si se ha seleccionado una fecha, la muestra.lblDate.Text = "Fecha seleccionada: " + calSource.SelectedDate;

else// Si se han seleccionado varias fechas las muestra.lblDate.Text = "Fechas seleccionadas: " + calSource.SelectedDates[0] +

" a " + calSource.SelectedDates[calSource.SelectedDates.Count - 1];}

4.1.15 Obtener archivos del clienteUtilice el control File Field de HTML para subir archivos del cliente al servidor. El control HTML File Field

en realidad es un control Text Field y un botón Submit con la etiqueta Examinar enlazados. Al pulsar el botón seejecuta un diálogo incorporado que muestra el diálogo Elegir Archivo de Windows en el ordenador del cliente.

Para recibir el archivo seleccionado en el servidor siga estos pasos:1. Coloque un control File Field de HTML en un formulario Web.2. Pulse con el botón derecho del ratón sobre el control y seleccione Ejecutar como Control del Servidor 3. Pulse con el botón derecho sobre el formulario y seleccione Ver Código Fuente HTML. Visual Studio mues-

tra el código HTML del servidor Web.4. Añada un atributo enctype a la etiqueta form. Este atributo establece el tipo MIME del formulario, y para su-

bir un archivo es necesario tanto un tipo MIME multipart/form-data como un método de formulario POST ,como se ve a continuación en negrita:<form action=”webform1.aspx” method=”post” enctype=”multipart/form-data”

runat=”server ID=”Form1”>5. Pulse con el botón derecho sobre el formulario Web y seleccione Ver diseño. Visual Studio muestra el for-

mulario en modo de diseño6. Añada un control Botón y un procedimiento de suceso Click para obtener y grabar el archivo seleccionado.

Por ejemplo, el siguiente procedimiento graba el archivo en el servidor.Visual Basic .NETPrivate Sub butUpload_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butUpload.ClickDim strFilename As String()' Divide el nombre de archivo en partes.strFilename = filUpload.PostedFile.FileName.Split("\")' Graba el archivo en el servidor con el nombre base.filUpload.PostedFile.SaveAs(Request.MapPath _

(Request.ApplicationPath) & "\" & strFilename(UBound(strFilename)))' Añade el archivo a la lista de archivos del servidor.lstServerFiles.Items.Add(strFilename(UBound(strFilename)))' Selecciona el primer elemento de la lista.lstServerFiles.SelectedIndex = 0

End SubVisual C#private void butUpload_Click(object sender, System.EventArgs e){

// Obtiene el nombre del archivo completo.string strFilename = filUpload.PostedFile.FileName;// Obtiene el nombre base.strFilename = System.IO.Path.GetFileName(strFilename);// Graba el archivo en el servidor con el nombre base.filUpload.PostedFile.SaveAs(Request.MapPath(Request.ApplicationPath) +

"\\" + strFilename);// Añade el archivo a la lista de archivos del servidor.lstServerFiles.Items.Add(strFilename);// Selecciona el primer elemento de la lista.lstServerFiles.SelectedIndex = 0;

}El método PostedFile del control HTML File Field representa el archivo que se está subiendo. Puede usar la

propiedad FileName y el método SaveAs del objeto devuelto para grabar el archivo en el servidor, como muestra el




69

código precedente. El siguiente código muestra una forma de recuperar el archivo del servidor. En este caso semuestra el archivo en el navegador.

Visual Basic .NETPrivate Sub butView_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butView.ClickDim strFilename As String' Obtiene el nombre de archivo seleccionado.strFilename = lstServerFiles.SelectedItem.ToString

' Muestra como página Web.Response.Redirect(Request.ApplicationPath & "/" & strFilename)

End Sub

Visual C#private void butView_Click(object sender, System.EventArgs e){

// Obtiene el nombre de archivo seleccionado.string strFilename = lstServerFiles.SelectedItem.ToString();// Muestra como página Web.Response.Redirect(Request.ApplicationPath + "/" + strFilename);

}

4.2 Validar datosUno de los pasos más importantes al obtener entradas de datos de un usuario es asegurarse de que los datos

son válidos. La validez viene determinada por una serie de criterios: ¿Ha introducido algo el usuario? ¿La entrada esdel tipo de datos correcto (un número de teléfono, por ejemplo)? ¿Están los datos dentro del rango exigido?.

ASP.NET proporciona controles de validación para ayudar a comprobar las entradas en formulario Web fren-te a estos y otros criterios antes de aceptar los elementos de datos. Esta lección le enseña cómo usar los controles devalidación para capturar datos no válidos y orientar al usuario para que corrija el problema.

4.2.1 Usar validaciónLos controles de validación comprueban la validez de los datos introducidos por el usuario en controles de

servidor asociados en el cliente antes de enviarlos al servidor. Esto es una mejora importante ante esquemas de vali-dación anteriores – la mayor parte de los problemas de validación se pueden capturar y corregir sin implicar unatransmisión de ida y vuelta al servidor.

La validación en el cliente la proporciona una librería JScript llamada WebUIValidation.js, que se descarga

al cliente por separado. Aunque existe un amplio soporte de JScript, el modelo de objetos de documento (DOM,Document Object Model) en que se basa la librería solo está disponible en Microsoft Explores 4.0 y posteriores. Por tanto, los controles de validación también proporcionan automáticamente validación en el servidor. La validación enel servidor se ejecuta siempre, se haya producido o no validación en el cliente. Esta doble comprobación asegura quela validación personalizada se ejecuta correctamente y que no se ha esquivado la validación en el cliente.

Los controles de validación comprueban el valor del control de servidor especificado en su propiedad Con-trolToValidate. La tabla 4.6 describe los seis controles de validación.

Tabla 4. 6: Controles de validación ASP.NETControl Se usa para

RequiredFieldValidator Comprobar si un control contiene datosCompareValidator Comprobar si un elemento introducido corresponde con el introducido en otro controlRangeValidator Comprobar si un elemento introducido se encuentra entre dos valoresRegularExpressionValidator Comprobar si un elemento introducido corresponde a un formato concretoCustomValidator Comprobar la validez de un elemento introducido usando una secuencia de comandos de cliente, códi-

go de servidor o ambos. ValidationSummary Muestra los errores de validación en un lugar único, o una descripción general de error de validación.

Para usar los controles de validación siga estos pasos:

1. Coloque un control de validación en un formulario Web y de cómo valor de su propiedad ControlToValidate el nombre del control que quiere validar. Si está usando el control CompareValidator también deberá especi-ficar la propiedad ControlToCompare.

2. En la propiedad ErrorMessage del control de validación escriba el mensaje que quiera mostrar al usuario silos datos no son válidos.

3. Si quiere que el control de validación muestre un mensaje diferente a ErrorMessage cuando se produzca unerror escríbalo en su propiedad Text . Esta propiedad le permite indicar brevemente dónde se ha producido elerror en el formulario, y mostrar el mensaje ErrorMessage, más largo en el control ValidationSummary.

4. Coloque un control ValidationSummary en el formulario Web para mostrar los mensajes de error de los con-troles de validación en un único lugar.

5. Proporcione un control que lance un suceso de envío. Aunque la validación se produce en el lado cliente, nocomienza hasta que no se solicita el envío.



MCAD/MCSD

70

Para mostrar los mensajes de validación en una caja de diálogo de el valor True a la propiedad ShowMessa-geBox de ValidationSummary.

4.2.2 Combinar validacionesUn control de servidor puede tener varios validadotes. Por ejemplo, un TextBox para un número de teléfono

podría ser tanto obligatorio como con un formato concreto, por tanto puede ser comprobado por dos controles devalidación, un RequiredFieldValidator y un RegularExpressionValidator.

Para escribir mensajes de error significativos cuando más de un control de validación comprueba un mismocontrol debe comprender las reglas de validación de ASP.NET. Estas reglas pueden no tener un sentido obvio, perohacen posible escribir mensajes de error que tratan problemas concretos.

Por ejemplo, todos los controles de validación salvo RequiredFieldValidator se consideran válidos si están en blanco. Esto posibilita proporcionar un mensaje de error si el control está en blanco, usando un RequiredFieldVali-dator, y un mensaje diferente cuando está fuera de rango o no tiene el formato correcto.

Las reglas listadas en la tabla 4-7 se aplican a la conversión de datos para el CompareValidator:

Tabla 4. 7: Reglas de validación de CompareValidatorSi el control El resultado es ...

Especificado en la propiedad ControlToValidate no se puede convertir al tipo de datos adecuado No válidoEspecificado en la propiedad ControlToCompare no se puede convertir al tipo de datos adecuado Válido

En el segundo caso de la tabla 4-7 se debe proporcionar un control de validación separado para el control especificado en la propiedad ControlToCompare para asegurarse de que es del tipo de datos adecuado.

4.2.3 Cancelar la validaciónComo la validación se produce antes de que el servidor procese la página, un usuario se puede ver atrapado

por la validación, salvo que se proporcione una forma de cancelar la validación sin en enviar.

Para cancelar la validación incluya un control HTML Submit que configure el atributo Pa-ge_ValidationActive, como muestra en negrita el siguiente fragmento de código HTML:

<INPUT id=”butCancel” onclick=”Page_ValidationActive=false” type=”submit”value=”Cancel”>

La anterior definición cancela la validación y envía la página de vuelta al servidor. Puede comprobar si elusuario ha cancelado la operación examinando la propiedad IsValid del objeto Page en el procedimiento de suceso

Page_Load . Tiene que volver a validar la página porque la operación de cancelación de validación pone IsValid aTrue. El siguiente código muestra cómo comprobar si el usuario ha cancelado la validación:


ByVal e As System.EventArgs) Handles MyBase.Load' Valida en caso de cancelación por el usuario.If Page.IsPostBack Then Page.Validate()

' Comprueba si la página es válida.If Not Page.IsValid Then

' El usuario ha cancelado la operación, vuelve al inicio.Response.Redirect("default.htm")

End IfEnd If

End Sub


// Valida en caso de cancelación por el usuario.if (Page.IsPostBack){

Page.Validate();if (!Page.IsValid)

// El usuario ha cancelado la validación.Response.Redirect("default.htm");

}}

4.2.4 Personalizar la validaciónPara ejecutar tipos de validación complejos no contemplados por los controles de validación estándar use un

control CustomValidator y escriba el código para realizar la validación en el lado cliente y (opcionalmente) en elservidor.




71

En el servidor, coloque el código de validación en el procedimiento de suceso ServerValidate. Los argumen-tos para este procedimiento proporcionan acceso al control que se valida. El siguiente procedimiento de suceso vali-da que el número introducido es primo:

Visual Basic .NET' Valida un número primo.Private Sub CustomValidator1_ServerValidate(ByVal source As System.Object, _

ByVal args As System.Web.UI.WebControls.ServerValidateEventArgs) _Handles CustomValidator1.ServerValidate

TryDim iPrime, iCount As Integer' Obtiene el valor de ControlToValidate (pasado como args)iPrime = Integer.Parse(args.Value)For iCount = 2 To iPrime \ 2

' Si el número se puede dividir, no es primo, devuelve False.If iPrime Mod iCount = 0 Then

args.IsValid = FalseReturn

End IfNext' Número primo, devuelve True.args.IsValid = TrueReturn

Catch ex As Exception' Si hay un error en el análisis devuelve False.args.IsValid = FalseReturn

End TryEnd Sub

Visual C#private void vldtxtPrime_ServerValidate(object source,

System.Web.UI.WebControls.ServerValidateEventArgs args){try{

// Obtiene el valor de ControlToValidate(pasado como args).int iPrime = Int32.Parse(args.Value);for (int iCount = 2; iCount <= (iPrime / 2); iCount++){

// Si se puede dividir no es primo, devuelve False.

if((iPrime % iCount) == 0){args.IsValid = false;return;

}// El número es primo, devuelve True.args.IsValid = true;return;

}}catch(Exception e){

// Si hay un error en el análisis devuelve False.args.IsValid = false;return;

}}

Para proporcionar validación en el cliente especifique una secuencia de comandos en la propiedad ClientVa-lidatorFunction del control CustomValidator. La validación en el cliente es opcional, y si se incluye debe mantener un código similar en ambos lugares. La siguiente secuencia de comandos proporciona una versión para cliente de lavalidación de número primo en el servidor:

VBScript<script language="vbscript">

Sub ClientValidate(source, arguments)For iCount = 2 To arguments.Value \ 2

' Si el número es divisible no es primo, devuelve False.If arguments.Value Mod iCount = 0 Then

arguments.IsValid = FalseExit Sub

End IfNextarguments.IsValid = True

End Sub</script>



MCAD/MCSD

72

JScript<script language="jscript">

function ClientValidate(source, arguments){for (var iCount = 2; iCount <= arguments.Value / 2; iCount++){

// Si el número es divisible no es primo, devuelve false.if ((arguments.Value % iCount) == 0){

arguments.IsValid = false;return false;

}

}// El número es primo, devuelve True.arguments.IsValid = true;return true;

}</script>

4.3 Navegación entre formulariosEl enlace de información es la esencia de la Web. En una aplicación de formularios Web los hiperenlaces y

los métodos de navegación son lo que enlaza múltiples formularios entre si en una aplicación coherente. ASP.NET proporciona varias formas de navegación entre páginas de la aplicación, y cada una de estas técnicas produce unosefectos diferentes en términos de cómo se muestra la página y cómo se intercambian datos entre páginas.

En esta lección aprenderá como usar cada una de las diferentes técnicas de navegación en código y HTML.

4.3.1 Formas de navegar ASP.NET proporciona cinco formas diferentes de navegar entre páginas en la aplicación:

Tabla 4. 8: Navegación entre PáginasMétodo de Navegación Se usa para

Control HyperLink Navegar a otra páginaResponse.Redirect Navegar a otra página desde código. Es equivalente a pulsar un hiperenlaceServer.Transfer Finaliza el formulario Web actual y comienza la ejecución de uno nuevo. Este método solo funciona

para navegar entre páginas de formulario web (.aspx)Server.Execute Comienza la ejecución de un nuevo formulario Web mientras sigue mostrando la página Web actual.

El contenido de ambos formularios se combina. Este método solo funciona entre páginas de formula-rio Web (.aspx)

Window.Open Método de secuencia de comandos que muestra una página en una nueva ventana de navegador enel cliente.

4.3.2 Uso de hiperenlaces y redirecciónLos controles de servidor Hyperlink responden a sucesos de pulsación del usuario mostrando la página espe-

cificada en su propiedad NavigateUrl. El control Hyperlink no expone sucesos de usuario de lado servidor; si quiereinterceptar un suceso de pulsación en el código use el control LinkButton o el control de servidor ImageButton.

Para navegar desde un LinkButton o ImageButton use el método Redirect del objeto Response:

Visual Basic .NETPrivate Sub LinkButton1_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles LinkButton1.Click' Muestra la siguiente página.Response.Redirect("PaginaSiguiente.aspx")

End Sub

Visual C#private void LinkButton1_Click(object sender, System.EventArgs e){

// Muestra la página siguiente.Response.Redirect("PaginaSiguiente.aspx");

}

4.3.3 Método Transfer El uso del método Transfer es muy similar a ejecutar un hiperenlace o usar el método Redirect , con una dife-

rencia: Transfer puede retener información de la página de origen entre peticiones. Cuando se da el valor True a la propiedad preserveForm del método Transfer la información de QueryString, ViewState y procedimiento resucesoestán disponibles en el formulario de destino.

Para usar el método Transfer con preserveForm a True primero debe dar el valor False al atributo Enable-

ViewStateMac de la directiva Page del formulario Web. De forma predeterminada ASP.NET aplica un código hash ala información de ViewState, y con este valor de atributo se desactiva esta codificación para que la información se pueda leer en el formulario Web siguiente. La siguiente línea muestra cómo desactivar la codificación para que se pueda usar el ViewState en otra página.




73

Visual Basic .NET<%@ Page language="vb" EnableViewStateMac="false"

Codebehind="RedirectNTransfer.aspx.vb"Inherits="vbNavigateSnippet.WebForm1" %>

Visual C#<%@ Page language="c#" EnableViewStateMac="false"Codebehind="RedirectNTransfer.aspx.cs" AutoEventWireup="false"Inherits="csNavigateSnippet.WebForm1" %>

El siguiente procedimiento de suceso para un ImageButton muestra cómo se puede pasar información entreformularios con el método Transfer .

Visual Basic .NET' Webform1.aspxPrivate Sub imgTransfer_Click(ByVal sender As System.Object, _

ByVal e As System.Web.UI.ImageClickEventArgs)Handles imgTransfer.Click' Transfiere a otro formulario reteniendo ViewState.Server.Transfer("Webform2.aspx", True)

End Sub

Visual C#// Webform1.aspxprivate void ImageButton1_Click(object sender,

System.Web.UI.ImageClickEventArgs e){// Transfiere a otro formulario reteniendo ViewState.Server.Transfer("Webform2.aspx", true);

}

Para recuperar la información de ViewState del formulario web de origen use el método Form del objeto Re-quest . El siguiente código muestra el estado de un TextBox y las coordenadas X e Y del suceso de pulsación del ImageButton de Webform1.aspx en Webform2.aspx:

Visual Basic .NET' Webform2.aspxPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.LoadDim colForm As System.Collections.Specialized.NameValueCollection' Obtiene los datos del formulario Web de origen.

colForm = Request.Form' Muestra el valor del TextBox de Webform1.Response.Write("TextBox1.Text: " & colForm.Item("TextBox1") & "<br>")' Muestra las coordenadas de la pulsación.Response.Write("ImageButton X, Y: " & colForm.Item("imgTransfer.x") & _

", " & colForm.Item("imgTransfer.y") & "<br>")End Sub

Visual C#// Webform2.aspxprivate void Page_Load(object sender, System.EventArgs e){

System.Collections.Specialized.NameValueCollection colForm;// Obtiene los datos del formulario Web de origen.colForm = Request.Form;// Muestra el valor del TextBox de Webform1.

Response.Write("TextBox1.Text: " + colForm["TextBox1"] + "<br>");// Muestra las coordenadas de la pulsación.Response.Write("ImageButton X, Y: " + colForm["imgTransfer.x"] + ", "

+ colForm["imgTransfer.y"] + "<br>");}

Nota: Los métodos Transfer y Execute del objeto Server solo funcionan con formularios Web. Si in-tenta navegar a una página HTML usando uno de estos métodos provocará un error en tiempode ejecución.

4.3.4 Método ExecuteUse el método Execute para procesar un segundo formulario Web sin abandonar el primero. Esto permite di-

rigir los resultados de un formulario Web a una región de la página actual. Como con el método Transfer , Execute exige que el atributo EnableViewStateMac del formulario Web sea False para desactivar la aplicación del hash a

ViewState.

Por ejemplo, el siguiente código ejecuta el formulario Web Table.aspx y lo muestra en un control literal en la página actual.



MCAD/MCSD

74

Visual Basic .NETPrivate Sub butExecute_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butExecute.ClickDim swrTarget As New System.IO.StringWriter()' Ejecuta un formulario Web y almacena los resultados.Server.Execute("Table.aspx", swrTarget)' Muestra el resultado en un control literal.litTable.Text = "<h2>Resultados de la tabla</h2>" & swrTarget.ToString

End Sub

Visual C#private void butExecute_Click(object sender, System.EventArgs e){

System.IO.StringWriter swrTarget = new System.IO.StringWriter();// Ejecuta un formulario Web y almacena los resultados.Server.Execute("Table.aspx", swrTarget);// Muestra el resultado en un control literal.litTarget.Text = "<h2>Resultados de la tabla</h2>" + swrTarget.ToString();

}

El segundo argumento del método Execute es opcional. Si lo omite el resultado se escribe en la página actual.El resultado es aditivo – se muestra a la vez el resultado de las dos páginas y los controles de servidor de ambas páginas pueden responder a sucesos.

Cuando combine formularios Web usando el método Execute tenga en cuenta que cualquier suceso de envío

que se produzca en el segundo formulario limpiará el primero. Por este motivo, la combinación de formularios esútil principalmente cuando el segundo no contiene controles que lancen sucesos de envío.

4.3.5 Mostrar una página en una nueva ventanaPara iniciar una nueva instancia del navegador use el método Open de objeto de cliente Window. Solo puede

hacerlo como parte de una secuencia de comandos de cliente, porque la nueva ventana se crea en el cliente. Sinembargo, hay formas de controlar el contenido y aspecto de la nueva ventana del navegador desde el servidor.

En su forma más sencilla, el método Window.Open tiene la forma que se muestra en negrita en la siguientedefinición de un control de botón HTML:

<INPUT onclick="window.open('webform2.aspx')" type="submit"value="Nueva Ventana">

Para usar una variable como URL de destino cambie webform2.aspx por una etiqueta de datos:<INPUT onclick="window.open('<%# urlDestino %>')" type="submit"value="Nueva Ventana">

Para actualizar el URL de destino desde el código use una variable pública y vinculación de datos. El si-guiente procedimiento de suceso Page_Load configura el URL de destino y lo actualiza mediante vinculación dedatos cuando se carga la página:

Visual Basic .NETPublic urlTarget As StringPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.LoadurlTarget = "webform2.aspx"Page.DataBind()

End Sub

Visual C#public string urlTarget;private void Page_Load(object sender, System.EventArgs e){

urlTarget = "webform2.aspx";Page.DataBind();

}

Como el método Window.Open recibe muchos argumentos diferentes para controlar los diferentes aspectosde la nueva ventana del navegador, puede crear una clase para manejar sus diferentes configuraciones. Las clases le permiten encapsular todas las opciones posibles, de forma que se pueden usar de forma orientada a objetos. El si-guiente procedimiento de suceso Page_Load y definición de clase muestran cómo controlar el tamaño, situación yURL de la nueva ventana mediante código de servidor usando una clase llamada BrowserWindow.

Visual Basic .NETPublic urlTarget As New BrowserWindow()




75


With urlTarget' Configura el URL de la nueva ventana..URL = "HTMLPage1.htm".Top = 100.Left = 100.Width = 400.Height = 400

End With' Actualiza el botón HTML.

Page.DataBind()End Sub

' Clase que controla las nuevas ventanas creadas en la secuencia de comandos.' Las opciones predeterminadas mostradas son las mismas del navegador.Public Class BrowserWindow

' Opciones de cadena: predeterminada en blanco.Public URL As String = "about:blank"' Opciones enteras: 0 llama a predeterminado.Public Height As Integer = 0Public Width As Integer = 0Public Top As Integer = 0Public Left As Integer = 0

' Opciones tipo boolean, 0 es "no" 1, es "si"Public ChannelMode As Integer = 0Public Directories As Integer = 1Public FullScreen As Integer = 0Public Location As Integer = 1Public Resizable As Integer = 1Public ScrollBars As Integer = 1Public Status As Integer = 1Public TitleBar As Integer = 1Public ToolBar As Integer = 1Public MenuBar As Integer = 1

End Class

Visual C#public BrowserWindow urlTarget = new BrowserWindow();

private void Page_Load(object sender, System.EventArgs e){urlTarget.URL = "Execute.aspx";urlTarget.Top = 100;urlTarget.Left = 100;urlTarget.Width = 400;urlTarget.Height = 400;// Update HTML Button.Page.DataBind();

}

// Clase que controla las nuevas ventanas creadas en la secuencia de comandos.// Las opciones predeterminadas mostradas son las mismas del navegador.public class BrowserWindow{

// Opciones de cadena: predeterminada en blanco.

public string URL = "about:blank";// Opciones enteras: 0 llama a predeterminado.public int Height = 0;public int Width = 0;public int Top = 0;public int Left = 0;// Opciones tipo boolean, 0 es "no" 1, es "si".public int ChannelMode = 0;public int Directories = 1;public int FullScreen = 0;public int Location = 1;public int Resizable = 1;public int ScrollBars = 1;public int Status = 1;public int TitleBar = 1;

public int ToolBar = 1;public int MenuBar = 1;

}



MCAD/MCSD

76

El código HTML para un botón que usa estas opciones tendrá el aspecto del siguiente ejemplo (la variable deservidor se muestra en negrita).

<INPUT type="button" value="Show New Window"onclick="window.open('<%# urlTarget.URL %>', null,'height=<%# urlTarget.Height %>, width=<%# urlTarget.Width %>,top=<%# urlTarget.Top %>, left=<%# urlTarget.Left %>,channelmode=<%# urlTarget.ChannelMode %>,directories=<%# urlTarget.Directories %>,fullscreen=<%# urlTarget.FullScreen %>,

location=<%# urlTarget.Location %>,menubar=<%# urlTarget.MenuBar %>,resizable=<%# urlTarget.Resizable %>,scrollbars=<%# urlTarget.ScrollBars %>,status=<%# urlTarget.Status %>,titlebar=<%# urlTarget.TitleBar %>,toolbar=<%# urlTarget.ToolBar %>')">

4.4 Resumen• Los controles de servidor proporcionan propiedades, métodos y sucesos que se pueden usar en el código de

servidor.• Los controles HTML proporcionan atributos y sucesos que se pueden usar en scripts que corren en el cliente.

Para acceder a propiedades de un control HTML en código de servidor añada un atributo runat=server a ladefinición del control.

• ASP.NET realiza validación de controles en el lado cliente inmediatamente antes de enviar el formulario alservidor. Una vez que la validación de cliente tiene éxito el formulario se valida de nuevo en el servidor antes

de que se produzca el suceso Page_Load . Esto asegura que no se ha modificado el formulario en el cliente para esquivar la validación y también garantiza que la validación funcionará con navegadores anteriores alInternet Explorer 4.0.

• Para comprobar varias condiciones sobre un único campo de datos use varios controles de validación. Por ejemplo un TextBox que exige un número de teléfono debe ser controlado por un RequiredFieldValidator y por un RegularExpressionValidator.

• Para navegar entre páginas de una aplicación de formularios Web use una de las siguientes técnicas (los mé-todos de Server solo funcionan con formularios Web).• Hiperenlaces• Método Response.Redirect • Método Server.Transfer • Método Server.Execute • Procedimientos de secuencia de comandos de cliente

• Para realizar una acción en el navegador cliente debe usar una secuencia de comandos de cliente, por ejemplo, para abrir una página en una nueva ventana podría usar un botón HTML con un atributo on-

click=”window.open”. Esto se debe a que las secuencias de comandos de cliente son el único código deuna aplicación de formularios Web que se ejecuta en el cliente.

4.5 Práctica: Editor de texto basado en WebEn esta práctica va a crear una aplicación de formulario Web con varias páginas que permitirá a los usuarios

crear y editar archivos de texto archivados en el servidor. La aplicación usa el nombre de conexión del usuario paradeterminar donde se almacenan los archivos. No hace un control de contraseña riguroso – de hecho la contraseñasiempre es Invitado. La autentificación de contraseñas se trata en el capítulo 8, Mantenimiento de Seguridad .

Importante: Para crear y borrar archivos la cuenta de usuario ASPNET debe tener derechos de modificacióny de escritura en el directorio raíz de la aplicación. De forma predeterminada esta cuenta solo tiene derechos delectura y ejecución. Par información sobre como asignar privilegios de seguridad en la carpeta de la aplicación veael capítulo 9 Crear y Desplegar Aplicaciones Web.

4.5.1 Crear el formulario de registroEn este ejercicio creará el formulario Web que permitirá a los usuarios registrarse en el editor de texto. El

formulario Web utiliza validación, disposición de flujo, navegación a otras páginas y el espacio de nombres Sys-tem.IO para los servicios de directorio.

►Para iniciar la aplicación y crear el formulario Web SignOn1. Abra un nuevo proyecto de aplicación ASP.NET. En el diálogo Nuevo Proyecto escriba el nombre Edi-

torTextoWeb. 2. En la ventana de propiedades, cambie el nombre del archivo Webform1.aspx a SignOn.aspx.3. En la ventana de propiedades seleccione el objeto DOCUMENT y cambie la propiedad pageLayout a

FlowLayout .Después de cambiar pageLayout a FlowLayout puede añadir controles pulsando dos veces sobre ello en la

caja de herramientas. Si crea los controles en el orden en que aparecen en la página el proceso es rápido. La si-




77

guiente tabla muestra los controles que debe crear en el orden adecuado, junto con los valores de sus propieda-des.

Control Propiedad ValorLiteral ID litNoAccount TextBox ID txtNameRequiredFieldValidator ID vldtxtName

ControlToValidate txtName

ErrorMessage Por favor, escriba un nombreTextBox ID txtPassword RequiredFieldValidator ID vldtxtPassword

ControlToValidate txtPassword ErrorMessage Por favor, escriba la contraseña

RangeValidator ID vldtxtPasswordGuest ControlToValidate txtPassword ErrorMessage La contraseña es “Invitado” MinimumValue Invitado MaximumValue Invitado

Button ID butSignOnText Registro

Después de crear los controles y establecer sus propiedades cambie el diseñador para ver el código

HTML de la página y edite la página en modo HTML, añadiendo texto y elementos HTML directamente.►Para editar el formulario Web en modo HTML

1. Pulse con el botón derecho sobre el formulario Web y seleccione Ver código fuente HTML.2. Edite el formulario Web añadiendo el texto y etiquetas HTML que se muestran en negrita:

<form id="Form1" method="post" runat="server"><h2>Bienvenido al Editor de Texto Web</h2><asp:Literal id="litNoAccount" runat="server"></asp:Literal><p>Por favor, regístrese</p> Nombre:<asp:TextBox id="txtName" runat="server" Width="165px"></asp:TextBox><asp:RequiredFieldValidator id="vldtxtName" runat="server"ErrorMessage="Por favor, escriba un nombre."ControlToValidate="txtName"></asp:RequiredFieldValidator><br><br>

Contraseña:<asp:TextBox id="txtPassword" runat="server" Width="163px"Height="21px" TextMode="Password"></asp:TextBox><asp:RequiredFieldValidator id="vldtxtPassword" runat="server"ErrorMessage="Por favor, escriba la contraseña."ControlToValidate="txtPassword"></asp:RequiredFieldValidator><br><asp:RangeValidator id="vldtxtPasswordGuest" runat="server"ControlToValidate="txtPassword" ErrorMessage='La contraseña es "Invitado".'MaximumValue="Guest" MinimumValue="Guest"></asp:RangeValidator><br><br><asp:Button id="butSignOn" runat="server" Text="Registro" Width="61px"Height="28px"></asp:Button><p>Usuarios nuevos, pulsar <a href="NewAccount.aspx">aquí</a> para

configurar una cuenta.</p></form>

3. Para ver el resultado de los cambios pulse con el botón derecho del ratón sobre el formulario Web y se-leccione Ver diseño.

Cuando termine de editar el formulario Web cambie a la vista de diseño y pulse dos veces sobre el formu-lario para ver la ventana de código. Escriba las siguientes sentencias antes de la definición de clase del formula-rio:

Visual BasicImports System.IO

Visual C#using System.IO

Añada el siguiente código en el procedimiento del suceso Click del botón:



MCAD/MCSD

78

Visual Basic .NETPrivate Sub butSignOn_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butSignOn.ClickDim strPath As String

'Si el usuario existe hay un directorio con su nombre.strPath = Server.MapPath(Request.ApplicationPath) & "\" & txtName.TextIf Directory.Exists(strPath) Then

' Configura las variables de sesión.Session("Path") = strPath

Server.Transfer("FileManager.aspx")Else

' En caso contrario informa de que no encontró al usuario.litNoAccount.Text = "<p>No se encontró el nombre " & txtName.Text & _"Compruebe el nombre o pulse <A href='NewAccount.aspx'>aquí</A>" & _" si es un nuevo usuario.</p>"

End IfEnd Sub

Visual C#private void butSignOn_Click(object sender, System.EventArgs e){

string strPath;// Si el usuario existe hay un directorio con su nombre.strPath = Server.MapPath(Request.ApplicationPath) + "\\" + txtName.Text;if(Directory.Exists(strPath)){

// Configura las variables de sesión.Session["Path"] = strPath;Server.Transfer("FileManager.aspx");

}else// En caso contrario informa de que no encontró al usuario.litNoAccount.Text = "<p>No se encontró el nombre " + txtName.Text +

"Compruebe el nombre o pulse <A href='NewAccount.aspx'>aquí</A>" +" si es un nuevo usuario.</p>";

}

4.5.2 Crear el formulario NewAccountEn este ejercicio creará el formulario Web que crea una cuenta para un nuevo usuario. En esta aplicación una

“cuenta” consiste en un directorio en el raíz de la aplicación con el nombre del usuario. De nuevo, en este ejerciciono se proporciona seguridad; la seguridad se trata en el capítulo 8.

El formulario Web creado aquí utiliza validación, disposición en flujo, navegación, controles HTML y el espacio de nombre System.IO para servicios de directorio. El formulario usa el nombre de usuario para crear un direc-torio para los archivos del usuario en el raíz de la aplicación en el servidor.

►Para crear el formulario Web NewAccount1. Cree un nuevo formulario Web llamado NewAccount.aspx.2. En la ventana de propiedades seleccione el objeto DOCUMENT y cambie su propiedad pageLayout a

FlowLayout. 3. Añada controles y configure sus propiedades según la siguiente tabla:

Control Propiedad ValorLiteral ID litNameExistsTextBox ID txtName

RequiredFieldValidator ID vldtxtNameControlToValidate txtNameErrorMessage Por favor escriba un nombre

Button ID butCreateText Crear

Control HTML Button id butCancelvalue Cancelar

4. Cambie el formulario Web a vista HTML y añada el texto que se muestra en negrita:




79

<form id="Form1" method="post" runat="server"><h2>Crear una Cuenta</h2>

<asp:Literal id="litNameExists" runat="server"></asp:Literal><p>Actualmente no tiene una cuenta en el servidor.<br>Escriba a continuación el nombre que quiere usar para registrarse y pulse

Crear.</p>

<asp:TextBox id="txtName" runat="server" Width="153px"Height="24px"></asp:TextBox><asp:RequiredFieldValidator id="vldtxtName" runat="server"

ErrorMessage="Por favor, escriba un nombre." ControlToValidate="txtName"></asp:RequiredFieldValidator><p></p><asp:Button id="butCreate" runat="server" Text="Crear" Width="67"Height="24"></asp:Button> <INPUT type="button" onclick="history.back()"value="Cancelar"></BUTTON></form>

La última modificación en el código anterior, onclick=”history.back()” permite que el usuariocancele la operación sin provocar validación. Es importante usar aquí un control HTML porque no queremos quese procese en el servidor – solo queremos volver al formulario SignOn.

Cuando termine de editar el formulario Web vuelva a la vista de diseño y pulse dos veces sobre el botón

Crear para ver la ventana de código. Coloque la sentencia Imports o using antes de la definición de la clase delformulario Web:

Visual Basic .NETImports System.IO


Añada el siguiente código al procedimiento de suceso butCreate_Click :

Visual Basic .NETPrivate Sub butCreate_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butCreate.ClickDim strPath As String

'Comprueba si el directorio existe.strPath = Server.MapPath(Request.ApplicationPath) & "\" & txtName.TextIf Directory.Exists(strPath) Then

' Pide al usuario que escriba otro nombre.litNameExists.Text = "<p>El nombre " & txtName.Text & _

" ya existe. Por favor escriba uno diferente.</p>"ReturnElse

TryDirectory.CreateDirectory(strPath) ' Crea el directorio.Session("Path") = strPath ' Configura variable de sesión.Server.Transfer("FileManager.aspx") ' Va al admin de archivos.

Catch ex As System.UnauthorizedAccessExceptionServer.Transfer("NotAuthorized.aspx")

End Try

End IfEnd Sub

Visual C#private void butCreate_Click(object sender, System.EventArgs e){

string strPath;// Comprueba si el directorio existe.strPath = Server.MapPath(Request.ApplicationPath) + "\\" + txtName.Text;if (Directory.Exists(strPath)){

// Pide al usuario que escriba otro nombre.litNameExists.Text = "<p>El nombre " + txtName.Text +

" ya existe. Por favor escriba uno diferente.</p>";return;



MCAD/MCSD

80

}else {try{

Directory.CreateDirectory(strPath); // Crea el directorio.Session["Path"] = strPath; // Configura variable sesión.Server.Transfer("FileManager.aspx"); // Va al admin de archivos.

}catch (System.UnauthorizedAccessException ex){Server.Transfer("NotAuthorized.aspx");

}}

}

4.5.3 Crear el formulario FileManager En este ejercicio creará el formulario Web que permite a los usuarios crear, abrir y borrar archivos en sus

cuentas del servidor. El formulario Web creado aquí usa vinculación de datos, disposición de flujo, navegación,QueryString y el espacio de nombres System.IO para acceso a archivos.

►Para crear el formulario Web FileManager 1. Cree un nuevo formulario Web llamado FileManager.aspx.2. En la ventana de propiedades seleccione el objeto DOCUMENT y cambie pageLayout a FlowLayout. 3. Añada controles y configure sus propiedades según la siguiente tabla:

Control Propiedad ValorLiteral ID litNoFile

TextBox ID txtNewFileButton ID butNewText Nuevo

Literal ID litNoneSelected ListBox ID lstFiles

DataSource strFilesButton ID butEdit

Text Editar Button ID butDelete

Text Borrar

4. Cambie el formulario Web a HTML y añada el texto y etiquetas HTML que se muestran en negrita:<form id="Form1" method="post" runat="server"><h2>Administrador de Archivos</h2>

<p>Para crear un nuevo archivo escriba el nombre y pulse Nuevo.</p><asp:Literal id="litNoFile" runat="server"></asp:Literal><asp:TextBox id="txtNewFile" runat="server" Width="191px"></asp:TextBox><asp:Button id="butNew" runat="server" Width="62px" Height="29px"Text="Nuevo"></asp:Button><p>Para editar un archivo selecciónelo en la lista y pulse Editar. PulseBorrar para borrar el archivo seleccionado.</p>

<asp:Literal id="litNoneSelected" runat="server"></asp:Literal><asp:listbox id="lstFiles" runat="server" Width="252px" Height="161px"DataSource="<%# strFiles %>"></asp:listbox><br><asp:Button id="butEdit" runat="server" Width="62" Height="29"Text="Edit"></asp:Button> <asp:Button id="butDelete" runat="server" Width="62px" Height="29px"Text="Delete"></asp:Button></form>

5. Cuando termine de editar el formulario Web vuelva a la vista de diseño y pulse dos veces sobre el botón Nuevo para ver la ventana de código. Coloque las sentencias Imports o using antes de la definición declase del formulario Web.Visual Basic .NETImports System.IO


6. Añada el siguiente código a los procedimientos de suceso:Visual Basic .NETPublic strPath As String, strFiles As String()




81


' Obtiene la ruta.strPath = Session("Path")' Si no es un suceso de envío.If Not IsPostBack Then

Dim iCount As Integer'Obtiene la lista de archivos en el directorio actual.strFiles = Directory.GetFiles(strPath)

' Obtiene los nombres cortos de los archivos.For iCount = 0 To UBound(strFiles)

strFiles(iCount) = Path.GetFileName(strFiles(iCount))Next

End If' Enlaza lstFiles con el array de archivos.lstFiles.DataBind()

End Sub

Private Sub butNew_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butNew.Click

' Si hay un nombre de archivo arranca el editor.If txtNewFile.Text <> "" Then

Response.Redirect("EditFile.aspx?file=" & txtNewFile.Text)Else

' O presenta un mensaje.litNoFile.Text = "<p>Debe escribir el nombre del archivo.<p>"

End IfEnd Sub

Private Sub butEdit_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butEdit.Click

' Si hay un nombre de archivo arranca el editor.If Not IsNothing(lstFiles.SelectedItem) Then

Response.Redirect("EditFile.aspx?file=" & _lstFiles.SelectedItem.ToString)

Else' Si no, muestra un mensaje.litNoneSelected.Text = "<p>Debe seleccionar un archivo.<p>"

End If

End Sub

Private Sub butDelete_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butDelete.Click

' Si hay un nombre de archivo, arranca el editor.If Not IsNothing(lstFiles.SelectedItem) Then

TryDim filToDelete As FilefilToDelete.Delete(strPath & "\" & _

lstFiles.SelectedItem.ToString)lstFiles.Items.Remove(lstFiles.SelectedItem)

Catch ex As System.Security.SecurityExceptionServer.Transfer("NotAuthorized.aspx")

End TryElse

' Si no, muestra un mensaje.litNoneSelected.Text = "<p>Debe seleccionar un archivo.<p>"

End IfEnd Sub

Visual C#string strPath;public string[] strFiles;



MCAD/MCSD

82

private void Page_Load(object sender, System.EventArgs e){// Obtiene la ruta.strPath = Session["Path"].ToString();// Si no es un suceso de envío.if(!Page.IsPostBack){

// Obtiene la lista de archivos en el directorio actual.strFiles = Directory.GetFiles(strPath);// Obtiene los nombres cortos de los archivos.for (int iCount = 0; iCount <= strFiles.GetUpperBound(0);

iCount++)strFiles[iCount] = Path.GetFileName(strFiles[iCount]);

}// Vincula lstFiles con el array de archivos.lstFiles.DataBind();

}

private void butNew_Click(object sender, System.EventArgs e){//Si hay un nombre de archivo, arranca el editor.if (!(txtNewFile.Text == ""))

Response.Redirect("EditFile.aspx?file=" + txtNewFile.Text);else

// Si no, muestra un mensaje.litNoFile.Text = "<p>Debe escribir un nombre de archivo.<p>";

}

private void butEdit_Click(object sender, System.EventArgs e){// Si hay un nombre de archivo arranca el editor.if (lstFiles.SelectedItem == null)

Response.Redirect("EditFile.aspx?file=" +lstFiles.SelectedItem.ToString());

else// Si no, muestra un mensaje.litNoneSelected.Text = "<p>Debe seleccionar un archivo.<p>";

}

private void butDelete_Click(object sender, System.EventArgs e){// Si hay un nombre de archivo, arranca el editor.if (lstFiles.SelectedItem != null)

try{

File.Delete(strPath + "\\" + lstFiles.SelectedItem.ToString());lstFiles.Items.Remove(lstFiles.SelectedItem);}catch(System.UnauthorizedAccessException ex){

Server.Transfer("NotAuthorized.aspx");}

else// Si no, muestra un mensaje.litNoneSelected.Text = "<p>Debe seleccionar un archivo.<p>";

}

4.5.4 Crear el formulario FileEditor En este ejercicio creará el formulario Web que edita los archivos almacenados en el servidor en la cuenta del

usuario. Este formulario usa la misma disposición y técnicas de programación que los del apartado anterior.

►Para crear el formulario Web FileEditor 1. Cree un nuevo formulario Web llamado FileEditor.aspx.2. En la ventana de propiedades seleccione el objeto DOCUMENT y cambie pageLayout a FlowLayout. 3. Añada controles y configure sus propiedades según la siguiente tabla:

Control Propiedad ValorTextBox ID txtEditFile

TextMode Multiline Height 256pxWidth 448px

Button ID butSaveText Grabar

HTML Button id butCancelvalue Cancelar

Button ID butExit Text Salir

4. Cambie el formulario Web a vista HTML y añada el texto que se muestra en negrita:




83

<form id="Form1" method="post" runat="server"><h2>Editor de Ficheros</h2>

<p>Modifique el fichero debajo. Pulse Grabar para guardar los cambios oCancelar para descartarlos.</p>

<asp:TextBox id="txtEditFile" runat="server" Width="448px" Height="253px"TextMode="MultiLine"></asp:TextBox><p></p>

<asp:Button id="butSave" runat="server" Width="65" Height="30"Text="Save"></asp:Button>

<INPUT id="butCancel" onclick="history.back()" type="button"value="Cancelar" style="WIDTH: 65px; HEIGHT: 30px"> <asp:Button id="butExit" runat="server" Width="65" Height="30"Text="Salir"></asp:Button></form>

5. Cuando termine de editar el formulario Web vuelva a la vista de diseño y pulse dos veces sobre el botónGrabar para ver la ventana de código. Coloque las sentencias Imports o using antes de la definición declase del formulario Web.Visual Basic .NETImports System.IO


6. Añada el siguiente código a los procedimientos de suceso:Visual Basic .NETDim strPath, strFile As String


' Obtiene la ruta y el nombre de archivo.strPath = Session("Path")strFile = Request.QueryString("file")' Si no es un suceso de envío.If Not IsPostBack Then

Try' Abre el archivo.strmEditFile = File.OpenText(strPath & "\" & strFile)' Lee su texto.txtEditFile.Text = strmEditFile.ReadToEnd.ToString' Cierra el archivo.strmEditFile.Close()

Catch ex As System.IO.FileNotFoundException' Si no existe, lo crea.File.CreateText(strPath + "\\" + strFile).Close()' Vacía la caja de texto.txtEditFile.Text = ""

Catch ex As System.UnauthorizedAccessExceptionServer.Transfer("NotAuthorized.aspx")

End TryEnd If

End Sub

Private Sub butExit_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butExit.ClickIf viewstate("changed") ThenSaveFile()

End If' Vuelve al administrador de archivos.Response.Redirect("FileManager.aspx")

End Sub

Private Sub txtEditFile_TextChanged(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles txtEditFile.TextChanged

' Configura el indicador de cambiado.viewstate("changed") = True

End Sub

Private Sub butSave_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butSave.Click

SaveFile()End Sub



MCAD/MCSD

84

Private Sub SaveFile()Dim strmEditWrite As StreamWriter' Borra el archivo.File.Delete(strPath & strFile)' Crea el archivo con el nuevo texto.strmEditWrite = File.CreateText(strPath & "\" & strFile)strmEditWrite.Write(txtEditFile.Text)strmEditWrite.Close()' Restablece el indicador de cambiado.

viewstate("changed") = FalseEnd Sub

Visual C#string strPath, strFile;

private void Page_Load(object sender, System.EventArgs e){// Obtiene la ruta y nombre del archivo.Session["Path"] = "c:";strPath = Session["Path"].ToString();strFile = Request.QueryString["file"];// Si no es un suceso de envío.if (! Page.IsPostBack){

StreamReader strmEditFile;try{

// Abre el archivo.strmEditFile = File.OpenText(strPath + "\\" + strFile);// Lee su texto.txtEditFile.Text = strmEditFile.ReadToEnd().ToString();// Cierra el archivo.strmEditFile.Close();

}catch(FileNotFoundException ex){// Si no existe, lo crea.File.CreateText(strPath + "\\" + strFile).Close();// Limpia la caja de texto.txtEditFile.Text = "";

}catch(System.UnauthorizedAccessException ex){Server.Transfer("NotAuthorized.aspx");

}}

}

private void butExit_Click(object sender, System.EventArgs e){if (ViewState["Changed"].ToString() == "true") SaveFile();// Vuelve al administrador de archivos.Response.Redirect("FileManager.aspx");

}

private void txtEditFile_TextChanged(object sender, System.EventArgs e){// Configura el indicador de cambio.ViewState["Changed"] = true.ToString();

}

private void butSave_Click(object sender, System.EventArgs e){SaveFile();}

void SaveFile(){

StreamWriter strmEditWrite;// Borra el archivo.File.Delete(strPath + strFile);// Crear el archivo con el nuevo texto.strmEditWrite = File.CreateText(strPath + "\\" + strFile);strmEditWrite.Write(txtEditFile.Text);strmEditWrite.Close();// Restablece el indicador de cambio.ViewState["Changed"] = false.ToString();

}

4.5.5 Crear el formulario Web NonAuthorizedComo se mencionó al inicio de esta práctica, debe autorizar a la cuenta de usuario ASPNET para que cree y

borre archivos en la carpeta raíz de la aplicación. Si no otorga estos permisos todos los intentos de crear, grabar o

borrar archivos provocarán un error System.UnauthorizedAccessException.El código de los ejercicios anteriores trata este error usando bloques de manejo de excepciones Try ... Catch /

try ... catch. Si se produce el error el Editor de Texto Web muestra un formulario Web con instrucciones.




85

1. Cree un nuevo formulario Web llamado NonAuthorized.aspx.2. Cambie a modo HTML y añada el siguiente texto al formulario Web:

<h2>No está autorizado para esta petición.</h2><p>Este error se produce cuando la cuenta de usuario ASPNET no está autorizadaPara acceder, crear o modificar una carpeta o archivo en el servidor.Utilice el Explorador de Windows para configurar los permisos en eldirectorio de proyecto de modo que permita que la cuenta de usuario ASPNETmodifique, lea y escriba archivos.

</p><a href="SignOn.aspx">Volver a Registro.</a>



1. ¿Cuál es la diferencia principal entre el control de servidor Button y el control HTML Button?

2. ¿Cómo se consigue que varios controles RadioButton interactúen en un formulario Web de forma que solo se pueda seleccionar uno a la vez?

3. ¿Por qué ASP.NET realiza la validación en el cliente y en el servidor?

4. ¿Qué tipos de validación debería utilizar para comprobar que un usuario ha introducido un número de clientecorrecto?

5. ¿Qué es incorrecto en la siguiente línea de código?

Visual Basic .NETServer.Transfer(“Default.htm”)

Visual C#Server.Transfer(“Default.htm”)

6. ¿Por qué no se puede abrir una nueva ventana de navegador mediante código de servidor?



MCAD/MCSD

86




87

5 ADO.NET.En este capítulo aprenderá como usar para leer y modificar datos almacenados en bases de datos OLE y SQL

desde formularios Web. Aprenderá sobre las herramientas de datos incluidas en Visual Studio .NET y cómo usarlas para crear conexiones con, obtener registros de y ejecutar comandos sobre bases de datos. También aprenderá cómomostrar datos en un formulario Web usando tanto vinculación de datos como código. Finalmente aprenderá cómousar transacciones para mantener la integridad de una base de datos.

Para completar las lecciones de este capítulo deberá:

• Tener instalado en su ordenador Microsoft Data Engine (MSDE) o SQL Server 2000 en su ordenador. VisualStudio .NET instala MSDE como parte de su instalación predeterminada.

• Instalar la base de datos SQL Contacts (Contacts.mdf) desde el CD-ROM que acompaña al libro. Esta basede datos se usa en los ejemplos de este capítulo.

• Estar familiarizado con los elementos básicos del lenguaje Transact-SQL. Para encontrar información sobreeste lenguaje vea el tema Referencia del Lenguaje Transact-SQL en la ayuda de SQL Server.

5.1 Acceso a datos con ADO.NETVisual Studio .NET proporciona acceso a bases de datos mediante el conjunto de herramientas y espacios de

nombres conocidos colectivamente como ADO.NET. El acceso a datos en ADO.NET está estandarizado de formaque en su mayor parte es independiente del origen de datos – una vez establecida una conexión con una base dedatos se usa un conjunto coherente de objetos, propiedades y métodos, independientemente del tipo de base de datosque se esté usando.

En esta lección aprenderá cómo usar ADO.NET para conectar con una base de datos y cómo leer, modificar y borrar registros de la base de datos. Las lecciones de este capítulo usan la base de datos Contacts (Contacts.mdf)incluida en el CD-ROM de acompañamiento para todos sus ejemplos. Asegúrese de instalar esta base de datos antesde intentar probar los ejemplos.

5.1.1 ADO.NETEn ADO.NET hay tres capas para el acceso a datos:

• Almacén de datos físico: Puede ser una base de datos OLE, una base de datos SQL o un archivo XML.• Proveedor de datos: Consiste en los objetos Connection y Command que crear la representación de los datos

en memoria.

• Conjunto de datos: Representación en memoria de las tablas y relaciones con las que se trabaja en la aplica-ción.

La capa proveedor de datos proporciona la abstracciónentre el almacén de datos físico y el conjunto de datos con el quese trabaja en el código. Después de crear el conjunto de datos noimporta de donde procede o donde está almacenado. Esta arqui-tectura se denomina desconectada porque el conjunto de datoses independiente del almacén de datos.

En ADO.NET hay dos formas de conexiones con base dedatos:

• Usar un objeto OleDbConnection para conectar con una base de datos local: Las conexiones con bases

de datos OLE usan el objeto OleDbDataAdapter para ejecutar comandos y recuperar datos.• Usar un objeto SqlDbConnection para conectar con una base de datos de servidor: Las conexiones con bases de datos SQL usan el objeto SqlDbDataAdapter para ejecutar comandos y recuperar datos.

Además de estas conexiones con bases de datos, puede acceder directamente a archivos XML desde conjun-tos de datos usando los métodos ReadXML y WriteXML del objeto DataSet . Los archivos XML son representacionesestáticas de conjuntos de datos. ADO.NET usa XML para todas sus transferencias a través de Internet.

ADO.NET proporciona sus objetos, propiedades y métodos mediante los tres espacios de nombres descritosen la tabla 5.1. Los espacios de nombres System.Data.SqlClient y System.Data.OleDb proporcionan funcionalidadesequivalentes para bases de datos SQL y OLE respectivamente.

Tabla 5. 1: Espacios de Nombres ADO.NETEspacio de Nombres Proporciona

System.Data Clases, tipos y servicios para crear y acceder a conjuntos de datos y sus objetos subordinados.

System.Data.SqlClient Clases y tipos para acceder a bases de datos Microsoft SQL ServerSystem.Data.OleDb Clases y tipos para acceder a bases de datos OLE.

Fig. 5. 1: Objetos Connection y Command



MCAD/MCSD

88

Cuando se trabaja con bases de datos en código necesitará añadir declaraciones Imports o using al principiodel módulo de código.

Para acceder a una base de datos mediante ADO.NET siga estos pasos:

1. Crear una conexión con la base de datos usando un objeto conexión.2. Llamar a un comando para crear un DataSet usando un objeto adaptador.3. Usar el objeto DataSet en el código para mostrar los datos o cambiar elementos de la base de datos.4. Llamar a un comando para actualizar la base de datos desde el DataSet usando un objeto adaptador.

5. Cerrar la conexión con la base de datos, si la abrió explícitamente en el paso 2 usando el método Open. Alllamar a un comando sin llamar primero al método Open abre y cierra implícitamente la conexión con cada petición.

Las siguientes secciones discuten cada uno de estos pasos con más detalle.

5.1.2 Conectar con una base de datosUse el explorador de servidores para conectar con una base de datos en Visual Studio.

Para conectar con una base de datos en el entorno de diseño de Visual Studio siga estos pasos:

1. En el menú Ver seleccione Explorador de Servidores.2. En la barra de herramientas del Explorador de Servidores pulse el botón Conectar con base de datos. Visual

Studio .NET muestra el diálogo Propiedades de vínculo de datos.

3. Pulse la lengüeta Proveedor para seleccionar el tipo de base de datos para la conexión. El proveedor prede-terminado es Microsoft OLE DB Provider for SQL Server. Esta es la opción correcta si su base de datos corre bajo Microsoft SQL Server. Para acceder a un tipo de base de datos diferente seleccione el proveedor ade-cuado. Por ejemplo, para acceder directamente a una base Microsoft Access 2000 seleccione Microsoft Jet4.0 OLE DB Provider.

4. Pulse la lengüeta Conexión para especificar la base de datos con la cual conectar. Al cambiar el proveedor enel paso 3 cambian las opciones de conexión.

5. Introduzca las opciones de conexión y pulse Probar conexión para asegurarse de que la configuración es co-rrecta. Cuando la configuración sea correcta pulse Aceptar. Visual Studio añade la conexión al servidor dedatos al Explorador de Servidores.

6. Al pulsar el signo más (+) en el Explorador de Servidores se expanden elementos. Para ver las tablas en unaconexión de base de datos expanda los elementos bajo la conexión y expanda los elementos bajo Tablas.

7. Para añadir un elemento a la aplicación arrástrelo desde el explorador y suéltelo en el formulario Web. Por

ejemplo, arrastre la tabla Contacts. Cuando suelte la tabla en el formulario Web Visual Studio crea los obje-tos conexión y adaptador con la configuración adecuada.

Importante: Las aplicaciones Web se ejecutan bajo la cuenta de usuario ASP.NET. El administrador de la base de datos deberá configurar esta cuenta y otorgarle permisos antes de que laaplicación tenga acceso a la base de datos. Para bases de datos Access debe otorgar a lacuenta de usuario ASP.NET permisos sobre el archivo de base de datos usando las op-ciones de seguridad de archivos de Windows.

5.1.3 Crear un conjunto de datosUtilice los objetos conexión y adaptador creados en el paso 7 de la sección anterior para crear un conjunto de

datos.

Para crear un conjunto de datos en modo diseño siga estos pasos:1. Pulse con el botón derecho sobre el objeto adaptador de datos y seleccione Generar conjunto de datos. Visual

Studio muestra el diálogo Generar conjunto de datos.2. Seleccione las tablas que se añadirán al conjunto de datos y pulse Aceptar. Visual Studio crea un nuevo obje-

to DataSet y lo añade al formulario Web.

Para ver los datos del conjunto de datos en modo diseño pulse con el botón derecho sobre el objeto DataSet yseleccione Ver esquema. Visual Studio muestra el conjunto de datos en la ventana del diseñador XML.

5.1.4 Mostrar un conjunto de datosPara mostrar un conjunto de datos en un formulario Web en tiempo de ejecución siga estos pasos:

1. Añada al formulario un control para mostrar el conjunto de datos, por ejemplo un DataGrid.2. Configure el conjunto de datos como origen de datos del control. Por ejemplo, para el control DataGrid pulse

sobre el enlace Generador de propiedades bajo la ventana de propiedades, seleccione el objeto DataSet comovalor de la propiedad DataSource y una de sus tablas como valor de DataMember .




89

3. Configure las columnas que mostrará el control. Para el control DataGrid pulse el elemento Columnas en lacaja de diálogo Propiedades, quite la marca de Crear columnas automáticamente en tiempo de ejecución, yañada las columnas que se van a mostrar de la lista Columnas disponibles. Pulse Aceptar cuando termine.

4. Añada al procedimiento de suceso Page_Load código para rellenar el conjunto de datos a partir del adaptador de datos y vincular los datos del objeto DataSet al control. Por ejemplo, el siguiente código muestra los datosen el control DataGrid creado en los pasos anteriores.


ByVal e As System.EventArgs) Handles MyBase.Load' Rellena el conjunto de datos.SqlDataAdapter1.Fill(DataSet1)' Actualiza el DataGrid.DataGrid1.DataBind()

End Sub


// Rellena el conjunto de datos.sqlDataAdapter1.Fill(DataSet1);// Actualiza el DataGrid.DataGrid1.DataBind();

}

5. Ejecute la aplicación. Cuando se carguen los datos debe ver una tabla con los mismos.Consejo: Como está rellenando el conjunto de datos y vinculando los datos con el control DataGrid

en el suceso Page_Load no necesita mantener información de estado para el control Data-Grid. Desactivar la información de estado mejora las prestaciones porque no es necesarioguardar los datos del DataGrid en el ViewState de la página entre peticiones. De el valor False a la propiedad EnableViewState para desactivar el mantenimiento de estado para elcontrol.

5.1.5 Cambiar registros en la base de datosEl DataSet es el objeto central de ADO.NET. Los añadidos, borrados o cam-

bios a los registros de una base de datos por lo general se hacen mediante un objeto DataSet .

Para cambiar registros por medio de un objeto DataSet siga estos pasos:

1. Obtenga un objeto DataSet como se describe en las secciones anteriores.2. Modifique el DataSet .3. Actualice la base de datos con el DataSet llamando al método Update del

adaptador de datos.

Para obtener los elementos de datos de un DataSet use las colecciones Tables, Rows y Columns.

5.1.6 Cómo hace referencia a objetos ADO.NETCuando se crean objetos conexión, adaptador y conjunto de datos en modo diseño se activa el tipado de datos

para estos objetos. Esto significa que puede usar los nombres específicos del esquema de base de datos para identifi-car tablas, filas y campos. Este es un gran cambio respecto a ADO, que solo proporciona referencias sin tipo a losobjetos de datos.

Las siguientes líneas de código equivalentes muestran una referencia con tipo frente a una referencia sin tipoa un objeto de una base de datos.

Visual Basic .NET' Referencia con tipo a la columna HomePhone de la tabla Contacts.DataSet1.Contacts.HomePhoneColumn.Caption = "@Home"' Referencia sin tipo a la misma columna.DataSet1.Tables("Contacts").Columns("HomePhone").Caption = "@Home"

Visual C#// Referencia con tipo a la columna HomePhone de la tabla Contacts.DataSet1.Contacts.HomePhoneColumn.Caption = "@Home";// Referencia sin tipo a la misma columna.

DataSet1.Tables["Contacts"].Columns["HomePhone"].Caption = "@Home";

Fig. 5. 2: Colecciones delDataSet



MCAD/MCSD

90

La primera línea no solo es más sencilla de leer y escribir, sino que también es mucho menos propensa aerrores, puesto que Visual Studio comprueba los tipos de datos mientras se trabaja, marcando cualquier error comoreferencia no reconocida.

En general debe usar referencias con tipos cuando trabaje con objetos de datos. La excepción a esta regla se produce cuando no se conoce el objeto específico con el que se está trabajando. Normalmente esta situación se pro-duce cuando se proporciona el origen de datos en tiempo de ejecución en lugar de en tiempo de diseño.

La información de tipos para objetos de datos procede del esquema XML que genera Visual Studio cuando se

crea un conjunto de datos en modo de diseño.Para ver información de tipo para un conjunto de datos pulse con el botón derecho sobre el conjunto de datos

en la ventana de diseño y seleccione Ver esquema. Visual Studio muestra el conjunto de datos en el diseñador XML.

Puede usar el diseñador XML para añadir elementos, especificar claves únicas y ver o cambiar los tipos dedatos de elementos en un conjunto de datos.

5.1.7 Añadir, cambiar y borrar filasPara añadir, cambiar o borrar filas en el objeto Table de DataSet use la colección Rows. Para añadir un regis-

tro a un conjunto de datos cree un nuevo objeto Row y añádalo a la colección Rows, como muestra este código:

Visual Basic .NET' Usa conexión, adaptador y conjunto de datos creados en modo diseño.

Private Sub butAddRow_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butAddRow.Click' Crea un nuevo objeto fila para la tabla Contacts.Dim rowNew As DataSet1.ContactsRow = DataSet1.Contacts.NewRow' Añade datos a las columnas de la fila.rowNew.ContactID = 42rowNew.FirstName = "Danielle"rowNew.LastName = "Tiedt"rowNew.WorkPhone = "(111) 555-1212"' Añade la fila al conjunto de datos.DataSet1.Contacts.Rows.Add(rowNew)

End Sub

Visual C#// Usa conexión, adaptador y conjunto de datos creados en modo diseño.

private void butAddRow_Click(object sender, System.EventArgs e){// Crea un nuevo objeto fila para la tabla Contacts.DataSet1.ContactsRow rowNew =

(DataSet1.ContactsRow)DataSet1.Contacts.NewRow();// Añade datos a las columnas de la fila.rowNew.ContactID = 42;rowNew.FirstName = "Danielle";rowNew.LastName = "Tiedt";rowNew.WorkPhone = "(111) 555-1212";

}

Para cambiar una fila en un conjunto de datos obtenga un objeto Row de la tabla usando el método FindBy yhaga los cambios a los campos de la fila, como muestra este código:

Visual Basic .NET

' Usa conexión, adaptador y conjunto de datos creados en modo diseño.Private Sub butChangeRow_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butChangeRow.Click

' Declara un objeto fila.Dim rowChange As DataSet1.ContactsRow' Obtiene la fila a modificar mediante su clave principal.rowChange = DataSet1.Contacts.FindByContactID(42)' Cambia un campo de la fila.rowChange.WorkPhone = "(111) 555-9000"

End Sub

Visual C#// Usa conexión, adaptador y conjunto de datos creados en modo diseño.private void butChangeRow_Click(object sender, System.EventArgs e){

// Declara un objeto fila.

DataSet1.ContactsRow rowChange;// Obtiene la fila a cambiar mediante su clave Principal.




91

rowChange = DataSet1.Contacts.FindByContactID(42);// Cambia un campo de la fila.rowChange.WorkPhone = "(111) 555-9000";

}

Para borrar una fila de un conjunto de datos obtenga un objeto Row de la tabla usando el método FindBy y bórrelo usando su método Delete:

Visual Basic .NET

' Usa conexión, adaptador y conjunto de datos creados en modo diseño.Private Sub butDeleteRow_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butDeleteRow.Click

' Declara un objeto fila.Dim rowDelete As DataSet1.ContactsRow' Obtiene la fila a borrar.rowDelete = DataSet1.Contacts.FindByContactID(42)' Borra la fila.rowDelete.Delete()

End Sub

Visual C#// Usa conexión, adaptador y conjunto de datos creados en modo diseño.private void butDeleteRow_Click(object sender, System.EventArgs e){

// Declara un objeto fila.

DataSet1.ContactsRow rowDelete;// Obtiene la fila a borrarrowDelete = DataSet1.Contacts.FindByContactID(42);// Borra la fila.rowDelete.Delete();

}

5.1.8 Actualizar la base de datos desde el conjunto de datosPara actualizar la base de datos con los cambios hechos en un objeto DataSet use el método Update del adap-

tador de datos. Normalmente querrá hacer esto después de que se hayan procesado todos los sucesos de control enuna página; por tanto, el método Update normalmente se llama desde el suceso Page_PreRender , como se muestraaquí:

Visual Basic .NET

' Usa conexión, adaptador y conjunto de datos creados en modo diseño.Private Sub Page_PreRender(ByVal sender As Object, _ByVal e As System.EventArgs) Handles MyBase.PreRender' Actualiza la base de datos con los cambios del conjunto de datos.SqlDataAdapter1.Update(DataSet1)

End Sub

Visual C#// Usa conexión, adaptador y conjunto de datos creados en modo diseño.private void Page_PreRender(object sender, System.EventArgs e) {

// Actualiza la base de datos con los cambios del conjunto de datos.sqlDataAdapter1.Update(DataSet1);

}

Cuando actualiza una base de datos desde un conjunto de datos ADO.NET sigue estos pasos:

1. Determina los cambios al conjunto de datos comprobando la propiedad RowState de cada objeto DataRow.Los valores posibles son Added , Deleted , Modified , Unchanged o Detached .

2. Llama a las propiedades InsertCommand , DeleteCommand o UpdateCommand del objeto adaptador parahacer los cambios necesarios en la base de datos.

3. Restablece las propiedades RowState de los objetos DataRow actualizados a Unchanged .

Las propiedades InsertCommand , DeleteCommand y UpdateCommand del objeto adaptador se generan au-tomáticamente a partir de la propiedad SelectCommand del objeto cuando se crea un conjunto de datos a partir de unadaptador de datos en modo diseño. Cada una de estas propiedades representa un objeto OleCommand o SqlCom-mand . Los objetos comando tienen las siguientes propiedades que determinan cómo se ejecutan:

• La propiedad CommandText contiene la sentencia SQL o el nombre del procedimiento almacenado.• La propiedad CommandType determina cómo se ejecuta el comando mediante las siguientes opciones:

• El valor Text ejecuta el comando como sentencia SQL (predeterminado).• El valor StoredProcedure ejecuta el comando como procedimiento almacenado en la base de datos.• El valor TableDirect devuelve la tabla completa. Solo se aplica a proveedores de datos NET para OLE

DB.



MCAD/MCSD

92

Puede cambiar el contenido del conjunto de datos y cómo se actualiza cambiando las sentencias SQL utiliza-das por estos objetos comando.

Para ver o modificar estos comandos siga estos pasos:

1. En la ventana de propiedades pulse dos veces sobre la propiedad comando que quiere modificar. Esto expan-de la lista de propiedades que se aplican al objeto comando.

2. Seleccione la propiedad CommandText del comando y pulse el botón elipsis a la derecha de su valor. VisualStudio muestra el diálogo Generador de consultas.

3. Seleccione las columnas que se incluirán en el comando marcando las cajas junto a los nombres de los campos de datos en el panel tabla, o escriba directamente la sentencia SQL en el panel de comando. Cuando ter-mine pulse Aceptar.

5.1.9 Crear una conexión en tiempo de ejecuciónLa creación de objetos de datos en modo de diseño es una gran forma de aprender sobre el acceso de datos en

ADO.NET porque Visual Studio genera las opciones de propiedades de los objetos conexión y adaptador. La confi-guración de algunas propiedades, como ConnectionString, puede ser difícil y confusa sin la ayuda del modo diseño.Después de crear una conexión en modo diseño puede cortar y pegar las opciones de propiedades para crear co-nexiones similares mediante código.

El uso de objetos de acceso a datos mediante código sigue la misma secuencia que en modo diseño:

1. Crear el objeto conexión2. Crear un objeto adaptador 3. Crear un objeto conjunto de datos4. Llamar a métodos del objeto adaptador para llenar o actualizar el conjunto de datos5. Usar vinculación de datos u otra técnica para mostrar los datos del conjunto de datos.

Por ejemplo, el siguiente código crea objetos de datos y muestra datos de un proveedor SQL:


ByVal e As System.EventArgs) Handles MyBase.Load' (1) Crear la conexión.Dim sqlconnectContactMgmt As New SqlConnection _

("server=(local);database=Contacts;Trusted_Connection=yes")' (2) Crear un adaptador de datos.

Dim sqladaptContactMgmt As New _SqlDataAdapter("select * from Contacts", sqlconnectContactMgmt)' (3) Crear un conjunto de datos.Dim dsContacts As New DataSet()' (4) Rellenar el conjunto de datos.sqladaptContactMgmt.Fill(dsContacts, "Contacts")' (5) Mostrar la tabla en una rejilla mediante vinculación de datos.DataGrid1.DataSource = dsContacts.Tables("Contacts").DefaultViewDataGrid1.DataBind()

End Sub


// (1) Crear la conexión.SqlConnection sqlconnectContactMgmt = new SqlConnection

("server=(local);database=Contacts;Trusted_Connection=yes");// (2) Crear un adaptador de datos.SqlDataAdapter sqladaptContactMgmt = new

SqlDataAdapter("select * from Contacts", sqlconnectContactMgmt);// (3) Crear un conjunto de datos.DataSet dsContacts = new DataSet();// (4) Rellenar el conjunto de datos.sqladaptContactMgmt.Fill(dsContacts, "Contacts");// (5) Mostrar la tabla en una rejilla mediante vinculación de datos.DataGrid1.DataSource = dsContacts.Tables["Contacts"].DefaultView;DataGrid1.DataBind();

}

5.1.10 Actualizar una Conexión en tiempo de ejecución

Como se mencionó anteriormente en esta sección ADO.NET usa las propiedades InsertCommand , Delete-Command y UpdateCommand para actualizar la base de datos desde el conjunto de datos. Cuando se crea una adap-tador de datos en tiempo de ejecución es necesario generar estas propiedades entes de llamar al método Update delobjeto adaptador.




93

Para generar las propiedades InsertCommand , DeleteCommand y UpdateCommand en tiempo de ejecuciónsiga estos pasos:

1. Configure el SelectCommand del objeto adaptador. ADO.NET usa la propiedad CommandText del Select-Command para generar las opciones para InsertCommand , DeleteCommand y UpdateCommand .

2. Cree un objeto generador de comando par el objeto adaptador. El objeto generador de comando depende del proveedor de datos, por lo que tiene dos formas: OleDbCommandBuilder y SqlCommandBuilder .

El siguiente código conecta con una base de datos (1), crea un conjunto de datos (2), genera comandos (3),

modifica el conjunto de datos (4) y actualiza la base de datos según estos cambios (5):Visual Basic .NETPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.Load' (1) Crea la conexión.Dim ContactMgmt As New SqlConnection _

("server=(local);database=Contacts;Trusted_Connection=yes")' Crea un adaptador.Dim adptContactMgmt As New _

SqlDataAdapter("select * from Contacts", ContactMgmt)' (2) Crea un conjunto de datos.Dim dsContacts As New DataSet()' Configura el comando de selección.adptContactMgmt.SelectCommand.CommandText = "SELECT * FROM Contacts"' (3) Crea comandos de inserción, borrado y actualización automáticamente.Dim cmdContactMgmt As SqlCommandBuilder = New _

SqlCommandBuilder(adptContactMgmt)' (4) Crea una nueva fila.Dim rowInsert As DataRow = dsContacts.Tables("Contacts").NewRow' Añade datos a los campos de la fila.rowInsert("ContactID") = 42rowInsert("FirstName") = "Danielle"rowInsert("LastName") = "Tiedt"rowInsert("WorkPhone") = "(555) 555-1212"' Añade la fila al conjunto de datos.dsContacts.Tables("Contacts").Rows.Add(rowInsert)' (5) Actualiza la base de datos.adptContactMgmt.Update(dsContacts.Tables("Contacts"))

End SubVisual C#private void Page_Load(object sender, System.EventArgs e){

// (1) Crea la conexión.SqlConnection ContactMgmt = new

SqlConnection("server=(local);database=Contacts;Trusted_Connection=yes");// Crea un adaptador.SqlDataAdapter adptContactMgmt = new SqlDataAdapter

("select * from Contacts", ContactMgmt);// (2) Crea un conjunto de datos.DataSet dsContacts = new DataSet();// Configura el comando de selección.adptContactMgmt.SelectCommand.CommandText = "SELECT * FROM Contacts";// (3) Crea comandos de inserción, borrado y actualización automáticamente.

SqlCommandBuilder cmdContactMgmt = new SqlCommandBuilder(adptContactMgmt);// (4) Crea una nueva fila.DataRow rowInsert = dsContacts.Tables["Contacts"].NewRow();// Añade datos a los campos de la fila.rowInsert["ContactID"] = 42;rowInsert["FirstName"] = "Danielle";rowInsert["LastName"] = "Tiedt";rowInsert["WorkPhone"] = "(222) 555-1212";// Añade la fila al conjunto de datos.dsContacts.Tables["Contacts"].Rows.Add(rowInsert);// (5) Actualiza la base de datos.adptContactMgmt.Update(dsContacts.Tables["Contacts"]);

}

El método Update del código precedente necesita que se cree primero el objeto SqlCommandBuilder . Al

crear este objeto se proporciona la configuración de la propiedad InsertCommand que el objeto adaptador usa paraañadir la nueva fila a la base de datos.



MCAD/MCSD

94

5.2 Usar conjuntos de datos en formularios WebLa mayor parte de los controles de servidor ASP.NET soportan vinculación de datos, que es una forma de

enlazar datos de la aplicación, como conjuntos de datos, a propiedades de un control. En concreto, los controles deservidor DataGrid y DataList están diseñados específicamente para que la presentación de un conjunto de datos enun formulario Web sea sencilla y eficiente.

En esta lección aprenderá cómo mostrar un conjunto de datos en un formulario Web usando DataGrid, Data-List y otros controles de servidor. Aprenderá cómo seleccionar registros de un conjunto de datos en un formulario

Web y cómo ejecutar comandos SQL en una base de datos desde procedimientos de suceso de un control.

5.2.1 Mostrar un conjunto de datos en un DataGridLa forma más sencilla de mostrar un conjunto de datos en un formulario web es mediante un control Data-

Grid usando vinculación de datos. Siga estos pasos:

1. Cree los objetos conexión, adaptador y conjunto de datos como se describe en la sección anterior.2. Añada un control DataGrid al formulario web3. Use como valor de la propiedad DataSource del DataGrid el nombre del conjunto de datos.4. Añada en el suceso Page_Load del formulario Web el código para rellenar el conjunto de datos a partir del

adaptador y vincular los datos del conjunto de datos con el DataGrid.

Por ejemplo, el siguiente procedimiento de suceso crea un conjunto de datos a partir de la tabla Contacts de la base de datos Contacts y lo muestra en un control DataGrid:


ByVal e As System.EventArgs) Handles MyBase.Load' Rellena el conjunto de datos.adptContacts.Fill(dsContacts)' Vincula el conjunto de datos con el control DataGrid.grdContacts.DataBind()

End Sub


// Rellena el conjunto de datos.adptContacts.Fill(dsContacts);// Vincula los datos con el control DataGrid.grdContacts.DataBind();

}

El procedimiento anterior muestra todas las columnas del conjunto de datos sin darles ningún formato. Por logeneral esto no es lo que se quiere; por ejemplo, la columna Birthdate incluye la hora además de la fecha.

Para seleccionar las columnas que quiere mostrar y dar formato a los datos siga estos pasos:

1. Pulse el enlace Generador de propiedades en la ventana Propiedades. Visual Studio muestra el diálogo Pro- piedades del DataGrid.

2. Seleccione el elemento Columnas en el lado izquierdo del diálogo para seleccionar las columnas del conjuntode datos que se van a mostrar y darles formato. Visual Studio muestra las propiedades de columnas.

Para mostrar columnas concretas del conjunto de datos siga estos pasos:

1. Quite la marca de la caja Crear columnas automáticamente en tiempo de ejecución. Esto limita las columnasdel DataGrid a las que se seleccionen.2. Seleccione la columna en la lista Columnas disponibles y pulse el botón Añadir (>) para añadirla a la lista

Columnas seleccionadas..

Para dar formato a los datos de una columna:

1. Seleccione la columna a la que quiere dar formato en la lista Columnas seleccionadas.2. Escriba la expresión de formato en la caja de texto Expresión de formato de datos. La expresión de formato

tiene la forma {0:expresionformato}, donde expresionformato es una de las expresiones de formato predefi-nidas del marco de trabajo Microsoft .NET, tal como se describen en los temas Cadenas de Formato de Fe-cha y Hora, Cadenas de Formato Numérico y Personalizar Cadenas de Formato de la ayuda de Visual Stu-dio .NET.

El diálogo Propiedades de DataGrid se usa para determinar todos los aspectos de la apariencia y comporta-miento del DataGrid, incluyendo el formato de las cabeceras de columna, determinando cómo recorre (pagina) losregistros, dónde se muestran bordes o líneas, y mucho más.




95

5.2.2 Mostrar un conjunto de datos en un DataListUtilice un control DataList para mostrar información de un conjunto de datos como una lista de filas, en lugar

de filas y columnas de un DataGrid.

Para mostrar un conjunto de datos en un control DataList siga estos pasos:

1. Cree los objetos conexión, adaptador y conjunto de datos como se describe en la lección anterior.2. Añada un control DataList al formulario Web.

3. Use el nombre del conjunto de datos como valor de la propiedad DataSource del DataList.4. Añada al suceso Page_Load del formulario Web para rellenar el conjunto de datos a partir del adaptador y para vincular los datos del conjunto de datos con el DataGrid.

5. Edite las plantillas de encabezado, elemento y separador del control DataList para crear su aspecto.

El control DataList utiliza plantillas para determinar el contenido de sus encabezados, pies y filas. Estas plan-tillas se editan para añadir literales y controles y vincularlos con elementos del conjunto de datos. El DataList proporciona tres categorías diferentes de plantillas para controlar los diferentes aspectos de su apariencia.

• Plantillas de encabezado y pie. Incluyen el título y líneas que aparecen en la parte superior e inferior delDataList.

• Plantillas de elemento. Determinan los contenidos de la filas en la lista de datos y permiten alternar el aspecto de las filas pares, impares, seleccionadas o en edición.

• Plantillas de separadores. Añaden línea u otros separadores entre filas.

Para editar una plantilla de un DataList:

1. Pulse con el botón derecho sobre el control DataList y seleccione Editar plantilla, seleccione la plantilla quequiere editar en la lista.

2. Cuando el DataList está en modo de edición cambia de aspecto. Escriba el texto que quiere que aparezca enla plantilla y añada los controles que desee.

3. Para mostrar un elemento del conjunto de datos en la plantilla añada un control a la plantilla y pulse sobre laelipsis a la derecha de a propiedad DataBindings del control. Visual Studio muestra el diálogo DataBindings para el control.

4. Cuando termine de editar las plantillas del control DataList pulse con el botón derecho sobre el DataList y se-leccione Terminar edición de plantilla.

La vinculación de datos para los controles de la plantilla de elemento de un control DataList puede ser una

sencilla vinculación con un elemento del contenedor, o puede ser una expresión compleja usando el método Eval.Por ejemplo, la siguiente expresión de vinculación personalizada combina el nombre y el apellido en un solo con-trol.

Visual Basic .NETDataBinder.Eval(Container, “DataItem.FirstName”) & “ “ & _

DataBinder.Eval(Container, “DataItem.LastName”)

Visual C#DataBinder.Eval(Container, “DataItem.FirstName”) + “ “ +

DataBinder.Eval(Container, “DataItem.LastName”);

Realmente, cuando se crea una plantilla de DataList con vinculación de datos lo que crea Visual Studio en elHTML del formulario Web es un método Eval de DataBinder. En ocasiones es más sencillo editar las plantillasdirectamente en HTML que mediante el procedimiento descrito anteriormente.

Para editar las plantillas de un DataList directamente en HTML pulse con el botón derecho sobre el formula-rio Web y seleccione Ver código fuente HTML. Visual Studio muestra el formulario Web en modo HTML.

Por ejemplo, el siguiente HTML muestra un control DataList que contiene nombre, cumpleaños y teléfonodel conjunto de datos Contacts:

<asp:DataList id="dlstContacts" runat="server" DataSource="<%# dsContacts %>">

<HeaderTemplate><h2>Información de Contacto <HR width="100%" SIZE="1"></h2>

</HeaderTemplate>

<FooterTemplate><HR></FooterTemplate>



MCAD/MCSD

96

<ItemTemplate><asp:Label id="lblName" runat="server" Text='<%# DataBinder.Eval(Container,

DataItem.FirstName") + " " +DataBinder.Eval(Container,"DataItem.LastName") %>'></asp:Label>

Fecha de Nacimiento:<asp:Label id="lblBirthdate" runat="server" Text='<%# DataBinder.Eval

(Container, "DataItem.Birthdate", "{0:d}") %>'></asp:Label> Teléfono de trabajo:<asp:Label id="lblWorkPhone" runat="server" Text='<%# DataBinder.Eval

(Container, "DataItem.WorkPhone") %>'></asp:Label></ItemTemplate>

<SeparatorTemplate><HR>SeparatorTemplate>

</asp:DataList>

Para mostrar los datos del conjunto de datos en el control anterior rellene el conjunto de datos a partir deladaptador y vincule el control DataList en el procedimiento de suceso Page_Load :


ByVal e As System.EventArgs) Handles MyBase.Load' Rellena el conjunto de datos.adptContacts.Fill(dsContacts)' Vincula el conjunto de datos con el control DataList.

dlstContacts.DataBind()End Sub


// Rellena el conjunto de datos.adptContacts.Fill(dsContacts);// Vincula los datos con el control DataList.dlstContacts.DataBind();

}

5.2.3 Mostrar datos en otros controles de listaDesde luego, puede vincular los elementos de un conjunto de datos con cualquier control de lista en un for-

mulario Web. Los controles DataGrid y DataList son solo dos de las formas más versátiles de mostrar un conjunto

de datos.Para mostrar elementos de un conjunto de datos en un control ListBox, DropDownList, CheckBoxList o Ra-

dioButtonList siga estos pasos:

1. En la propiedad DataSource del control ponga el nombre del conjunto de datos.2. En la propiedad DataText del control indique el miembro del conjunto de datos que se mostrará en la propie-

dad Text del elemento de lista.3. En la propiedad DataValue del control indique el miembro del conjunto de datos que se devolverá en la pro-

piedad Value del elemento de lista.4. Mediante código, rellene el conjunto de datos a partir del adaptador y vincule el control

El siguiente código HTML muestra las configuraciones de propiedades para un control DropDownList vincu-lado con el conjunto de datos Contacts:

<asp:DropDownList id="drpContacts" runat="server" Width="384px" Height="22px"DataSource="<%# dsContacts %>" DataTextField='LastName'DataValueField="ContactID"></asp:DropDownList>

El siguiente código rellena el conjunto de datos y vincula los datos con el DropDownList.


ByVal e As System.EventArgs) Handles MyBase.Load' Rellena el conjunto de datos.adptContacts.Fill(dsContacts)' Vincula los datos con el control.drpContacts.DataBind()

End Sub




97


// Rellena el conjunto de datos.adptContacts.Fill(dsContacts);// Vincula el conjunto de datos con el control DataList.dlstContacts.DataBind();

}

En tiempo de ejecución el DropDownList muestra una lista de los apellidos de la tabla Contacts y la propie-

dad SelectedItem.Value devuelve el ContactID, que es útil para buscar otra información sobre el individuo,La limitación es que solo puede incluir un valor en cada una de las propiedades DataText y DataValue. Si

quiere incluir el nombre y apellido del contacto en la lista desplegable tiene que hacerlo mediante código. El si-guiente procedimiento para el suceso Page_Load añade el nombre y apellido a la lista desplegable e incluye Contac-tID como propiedad Value de cada elemento de lista.


ByVal e As System.EventArgs) Handles MyBase.Load' Se ejecuta la primera vez que se muestra la página.If Not IsPostBack Then

' Rellena el conjunto de datos Contacts.adptContacts.Fill(dsContacts)' Para cada fila de la tabla ...

Dim drowItem As dsContacts.ContactsRowFor Each drowItem In dsContacts.Contacts

' Crea un nuevo elemento de lista.Dim lstNew As New ListItem()lstNew.Text = drowItem.FirstName & " " & drowItem.LastNamelstNew.Value = drowItem.ContactID' Añade el elemento de lista a la lista desplegable.drpContacts.Items.Add(lstNew)

NextEnd If

End Sub


// Se ejecuta la primera vez que se muestra la página.if (!IsPostBack){

// Rellena el conjunto de datos Contacts.adptContacts.Fill(dsContacts);// Para cada fila de la tabla...foreach (dsContacts.ContactsRow drowItem in dsContacts.Contacts) {

// Crea un nuevo elemento de lista.ListItem lstNew = new ListItem();lstNew.Text = drowItem.FirstName + " " + drowItem.LastName;lstNew.Value = drowItem.ContactID.ToString();// Añade el elemento de lista a la lista desplegable.drpContacts.Items.Add(lstNew);

}}

}

5.2.4 Seleccionar registros concretosEl DropDownList creado en la sección anterior es útil para seleccionar elementos de la tabla Calls en la base

de datos Contacts. Como ContactsID es una clave única puede usarlo para seleccionar el registro de la tabla Callscorrespondiente a un contacto concreto. El siguiente código crea un conjunto de datos que contiene las llamadas para el contacto seleccionado en el DropDownList.

Visual Basic .NETPrivate Sub drpContacts_SelectedIndexChanged(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles drpContacts.SelectedIndexChanged' Cuando se selecciona un contacto muestra sus llamadas.adptCalls.SelectCommand.CommandText = "SELECT * FROM Calls" & _

" WHERE ContactID =" & drpContacts.SelectedItem.Value' Limpia el conjunto de datos.

dsCalls.ClearadptCalls.Fill(dsCalls)



MCAD/MCSD

98

' Muestra los resultados en una rejilla de datos.grdCalls.DataBind()

End Sub

Visual C#private void drpContacts_SelectedIndexChanged(object sender, System.EventArgs e){

// Cuando se selecciona un contacto muestra sus llamadas.adptCalls.SelectCommand.CommandText = "SELECT * FROM Calls" +

" WHERE ContactID =" + drpContacts.SelectedItem.Value;

// Limpia el conjunto de datos.dsCalls.Clear();adptCalls.Fill(dsCalls);// Muestra los resultados en una rejilla de datos.grdCalls.DataBind();

}

En tiempo de ejecución, el formulario Web muestra una lista de las llamadas para el contacto seleccionado enla lista desplegable.

5.2.5 Ejecutar comandos sobre una base de datosAdemás de trabajar con conjuntos de datos puede ejecutar comandos directamente sobre la conexión con la

base de datos. El objeto conexión proporciona tres métodos para comandos:

• ExecuteScalar. Ejecuta comandos de consulta que devuelve un único valor, como contar el número de regis-tros de una tabla.

• ExecuteNonQuery. Ejecuta comandos que cambian la base de datos pero no devuelven un valor concreto.Esto incluye añadir y borrar elementos de una base de datos. El método ExecuteNonQuery devuelve el núme-ro de filas afectadas por el comando.

• ExecuteReader. Lee registros de la base de datos secuencialmente.

Para usar estos métodos siga estos pasos:

1. Cree una conexión con la base de datos.2. Abra la conexión.3. Cree un objeto comando que contenga el comando SQL o procedimiento almacenado a ejecutar.4. Ejecute el método sobre el objeto comando.5. Cierre la conexión.

5.2.6 Devolver un valor desde una base de datosLa lección 1 mostró cómo añadir filas a y eliminar filas de una base y cómo actualizar después la base de da-

tos a partir del conjunto de datos, pero pasó por alto un importante detalle: a menudo es necesario recuperar infor-mación de la base de datos antes de poder añadir un registro. El ejemplo más común de esto es cuando un registroincluye un campo de clave única, como ContactsID en la base de datos Contacts. Debe obtener un valor único antes para cada registro antes de poder añadirlo a la base de datos.

Hay varias formas de obtener un nuevo valor de clave única de una base de datos. Tal vez el más directo seacrear un objeto comando y usar el método ExecuteScalar para devolver un valor. Hay dos tipos de objetos comando:

• Los objetos SqlCommand ejecutan comandos sobre conexiones con bases de datos SQL.• Los objetos OleDbCommand ejecutan comandos sobre conexiones con bases de datos OLE.

El siguiente código usa un objeto SqlCommand para recuperar el número más alto usado por ContactID, in-crementa el valor y usa el número como clave única para una nueva fila de la tabla Contact:

Visual Basic .NET' Usa conexión, adaptador y conjunto de datos creados en modo diseño.Private Sub butAddRow_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butAddRow.Click' Obtiene un ContactID único.Dim intID As IntegerDim cmdNewID As New SqlCommand("SELECT MAX(ContactID)" & _

" FROM Contacts", ContactMgmt)' Abre la conexión con la base de datos.ContactMgmt.Open()intID = CInt(cmdNewID.ExecuteScalar())




99

' Crea un nuevo objeto fila para la tabla Contacts.Dim rowNew As dsContacts.ContactsRow = dsContacts.Contacts.NewRow' Añade datos a los campos de la fila.rowNew.ContactID = intID + 1rowNew.FirstName = "Max"rowNew.LastName = "Benson"rowNew.WorkPhone = "(111) 555-1212"' Añade la fila al conjunto de datos.dsContacts.Contacts.AddContactsRow(rowNew)

' Cierra la conexión con la base de datos.ContactMgmt.Close()

End Sub

Visual C#private void butAddRow_Click(object sender, System.EventArgs e){

// Obtiene un ContactID único.int intID;SqlCommand cmdNewID = new SqlCommand("SELECT MAX(ContactID)" +

" FROM Contacts", ContactMgmt);// Abre la conexión con la base de datos.ContactMgmt.Open();intID = (int)sqlcommNewID.ExecuteScalar();// Crea un nuevo objeto fila para la tabla Contacts.dsContacts.ContactsRow rowNew = (dsContacts.ContactsRow)

dsContacts.Contacts.NewRow();// Añade datos a los campos de la fila.rowNew.ContactID = intID + 1;rowNew.FirstName = "Max";rowNew.LastName = "Benson";rowNew.WorkPhone = "(111) 555-1212";// Añade la fila al conjunto de datos.dsContacts.Contacts.AddContactsRow(rowNew);// Cierra la conexión con la base de datos.ContactMgmt.Close();

}

El método ExecuteScalar se puede usar con cualquier sentencia SQL que devuelva un único valor. Para eje-cutar otros tipos de sentencias utilice los métodos ExecuteNonQuery o ExecuteReader .

5.2.7 Cambiar registros directamente en la base de datosEl método ExecuteNonQuery ejecuta comandos que no devuelven un conjunto de datos, como INSERT, DE-

LETE o UPDATE de SQL. Por ejemplo, el siguiente código usa ExecuteNonQuery para borrar una fila directamente

Visual Basic .NETPrivate Sub butDelete_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butDelete.ClickDim intRows As Integer' Crea un objeto comando.Dim cmdDeleteRow As New SqlCommand("DELETE ROW " & _

" FROM Contacts WHERE ContactID=1", ContactMgmt)' Abre la conexión con la base de datos.ContactMgmt.Open()' Ejecuta el comando.

intRows = cmdDeleteRow.ExecuteNonQuery()' Muestra el número de registros borrados.Response.Write("Registros Borrados : " & intRows)' Cierra la conexión.ContactMgmt.Close()

End Sub

Visual C#private void butDeleteRow_Click(object sender, System.EventArgs e){

int intRows;// Crea un objeto comando.SqlCommand cmdDeleteRow = new SqlCommand("DELETE ROW" +

" FROM Contacts WHERE ContactID=1", ContactMgmt);// Abre la conexión con la base de datos.ContactMgmt.Open();// Ejecuta el comando.intRows = cmdDeleteRow.ExecuteNonQuery();



MCAD/MCSD

100

// Muestra el número de registros borrados.Response.Write("Registros Borrados: " + intRows.ToString());// Cierra la conexión.ContactMgmt.Close();

}

El método ExecuteNonQuery actúa directamente sobre la conexión con la base de datos. No pasa por mediode adaptador o un conjunto de datos. Si hace cambios a una tabla en la base de datos mediante ExecuteNonQuery debe actualizar los conjuntos de datos afectados por estos cambios llamando al método Fill del adaptador.

5.2.8 Recuperar registros directamente de la base de datosEl método ExecuteReader ejecuta comandos que devuelven registros, como SELECT de SQL. Los registros

se devuelven en un objeto lector de datos, que es una especie de versión de solo lectura de un conjunto de datos.Como el método ExecuteReader actúa directamente sobre la conexión con la base de datos hay dos versiones delobjeto lector de datos: OleDbDataReader y SqlDataReader .

El uso de ExecuteReader para crear objetos lectores de datos proporciona mejores prestaciones que la crea-ción de un conjunto de datos a partir de un adaptador, pero no da mucha flexibilidad. Los objetos lectores de datosson de solo lectura y solo se leen hacia delante, un registro cada vez. Los conjuntos de datos permiten obtener losregistros en cualquier orden y, más importante, permiten escribir cambios en la base de datos.

El siguiente código obtiene todas las llamadas para un contacto y muestra las líneas de tema de cada llamadaen un formulario Web usando un objeto lector de datos y ExecuteReader :

Visual Basic .NETPrivate Sub butShowCalls_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butShowCalls.Click' Crea un objeto comando.Dim cmdGetCalls As New SqlCommand("SELECT * FROM Calls" & _

" WHERE ContactID=3", ContactMgmt)' Abre la conexión.ContactMgmt.Open()' Crea un objeto lector de datos.Dim dreadCalls As SqlDataReader' Ejecuta el comando.dreadCalls = cmdGetCalls.ExecuteReader()' Muestra los registros.Do While dreadCalls.Read()

Response.Write(dreadCalls.GetString(4))Loop' Cierra el lector.dreadCalls.Close()' Cierra la conexión con la base de datos.ContactMgmt.Close()

End Sub

Visual C#private void butShowCalls_Click(object sender, System.EventArgs e){

// Crea un objeto comando.SqlCommand cmdGetCalls = new SqlCommand("SELECT * FROM Calls" +

" WHERE ContactID=3", ContactMgmt);// Abre la conexión.ContactMgmt.Open();// Crea un objeto lector de datos.SqlDataReader dreadCalls;// Ejecuta el comando.dreadCalls = cmdGetCalls.ExecuteReader();// Muestra los registros

while (dreadCalls.Read())Response.Write(dreadCalls.GetString(4));

// Cierra el lector.dreadCalls.Close();// Cierra la conexión.ContactMgmt.Close();

}

El objeto lector de datos es un conjunto de registros de lectura hacia delante, de modo que el método Read

lee cada línea siguiente hasta que llega al final del conjunto de registros. Un objeto lector bloquea la conexión con la base de datos mientras está en ejecución, por lo que hay que llamar a su método Close cuando se termina de leer losregistros, como se muestra en el ejemplo.




101

5.3 Proceso de transaccionesADO.NET permite agrupar operaciones de base de datos en transacciones. Un transacción es un grupo de

comandos que cambian los datos almacenados en una base de datos. La transacción, que se trata como una solaunidad, asegura que los comandos se manejan de modo todo o nada – si falla uno de los comandos fallan todos, ycualesquiera datos que hayan sido escritos en la base de datos por estos comandos se recuperan a su estado anterior.De esta forma las transacciones mantienen la integridad de una base de datos.

En esta lección aprenderá cómo implementar procesamiento de transacciones para conjuntos de datos y bases

de datos en una aplicación Web

5.3.1 TransaccionesComo ya se ha dicho, una transacción es un grupo de comandos de base de datos que se tratan como una uni-

dad. Los programadores de base de datos determinan qué comandos pertenecen a una transacción usando la pruebaACID: los comandos de base de datos deben ser atómicos, coherentes, aislados y permanentes (atomic, consistent,isolated, durable). Los comandos pertenecen a una transacción si son:

• Atómicos. En otras palabras, componen una sola unidad de trabajo. Por ejemplo, si un cliente se muda querráque el operador de datos cambie todos los campos de dirección del cliente como una sola unidad, en lugar decambiar primero la calle, luego la ciudad y después el estado.

• Coherentes. Todas las relaciones entre datos en una base de datos se mantienen correctamente. Por ejemplo,si la información de cliente usa una tasa de impuestos de la tabla autonómica, la autonomía introducida para

el cliente debe existir en la tabla de tasas de impuestos.• Aislados. Los cambios que hagan otros clientes no pueden afectar a los que están en curso. Por ejemplo, si

dos operadores de datos intentan hacer un cambio en el mismo cliente a la vez pueden pasar dos cosas: o seaceptan los cambios de un operador y se informa al otro de que sus cambios no se han hecho, o se notifica aambos que sus cambios no se han hecho. En ninguno de los dos casos se deja al cliente en un estado indeter-minado.

• Permanentes. Una vez que se hace un cambio, se mantiene. Si se produce un fallo de corriente o un error delsistema antes de que se complete el conjunto de comandos, una vez que se rearranca el sistema los cambiosse deshacen y se devuelven los datos a su estado original.

El procesamiento de transacciones es particularmente importante para las aplicaciones Web que usan accesoa datos, puesto que estas aplicaciones se encuentran distribuidas entre varios clientes. En una aplicación Web las bases de datos son un recurso compartido, y tener muchos clientes repartidos sobre un área amplia puede arrastrar

estos problemas clave:• Competencia por los recursos. Varios clientes pueden intentar cambiar el mismo registro a la vez. Este pro-

blema empeora al crecer el número de clientes.• Fallos inesperados. Internet no es la red más fiable que existe, incluso aunque la aplicación Web y el servi-

dor Web sean 100% fiables. Los clientes pueden ser desconectados inesperadamente por los proveedores deservicio, por sus módem o por fallos de corriente.

• Ciclo de vida de la aplicación Web. Las aplicaciones Web no siguen el mismo ciclo de vida que las aplica-ciones Windows – los formularios Web solo duran un instante, y un cliente puede abandonar la aplicación encualquier momento sencillamente escribiendo una nueva dirección en su navegador.

El procesamiento de transacciones sigue estos pasos:

1. Comenzar una transacción

2. Procesar comandos de base de datos3. Comprobar errores4. Si hay errores, restablecer la base de datos a su estado al comienzo de la transacción, si no, consignar la tran-

sacción en la base de datos.

En ADO.NET las transacciones se manejan de formas diferentes, dependiendo del nivel:

• Los conjuntos de datos proporcionan procesamiento de transacciones mediante los métodos Reject-Changes y Update. Los conjuntos de datos también proporcionan un método AcceptChanges que restableceel estado de los registros como sin cambios.

• Las objetos conexión proporcionan procesamiento de transacciones mediante el objeto transacción.Los objetos transacción hacen un seguimiento de los comandos ejecutados sobre una base de datos y propor-cionan los métodos Rollback , Commit y Save para restablecer el estado de la base de datos, consignar cambios o crear un punto de restauración dentro de una transacción, respectivamente.

• El espacio de nombres System.EnterpriseServices proporciona transacciones a nivel empresarial me-diante la clase ContextUtil. Las transacciones a nivel empresarial usan el coordinador de transacciones dis-tribuidas (DTC: Distributed Transactions Coordinator) que incluye SQL Server para seguir transacciones en-tre varios formularios Web y entre varios componentes COM+.



MCAD/MCSD

102

5.3.2 Transacciones de conjunto de datosLos conjuntos de datos proporcionan procesamiento de transacciones implícito, puesto que no se hacen los

cambios en la base de datos hasta que no se llama al método Update del objeto adaptador de datos. Esto permiteejecutar una serie de comandos sobre los datos y seleccionar un punto en el que estos cambios se hacen permanentesen la base de datos.

Si se produce un error durante el método Update ninguno de los cambios del conjunto de datos se hace en la base de datos. En este punto, puede intentar corregir el error y reintentar el método Update, o puede deshacer los

cambios pendientes en el conjunto de datos mediante su método RejectChanges. Por ejemplo, el siguiente códigomuestra la lista de contactos en un control DataGrid y permite que el usuario borre filas pulsando Delete en el Data-Grid:


ByVal e As System.EventArgs) Handles MyBase.Load' Comprueba si es la primera vez que se muestra la página.If Not IsPostBack Then

' En la primera presentación rellena el conjunto de datos.adptContacts.Fill(dsContacts)' Graba el conjunto de datos como variable de estado.Session("dsContacts") = dsContacts

Else

' En posteriores obtiene el conjunto de datos de la variable de estado.dsContacts = Session("dsContacts")End If' Vincula con el conjunto de datos.grdContacts.DataBind()

End Sub

Private Sub grdContacts_ItemCommand(ByVal source As Object, _ByVal e As System.Web.UI.WebControls.DataGridCommandEventArgs) _Handles grdContacts.ItemCommand

' Si se ha pulsado el botón Delete.If e.CommandName = "Delete" Then

Dim intContactID' Obtiene el ContactID de la dila seleccionada.intContactID = _

CInt(grdContacts.Items(e.Item.ItemIndex).Cells(3).Text)Dim rowDelete As dsContacts.ContactsRow' Obtiene la fila a borrar del conjunto de datos.rowDelete = dsContacts.Contacts.FindByContactID(intContactID)' Borra la fila.rowDelete.Delete()' Refresca la rejilla de datos.grdContacts.DataBind()

End IfEnd Sub


// Comprueba si es la primera vez que se muestra la página.if (!IsPostBack){

// La primera vez rellena el conjunto de datos.adptContacts.Fill(dsContacts);// Graba el conjunto de datos como variable de estado.Session["dsContacts"] = dsContacts;

}else// Las siguientes obtiene los datos de la variable de estado.dsContacts = (dsContacts)Session["dsContacts"];

// Vincula con el conjunto de datos.grdContacts.DataBind();

}

private void grdContacts_ItemCommand(object sender,System.Web.UI.WebControls.DataGridCommandEventArgs e){




103

// Si se ha pulsado el botón Delete.if (e.CommandName == "Delete"){

int intContactID;// Obtiene el ContactID de la fila seleccionada.intContactID = Convert.ToInt16

(grdContacts.Items[e.Item.ItemIndex].Cells[3].Text);dsContacts.ContactsRow rowDelete;// Obtiene la fila a borrar del Conjunto de datos.rowDelete = dsContacts.Contacts.FindByContactID(intContactID);

// Borra la fila.rowDelete.Delete();// Refresca la rejilla de datos.grdContacts.DataBind();

}}

El siguiente procedimiento de suceso para los botones Restore y Commit permiten que el usuario restablezcael conjunto de datos a su estado previo o, como alternativa, actualice la base de datos con los borrados que se hicie-ron en el código anterior.

Visual Basic .NETPrivate Sub butRestore_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butRestore.Click' Restablece el conjunto de datos a su estado original.

dsContacts.RejectChanges()' Refresca la rejilla de datos.grdContacts.DataBind()

End Sub

Private Sub butCommit_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butCommit.Click

' Actualiza la base de datos a partir del conjunto de datos.adptContacts.Update(dsContacts)' Graba los cambios en la variable de estado.Session("dsContacts") = dsContacts' Refresca la rejilla de datos.grdContacts.DataBind()

End Sub

Visual C#private void butRestore_Click(object sender, System.EventArgs e){// Restablece el conjunto de datos a su estado original.dsContacts.RejectChanges();// Refresca la rejilla de datos.grdContacts.DataBind();

}

private void butCommit_Click(object sender, System.EventArgs e){int intRows;// Actualiza la base de datos a partir del conjunto de datos.intRows = adptContacts.Update(dsContacts);// Graba los cambios en la variable de estado.Session["dsContacts"] = dsContacts;// Refresca la rejilla de datos.

grdContacts.DataBind();}

El método RejectChanges en el procedimiento de suceso butRestore_Click anterior devuelve el conjunto dedatos a su estado anterior al borrado de la fila. El método AcceptChanges del conjunto de datos es el inverso a Re- jectChanges – restablece la propiedad DataRowState de todas las filas cambiadas en un conjunto de datos a Un-changed y elimina las filas borradas.

El método AcceptChanges impide que el método Update haga estos cambios en la base de datos, porque Up-date usa la propiedad DataRowState de las filas para determinar qué filas debe modificar en la base de datos. Por este motivo, el método AcceptChanges solo es útil cuando no se tiene intención de actualizar la base de datos a par-tir del conjunto de datos.

5.3.3 Transacciones de base de datos

Puede manejar las transacciones a nivel base de datos mediante un objeto transacción. Como en ADO.NEThay dos tipos de conexiones con base de datos, también hay dos tipos de objetos transacción: SqlTransaction yOleDbTransaction.



MCAD/MCSD

104

Para usar cualquiera de estos dos tipos de transacciones siga estos pasos:

1. Abra una conexión con la base de datos2. Cree el objeto transacción usando el método BeginTransaction del objeto conexión3. Cree objetos comando que se controlarán mediante esta transacción, asignando a la propiedad Transaction de

cada objeto comando al nombre de la transacción creada en el paso 2.4. Ejecute los comandos. Como el objetivo del procesamiento de transacciones es detectar y corregir errores an-

tes de que se escriban los datos en la base de datos, normalmente esto se hace como parte de una estructura

de manipulación de errores.5. Consigne los cambios en la base de datos o restablezca su estado, dependiendo del éxito de los comandos.6. Cierre la conexión con la base de datos.

El siguiente código usa un DataGrid para mostrar una lista de contactos de la base de datos Contacts. El Da-taGrid incluye una columna de botones que permite al usuario borrar contactos. La función DeleteContact usa unatransacción para asegurarse de que se borran las llamadas a un contacto si se borra este contacto. Esto ayuda a ase-gurar la integridad de la base de datos.


ByVal e As System.EventArgs) Handles MyBase.LoadadptContacts.Fill(dsContacts) ' Rellena el conjunto de datos.grdContacts.DataBind() ' Vincula el conjunto de datos.

End Sub

Private Sub grdContacts_ItemCommand(ByVal source As Object, _ByVal e As System.Web.UI.WebControls.DataGridCommandEventArgs) _Handles grdContacts.ItemCommand

' Si se ha pulsado el botón Delete.If e.CommandName = "Delete" Then

Dim intContactID' Obtiene el Contactad de la fila seleccionada.intContactID = _

CInt(grdContacts.Items(e.Item.ItemIndex).Cells(3).Text)' Borra la información del contacto.lblStatus.Text = DeleteContact(intContactID)

End IfadptContacts.Fill(dsContacts) ' Refresca el conjunto de datos.grdContacts.DataBind() ' Refresca el DataGrid.

End Sub

Function DeleteContact(ByVal intContactID As Integer) As String' Abre la conexión con la base de datos.ContactMgmt.Open()' Declara un objeto transacción.Dim transDelete As SqlTransaction' Crea la transacción.transDelete = ContactMgmt.BeginTransaction(IsolationLevel.ReadCommitted)' Crea el comando para borrar de la tabla Contacts.Dim cmdDelete As New SqlCommand("DELETE FROM Contacts WHERE ContactID=" & _

intContactID, ContactMgmt, transDelete)' Ejecuta los comandos.Try

Dim intRows As Integer

' Borra la fila de la tabla Contacts.intRows = cmdDelete.ExecuteNonQuery()' Borra las llamadas para este ContactID.cmdDelete.CommandText = "DELETE FROM Calls WHERE ContactID=" & intContactIDintRows = intRows + cmdDelete.ExecuteNonQuery()' Consigna la transacción.transDelete.Commit()' Devuelve el mensaje de éxito.Return intRows & " Borrados."

Catch' Restablece el estado de la base de datos si hubo un error.transDelete.Rollback()' Devuelve un mensaje de error.Return "No se pudo borrar el contacto."

Finally' Cierra la base de datos.ContactMgmt.Close()

End TryEnd Function




105


adptContacts.Fill(dsContacts); // Rellena el conjunto de datos.grdContacts.DataBind(); // Vincula el conjunto de datos.

}

private void grdContacts_ItemCommand(object sender,System.Web.UI.WebControls.DataGridCommandEventArgs e){// Si se pulsó el botón Delete.

if (e.CommandName == "Delete"){int intContactID;// Obtiene el ContactID de la fila seleccionada.intContactID = Convert.ToInt16(grdContacts.Items

[e.Item.ItemIndex].Cells[3].Text);// Borra la información del contacto.lblStatus.Text = DeleteContact(intContactID);

}adptContacts.Fill(dsContacts); // Refresca el conjunto de datos.grdContacts.DataBind(); // Refresca la rejilla de datos.

}

string DeleteContact(int intContactID){// Abre la conexión con la base de datos.ContactMgmt.Open();

// Declara un objeto transacción.SqlTransaction transDelete;// Crea la transacción.transDelete = ContactMgmt.BeginTransaction(IsolationLevel.ReadCommitted);// Crea el comando para borrar de la tabla Contacts.SqlCommand cmdDelete = new SqlCommand("DELETE FROM Contacts WHERE ContactID="

+ intContactID.ToString(), ContactMgmt, transDelete);// Ejecuta los comandos.try{

int intRows;// Borra la fila de la tabla Contacts.intRows = cmdDelete.ExecuteNonQuery();// Borra las llamadas para este ContactID.cmdDelete.CommandText = "DELETE FROM Calls WHERE ContactID="

+ intContactID.ToString();

intRows = intRows + cmdDelete.ExecuteNonQuery();// Consigna la transacción.transDelete.Commit();// Devuelve el mensaje de éxito.return intRows.ToString() + " borrados.";

}catch{// Restablece el estado de la base de datos si hubo un error.transDelete.Rollback();// Devuelve un mensaje de error.return "No se pudo borrar el contacto.";

}finally// Cierra la base de datos.ContactMgmt.Close();

}

El objeto transacción determina cómo se manejan los cambios concurrentes en una base de datos mediante la propiedad IsolationLevel. El nivel de protección varía como especifican las opciones de la tabla 5.2.

Tabla 5. 2: Opciones de nivel de aislamientoNivel Comportamiento

ReadUncommitted No bloquea los registros que se están leyendo. Esto significa que un cambio sin consignar se puede leer y seranulado por otro cliente, causando una copia local de un registro que no es coherente con lo que está alma-cenado en la base de datos. Esto se denomina lectura sucia porque los datos no son coherentes.

Chaos Se comporta igual que ReadUncommitted , pero comprueba el nivel de aislamiento de otras transaccionespendientes durante una operación de escritura, de modo que las transacciones con nivel de aislamiento másrestrictivo no se sobrescriben.

ReadCommitted Bloquea los registros que se están leyendo y libera el bloqueo tan pronto como se han leído. Esto impide quese lean los cambios antes de que se consignen, pero no impide que otros clientes añadan, borren o modifi-quen registros durante la transacción. Es el nivel de aislamiento predeterminado.

RepeatableRead Bloquea los registros que se están leyendo y mantiene el bloqueo hasta que se completa la transacción. Esto

asegura que los datos que se están leyendo no cambian durante la misma.Serializable Bloquea el conjunto de datos completo y mantiene el bloqueo hasta que se completa la transacción. Esto

asegura que los datos y su orden dentro de la base de datos no cambian durante la transacción.



MCAD/MCSD

106

Las conexiones con bases de datos SQL proporcionan una capacidad de transacción que no está disponible para las conexiones con bases de datos OLE: la posibilidad de crear puntos de restauración dentro de una transac-ción. Los puntos de restauración permiten devolver la base de daos a una posición concreta dentro de la transacciónactual. Para crear un punto de restauración dentro de una transacción SQL use el método Save:

Visual Basic .NETtransDelete.Save("FirstStep")

Visual C#

transDelete.Save("FirstStep");

Para devolver una transacción SQL a un punto de restauración especifique el nombre del punto en el método Rollback .

Visual Basic .NETtransDelete.Rollback("FirstStep")

Visual C#transDelete.Rollback("FirstStep");

5.3.4 Transacciones de empresaComo las transacciones de empresa pueden abarcar varios formularios Web o incluso varios componentes

dentro de una aplicación distribuida ASP.NET proporciona una forma para que los formularios Web trabajen conDTC.

Para usar DTC desde un formulario Web siga estos pasos:

1. Inicie una nueva transacción o continúe una existente configurando el atributo transaction del documento.Por ejemplo, la siguiente directiva @Page inicia una nueva transacción.<% Page Language=”vb” AutoEventWireup=”false”CodeBehind=”PageTransactions.aspx.vb”Inherits=”vbTransactionSnippet.PageTransactions”Transactions=”RequiresNew” %>

2. Añada al proyecto una referencia al espacio de nombres System.EnterpriseServices.3. Use los métodos SetAbort y SetComplete de la clase ContextUtil para cambiar el estado de la transacción co-

mo sea necesario.4. Use los sucesos CommitTransaction y AbortTransaction de la clase Page para responder a los cambios en el

estado de la transacción.

Para más información sobre DTC vea la ayuda en línea de Visual Studio.

5.4 Resumen• ADO.NET incluye tres componentes clave usados para la mayor parte del acceso a datos: conexión con base

de datos, adaptador de datos y conjunto de datos.• Para acceder a una base de datos siga estos pasos: Cree una conexión con la base de datos. Cree un conjunto de datos usando un objeto adaptador. Use el conjunto de datos para mostrar datos o cambiar elementos en la base de datos. Actualice la base de datos a partir del conjunto de datos. Cierre la conexión con la base de datos.

• ADO.NET proporciona conjuntos de datos con tipo. Los conjuntos de datos con tipo usan nombres y tipos de

datos explícitos que ayudan a evitar errores durante la programación.• Utilice vinculación de datos para mostrar rápidamente conjuntos de datos en formularios Web mediante Da-

taGrid, DataList u otros controles de lista.• Cree objetos comando para ejecutar sentencias SQL directamente sobre una base de datos. Los objetos co-

mando pueden devolver un único valor (ExecuteScalar ), modificar la base de datos (ExecuteNonQuery) odevolver datos (ExecuteReader ).

• Las transacciones agrupan los comandos de base de datos de forma que tienen éxito o fracasan de modo todoo nada. Esto asegura que los cambios no se hacen de forma parcial, preservando la integridad de la base dedatos.

• Para determinar qué comandos se deben incluir en una transacción use la prueba ACID. Una transacción debe ser atómica, coherente, aislada y permanente (atomic, isolated , consistent , durable)

• Para usar una transacción siga estos pasos: Comience la transacción Ejecute comandos y haga cambios que son parte de la transacción Compruebe errores




107

Si se producen errores deshaga los cambios (roll back). Si no se producen errores consigne los cambios.Esto termina la transacción.

• Maneje las transacciones de conjunto de datos usando el método Update para consignar los cambios y el mé-todo RejectChanges para deshacerlos (roll back)

• Maneje las transacciones con base de datos usando los métodos Commit y Rollback del objeto transacción.

5.5 Práctica: Aplicación de gestión de contactosEn esta práctica creará una aplicación Web con varias páginas que usa una base de datos para almacenar in-

formación de contactos y llamadas. La aplicación permite añadir contactos, ver y añadir llamadas hechas por uncontacto y añadir nuevos tipos de contacto. Esta aplicación usa la base de datos Contacts (Contacts.mdb) incluida enel CD-ROM del libro.

La aplicación de gestión de contactos muestra estos conceptos clave:

• Navegación. Los usuarios navegan desde una página central de conmutación a páginas de tareas específicas.Una vez que los usuarios terminan una tarea vuelven a la página de conmutación.

• Conexión de datos central. Los componentes de conexión con base de datos, adaptador de datos y conjuntode datos residen en el archivo Global.asax y se inicializan una vez por usuario. Estos objetos se compartenentre formularios Web usando variables de estado de sesión.

• Transacciones de conjunto de datos. Todos los cambios en la base de datos se procesan mediante conjuntosde datos, y todas las actualizaciones están contenidas dentro de estructuras de manejo de errores. Si una ac-

tualización falla, el usuario puede intentar de nuevo o cancelar la operación sin dañar la integridad de la basede datos.• Controles vinculados y no vinculados. Las llamadas se muestran utilizando un control DataList que contie-

ne controles etiqueta vinculados con datos. Los contactos se muestran en una lista desplegable usando códigoen lugar de vinculación de datos.

• Comandos de base de datos. La aplicación obtiene valores de clave únicos ejecutando comandos sobre la base de datos.

5.5.1 Inicie un proyecto y cree el formulario SwichtBoardEn este ejercicio va a iniciar un nuevo proyecto y crear el formulario Web usado para navegar a otros formu-

larios Web de la aplicación. Este formulario es muy sencillo y no contiene código ejecutable.

1. Cree un nuevo proyecto de aplicación Web ASP.NET llamado ContactManagement.2. Cambie el nombre de Webform1.aspx a SwitchBoard.aspx y muestre el formulario en modo HTML.3. Escriba el siguiente código HTML entre las etiquetas < form> y </ form>

<h2>Conmutador de Gestión de Contactos</h2><P>¿Qué quiere hacer? </P><P><a href="Calls.aspx">Ver/Añadir llamadas.</a></P><P><a href="AddContact.aspx">Añadir un contacto.</a></P><P><a href="DeleteContact.aspx">Borrar un contacto.</a></P><P><a href="ContactTypes.aspx">Añadir un tipo de contacto.</a></P>

5.5.2 Añadir componentes de base de datosLa aplicación de gestión de contactos realiza acceso a la base de datos desde diferentes formularios Web. Los

componentes de conexión, adaptador y conjunto de datos se añaden al archivo Global.asax y se graban como variables de estado de sesión de modo que se puede acceder a ellos desde los formularios Web respectivos.

Todos los formularios Web, y todos los usuarios de los formularios Web, comparten una única conexión conla base de datos. Esto conserva recursos y facilita el mantenimiento de las configuraciones de conexión y de adapta-dor durante el desarrollo de la aplicación porque todos los componentes de base de datos están en un único lugar.

1. Abra el archivo Global.asax y pulse el enlace Explorador de servidores. Visual Studio muestra el explorador de servidores.

2. Pulse el botón Conectar con base de datos en la ventana del explorador de servidores. Visual Studio muestrala caja de diálogo Propiedades de vínculo de datos.

3. Seleccione el nombre del servidor SQL Server donde está instalada la base de datos Contacts, seleccione laopción Usar la seguridad Integrada de Windows NT y escriba Contacts en le la caja de texto Seleccione la base de datos del servidor. Pulse Probar conexión para comprobar la configuración y pulse Aceptar cuandotermine. Visual Studio añade la conexión con la base de datos al Explorador de Servidores.

4. En la ventana del Explorador de Servidores, expanda los elementos bajo la conexión de datos recién creada pulsando en el signo más a la izquierda de la conexión de datos Contacts.dbo y haga lo mismo con el sub-

elemento tablas. Arrastre las tablas Calls, ContactTypes y Contacts del Explorador de Soluciones a la páginaGlobal.asax. Visual Studio añade un componente de conexión con base de datos y componentes adaptador dedatos para cada una de las tablas.



MCAD/MCSD

108

5. Cada adaptador de datos representa a una de las tablas arrastradas a la página. Pulse con el botón derecho sobre uno de los adaptadores y seleccione Generar conjunto de datos. Visual Studio muestra el diálogo Generar conjunto de datos

6. Escriba el nombre del conjunto de datos en la caja de texto Nuevo. Use un nombre correspondiente a la tablaque representa (por ejemplo, dsCalls para la tabla Calls), seleccione Agregar este conjunto de datos al dise-ñador y pulse Aceptar. Visual Studio añade el conjunto de datos a la página Global.asax.Nota: Cuando Visual Studio añade un conjunto de datos añade un número al nombre que se le da. Para eli-

minar el número hay que editar el nombre en la ventana de propiedades.

7. Repita los pasos 5 y 6 para cada adaptador de datos8. Pulse dos veces sobre la página Global.asax en la ventana de código para ver el código de la página. Añada el

siguiente procedimiento de suceso Session_Start para crear las variables de estado de sesión que se usarán enlos formularios Web para acceder a los componentes de base de datos:Visual Basic .NETSub Session_Start(ByVal sender As Object, ByVal e As EventArgs)

' Conexión con la base de datos.Session("ContactMgmt") = SqlConnection1' Adaptadores de datos.Session("adptCalls") = SqlDataAdapter1Session("adptContactTypes") = SqlDataAdapter2Session("adptContacts") = SqlDataAdapter3' Conjunto de datos.Session("dsCalls") = dsCallsSession("dsContactTypes") = dsContactTypesSession("dsContacts") = dsContacts

End Sub

Visual C#protected void Session_Start(Object sender, EventArgs e){

// Conexión con la base de datos.Session["ContactMgmt"] = sqlConnection1;// Adaptadores de datos.Session["adptCalls"] = sqlDataAdapter1;Session["adptContactTypes"] = sqlDataAdapter2;Session["adptContacts"] = sqlDataAdapter3;// Conjuntos de datos.Session["dsCalls"] = dsCalls;

Session["dsContactTypes"] = dsContactTypes;Session["dsContacts"] = dsContacts;}

5.5.3 Crear el formulario AddContactLa aplicación permite a los usuarios añadir información sobre nuevos contactos por medio del formulario

Web AddContact. Este formulario es una entrada de datos sencilla con cajas de texto para cada uno de los elementosde datos de un registro de la tabla Contacts.

1. Añada al proyecto un nuevo formulario Web llamado AddContact.aspx2. En la ventana de propiedades, seleccione el objeto DOCUMENT y de a la propiedad pageLayout el valor

FlowLayout .3. Añada al formulario Web los controles de la tabla siguiente, con la configuración que se indica.

Control Propiedad Configuración

TextBox ID txtFirstNameTextBox ID txtLastNameTextBox ID txtAddress

TextMode MultilineTextBox ID txtCityDropDownList ID drpStates

DataSource arrStateTextBox ID txtZIPTextBox ID txtHomePhoneTextBox ID txtWorkPhoneTextBox ID txtNotes

TextMode MultilineDropDownList ID drpContactTypes

Button ID butAdd Text Añadir

Button ID butCancelText Cancelar




109

Control Propiedad ConfiguraciónLiteral ID litStatusHyperlink Text Volver a Conmutador

NavigateUrl SwitchBoard.aspx4. Escriba directamente en la página Web texto para identificar los campos. Utilice retornos de carro para ini-

ciar nuevas líneas3.5. Pulse dos veces sobre el formulario Web para mostrar la ventana de código y añada la siguiente sentencia

Imports o using en la parte superior del módulo.

Visual Basic .NETImports System.Data.SqlClient

Visual C#using System.Data.SqlClient;

6. El formulario Web AddContact usa los componentes de base de datos creados en Global.asax en la sección5.5.2. Para usar estos componentes en el formulario Web declare variables a nivel de clase y recupere las re-ferencias a los componentes de las variables de estado en las que están almacenados. El siguiente códigomuestra cómo hacerlo:Visual Basic .NETDim ContactMgmt As SqlConnectionDim adptContactTypes As SqlDataAdapterDim adptContacts As SqlDataAdapter

Dim dsContacts As New dsContacts()' Estas variables son públicas para la vinculación de datos.Public dsContactTypes As New dsContactTypes()Public arrState As String() = {"AL", "AK", "AR", "AZ", "CA", "CO", "CT", _

"DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", _"MA", "ME", "MD", "MI", "MN", "MO", "MS", "MT", "NC", "ND", "NE", _"NH", "NJ", "NM", "NV", "NY", "OH", "OK", "OR", "PA", "RI", "SC", _"SD", "TN", "TX", "UT", "VA", "VT", "WA", "WI", "WY"}


' Obtiene la conexión y adaptadores del estado de sesión.ContactMgmt = Session("ContactMgmt")adptContactTypes = Session("adptContactTypes")adptContacts = Session("adptContacts")

' Rellena el conjunto de datos ContactType.adptContactTypes.Fill(dsContactTypes)' Rellena el conjunto de datos Contacts.adptContacts.Fill(dsContacts)' Vincula datos – rellena las listas drpContactTypes y drpStates.drpContactTypes.DataBind()drpStates.DataBind()

End Sub

Visual C#SqlConnection ContactMgmt;SqlDataAdapter adptContactTypes;SqlDataAdapter adptContacts;dsContacts dsContacts = new dsContacts();// Estas variables son públicas para la vinculación de datos.

public dsContactTypes dsContactTypes = new dsContactTypes();public string[] arrState = {"AL", "AK", "AR", "AZ", "CA", "CO", "CT", "DE","FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "MA", "ME","MD", "MI", "MN", "MO", "MS", "MT", "NC", "ND", "NE", "NH", "NJ", "NM","NV", "NY", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT","VA", "VT", "WA", "WI", "WY"};

private void Page_Load(object sender, System.EventArgs e){// Obtiene la conexión y adaptadores del estado de sesión.ContactMgmt = (SqlConnection)Session["ContactMgmt"];adptContactTypes = (SqlDataAdapter)Session["adptContactTypes"];adptContacts = (SqlDataAdapter)Session["adptContacts"];// Rellena el conjunto de datos ContactType.adptContactTypes.Fill(dsContactTypes, "Contact_Types");// Rellena el conjunto de datos Contacts.

adptContacts.Fill(dsContacts);//Asigna el conjunto de datos tipos de contactos a su lista

3 Consejo del traductor: utilice una tabla estándar HTML para dar un aspecto más ordenado al formulario.



MCAD/MCSD

110

//Nota: las cuatro siguientes líneas no figuran en el original, pero sin//ellas no se carga la lista de tipos de contactos.drpContactTypes.DataSource = dsContactTypes;drpContactTypes.DataMember = "Contact_Types";drpContactTypes.DataTextField = "ContactType";drpContactTypes.DataValueField = "ContactTypeID";// Vincula datos – rellena las listas drpContactTypes y drpStates.drpContactTypes.DataBind();drpStates.DataBind();

}

7. Cada contacto de la tabla Contacts está identificado está identificado por un ContactID. Esta es la clave prin-cipal de la tabla, por lo que debe ser única para cada contacto. Por tanto, antes de poder añadir un contacto alconjunto de datos Contact debe obtener de la base de datos un ContactID único. Añada a la clase del formula-rio Web la siguiente función auxiliar para obtener este ID único antes de añadir el contacto.Visual Basic .NET' Devuelve un ContactID único nuevo.Private Function GetNewContactID() As Integer

Dim cmdNewID As New SqlCommand("SELECT MAX(ContactID)" & _" FROM Contacts", ContactMgmt)

ContactMgmt.Open() ' Abre la conexión con la base de datos.Dim intID As Integer ' Obtiene el ID más alto.' Se asegura de que el registro existe.

If Not (cmdNewID.ExecuteScalar() Is DBNull.Value) ThenintID = CInt(cmdNewID.ExecuteScalar()) ' Obtiene el número más alto.Else

intID = 0 ' En caso contrario ID cero.End If' Cierra la conexión.ContactMgmt.Close()' Devuelve un ID nuevo (mayor en uno que el más alto).Return intID + 1

End Function

Visual C#// Devuelve un ContactID único nuevo.int GetNewContactID(){

SqlCommand cmdNewID = new SqlCommand("SELECT " +

"MAX(ContactID) FROM Contacts", ContactMgmt);ContactMgmt.Open(); // Abre la conexión con la base de datos.int intID; // Obtiene el ID más alto.// Se asegura de que el registro existe.if (cmdNewID.ExecuteScalar() != DBNull.Value)

intID = (int)cmdNewID.ExecuteScalar(); // Obtiene el número más alto.else

intID = 0; // En caso contrario ID cero.// Cierra la conexiónContactMgmt.Close();// Devuelve un ID nuevo (mayor en uno que el más alto).return intID + 1;

}

8. Añada el siguiente procedimiento de suceso butAdd_Click para añadir la información del nuevo contacto a la

base de datos.Visual Basic .NETPrivate Sub butAdd_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butAdd.Click' Crea una nueva fila para el conjunto de datos.Dim rowNew As dsContacts.ContactsRowrowNew = dsContacts.Contacts.NewContactsRow()




111

' Añade datos a la fila.rowNew.ContactID = GetNewContactID()rowNew.FirstName = txtFirstName.TextrowNew.LastName = txtLastName.TextrowNew.Address = txtAddress.TextrowNew.City = txtCity.TextrowNew.StateOrProvince = drpStates.SelectedItem.TextrowNew.PostalCode = txtZip.TextrowNew.HomePhone = txtHomePhone.Text

rowNew.WorkPhone = txtWorkPhone.TextrowNew.Notes = txtNotes.TextrowNew.ContactTypeID = drpContactTypes.SelectedItem.Value' Añade la fila al conjunto de datos.dsContacts.Contacts.AddContactsRow(rowNew)Try

' Modifica la base de datos.adptContacts.Update(dsContacts)' Indica el éxito.litStatus.Text = rowNew.FirstName & " " & rowNew.LastName & _

" añadido con éxito.<br>"' Vuelve a mostrar la página para limpiar los campos.Server.Transfer("AddContact.aspx")

Catch ex As ExceptionlitStatus.Text = "Se ha producido el error:<br>" & ex.Message & _

"<br>" & "Corrija el error y pulse Añadir para añadir " & _"el contacto o pulse Cancelar para abortar. <br> "

End TryEnd Sub


// Crea una nueva fila para el conjunto de datos.dsContacts.ContactsRow rowNew;rowNew = dsContacts.Contacts.NewContactsRow();// Añade datos a la fila.rowNew.ContactID = GetNewContactID();rowNew.FirstName = txtFirstName.Text;rowNew.LastName = txtLastName.Text;

rowNew.Address = txtAddress.Text;rowNew.City = txtCity.Text;rowNew.StateOrProvince = drpStates.SelectedItem.Text;rowNew.PostalCode = txtZip.Text;rowNew.HomePhone = txtHomePhone.Text;rowNew.WorkPhone = txtWorkPhone.Text;rowNew.Notes = txtNotes.Text;rowNew.ContactTypeID = Convert.ToInt16(drpContactTypes.SelectedItem.Value);// Añade la fila al conjunto de datos.dsContacts.Contacts.AddContactsRow(rowNew);try{

// Modifica la base de datos.adptContacts.Update(dsContacts);// Indica el éxito.litStatus.Text = rowNew.FirstName + " " + rowNew.LastName +

" añadido con éxito.<br>";// Vuelve a mostrar la página para limpiar los campos.Server.Transfer("AddContact.aspx");

}catch (Exception ex){litStatus.Text = "Se ha producido el error:<br>" + ex.Message + "<br>" +

"Corrija el error y pulse Añadir para añadir el contacto o pulse " +"Cancelar para abortar.<br>";

}}

9. Añada el procedimiento de suceso butCancel_Click para permitir que el usuario cancele la operación y lim- pie las cajas de texto del formulario.Visual Basic .NETPrivate Sub butCancel_ServerClick(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butCancel.ServerClick' Vuelve a mostrar la página para limpiar las cajas de texto.Server.Transfer("AddContact.aspx")

End Sub



MCAD/MCSD

112

Visual C#private void butCancel_ServerClick(object sender, System.EventArgs e){

// Vuelve a mostrar la página para limpiar las cajas de texto.Server.Transfer("AddContact.aspx");

}

5.5.4 Crear el formulario CallsEl formulario Web Calls permite que el usuario introduzca y vea llamadas telefónicas de un contacto. Usa un

control DataList para ver las llamadas telefónicas para un contacto seleccionado en una lista desplegable, y contienelos controles que añaden una llamada en un control Panel para que se puedan ocultar y .

1. Añada al proyecto un nuevo formulario Web llamado Calls.aspx.2. Añada al formulario los controles que muestra la siguiente tabla con las configuraciones que se indican. Co-

loque los controle que siguen al control Panel dentro del panel de modo que se pueda controlar con facilidadsu presentación en tiempo de ejecución.

Control Propiedad ConfiguraciónDropDownList ID drpContactsButton ID butView

Text Ver llamadaButton ID butAddCall

Text Añadir LlamadaPanel4 ID pnlAdd TextBox ID txtDateTextBox ID txtTimeTextBox ID txtSubject TextBox ID txtNotes

TextMode MultilineButton ID butOkAdd Button ID butCancelAdd Literal ID litError

3. Abra la lengüeta Datos de la Caja de herramientas y arrastre un componente DataSet al formulario Web. Vi-sual Studio muestra el diálogo Agregar conjunto de datos con la opción Conjunto de datos con tipo seleccio-nada.

4. En la lista desplegable Nombre seleccione el conjunto de datos con tipo llamado ContactManagement.dsCallsy pulse aceptar. Visual Studio añade el conjunto de datos al formulario Web.

5. Añada un control DataList de la lengüeta Web Forms de la Caja de herramientas al formulario Web bajo el panel. Configure sus propiedades y edite sus plantillas como indica la siguiente tabla:

Control Propiedad ConfiguraciónDataList ID dlstCalls

DataSource dsCallsHeaderTemplate Texto Ordinario Ninguna LlamadasLínea HTML Ninguna <HR>FooterTemplate Línea HTML Ninguna <HR>ItemTemplate Label ID lblDate

(DataBindings) Usando el diálogo DataBindings seleccione Container.DataItem.CallDate del árbol Enlace simple. Seleccione el formato {0:d}Label ID lblTime

(DataBindings) Usando el diálogo DataBindings seleccione Container.DataItem.CallTime del árbol Enlace simple. Seleccione el formato {0:t}

Texto ordinario Ninguna Asunto:Label ID lblSubject

(DataBindings) Usando el diálogo DataBindings seleccione Container.DataItem.Subject del árbol Enlace simple.

Texto ordinario Ninguna Notas:Label ID lblNotes

(DataBindings) Usando el diálogo DataBindings seleccione Container.DataItem. Notes del árbol Enlace simple.

SeparatorTemplate Línea HTML Ninguna <HR>

4 El panel debería tener visible =false para que inicialmente no se vea (N. del T.)




113

6. Copie el control Hyperlink de la parte inferior del formulario AddContact a la parte inferior del formularioCalls. Para copiar el control selecciónelo y pulse CTRL+C. Para pegar la copia en el formulario Calls pulsesobre el formulario en modo diseño y pulse CTRL+V.

7. Pulse dos veces sobre el formulario Web Calls para ver la ventana de código y añada la siguiente sentencia Imports o using en la parte superior del módulo.Visual Basic .NETImports System.Data.SqlClient

Visual C#using System.Data.SqlClient;

8. El formulario Web Calls usa los componentes de datos del archivo Global.asax, de modo que es necesario re-cuperar referencias a estos componentes de las variables de estado creadas en la sección 5.5.2. Las siguientesdeclaraciones y procedimiento de suceso Page_Load recuperan referencias a los componentes de datos y loshacen disponibles para el código del formulario:Visual Basic .NETDim ContactMgmt As SqlConnectionDim adptContacts As SqlDataAdapterDim adptCalls As SqlDataAdapterDim dsContacts As New dsContacts()


' Obtiene variables de estado de sesión.ContactMgmt = Session("ContactMgmt")adptContacts = Session("adptContacts")adptCalls = Session("adptCalls")dsCalls = Session("dsCalls")dsContacts = Session("dsContacts")' Se ejecuta la primera vez que se muestra la página.If Not IsPostBack Then

' Rellena el conjunto de datos Contacts.adptContacts.Fill(dsContacts)' Por cada fila de la tabla ...Dim rowNext As dsContacts.ContactsRowFor Each rowNext In dsContacts.Contacts

' Crea un nuevo elemento de lista.Dim lstNew As New ListItem()

lstNew.Text = rowNext.FirstName & " " & rowNext.LastNamelstNew.Value = rowNext.ContactID' Añade el elemento a la lista desplegable.drpContacts.Items.Add(lstNew)

Next' Selecciona el primer elemento de la lista.drpContacts.SelectedIndex = 0

End IfEnd Sub

Visual C#SqlConnection ContactMgmt;SqlDataAdapter adptContacts;SqlDataAdapter adptCalls;dsContacts dsContacts = new dsContacts();

private void Page_Load(object sender, System.EventArgs e){// Obtiene variables de estado de sesión.ContactMgmt = (SqlConnection)Session["ContactMgmt"];adptContacts = (SqlDataAdapter)Session["adptContacts"];adptCalls = (SqlDataAdapter)Session["adptCalls"];dsCalls = (dsCalls)Session["dsCalls"];dsContacts = (dsContacts)Session["dsContacts"];



MCAD/MCSD

114

// Se ejecuta la primera vez que se muestra la página.if (!IsPostBack){

// Rellena el conjunto de datos Contacts.adptContacts.Fill(dsContacts);// Por cada fila de la tabla...foreach (dsContacts.ContactsRow rowNext in dsContacts.Contacts){

// Crea un nuevo elemento de lista.ListItem lstNew = new ListItem();lstNew.Text = rowNext.FirstName + " " + rowNext.LastName;

lstNew.Value = rowNext.ContactID.ToString();// Añade el elemento a la lista desplegable.drpContacts.Items.Add(lstNew);

}// Selecciona el primer elemento de la lista.drpContacts.SelectedIndex = 0;

}}

9. El formulario Web Calls modifica el conjunto de datos Calls en tiempo de ejecución. Necesita añadir el si-guiente código al procedimiento de suceso Page_PreRender para almacenar el conjunto de datos de nuevo enla variable de estado después de que se finalice el procesamiento de la página. (El suceso PreRender es el úl-timo que se procesa antes de mostrar la página).Visual Basic .NET

Private Sub Page_PreRender(ByVal sender As Object, _ByVal e As System.EventArgs) Handles MyBase.PreRender' Graba el conjunto de datos en el estado de sesión.Session("dsCalls") = dsCalls

End Sub

Visual C#private void Page_PreRender(object sender, System.EventArgs e){

// Graba el conjunto de datos en el estado de sesión.Session["dsCalls"] = dsCalls;

}

10. Añada el siguiente código para los procedimientos de suceso de pulsación de los botones Ver y Añadir.Visual Basic .NETPrivate Sub butView_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butView.Click' Configura el comando de selección para el conjunto de datos.adptCalls.SelectCommand.CommandText = "SELECT * FROM Calls " & _

"WHERE ContactID=" & drpContacts.SelectedItem.Value' Limpia el conjunto de datos.dsCalls.Clear' Rellena el conjunto de datos.adptCalls.Fill(dsCalls)' Vincula con el control DataListdlstCalls.DataBind()

End Sub

Private Sub butAddCall_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butAddCall.Click

' Configura los valores iniciales de fecha y hora.

txtDate.Text = Now.ToShortDateString()txtTime.Text = Now.ToShortTimeString()' Hace visible el panel de añadir llamada.pnlAdd.Visible = True' Desactiva los botones y la lista desplegable.butView.Enabled = FalsebutAddCall.Enabled = FalsedrpContacts.Enabled = False

End Sub

Visual C#private void butView_Click(object sender, System.EventArgs e){

// Configura el comando de selección para el conjunto de datos.adptCalls.SelectCommand.CommandText = "SELECT * FROM Calls " +

"WHERE ContactID=" + drpContacts.SelectedItem.Value;

dsCalls.Clear(); // Limpia el conjunto de datos.adptCalls.Fill(dsCalls); // Rellena el conjunto de datos.dlstCalls.DataBind(); // Vincula con el control DataList

}




115

private void butAddCall_Click(object sender, System.EventArgs e){// Configura los valores iniciales de fecha y hora.txtDate.Text = System.DateTime.Now.ToShortDateString();txtTime.Text = System.DateTime.Now.ToShortTimeString();// Hace visible el panel de añadir llamadapnlAdd.Visible = true;// Desactiva los botones y la lista desplegable.butView.Enabled = false;butAddCall.Enabled = false;

drpContacts.Enabled = false;}

11. Añada la siguiente función auxiliar para obtener un nuevo valor de CallID. Como CallID es la clave principalde la tabla Calls necesita un valor único dentro de la base de datos, como se muestra aquí:Visual Basic .NET' Devuelve un nuevo CallID único.Private Function GetCallID() As Integer

Dim cmdNewID As New SqlCommand("SELECT MAX(CallID) FROM Calls", ContactMgmt)ContactMgmt.Open() ' Abre la conexión.Dim intID As Integer ' Obtiene el ID más alto.' Se asegura de que el registro existe.If Not (cmdNewID.ExecuteScalar() Is DBNull.Value) Then

intID = CInt(cmdNewID.ExecuteScalar()) ' Obtiene el número más alto.Else

intID = 0 ' O le da el valor cero.End IfContactMgmt.Close() ' Cierra la conexión.' Devuelve un nuevo ID, superior en uno al más alto.Return intID + 1

End Sub

Visual C#int GetCallID(){

SqlCommand cmdNewID = new SqlCommand("SELECT MAX(CallID)FROM Calls",ContactMgmt);

ContactMgmt.Open(); // Abre la conexión.int intID; // Obtiene el ID más alto.

// Se asegura de que el registro existe.if (cmdNewID.ExecuteScalar() != DBNull.Value)intID = (int)cmdNewID.ExecuteScalar(); // Obtiene el número más alto.

elseintID = 0; // O le da el valor cero.

// Cierra la conexiónContactMgmt.Close();// Devuelve un nuevo ID, superior en uno al más alto.return intID + 1;

}

12. Añada el siguiente código a los procedimientos de suceso de los botones Aceptar y Cancelar. Estos procedi-mientos de suceso son muy similares a los usados para añadir o cancelar en la tabla Contacts del ejercicio an-terior.Visual Basic .NETPrivate Sub butOKAdd_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butOKAdd.ClickDim rowNew As dsCalls.CallsRowrowNew = dsCalls.Calls.NewCallsRowrowNew.ContactID = drpContacts.SelectedItem.ValuerowNew.CallID = GetCallID()rowNew.CallDate = txtDate.TextrowNew.CallTime = txtDate.Text & " " & txtTime.TextrowNew.Subject = txtSubject.TextrowNew.Notes = txtNotes.Text' Añade la fila al conjunto de datos Calls.dsCalls.Calls.AddCallsRow(rowNew)



MCAD/MCSD

116

TryadptCalls.Update(dsCalls)' Oculta el panel añadir llamada.pnlAdd.Visible = False' Limpia los campos.txtSubject.Text = ""txtNotes.Text = ""' Activa los otros controles.butView.Enabled = True

butAddCall.Enabled = TruedrpContacts.Enabled = True

Catch ex As Exception' Muestra el error.litError.Text = "Se ha producido el siguiente error: <br>" & _

ex.Message & "<br>" & "Corrija el error e intente de nuevo, " & _o pulse Cancelar.<br>"

End TryEnd Sub

Private Sub butCancelAdd_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butCancelAdd.Click

' Oculta el panel Añadir llamada.pnlAdd.Visible = False' Limpia los campos.

txtSubject.Text = ""txtNotes.Text = ""' Activa los otros controles.butAddCall.Enabled = TruedrpContacts.Enabled = True

End Sub

Visual C#private void butOKAdd_Click(object sender, System.EventArgs e){

dsCalls.CallsRow rowNew;rowNew = dsCalls.Calls.NewCallsRow();rowNew.ContactID = Convert.ToInt16(drpContacts.SelectedItem.Value);rowNew.CallID = GetCallID();rowNew.CallDate = Convert.ToDateTime(txtDate.Text);rowNew.CallTime = Convert.ToDateTime(txtDate.Text + " " + txtTime.Text);

rowNew.Subject = txtSubject.Text;rowNew.Notes = txtNotes.Text;// Añade la fila al conjunto de datos Calls.dsCalls.Calls.AddCallsRow(rowNew);try{

adptCalls.Update(dsCalls);pnlAdd.Visible = false; // Oculta el panel añadir llamada.txtSubject.Text = ""; // Limpia los campos.txtNotes.Text = "";butView.Enabled = true; // Activa los otros controles.butAddCall.Enabled = true;drpContacts.Enabled = true;

}catch (Exception ex){// Muestra el error.

litError.Text = " Se ha producido el siguiente error:<br>" + ex.Message +"<br>" + " Corrija el error e intente de nuevo, o pulse Cancelar<br>";}

}

private void butCancelAdd_Click(object sender, System.EventArgs e){

// Oculta el panel Añadir llamada.pnlAdd.Visible = false;// Limpia los campos.txtSubject.Text = "";txtNotes.Text = "";// Activa los otros controles.butAddCall.Enabled = true;drpContacts.Enabled = true;

}




117

5.5.5 Crear los formularios DeleteContact y ContactTypesHasta ahora esta práctica ha mostrado cómo crear formularios Web paso a paso. Ahora es el momento de que

vuele solo. Cree los formularios DeleteContact y ContactTypes por si mismo. Estos formularios Web deben realizar las siguientes tareas:

• Use los componentes de datos del archivo Global.asax• Realice operaciones sobre la base de datos. El formulario DeleteContact debe permitir a los usuarios borrar

contactos de la base de datos. El formulario ContactTypes debe permitir a los usuarios ver y añadir nuevostipos de contactos.

• Use transacciones de conjunto de datos, como se muestra en los formularios AddContact y Calls.• Proporcione un modo de volver al formulario SwitchBoard.

Cuando termine, compare sus resultados con la aplicación Contact Management incluida en el CD-ROM.



1. ¿Qué pasos debe seguir y qué objetos debe usar para encontrar rápidamente el número de registros en una tabla de base de datos?

2. ¿En qué se diferencian los conjuntos de datos sin tipo de los conjuntos de datos con tipo, y cuales son lasventajas de los conjuntos de datos con tipo?

3. ¿Cómo se reutiliza un componente de conexión de base de datos en una aplicación Web?

4. Explique las diferencias entre manejar transacciones a nivel base de datos y a nivel conjunto de datos.



MCAD/MCSD

118




119

6 Capturar y corregir erroresEn este capítulo aprenderá cómo tratar con los problemas que aparecen en su aplicación como resultado de

circunstancias externas. Este capítulo le ayudará a anticipar, identificar y tratar estos tipos de problemas en su apli-cación de modo eficaz.

Las lecciones 1 y 2 tratan las dos técnicas principales para tratar con estos tipos de problemas de programa-ción dentro de una aplicación Web ASP.NET. La lección 3 explica cómo controlar una aplicación durante las pruebas o después de que se haya desplegado para asegurar que los problemas se han tratado correctamente.

Para completar las lecciones de este capítulo debe:

• Estar familiarizado con los aspectos básicos del lenguaje de programación Visual Basic o C#. Esto incluyefamiliaridad con los conceptos de variables, procedimientos, estructuras de decisión y alcance. Vea los temasde ayuda Cambios en el Lenguaje Visual Basic o Recorrido del Lenguaje C# en Visual Studio .NET.

• Comprender cómo crear una aplicación Web básica usando formularios Web, controles de servidor y proce-dimientos de suceso que se introdujeron en el Capítulo 2, Crear Aplicaciones de Formulario Web.

• Haber completado la aplicación Contact Management tratada en el Capítulo 5, Almacenar y Recuperar Datoscon ADO.NET . La práctica final de este capítulo amplía este ejemplo con tratamiento de excepciones.

6.1 Uso del manejo de excepcionesLas excepciones son circunstancias inusuales que se producen dentro de la lógica de una aplicación. En la

documentación de Visual Studio a menudo se intercambian los términos excepción y error porque se usan las mis-mas técnicas para manejar ambas situaciones.

En esta lección aprenderá las diferentes técnicas de programación que puede usar para controlar excepcionesen una aplicación Web. Esta lección trata solo las técnicas modernas que proporcionan Visual Studio .NET yASP.NET. No trata sintaxis de control de excepciones antiguas como On Error , que aún soporta Visual Basic .NET.

6.1.1 Técnicas de control de excepcionesCuando se produce un problema no anticipado en una aplicación Web, es inmediatamente aparente para el

usuario, que generalmente verá un mensaje de error. Cuando sucede esto el usuario se queda bloqueado – lo únicoque puede hacer es pulsar Atrás en su navegador e intentar de nuevo. El programador es responsable de anticipar estas situaciones y tratarlas en su código antes de que se produzcan. El proceso para tratar con estos tipos de situa-ciones se llama control de excepciones. Los errores con los que no se trata en el código se llaman excepciones no

controladas y son los que aparecen ante el usuario.Hay dos aproximaciones diferentes para manejar excepciones en una aplicación Web:

• Utilizar bloques de control de excepciones para tratar con estas dentro del alcance de un procedimiento. Estatécnica se denomina control de excepciones estructurado (SEH, estructured exception handling) en ladocumentación de Visual Studio

• Usar sucesos de error para tratar con excepciones dentro del alcance de un objeto.

6.1.2 Usar bloques de control de excepcionesUtilice bloques de control de excepciones para encerrar sentencias que pueden fallar debido a condiciones

externas. Un ejemplo habitual es el acceso a ficheros. Cuando se intenta grabar un archivo en un servidor pueden producirse una serie de problemas: el disco puede estar lleno, el nombre de fichero puede estar ya en uso, o puedeque la ruta para grabar el fichero no exista.

Para tratar con estos posibles problemas encierre las sentencias de acceso a archivos en un bloque de controlde excepciones. La tabla 6-1 describe las palabras clave usadas para crear un bloque de control de excepciones.

Tabla 6. 1: Palabras clave de control de excepciones VisualBasic .NET

C# Se usa para

Try try Comenzar una estructura de control de errores. Si una sentencia que siga a esta palabra clave provoca unaexcepción el flujo de control pasa inmediatamente a la siguiente sentencia Catch /catch

Catch catch Recupera cualquier excepción que se haya producido y la gestiona. Cuando el flujo de control pasa a unbloque Catch /catch se procesan las sentencias contenidas en el bloque para corregir el error o manejar laexcepción de alguna otra forma.

Finally finally Procesa las sentencias que se deben ejecutar como parte del bloque de control de excepciones tanto si seproduce un error como si no.

End Try N/A Finaliza un bloque de control de excepciones.Throw throw Provoca una excepción. Use esta palabra dentro del bloque de control de excepciones para pasar inmedia-

tamente el flujo de control a la sentencia Catch /catch .



MCAD/MCSD

120

La forma más sencilla de comprender el uso combinado de estas palabras clave es un ejemplo. Imagine unformulario Web que permite seleccionar un archivo de su máquina para subir al servidor. Cuando se sube el archivose añade a una caja de lista.

Cuando el usuario introduce un nombre de archivo y pulsa Subir pueden darse una serie de condiciones deexcepción:

• El archivo puede no existir en el ordenador cliente• La conexión Internet puede fallar durante la subida• El archivo puede ser demasiado grande para subirlo en Internet• El servidor puede no tener suficiente espacio en disco para el archivo.

Para controlar estas situaciones imprevisibles, encierre las sentencias que pueden causar estas condiciones enun bloque de control de excepciones, como muestra el siguiente código:

Visual Basic .NETPrivate Sub butUpload_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butUpload.ClickDim strFilename As String = fileUpload.PostedFile.Filename' Divide el nombre de archivo en partes.strFilename = System.IO.Path.GetFilename(strFilename)Try

' (1) Comprueba si el archivo tiene longitud cero (no existe).

If filUpload.PostedFile.ContentLength = 0 ThenThrow New System.IO.FileNotFoundException()End If' (2) Graba el archivo en el servidor usando su nombre base.filUpload.PostedFile.SaveAs(Request.MapPath(Request.ApplicationPath) & _

"\" & strFilename)' Añade el archivo a la lista de archivos del servidor.lstFiles.Items.Add(strFilename)' Selecciona el primer elemento de la lista.lstFiles.SelectedIndex = 0

Catch ex As Exception ' (3) Controla las posibles excepciones.litError.Text = "<p>SE ha producido el error:</p>" & ex.Message & "<br>"

Finally ' (4) Ejecuta limpieza.' Reinicia el campo Archivo.filUpload.Value = ""

End TryEnd Sub

Visual C#private void butUpload_Click(object sender, System.EventArgs e){

string strFilename = filUpload.PostedFile.FileName;// Divide el nombre de archivo en partes.strFilename = System.IO.Path.GetFileName(strFilename);try{

// (1) Comprueba si el archivo tiene longitud cero (no existe).if (filUpload.PostedFile.ContentLength == 0)

throw new System.IO.FileNotFoundException();// (2) Graba el archivo en el servidor usando su nombre base.filUpload.PostedFile.SaveAs(Request.MapPath(Request.ApplicationPath) +

"\\" + strFilename);

// Añade el archivo a la lista de archivos del servidor.lstFiles.Items.Add(strFilename);// Selecciona el primer elemento de la lista.lstFiles.SelectedIndex = 0;

}catch (Exception ex) // (3) Controla las posibles excepciones.litError.Text = "<p>Se ha producido el error:</p>" + ex.Message + "<br>";

finally // (4) Ejecuta limpieza.// Reinicia el campo Archivo.filUpload.Value = "";

}

Cuando se ejecuta el código anterior sigue estos pasos:

1. Comprueba si existe el fichero en la máquina cliente. Si el archivo introducido tiene longitud cero, el archivono existe, de modo que el código causa una System.IO.FileNotFoundException y el flujo pasa inmediatamen-

te al paso 3.2. Graba el archivo en el servidor. Si tiene éxito, el flujo de control continúa añadiendo el nombre del archivo a

la ListBox. Si falla, el flujo de control pasa al paso 3, saltándose la ListBox.




121

3. Controla la excepción. En este caso, las excepciones se controlan sencillamente mostrándolas en un controlLiteral en el formulario Web. Si no se ha producido ninguna excepción, el flujo de control se salta este paso yva directamente al 4.

4. Limpieza final. Estas sentencias son el último paso en el bloque de control de excepciones.

La palabra clave Catch/catch puede interceptar excepciones generales, como muestra el ejemplo anterior, o puede interceptar y responder de forma diferente a tipos de excepciones concretos, como muestra este fragmento:

Visual Basic .NETTry

' Algunas sentencias...Catch ex As System.IO.FileNotFoundException

litError.Text = "<p>El archivo no existe.</p>"Catch ex As System.IO.IOException

litError.Text = "<p>No se puede grabar el archivo en el servidor.</p>"Catch ex As System.Net.WebException

litError.Text = "<p>Error de Internet durante la subida.</p>"Catch ex As Exception

litError.Text = "<p>Se ha producido el error:</p>" & ex.Message & "<br>"End Try

Visual C#try{

// Algunas sentencias...

}catch (System.IO.FileNotFoundException ex)

litError.Text = "<p> El archivo no existe.</p>";catch (System.IO.IOException ex)

litError.Text = "<p> No se puede grabar el archivo en el servidor.</p>";catch (System.Net.WebException ex)

litError.Text = "<p> Error de Internet durante la subida.</p>";catch (Exception ex)

litError.Text = "<p> Se ha producido el error:</p>" + ex.Message + "<br>";

El código anterior ejecuta cuatro sentencias diferentes dependiendo de si la excepción es FileNotFoundEx-ception, IOException, WebException o cualquier otro tipo de excepción.

Como las sentencias Catch se procesan secuencialmente, debe ponerlas en orden, de la excepción más espe-cífica a la más general. Por ejemplo, el siguiente fragmento de código nunca ejecutará las sentencias para Sys-tem.IO.IOException, System.IO.FileNotFoundException o System.Net.WebException, porque estos errores los captu-ra primero el tipo de excepción general Exception:

Visual Basic .NETCatch ex As Exception

litError.Text = "<p>Se ha producido el error:</p>" & ex.Message & "<br>"Catch ex As System.IO.FileNotFoundException

litError.Text = "<p>El archivo no existe.</p>"Catch ex As System.IO.IOException

litError.Text = "<p>No se puede grabar el archivo en el servidor.</p>"Catch ex As System.Net.WebException

litError.Text = "<p>Error de Internet durante la subida.</p>"

Visual C#catch (Exception ex)

litError.Text = "<p> Se ha producido el error:</p>" + ex.Message + "<br>";catch (System.IO.FileNotFoundException ex)


litError.Text = "<p> No se puede grabar el archivo en el servidor.</p>";catch (System.Net.WebException ex)

litError.Text = "<p> Error de Internet durante la subida.</p>";

El marco de trabajo .NET incluye tipos de excepción específicos con las clases individuales. Esto significaque no hay una única lista completa de tipos de excepción en la documentación de .NET. En su lugar debe usar eldiálogo Excepciones de Visual Studio .NET para ver los tipos de excepción concretos, como describe el siguiente procedimiento.

1. En el menú Depurar seleccione Excepciones. Visual Studio muestra el diálogo Excepciones.

2. Pulse el signo más a la izquierda de los elementos de la lista para ver las excepciones que proporciona.



MCAD/MCSD

122

6.1.3 Causar excepcionesComo ha visto en la sección anterior, la palabra clave Throw/throw se usa para causar una excepción concre-

ta. Esta técnica es útil para mostrar cómo funciona el control de excepciones, pero provoca la pregunta “¿para quéquerremos provocar una excepción en una aplicación del mundo real?.

El control de excepciones es una forma de implementar un cierto tipo de lógica en la aplicación. Sencilla-mente está especificando una serie de situaciones que no son normalmente parte del curso de los sucesos de la apli-cación y diciendo: “Esto son excepciones”. Esto permite dejar aparte la complejidad de tratar con estas excepciones,

simplificando de esta forma la lógica principal de la aplicación.

Por ejemplo, en el ejemplo FileUpload a continuación es razonable causar la excepción FileNotFoundExcep-tion si el archivo subido tiene longitud cero. De lo contrario es muy difícil determinar si un archivo existe en la má-quina cliente antes de subirlo. FileNotFoundException es una excepción estándar del espacio de nombres System.IO,y es descriptiva de lo que sucede.

Visual Basic .NETPrivate Sub butUpload_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butUpload.ClickDim strFilename As String = filUpload.PostedFile.Filename' Divide el nombre de archivo en partes.strFilename = System.IO.Path.GetFilename(strFilename)Try

' Comprueba si el archivo tiene longitud cero (no existe).If filUpload.PostedFile.ContentLength = 0 Then

Throw New System.IO.FileNotFoundException()End If' Graba el archivo en el servidor con su nombre.filUpload.PostedFile.SaveAs(Request.MapPath(Request.ApplicationPath) & _

"\" & strFilename)' Añade el archivo a la lista de archivos del servidor.lstFiles.Items.Add(strFilename)' Selecciona el primer elemento de la lista.lstFiles.SelectedIndex = 0' Controla posibles excepciones.

Catch ex As System.IO.FileNotFoundExceptionlitError.Text = "<p>El archivo no existe.</p>"

Catch ex As System.IO.IOException

litError.Text = "<p>No se pudo grabar el archivo en el servidor.</p>"Catch ex As System.Net.WebException

litError.Text = "<p>Error de Internet durante la subida del archivo.</p>"Catch ex As Exception

litError.Text = "<p>Se produjo el error:</p>" & ex.Message & "<br>"' Limpieza.Finally

' Reinicia el campo Archivo.filUpload.Value = ""

End TryEnd Sub

Visual C#private void butUpload_Click(object sender, System.EventArgs e){

string strFilename = filUpload.PostedFile.FileName;

// Divide el nombre de archivo en partes.strFilename = System.IO.Path.GetFileName(strFilename);try{

// (1) Comprueba si el archivo tiene longitud cero (no existe).if (filUpload.PostedFile.ContentLength == 0)

throw new System.IO.FileNotFoundException();// (2) Graba el archivo en el servidor con su nombre.filUpload.PostedFile.SaveAs(Request.MapPath(Request.ApplicationPath) +

"\\" + strFilename);// Añade el archivo a la lista de archivos del servidor.lstFiles.Items.Add(strFilename);// Selecciona el primer elemento de la lista.lstFiles.SelectedIndex = 0;

}




123

// (3) Controla posibles excepciones.catch (System.IO.FileNotFoundException ex)


litError.Text = "<p> No se pudo grabar el archivo en el servidor.</p>";catch (System.Net.WebException ex)

litError.Text = "<p> Error de Internet durante la subida del archivo.</p>";catch (Exception ex)

litError.Text = "<p> Se produjo el error:</p>" + ex.Message + "<br>";

// (4) Limpieza.finally

// Reinicia el campo Archivo.filUpload.Value = "";

}

6.1.4 Definir nuevas excepcionesEn algunos casos querrá provocar en su aplicación una excepción que no tenga un equivalente descriptivo en

el marco de trabajo .NET. En estos casos deberá crear una nueva excepción del tipo ApplicationException. Por ejemplo, el siguiente fragmento de código causa una excepción que indica que el usuario ya está conectado:

Visual Basic .NETThrow New ApplicationException("El usuario ya está conectado")

Visual C#throw new ApplicationException("El usuario ya está conectado”);

Para controlar esta excepción utilice la siguiente sentencia:

Visual Basic .NETCatch ex As ApplicationException

Visual C#catch(ApplicationException ex)

La clase ApplicationException proporciona las mismas características que la clase Exception estándar. Senci-llamente proporciona una forma de diferenciar entre las excepciones definidas en el marco de trabajo .NET y lasdefinidas en la aplicación.

Si está creando una gran aplicación o si está creando componentes utilizados por otras aplicaciones querrá

definir sus propias clases de excepción basadas en la clase ApplicationException. Por ejemplo, el siguiente códigodefine una clase para UserLoggedOnException.

Visual Basic .NETPublic Class UserLoggedOnException

Inherits ApplicationException

' Constructor de Excepción.Sub New(Optional ByVal Message As String = "El usuario ya está conectado.", _

Optional ByVal Inner As Exception = Nothing)MyBase.New(Message, Inner)

End Sub

End Class

Visual C#public class UserLoggedOnException : System.ApplicationException{

// Constructor de Excepción (sobrecargado)public UserLoggedOnException() :

this("El usuario ya está conectado ", null){}public UserLoggedOnException(string message) : this(message, null){}public UserLoggedOnException(string message, Exception inner) :

base(message, inner){}}

La clase UserLoggedOnException anterior hereda sus propiedades y métodos de la clase base ApplicationEx-ception. La nueva clase proporciona solamente su propio constructor para configurar el mensaje predeterminado quemuestra. Este es un método estándar.

6.1.5 Uso de sucesos de error Otra forma de controlar excepciones es mediante los sucesos de error incorporados a los objetos Web. Cuan-do se produce una aplicación no controlada en una aplicación Web ASP.NET lanza los sucesos que se describen enla tabla 6.2.



MCAD/MCSD

124

Tabla 6. 2: Sucesos de control de excepcionesProcedimiento desuceso

Se produce cuando

Page_Error Se produce una excepción sin controlar en la página. Este procedimiento reside en el formulario Web.Global_Error Se produce una excepción sin controlar en la aplicación. Este procedimiento reside en el archivo Global.asax.

Application_Error Se produce una excepción sin controlar en la aplicación. Este procedimiento reside en el archivo Global.asax.

Los sucesos de error permiten controlar excepciones para todo un objeto en un lugar único centralizado. Esdiferente al uso de bloques de control de excepciones, que controlan las excepciones dentro del procedimiento en el

que suceden. Puede usar los sucesos de error de las siguientes formas:• Como sustitutos de los bloques de control de excepciones. Como los sucesos de error se producen fuera

del alcance del procedimiento donde se produjo el error, tiene menos información sobre los pasos que llevana la excepción, y por tanto menos capacidad de corregir la condición de error por el usuario. Sin embargo, esadecuado para tareas donde no se podrá corregir la excepción en el código.

• Como complemento de los bloques de control de excepciones. Los sucesos de error pueden proporcionar un último punto de defensa centralizado contra las excepciones no previstas o controladas en algún otro lu-gar. Usando las dos técnicas de control de excepciones juntas se asegura de capturar todas las excepcionesantes de que el usuario las vea, mostrar un mensaje razonable, e incluso registrar el error para mejorar la apli-cación.

Cuando controle excepciones en sucesos de error use el objeto Server para obtener información sobre lo queha sucedido. El objeto Server proporciona los métodos que muestra la tabla 6.3 para trabajar con excepciones.

Tabla 6. 3: métodos de control de excepciones de objeto ServerMétodo Se usa para

GetLastError() Obtiene la última excepción producida en el servidor.ClearError() Elimina la última excepción producida en el servidor. La llamada a ClearError controla la excepción, de modo

que no lanza sucesos de error posteriores ni aparece al usuario en el navegador.

Para controlar una excepción en un suceso de error siga estos pasos:

1. En el procedimiento de suceso Page_Error , Global_Error o Application_Error obtenga la excepción que se produjo usando el método GetLastError .

2. Haga algo con la excepción, como mostrar un mensaje al usuario, corregir el problema o escribir un registrode error.

3. Elimine la excepción usando ClearError .4. Vuelva a mostrar la página Web. El procesamiento de una página Web se detiene inmediatamente cuando se

produce una excepción, de forma que los controles de servidor y otros elementos de la página podrían nomostrarse después de procesar la excepción.

El siguiente código muestra estos pasos:

Visual Basic .NETPrivate Sub Page_Error(ByVal sender As Object, _

ByVal e As System.EventArgs) Handles MyBase.ErrorDim ex As Exception = Server.GetLastError() ' Obtiene el error.Session("Error") = ex.Message() ' Almacena el mensaje de error.Server.ClearError() ' Elimina el error.Response.Redirect("ErrorEvents.aspx") ' De vuelta a esta página.

End Sub

Visual C#

private void Page_Error(object sender, System.EventArgs e){Exception ex = Server.GetLastError(); // Obtiene el error.Session["Error"] = ex.Message; // Almacena el mensaje de error.Server.ClearError(); // Elimina el error.Response.Redirect("ErrorEvents.aspx"); // Redirige de vuelta a esta página.

}

El código anterior almacena el mensaje de excepción como variable de estado Session antes de limpiar la ex-cepción de modo que se pueda mostrar el mensaje cuando se recargue la página mediante el método Redirect . Elsiguiente código muestra el mensaje de excepción grabado cuando se vuelve a mostrar la página:




125


ByVal e As System.EventArgs) Handles MyBase.Load' Muestra el error, si lo hay.If Session("Error") <> Nothing Then

litError.Text = "<p>Se produjo el error:</p>" & Session("Error") & "<br>"' Limpia la variable de estado de sesión.Session("Error") = Nothing

End If

End Sub


// Muestra el error, si lo hay.if(Session["Error"] != null){

litError.Text = "<p> Se produjo el error:</p>" +Session["Error"].ToString();

// Limpia la variable de estado de sesión.Session["Error"] = null;

}}

6.2 Usar páginas de error

La lección 6.1 proporcionó técnicas para controlar excepciones que ocurren en el servidor que ejecuta la apli-cación Web. Sin embargo, como las aplicaciones Web corren sobre Internet, hay toda una clase de excepciones queno se pueden detectar desde el código. Para interceptar estos errores y proporcionar la mejor respuesta posible nece-sita usar páginas de error.

En esta lección aprenderá como usar páginas de error en ASP.NET para interceptar errores HTTP y respon-der ante ellos a nivel aplicación y página.

6.2.1 Control de excepciones relacionadas con internetCuando un usuario ejecuta una aplicación Web desde su navegador se pueden producir una serie de excep-

ciones fuera del alcance de la verdadera aplicación. Por ejemplo, se pueden producir errores de servidor cuando seagota el tiempo de espera para una respuesta del usuario, o la página solicitada puede no encontrarse en el servidor.

Las páginas de error son páginas .htm o .aspx en el servidor a las que se redirige al usuario cuando se pro-

duce una excepción no controlada. ASP.NET permite definir páginas de error a dos niveles:• Especificar opciones de página de error a nivel aplicación en la sección customErrors del archivo

Web.config. Estas opciones determinan la página que se muestra para errores HTTP concretos.• Especificar una página de error para un formulario Web concreto en el atributo ErrorPage de la di-

rectiva Page. Esta opción determina la página de error que se muestra si el formulario Web encuentra unaexcepción no controlada.

6.2.2 Páginas de error a nivel de aplicaciónInternet Information Service (IIS) de Microsoft define las páginas de error que se muestran de forma prede-

terminada para respuestas HTTP específicas. Para ver o cambiar la configuración de página de error para una aplica-ción en IIS siga estos pasos:

1. Pulse con el botón derecho sobre el directorio de aplicación Web y seleccione Propiedades. IIS muestra eldiálogo Propiedades.

2. Pulse sobre la lengüeta Errores personalizados. IIS muestra la configuración de páginas de error para códigosde respuesta HTTP específicos.

3. Seleccione el código de respuesta cuya página de error quiere cambiar y pulse Modificar propiedades. IISmuestra el diálogo Propiedades de asignación de errores.

4. Pulse Examinar para reemplazar la página de error por una página de su propio directorio de aplicación. Pul-se Aceptar cuando termine.

Al usar IIS para cambiar las páginas de error a nivel aplicación los cambios se hacen en el servidor donde es-tá desplegada la aplicación. Si se cambia de servidor habrá que repetir estos cambios. Como alternativa, puede hacer que la configuración de páginas de error a nivel de aplicación sea parte de la aplicación usando el archivoWeb.config del proyecto.

Para especificar las páginas que se mostrarán si se producen errores HTTP específicos no controlados en unaaplicación Web use la sección customErrors del archivo Web.config. Los errores HTTP están identificados por uncódigo de estado definido en la especificación HTTP 1.1. ASP.NET recoge estos códigos de estado en la enumera-ción HTTPStatusCode. Algunos de los más habituales se recogen en la tabla 6-4.



MCAD/MCSD

126

Tabla 6. 4: Códigos de estado HTTP habituales Valor Miembro HTTPStatusCode Indica

200 OK La petición ha tenido éxito204 NoContent La petición he tenido éxito, pero la respuesta está intencionadamente en blanco.301 Moved, MovedPermanently La petición se está redirigiendo a otra dirección302 Found, Redirect La petición se está redirigiendo a otra dirección400 BadRequest El servidor no puede comprender la petición401 Unauthorized El recurso solicitado necesita una autorización que no ha sido proporcionada con la

petición.

403 Forbidden El servidor rechaza cumplir la petición404 NotFound El recurso solicitado no existe en el servidor.408 RequestTimeOut El cliente no envió una petición antes de que terminara el tiempo de espera de petición

del servidor.500 InternalServerError Se ha producido un error genérico en el servidor.503 ServiceUnavailable El servidor está temporalmente no disponible505 HttpVersionNotSupported El servidor no da soporte a la versión de HTTP solicitada.

Para mostrar una página concreta en respuesta a uno o más de estos códigos de estado incluya un etiqueta<error > en la sección customErrors del archivo Web.config de su aplicación. Por ejemplo, la siguiente sección cus-tomErrors especifica una página de error predeterminada, junto con tres páginas de error diferentes para códigos derespuesta HTTP concretos:

<customErrors mode="On" defaultRedirect="ErrDefault.aspx"><error statusCode="401" redirect="ErrUnauthorized.aspx" />

<error statusCode="404" redirect="ErrPageNotFound.aspx" /><error statusCode="500" redirect="ErrServer.htm" /></customErrors>

EL campo mode de customErrors debe tener el valor on para ver las páginas de error mientras se depura laaplicación en la máquina local. Si se le da el valor RemoteOnly (predeterminado) se mostrarán las páginas designa-das cuando se acceda a la aplicación desde una máquina cliente, pero no cuando se acceda de modo local.

6.2.3 Páginas de error a nivel de páginaPara mostrar una página concreta cuando se produzca una excepción no controlada en un formulario Web use

el atributo ErrorPage del objeto Page. Puede usar los métodos GetLastError y ClearError del objeto Server desdela página de error, como se mostró anteriormente para los sucesos de error.

Por ejemplo, el siguiente HTML establece el atributo ErrorPage para un formulario Web.

Visual Basic .NET<%@ Page Language="vb" AutoEventWireup="false" Codebehind="WebForm1.aspx.vb"Inherits="vbExceptionSnippet.WebForm1" errorPage="errDefault.aspx"%>

Visual C#<%@ Page language="c#" Codebehind="ErrorPage.aspx.cs" AutoEventWireup="false"Inherits="csErrorPageSnippet.WebForm1" errorPage="ErrDefault.aspx"%>

A continuación, el siguiente código provoca una excepción cuando el usuario pulsa butError.

Visual Basic .NET' Webform1.aspxPrivate Sub butError_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butError.Click' Causa excepción.

Throw New System.Net.WebException()End Sub

Visual C#// Webform1.aspxprivate void butError_Click(object sender, System.EventArgs e){

// Causa excepción.throw new System.Net.WebException();

}

Cuando se produce una excepción se muestra la página ErrDefault.aspx, que describe el error al usuariousando el siguiente código.

Visual Basic .NET' ErrDefault.aspxPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.Load' Muestra el error producido.litError.Text = "<p>Se ha producido el error:</p>" & _

Server.GetLastError.Message




127

' Limpia el error.Server.ClearError()

End Sub

Visual C#// ErrDefault.aspxprivate void Page_Load(object sender, System.EventArgs e){// Muestra el error producido.litError.Text = "<p>Se ha producido el error:</p>" +

Server.GetLastError().Message;// Limpia el error.Server.ClearError();

}

6.3 Registro de excepcionesMientras se desarrolla la aplicación es una buena idea usar registro de excepciones para proporcionar un me-

dio de seguimiento de las mismas. Un registro de excepciones es una lista de excepciones controladas que se pro-ducen durante la ejecución de la aplicación. El repaso periódico del registro de excepciones le ayuda a comprobar que las excepciones se están controlando correctamente, no se están produciendo con demasiada frecuencia y noestán impidiendo a los usuarios que realicen tareas con su aplicación.

En esta lección aprenderá cómo usar las características de seguimiento de ASP.NET para implementar el re-gistro de excepciones en su aplicación.

6.3.1 Usar seguimiento para registrar erroresEl seguimiento es una técnica para registrar sucesos, como las excepciones, en una aplicación. Siempre ha

habido formas de registrar los errores de una aplicación – normalmente abriendo un archivo y escribiendo en él losmensajes de error – pero el seguimiento ofrece ventajas significativas.

• Estandarización. Incorporar el seguimiento en el marco de trabajo .NET asegura que las técnicas de pro-gramación son las mismas en todas las aplicaciones que se desarrollen con él.

• Soporte Web Incorporado. ASP.NET amplía las herramientas del marco de trabajo .NET incluyendo in-formación relativa a las prestaciones y comportamiento de las peticiones Web.

• Configuración. Puede activar y desactivar el seguimiento usando opciones del archivo de configuración dela aplicación. No necesita recompilar la aplicación.

• Prestaciones. Cuando están desactivadas, las sentencias de seguimiento no afectan a las prestaciones.

Para usar seguimiento en una aplicación Web siga estos pasos:

1. Active el seguimiento.2. Escriba en el registro de seguimiento.3. Lea el registro de seguimiento.

Las seccione siguientes proporcionan detalles sobre estos pasos.

6.3.2 Activar y desactivar el seguimientoEl seguimiento se puede activar y desactivar para una aplicación Web completa o para una página individual.

• Para activar el seguimiento para toda una aplicación, de el valor True al atributo Enabled del elemento <tra-ce> en el archivo Web.config.

• Para activar el seguimiento para una única página de el valor True a la propiedad Trace del objeto DOCU- MENT .

De forma predeterminada la salida de seguimiento se muestra al final de cada página Web.

Aunque esto es adecuado para depurado, por lo general cuando empiece a probar una aplicación terminadaquerrá escribir el seguimiento en un archivo de registro. Para escribir el seguimiento en un archivo para toda la apli-cación de el valor False al atributo PageOutput del elemento <trace>. ASP.NET escribe la salida de seguimiento enun archivo Trace.axd en el directorio raíz de la aplicación.

El elemento <trace> incluye un atributo RequestLimits para determinar cuantas peticiones de página escribir en el registro. Por ejemplo, la siguiente línea de un archivo Web.config activa el seguimiento para la aplicación yescribe las 20 primeras peticiones en el archivo Trace.axd.

<trace enabled="true" requestLimit="20" pageOutput="false"traceMode="SortByTime" localOnly="true" />

La escritura de los mensajes de seguimiento en un archivo de registro no afecta al seguimiento configurado anivel de página. Cuando la propiedad Trace de un objeto DOCUMENT tiene el valor True todos los mensajes deseguimiento para esta página se muestran en la misma.



MCAD/MCSD

128

Para escribir mensajes de seguimiento en un archivo solo para las páginas seleccionadas de una aplicación si-ga estos pasos:

1. En el elemento <trace> del archivo Web.config de la aplicación de el valor True al atributo Enabled y el va-lor False al atributo PageOutput .

2. De el valor False a la propiedad Trace del objeto DOCUMENT en cada página que quiera excluir del segui-miento.

Cuando se ha establecido la propiedad Trace de un objeto DOCUMENT a True o False no se puede restable-

cer la opción predeterminada desde la ventana de propiedades de Visual Studio, sino que debe editar el HTML delformulario Web para eliminar el campo trace del elemento Page. El siguiente código muestra en negrita el texto quedebe borrar.

Visual Basic .NET<%@ Page Language="vb" AutoEventWireup="false" Codebehind="Trace.aspx.vb"

Inherits="vbErrorLogSnippet.WebForm1" trace="True" %>

Visual C#<%@ Page language="c#" Codebehind="WebForm1.aspx.cs" AutoEventWireup="false"

Inherits="csTracing.WebForm1" trace="True"%>

6.3.3 Escribir mensajes en el registro de seguimientoEl objeto Trace proporciona los métodos Write y Warn que permiten escribir mensajes en la información de

seguimiento. Los dos métodos son idénticos con una excepción: los mensajes escritos con Write se muestran ennegro, mientras que los escritos con Warn se muestran en rojo.

Por ejemplo, el siguiente código escribe información sobre excepciones no controladas en el registro de se-guimiento usando el método Warn, por lo que se ven en rojo.


ByVal e As System.EventArgs) Handles MyBase.Error' escribe un mensaje en el registro de seguimiento.Trace.Warn("Error", "", Server.GetLastError())' Limpia el error de modo que la aplicación puede continuar.Server.ClearError()' Vuelve a mostrar la página.

Response.Redirect("Trace.aspx")

End Sub

Visual C#private void Page_Error(object sender, System.EventArgs e){

// Escribe un mensaje en la registro de seguimiento.Trace.Warn("Error", "", Server.GetLastError());// Limpia el error de modo que la aplicación puede continuar.Server.ClearError();// Vuelve a mostrar la página.Response.Redirect("Trace.aspx");

}

En algunos casos querrá realizar algunas acciones adicionales cuando el seguimiento está activo, por ejemplo, especificar información de usuario. La propiedad IsEnabled del objeto Trace permite ejecutar este código con-dicionalmente, de modo que no afecta a las prestaciones cuando el seguimiento está desactivado. Por ejemplo, el

siguiente código añade información de navegador al mensaje de seguimiento si este está activado.


ByVal e As System.EventArgs) Handles MyBase.ErrorIf Trace.IsEnabled Then

Dim strMessage As StringIf Request.Browser.AOL Then

strMessage = "Navegador AOL"Else

strMessage = "Navegador no AOL"End IfTrace.Warn("Error", strMessage, Server.GetLastError())

End IfServer.ClearError()Response.Redirect("Trace.aspx")

End Sub




129


if (Trace.IsEnabled){string strMessage;if (Request.Browser.AOL)

strMessage = "Navegador AOL";else

strMessage = "Navegador no AOL";Trace.Warn("Error", strMessage, Server.GetLastError());

}Server.ClearError();Response.Redirect("Trace.aspx");

}

6.3.4 Leer el registro de seguimientoDe forma predeterminada la salida de seguimiento se muestra en la parte inferior de cada página Web que

tiene el seguimiento activado. Como se mencionó anteriormente, si el atributo PageOutput del elemento <trace>del archivo Web.config tiene el valor False la salida de seguimiento se escribe en el archivo Trace.axd en el directo-rio raíz de la aplicación en lugar de mostrarse en la página. Puede ver este archivo sencillamente pidiéndolo en sunavegador. Por ejemplo, puede usar el enlace:

<A href="Trace.axd">Ver Seguimiento</A>

De forma predeterminada solo puede ver Trace.axd desde el servidor local en la que corre la aplicación. Siquiere verlo desde una máquina remota, como cuando se depura en remoto, de el valor False al atributo localOnly del elemento <trace> en el archivo Web.config:

<trace Enabled="true" requestLimit="20" pageOutput="false" traceMode="SortByTime"localOnly="false" />

El seguimiento ASP.NET se detiene después de que el servidor recibe el número de peticiones HTTP indica-do en el atributo requestLimit del elemento <trace>. Para limpiar la lista y comenzar el seguimiento de nuevo pulseel enlace Borrar rastro actual en la parte superior derecha de la página Trace.axd. Este enlace vuelve a mostrar Tra-ce.axd pasándole la cadena de consulta “clear=1”

6.4 Resumen• El control de excepciones proporciona un modo de tratar con sucesos no usuales en un programa. Cada una

de las diferentes técnicas de control de excepciones proporciona una forma de dejar aparte la complejidad deltrato con estos sucesos no usuales de modo que no oculten la lógica principal de la aplicación.

• Los bloques de control de excepciones usan las palabras clave Try, Catch, Finally (Visual Basic .NET) o try,catch, finally (C#)

• Capture las excepciones en orden de más específica a más general.• Use la palabra clave Throw (Visual Basic .NET) o throw (C#) para causar una interrupción intencionada.• Los sucesos de error controlan las excepciones en un procedimiento de suceso separado. Use los métodos

GetLastError y ClearError para controlar excepciones en estos sucesos de error.• Las páginas de error controlan excepciones que se producen fuera de la aplicación Web a causa de problemas

relacionados con Internet.• Vigile las excepciones que controla su aplicación escribiendo mensajes en el registro de seguimiento usando

los métodos Write y Warn del objeto Trace.•

Active el seguimiento a nivel de aplicación configurando los atributos del elemento <trace

> en el archivoWeb.config.• Active el seguimiento a nivel de página configurando el atributo Trace en la directiva Page de un formulario

Web.

6.5 Práctica: Añadir cont rol de excepciones a una aplicaciónEn esta práctica añadirá características de control de excepciones a la aplicación Contact Management ya

existente. Cuando se introdujo esta aplicación en el Capítulo 5 usaba algunos bloques de control de excepcione sen-cillos para enfrentarse a problemas que podían surgir al actualizar registros en la base de datos. Esta lección amplíaestos bloques para tratar con tipos concretos de errores de datos e implementa seguimiento para ver cómo se contro-lan los errores.

6.5.1 Ampliar el control de errores

La aplicación Contact Management trata con excepciones de base de datos de una forma muy sencilla: Si seencuentra una excepción muestra el error y deja que el usuario cancele la operación. Por ejemplo, vea el código parael suceso butAdd_Click del formulario AddContact, apartado 5.5.3, paso 8.



MCAD/MCSD

130

Para crear un control de excepciones más detallado edite las sentencias Catch/catch en la aplicación paracontrolar las siguientes excepciones posibles:

• ConstraintException. Esta excepción se produce si se viola la excepción de clave única de un conjunto dedatos. En la práctica esto puede suceder si dos usuarios añaden un contacto en el mismo instante y ambos ob-tienen el mismo ContactID. Cuando el segundo usuario intenta actualizar la base de datos se produce unaConstraintException porque el primero ya ha añadido un contacto con este Contactad. Para resolver esta si-tuación, obtenga otro ContactID e intente actualizar de nuevo, como se muestra a continuación.

Visual Basic .NET' Se produce si el ContactID no es único.Catch ex As ConstraintException

rowNew.ContactID = GetNewContactID() ' Obtiene otro ID.Try ' Intenta de nuevo.

adptContacts.Update(dsContacts)' Indica éxito.litStatus.Text = rowNew.FirstName & " " & rowNew.LastName & _

" añadido con éxito.<br>"Catch

litStatus.Text = "No se pudo añadir el registro. Pulse Añadir para " & _" intentar de nuevo o Cancelar para terminar."

End Try

Visual C#// Se produce si el ContactID no es único.catch (ConstraintException ex){

rowNew.ContactID = GetNewContactID(); // Obtiene otro ID.try{ // Intenta de nuevo.

adptContacts.Update(dsContacts);// Indica éxito.litStatus.Text = rowNew.FirstName + " " + rowNew.LastName +

" añadido con éxito.<br>";}catch

litStatus.Text = " No se pudo añadir el registro. Pulse Añadir para " +" intentar de nuevo o Cancelar para terminar.";

}

• DBConcurrencyException. Esta excepción se puede producir si un usuario intenta actualizar la base de da-

tos mientras otro usuario tiene acceso exclusivo. En este caso es mejor notificar al primer usuario que la ac-tualización no se ha realizado y permitir que vuelva a enviar los cambios, como muestra el código:

Visual Basic .NET' La base de datos puede estar bloqueada por otra sesión. Permite reintentar.Catch ex As DBConcurrencyException

litStatus.Text = "La base de datos está bloqueada. " & _"Espere unos segundos y pulse de nuevo Añadir."

Visual C#// La base de datos puede estar bloqueada por otra sesión. Permite reintentar.catch (DBConcurrencyException ex)

litStatus.Text = " La base de datos está bloqueada. " +_"Espere unos segundos y pulse de nuevo Añadir.";

•

DataException.

Es la excepción general para asuntos relacionados con datos. Controle esta excepción comoforma de interceptar problemas en los que puede que no haya pensado. El siguiente código muestra un men-saje al usuario y registra la excepción para verla en el registro como herramienta de diagnóstico.

Visual Basic .NET' Excepción de datos genérica, informa.Catch ex As DataException

litStatus.Text = "Se ha producido un error de base de datos:<br>" & _ex.Message & "<br>" & "Corrija el error y pulse Añadir para " & _

"añadir el contacto o pulse Cancel para terminar.<br>"Trace.Warn("Error", "Excepción de datos", ex)

End Try




131

Visual C#// Excepción de datos genérica, informa.catch(DataException ex){

litStatus.Text = " Se ha producido un error de base de datos:<br>" +ex.Message + "<br>" + " Corrija el error y pulse Añadir para " +

"añadir el contacto o pulse Cancel para terminar.<br>";Trace.Warn("Error", "Excepción de datos", ex);

}

Estos cambios en butAdd_Click dejan sin controlar las excepciones que no estén relacionadas con datos. Paracubrir los objetivos de esta práctica controlaremos estas posibles excepciones en sucesos de error.

6.5.2 Añadir un suceso de error Tras controlar las posibles excepciones de datos en el procedimiento de suceso butAdd_Click del formulario

Web AddContacts debe proporcionar una forma de controlar y registrar excepciones no anticipadas mediante el procedimiento de suceso Error . Esto sirve a dos cometidos:

• Impide que el usuario vea mensajes de error técnicos y los reemplaza por información más útil.• Mantiene información sobre excepciones no anticipadas en un registro que se puede usar como herramienta

de diagnóstico que le ayude a determinar si necesita controlar otras excepciones.

1. Añada al formulario Web un procedimiento de suceso Page_Error que trate con todas las demás excepcionesen la página. El siguiente código graba información sobre la excepción en el registro de seguimiento, crea un

mensaje de error para presentar y limpia el error de modo que la aplicación pueda continuar:Visual Basic .NETPrivate Sub Page_Error(ByVal sender As Object, ByVal e As _

System.EventArgs) Handles MyBase.Error' Escribe el error en el registro.Trace.Warn("Error", "Suceso de Error", Server.GetLastError())' Guarda un mensaje para mostrar como variable de sesión.Session("Error") = "<p>Se ha producido un error inesperado. " & _

"Intente de nuevo.</p>"' Limpia el error.Server.ClearError()' Vuelve a mostrar la página.

Response.Redirect("AddContact.aspx")End Sub


// Escribe el error en el registro.Trace.Warn("Error", "Suceso de Error", Server.GetLastError());// Guarda un mensaje para mostrar como variable de sesión.Session["Error"] = "<p> Se ha producido un error inesperado. " +

"Intente de nuevo.</p>";// Limpia el errorServer.ClearError();// Vuelve a mostrar la página.Response.Redirect("AddContact.aspx");

}

2. Modifique el procedimiento de suceso Page_Load para mostrar el mensaje de error que se ha grabado como

variable de sesión. Para ello añada a este suceso las líneas siguientes, al final del mismo, a continuación de lasentencia drpStates.DataBind() Visual Basic .NET

' Si ha habido un error sin controlar lo muestra.If Session("Error") <> "" Then

litStatus.Text = Session("Error")Session("Error") = Nothing ' Reinicia el mensaje de error.

End IfEnd Sub

Visual C#// Si ha habido un error sin controlar lo muestra.if(Session["Error"] != null){

litStatus.Text = Session["Error"].ToString();Session["Error"] = null; // Reinicia el mensaje de error.

}}



MCAD/MCSD

132

6.5.3 Crear y ver el registro de seguimientoLos ejercicios 1 y 2 escribieron en el registro de seguimiento mensajes que le ayudan a capturar errores no

anticipados cuando la gente empieza a usar su aplicación. Para hacer estos mensajes visibles active el seguimiento yañada a su aplicación un enlace para mostrar el registro de seguimiento.

1. Modifique el archivo Web.config para activar el seguimiento. El siguiente elemento < trace> activa el segui-miento, graba la salida como Trace.axd, aumenta el número de peticiones registradas a 20 y permite que elregistro se vea de forma remota.<trace enable="true" requestLimit="20" pageOutoput="false"

traceMode="SortByTime" localOnly="false" />2. Añada al formulario Web SwitchBoard un enlace para mostrar condicionalmente el registro de seguimiento.

El siguiente HTML crea el enlace como un control de servidor Hyperlink de modo que puede mostrarlo uocultarlo en tiempo de ejecución, dependiendo del valor del elemento <trace>.<asp:Hyperlink NavigateUrl="Trace.axd" ID="hypTrace" runat="server"

text="Ver registro de seguimiento" Visible="false"></asp:Hyperlink>3. Añada el siguiente código al procedimiento de suceso Page_Load del formulario Web SwitchBoard para

mostrar el enlace del registro de seguimiento.Visual Basic .NETPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.Load' Muestra el enlace de seguimiento si éste está activado.If Trace.IsEnabled Then

hypTrace.Visible = TrueEnd If

End Sub


// Muestra el enlace de seguimiento si éste está activado.if (Trace.IsEnabled) hypTrace.Visible = true;

}

6.5.4 Ampliar el control de excepciones a otros formularios WebHasta ahora esta práctica le ha mostrado cómo añadir control de excepciones paso a paso. Ahora es el mo-

mento de que lo haga por si mismo. Amplíe el control de excepciones a los formularios Calls, DeleteContact y Con-tactTypes. Estos formularios Web deben:

• Controlar las posibles excepciones de datos usando bloques de control de excepciones como se mostró en elejercicio 6.5.1.

• Añadir sucesos Error para capturar y registrar excepciones no anticipadas como se mostró en el ejercicio6.5.2.

Cuando termine compare sus resultados con la aplicación Contact Management incluida en el CD.



1. Explique por qué es importante el control de excepciones en una aplicación terminada.

2. Indique dos aproximaciones al control de excepciones en aplicaciones Web ASP.NET

3. Describa el cometido de la páginas de error y por qué son necesarias.

4. Explique por qué el seguimiento ayuda con el control de excepciones.




133

7 Programación avanzada de formularios WebEn este capítulo aprenderá cómo realizar algunas tareas de programación avanzada que no encajan con clari-

dad en ninguna otra categoría. Aunque puede crear aplicaciones Web sin conocer los temas que trata este capítulo,las lecciones que contiene son una parte importante de la corriente principal de la programación Web y le ayudarána completar su conjunto de habilidades.

Para completar las lecciones de este capítulo necesitará:

• Soltura en la creación de aplicaciones Web usando controles y código de servidor.• Tener alguna experiencia con un lenguaje de secuencias de comandos, como VBScript o JScript. Si nunca ha

usado un lenguaje de secuencias de comandos consulte los temas relativos a VBScript p JScript en la ayudaen línea de Visual Studio antes de comenzar con la lección 4 de este capítulo.

7.1 Guardar y recuperar información del usuarioLas aplicaciones Web que necesitan que los usuarios registren información pueden recuperar esta informa-

ción cada vez que un usuario concreto vuelve a visitar el sitio web. Por ejemplo, un sitio web de compras puederegistrar la información de envíos y facturación del cliente y recuperarla para utilizar los datos de dirección cada vezque el cliente hace un nuevo pedido.

7.1.1 Identificar usuarios de la aplicación WebLas aplicaciones Web pueden identificar a los usuarios exigiendo que introduzcan un nombre e usuario y una

contraseña cada vez que visitan el sitio Web. También pueden identificarlos mediante información almacenada ensus ordenadores en forma de cookies. Las Cookies son pequeños archivos que una aplicación web puede escribir enel ordenador cliente.

La ventaja de usar cookies es que la interacción es invisible al usuario. Los usuarios no tienen que registrarsecada vez que visitan el sitio Web; su información aparece automáticamente cuando es necesaria.

La desventaja es que los usuarios pueden configurar sus ordenadores para que no acepten cookies. A algunosusuarios no les gusta la idea de que los sitios Web almacenen información en sus ordenadores y posiblemente usenesta información para seguir sus movimientos en Internet. Por tanto, antes de intentar usar cookies hay que comprobar si el usuario las acepta.

Puede utilizar dos aproximaciones cuando almacene y recupere información mediante cookies:

•

Almacene toda la información del usuario en una cookie en la máquina cliente. Esta aproximación es útilcuando la información del usuario es sencilla y no es necesaria en el servidor para otras tareas.• Almacene una clave identificativa en la máquina cliente y recupere la información del usuario de un

origen de datos en el servidor usando esta clave. Es la mejor aproximación para almacenar informaciónmás amplia.

Las siguientes secciones describe cómo grabar y recuperar información del usuario usando estas aproxima-ciones.

7.1.2 Almacenar nformación de suario en el clientePara almacenar una cookie en la máquina cliente:

1. Compruebe si el cliente soporta cookies usando la propiedad Cookies del objeto Browser .2. Si el cliente soporta cookies, compruebe si ya existe usando la colección Cookies del objeto Request .

3. Si la cookie no existe aún cree un nuevo objeto cookie usando la clase HttpCookie.4. Configure las propiedades Value y Expiration del objeto cookie.5. Añada el objeto cookie a la colección Cookies del objeto Response.

El siguiente procedimiento de suceso Page_Load muestra los pasos anteriores creando una cookie que haceun seguimiento de la última visita del usuario a una página Web. El código comprueba si el usuario acepta cookies yañade una si es la primera vez que el usuario visita la página o la actualiza si ya la ha visitado antes.


ByVal e As System.EventArgs) Handles MyBase.Load' (1) Comprueba si el navegador acepta cookies.If Request.Browser.Cookies Then

' (2) Si la cookie no existe...If Request.Cookies("LastVisit") Is Nothing Then

' (3) Crea la cookie.Dim cookLastVisit As New HttpCookie("LastVisit", Now.ToString())



MCAD/MCSD

134

' (4) Configura la expiración a mañana.cookLastVisit.Expires = DateTime.Now.AddDays(1)' (5) Añade a la colección de cookies.Response.Cookies.Add(cookLastVisit)' Muestra un mensaje.Response.Write("Esta es su primera visita.")

Else' Obtiene la cookie.Dim cookLastVisit As HttpCookie = Request.Cookies("LastVisit")

' Muestra un mensaje con la hora de la última visita.Response.Write("Su última visita a la página fue en: " & _

cookLastVisit.Value)' Actualiza la cookie en el cliente.Response.Cookies("LastVisit").Value = Now.ToString()Response.Cookies("LastVisit").Expires = DateTime.Now.AddDays(1)

End IfElse

Response.Write("Su navegador no acepta cookies.")End If

End Sub


// (1) Comprueba si el navegador acepta cookies.

if (Request.Browser.Cookies){// (2) Si la cookie no existe...if (Request.Cookies["LastVisit"] == null){

// (3) Crea la cookie.HttpCookie cookLastVisit = new HttpCookie("LastVisit",

DateTime.Now.ToString());// (4) Configura la expiración a mañana.cookLastVisit.Expires = DateTime.Now.AddDays(1);// (5) Añade a la colección de cookies.Response.Cookies.Add(cookLastVisit);// Muestra un mensaje.Response.Write("Esta es su primera visita.");

}else {// Obtiene la cookie.

HttpCookie cookLastVisit = Request.Cookies["LastVisit1"];// Muestra un mensaje con la hora de la última visita.Response.Write("Su última visita a la página fue en: " +

cookLastVisit.Value);// Actualiza la cookie en el cliente.Response.Cookies["LastVisit"].Value = DateTime.Now.ToString();Response.Cookies["LastVisit"].Expires = DateTime.Now.AddDays(1);

}}else

Response.Write("Su navegador no acepta cookies.");}

Sobre las cookiesLas cookies diferencian mayúsculas y minúsculas. Por ejemplo, LastVisit no es la misma cookie que ulti-

maVisita. La propiedad Expires determina cuándo puede la máquina cliente descartar la cookie. De forma prede-terminada, las cookies expiran cuando termina la sesión de un usuario. Si se da a Expires el valor DateTi-me.MaxValue la cookie nunca expira.

Puede eliminar una cookie de la máquina cliente dando a Expires el valor de la hora actual. Por ejemplo,el siguiente código elimina la cookie LastVisit de la máquina cliente.

Visual Basic .NETPrivate Sub butRemoveCookie_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butRemoveCookie.Click' Configura la cookie para expiración inmediata.Response.Cookies("LastVisit").Expires = DateTime.Now

End Sub

Visual C#

private void butRemoveCookie_Click(object sender, System.EventArgs e){// Configura la cookie para expiración inmediata.Response.Cookies["LastVisit"].Expires = DateTime.Now;

}




135

Uso de claves dentro de cookiesPuede grabar hasta 4096 bytes de información en una única cookie, y puede identificar información de-

ntro de una cookie usando claves. Por ejemplo, el siguiente código guarda información de nombre y direccióndel usuario como cookie con claves individuales.


ByVal e As System.EventArgs) Handles butOK.Click' Crea una cookie.

Dim cookUserInfo As New HttpCookie("UserInfo")' Rellena las claves con los datos del formulario.cookUserInfo("FirstName") = txtFirstName.TextcookUserInfo("LastName") = txtLastName.TextcookUserInfo("Street") = txtStreet.TextcookUserInfo("City") = txtCity.TextcookUserInfo("State") = drpState.SelectedItem.ValuecookUserInfo("ZIP") = txtZIP.Text' Configura la caducidad.cookUserInfo.Expires = DateTime.Now.AddDays(30)' Añade la cookie.Response.Cookies.Add(cookUserInfo)

End Sub


// Crea una cookie.HttpCookie cookUserInfo = new HttpCookie("UserInfo");// Rellena las claves con los datos del formulario.cookUserInfo["FirstName"] = txtFirstName.Text;cookUserInfo["LastName"] = txtLastName.Text;cookUserInfo["Street"] = txtStreet.Text;cookUserInfo["City"] = txtCity.Text;cookUserInfo["State"] = drpState.SelectedItem.Value;cookUserInfo["ZIP"] = txtZIP.Text;// Configura la caducidad.cookUserInfo.Expires = DateTime.Now.AddDays(30);// Añade la cookie.Response.Cookies.Add(cookUserInfo);

}Para obtener los valores de las claves almacenadas en una cookie sencillamente use el nombre de la clave,

como muestra el código siguiente:

Visual Basic .NETPrivate Sub butGetData_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butGetData.Click' Obtiene la cookie.Dim cookUserInfo As HttpCookie = Request.Cookies("UserInfo")' Rellena los campos.txtFirstName.Text = cookUserInfo("FirstName")txtLastName.Text = cookUserInfo("LastName")txtStreet.Text = cookUserInfo("Street")txtCity.Text = cookUserInfo("City")

drpState.SelectedItem.Value = cookUserInfo("State")txtZIP.Text = cookUserInfo("ZIP")End Sub

Visual C#private void butGetData_Click(object sender, System.EventArgs e){

// Obtiene la cookie.HttpCookie cookUserInfo = Request.Cookies["UserInfo"];// Rellena los campos.txtFirstName.Text = cookUserInfo["FirstName"];txtLastName.Text = cookUserInfo["LastName"];txtStreet.Text = cookUserInfo["Street"];txtCity.Text = cookUserInfo["City"];drpState.SelectedItem.Value = cookUserInfo["State"];txtZIP.Text = cookUserInfo["ZIP"];

}



MCAD/MCSD

136

7.1.3 Almacenar información de usuario en el servidor Para almacenar información del usuario en el servidor en lugar de la máquina cliente utilice cookies como

dispositivo de identificación para almacenar y recuperar información del usuario en el servidor. Puede almacenar información del usuario en el servidor usando una base de datos, un archivo XML o cualquier otro tipo de almacénde datos.

Para almacenar información del usuario en el servidor siga estos pasos

1. Cree una clave única para identificar al usuario.2. Grabe la clave única en el ordenador del usuario como cookie3. Cree un archivo en el servidor para almacenar la información del usuario4. Grabe la información del usuario en el servidor usando la clave única como índice.

7.1.4 Crear claves únicas para identificar usuariosEl marco de trabajo Microsoft .NET proporciona un espacio de nombres System.GUID para crear identifica-

dores únicos globales (Globally Unique Identifier, GUID). Un GUID es un entero de 128 bits que sirve como identi-ficador único entre redes. Puede usar los GUID como claves únicas para identificar todo tipo de cosas, incluyendousuarios.

El siguiente código crea un GUID y lo almacena como cookie en la máquina cliente.

Visual Basic .NET

Private Sub butOK_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butOK.Click' Obtiene la cookie de la petición.

Dim cookUserID As HttpCookie = Request.Cookies("UserID")' Si no existe, la crea.If cookUserID Is Nothing Then

' Crea una nueva cookie con un nuevo GUID.cookUserID = New HttpCookie("UserID", System.Guid.NewGuid().ToString())cookUserID.Name = "UserID"

End If' Configura la caducidad.cookUserID.Expires = DateTime.Now.AddDays(30)' Añade la cookie a la respuesta.Response.Cookies.Add(cookUserID)' Graba la información del usuario de los datos del formulario.

SetUserInfo(cookUserID.Value)End Sub


// Obtiene la cookie de la petición.HttpCookie cookUserID = Request.Cookies["UserID"];// Si no existe, la crea.if (cookUserID == null)

// Crea una nueva cookie con un nuevo GUID.cookUserID = new HttpCookie("UserID", System.Guid.NewGuid().ToString());

// Configura la caducidad.cookUserID.Expires = DateTime.Now.AddDays(30);// Añade la cookie a la respuesta.Response.Cookies.Add(cookUserID);// Graba la información del usuario de los datos del formulario.SetUserInfo(cookUserID.Value);

}

7.1.5 Crear un archivo para guardar información del usuarioLa utilidad de guardar información de usuario es ser capaz de recuperar esta información rápidamente la si-

guiente vez que el usuario visite la aplicación Web. Como estos usuarios ya están identificados por una clave única(el GUID creado en la sección anterior) tiene sentido intentar acceder a sus datos mediante un conjunto de datos.Los conjuntos de datos incluyen un método Find para recuperar filas de datos mediante su clave única.

Usar un conjunto de datos significa que el archivo creado en el servidor debe ser una base de datos o un ar-chivo XML. XML proporciona una forma de guardar datos estructurados en un archivo sin la complejidad o sobre-carga de una base de datos, de modo que para algo tan sencillo como información de nombre y dirección de un usua-

rio resulta más rentable.Para crear un archivo XML para almacenar información de usuario siga estos pasos:




137

1. Cree en Visual Studio un archivo XML que contenga datos de prueba para cada uno de los campos que quie-ra registrar sobre el usuario.

2. Genere un esquema XML para el archivo. El esquema XML permite que el conjunto de datos haga referenciaa los datos contenidos en el archivo por su nombre.

3. Especifique un campo clave dentro del esquema XML. Esto permite encontrar los registros usando este campo con el método Find del conjunto de datos.

4. Lea el esquema y el archivo XML en un conjunto de datos.

7.1.6 Crear un archivo XMLPara crear un archivo XML en Visual Studio seleccione Agregar Nuevo Elemento en el menú Proyecto y se-leccione Archivo XML en la lista Plantillas.

Los archivos XML son muy parecidos a archivos HTML; sin embargo, los elementos y atributos XML dife-rencian mayúsculas y minúsculas y usan una sintaxis estricta. Para identificar elementos de datos en un archivoXML se usan las etiquetas <elemento> y </elemento>. El siguiente ejemplo muestra un archivo XML para almace-nar información del nombre y dirección del usuario.

<?xml version="1.0" standalone="yes"?><USERS xmlns="http://tempuri.org/UserPrefs.xsd">

<USER><FIRSTNAME>Joan</FIRSTNAME><LASTNAME>Reddington</LASTNAME>

<STREET>436 Atlantic Ave.</STREET><CITY>Melbourne Beach</CITY><STATE>FL</STATE><ZIP>32401</ZIP><ID>79844302-6d86-4520-ac64-c8c3240e21a9</ID>

</USER></USERS>

7.1.7 Crear un esquema XMLPara usar un archivo XML con un conjunto de datos debe crear primero un esquema XML para el conjunto

de datos. Un esquema XML es una descripción de los elementos de datos que contiene el archivo XML. Proporcio-na los nombres de los elementos, sus tipos, si hay campo clave y otra información.

Para crear un esquema XML a partir de un archivo XML seleccione Crear esquema en el menú XML mien-

tras se está mostrando el archivo XML en la ventana de diseño. Visual Studio crea un archivo de esquema que des-cribe el archivo XML.

7.1.8 Especificar un campo claveA un archivo XML se le añade una clave principal para permitir búsquedas. Siga estos pasos:

1. Pulse con el botón derecho sobre el elemento que será la clave, seleccione Agregar y Nueva clave. VisualStudio muestra el diálogo Editar clave.

2. Seleccione la marca Clave principal del conjunto de datos y pulse Aceptar. Esto permite usar el método Find del objeto DataSet para recuperar filas del conjunto de datos usando el valor de este elemento.

7.1.9 Leer XML en un conjunto de datosCuando se ha creado esquema y un archivo XML puede leer estos archivos en un conjunto de datos usando

los métodos ReadXmlSchema y ReadXml. El siguiente código muestra una función auxiliar que devuelve un conjun-to de datos creado a partir del archivo UserInfo.

Visual Basic .NETFunction GetUserData() As DataSet

' Configura la ruta del archivo y esquema XML.Dim strPath As String = Server.MapPath(Request.ApplicationPath)' Declara un conjunto de datos.Dim dsUsers As New DataSet()' Aplica el esquema XML al conjunto de datos.dsUsers.ReadXmlSchema(strPath & "\UserInfo.xsd")' Lee el XML en el conjunto de datos.dsUsers.ReadXml(strPath & "\UserInfo.xml")Return dsUsers

End Function



MCAD/MCSD

138

Visual C#private DataSet GetUserData(){

// Configura la ruta del archivo y esquema XML.string strPath = Server.MapPath(Request.ApplicationPath);// Declara un conjunto de datos.DataSet dsUsers = new DataSet();// Aplica el esquema XML al conjunto de datos.dsUsers.ReadXmlSchema(strPath + "\\UserInfo.xsd");// Lee el XML en el conjunto de datos.

dsUsers.ReadXml(strPath + "\\UserInfo.xml");return dsUsers;

}

7.1.10 Guardar información del usuario en el servidor Para guardar información del usuario en el servidor dentro de un archivo XML use el método SaveXML del

objeto conjunto de datos. El siguiente procedimiento SetUserInfo usa el procedimiento GetUserData de la secciónanterior para obtener un conjunto de datos de un archivo XML y después usa el método Find para averiguar si el IDde usuario existe en el conjunto de datos. Si no lo encuentra, añade una fila para el usuario antes de configurar losvalores de los campos de esta fila a partir de los controles de servidor de un formulario Web. Finalmente, escribetodo el conjunto de datos de vuelta al servidor.

Visual Basic .NETSub SetUserInfo(ByVal UserID As String)

' Configura la ruta del archivo y del esquema XML.Dim strPath As String = Server.MapPath(Request.ApplicationPath())' Obtiene el conjunto de datos de usuarios.Dim dsUsers As DataSet = GetUserData()' Localiza la fila en el conjunto de datos.Dim rowUser As DataRow = dsUsers.Tables("User").Rows.Find(UserID)' Si no encuentra la fila crea una nueva.If rowUser Is Nothing Then

rowUser = dsUsers.Tables("User").NewRowdsUsers.Tables("User").Rows.Add(rowUser)

End If' Graba datos de los campos.rowUser("FirstName") = txtFirstName.TextrowUser("LastName") = txtLastName.Text

rowUser("Street") = txtStreet.TextrowUser("City") = txtCity.TextrowUser("State") = drpState.SelectedItem.TextrowUser("ZIP") = txtZIP.TextrowUser("ID") = UserID' Escribe el XML desde el conjunto de datos.dsUsers.WriteXml(strPath & "\UserInfo.xml")

End Sub

Visual C#private void SetUserInfo(string UserID){

// Configura la ruta del archivo y del esquema XML.string strPath = Server.MapPath(Request.ApplicationPath);// Obtiene el conjunto de datos de usuarios.DataSet dsUsers = GetUserData();

// Localiza la fila en el conjunto de datos.DataRow rowUser = dsUsers.Tables["User"].Rows.Find(UserID);// Si no encuentra la fila crea una nueva.if (rowUser == null){

rowUser = dsUsers.Tables["User"].NewRow();dsUsers.Tables["User"].Rows.Add(rowUser);

}// Graba datos de los campos.rowUser["FirstName"] = txtFirstName.Text;rowUser["LastName"] = txtLastName.Text;rowUser["Street"] = txtStreet.Text;rowUser["City"] = txtCity.Text;rowUser["State"] = drpState.SelectedItem.Text;rowUser["ZIP"] = txtZIP.Text;rowUser["ID"] = UserID;// Escribe el XML desde el conjunto de datos.dsUsers.WriteXml(strPath + "\\UserInfo.xml");

}




139

7.1.11 Recuperar información de usuario del DataSetPara recuperar información de usuario del archivo XML use el procedimiento GetUserData para crear un

conjunto de datos a partir del archivo XML, y use el método Find para recuperar la fila que corresponde al ID delusuario. El siguiente procedimiento GetUserInfo recupera información del conjunto de datos y la usa para rellenar los controles de servidor en un formulario Web.

Visual Basic .NETSub GetUserInfo(ByVal UserID As String)

' Obtiene el conjunto de datos de usuarios.Dim dsUsers As Data.DataSet = GetUserData()' Localiza la fila en el conjunto de datos.Dim rowUser As Data.DataRow = dsUsers.Tables("User").Rows.Find(UserID)' Si no encuentra el usuario, sale.If rowUser Is Nothing Then Exit Sub' Añade datos a los campos del formulario.txtFirstName.Text = rowUser.Item("FirstName")txtLastName.Text = rowUser.Item("LastName")txtStreet.Text = rowUser.Item("Street")txtCity.Text = rowUser.Item("City")drpState.SelectedItem.Text = rowUser.Item("State")txtZIP.Text = rowUser.Item("ZIP")

End Sub

Visual C#void GetUserInfo(string UserID){

// Obtiene el conjunto de datos de usuarios.DataSet dsUsers = GetUserData();// Localiza la fila en el conjunto de datos.DataRow rowUser = dsUsers.Tables["User"].Rows.Find(UserID);// Si no encuentra el usuario, sale.if (rowUser == null) return;// Añade datos a los campos del formulario.txtFirstName.Text = rowUser["FirstName"].ToString();txtLastName.Text = rowUser["LastName"].ToString();txtStreet.Text = rowUser["Street"].ToString();txtCity.Text = rowUser["City"].ToString();drpState.SelectedItem.Text = rowUser["State"].ToString();

txtZIP.Text = rowUser["ZIP"].ToString();}

7.2 Enviar correoPuede enviar correo desde una aplicación Web de dos formas distintas, dependiendo de desde donde quiere

enviarlo.

• Usar el protocolo mailto: para enviar correo desde el cliente. Esta técnica usa el sistema de correo delcliente y es útil para obtener realimentación para un sitio Web, proporcionar soporte técnico u otras tareasque precisan una respuesta al correo del usuario.

• Usar las clases MailMessage y SmtpMail para enviar corro desde el servidor. Esta técnica usa el sistemade correo del servidor, que es útil para informe de errores automatizado, crear correo anónimo u otras tareasque no necesariamente precisan una dirección de correo para respuesta del cliente.

7.2.1 Enviar correo desde un clientePara enviar correo usando el sistema de correo del cliente cree un enlace usando el protocolo mailto. Por

ejemplo, el siguiente HTML muestra un enlace que crea un nuevo mensaje con una línea de asunto y un cuerpo demensaje:

<A href="mailto:[email protected]?SUBJECT=Envío desde un cliente&BODY=Cuerpode texto del mensaje.">Enviar correo</A>

Cuando el usuario pulsa sobre el enlace el navegador abre la aplicación de correo y crea un mensaje.

Puede usar el protocolo mailto en lugar de cualquier URL de destino en un control de servidor o HTML. Por ejemplo, el siguiente HTML define un control de servidor Hyperlink que envía un mensaje de correo.

<asp:HyperLink ID="hypMail" NavigateUrl="mailto:[email protected]?SUBJECT=Correo desde un Formulario Web;BODY=Cuerpo del mensaje." Runat="server">

Enviar correo.</asp:HyperLink>

También puede usar el protocolo mailto como parte de un método Redirect en código, pero tiene el efecto se-cundario de mostrar una página en blanco en el navegador a la vez que crea el mensaje de correo.



MCAD/MCSD

140

Las partes del mensaje de correo se especifican usando la claves que soporta el protocolo mailto. Estas clavesse incluyen dentro de una cadena de consulta, separadas por ampersands (&), y son las que se describen en la tabla7.1

Tabla 7. 1: Claves soportadas por el protocolo mailtoClave Especifica

SUBJECT Texto que aparece en la línea de asunto del mensajeCC Lista de direcciones a las que copiar el mensaje. Si hay varias direcciones se separan con punto y coma (;)BCC Lista de direcciones a las que enviar copia ciega del mensaje. Si hay varias direcciones se separan con punto y coma

(;)BODY Texto del mensaje

El protocolo mailto no proporciona una clave para anexar archivos; sin embargo, el usuario puede anexarlosmanualmente cuando se abra la ventana de mensaje. Si quiere que el usuario anexe un archivo (como un registro deerror o algún otro informe), coloque las instrucciones correspondientes en el cuerpo del mensaje.

7.2.2 Enviar correo desde el servidor Cuando se envía correo desde el servidor ASP.NET no arranca el sistema de correo del cliente para permitir

que el usuario componga el mensaje a enviar, añadir anexos o validar direcciones. El mensaje se compone mediantecódigo y se envía de una de dos formas.

• Puede enviar un mensaje sencillo usando el método Send de la clase SmtpMail.• Puede crear un mensaje más complejo usando la clase MailMessage y enviar el mensaje usando el método

Send de SmtpMail.Ambas clases, SmtpMail y MailMessage, son parte del espacio de nombres System.Web.Mail del marco de

trabajo .NET, de modo que tendrá que añadir una referencia al mismo ( Imports o using) al mismo al inicio de sumódulo para facilitar el acceso.

No es necesario crear una instancia de la clase SmtpMail antes de usarla. Para enviar un mensaje sencillo bas-ta con usar el método Send :

Visual Basic .NETSmtpMail.Send ("[email protected]", "[email protected]",

"Línea de Asunto", "Texto del mensaje.")

Visual C#SmtpMail.Send ("[email protected]", "[email protected]",

"Línea de Asunto", "Texto del mensaje.");La línea de código precedente envía inmediatamente un mensaje desde [email protected] a jes-

[email protected]. Estos dos valores, de y a son necesarios, aunque el método Send no los valida. La clase SmtpMail envía correo usando el servidor SMTP local de forma predeterminada. Para usar un servidor diferente configure la propiedad SmtpServer .

El método Send por si solo es adecuado para mensajes de texto sencillos, pero para enviar un mensaje conformato o con anexos necesita crear un objeto basado en la clase MailMessage y usar el método Send de SmtpMail para enviarlo, como en el código siguiente.

Visual Basic .NETPrivate Sub butMail_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butMail.ClickDim mailNew As New MailMessage() ' Crea el mensaje.

mailNew.From = "[email protected]" ' Configura las propiedades.mailNew.To = "[email protected]"mailNew.Subject = "Este es el texto del asunto."mailNew.Body = "Este es el texto del mensaje."Dim atcItem As New _ ' Crea un anexo.

MailAttachment(Server.MapPath(Request.ApplicationPath) & "\joey.jpg")mailNew.Attachments.Add(atcItem) ' Lo anexa al mensaje.SmtpMail.Send(mailNew) ' Envía el mensaje.

End Sub




141

Visual C#private void butSendMail_Click(object sender, System.EventArgs e){

MailMessage mailNew = new MailMessage(); // Crea el mensaje.mailNew.From = "[email protected]"; // Configura las propiedades.mailNew.To = "[email protected]";mailNew.Subject = " Este es el texto del asunto.";mailNew.Body = " [email protected].";MailAttachment atcItem = new MailAttachment // Crea un anexo.

(Server.MapPath(Request.ApplicationPath) + "\\joey.jpg");

mailNew.Attachments.Add(atcItem); // Lo anexa al mensaje.SmtpMail.Send(mailNew); // Envía el mensaje.

}

El código anterior crea un mensaje, configura sus propiedades, le anexa un archivo y lo envía. Como en elejemplo anterior con Send , las propiedades From y To son obligatorias, pero no se validan.

7.3 Uso de marcosLos marcos son partes de una página Web que puede usar ara mostrar otras páginas Web. Se usan marcos

para mostrar varias regiones que se desplazan y comportan de forma independiente entre si. En esta lección aprende-rá cómo crear marcos con Visual Studio y cómo controlar los marcos.

7.3.1 Crear marcos en Visual Studio

Para crear marcos en Visual Studio siga estos pasos:1. Cree un conjunto de marcos2. Cree las páginas que mostrará en los marcos3. Configure la página web para que muestre los marcos en el conjunto de marcos

7.3.2 Crear un conjunto de marcosPara crear un conjunto de marcos en Visual Studio siga estos pasos:

1. En el menú Proyecto, seleccione Agregar nuevo elemento, Visual Studio muestra el diálogo Agregar nuevoelemento.

2. En la lista de plantillas seleccione Conjunto de marcos, escriba el nombre de la página Web en el cuadro Nombre y pulse Abrir. Visual Studio muestra el diálogo Seleccione una plantilla de conjunto de marcos.

3. Seleccione el tipo de marcos que quiere crear y pulse Aceptar. Visual Studio crea la página Web como archi-

vo htm y la abre en el diseñador.

7.3.3 Crear páginas y añadirlas al conjunto de marcosDespués de crear el conjunto de marcos puede mostrar páginas HTML o formularios Web en cada uno de los

marcos del conjunto. Aunque los conjuntos de trabajo son archivos HTML las páginas que se muestren dentro deellos pueden ser tanto HTML como formularios Web.

Después de crear las páginas que va a mostrar en los marcos asocie cada marco con una página:

1. Pulse con el botón derecho sobre el marco que quiere asociar con una página y seleccione Establecer página para marco. Visual Studio muestra el diálogo Página de selección.

2. Seleccione en la lista Contenido la página que quiere mostrar y pulse Aceptar. Visual Studio añade la página seleccionada al marco.

3. Repita los pasos 1 y 2 para cada uno de los marcos. Cuando termine, el conjunto de marcos mostrará

cada una de las páginas en el marco correspondiente.Visual Studio no puede mostrar correctamente el formulario Web en el conjunto de marcos en modo de dise-

ño – los marcos aparecerán con mensajes de error o con controles extraños. Sin embargo, en tiempo de ejecución semostrará correctamente.

Puede ver el marco de trabajo en tiempo de ejecución de dos formas:

• Establecer el conjunto de marcos como página de inicio de la aplicación Web e iniciar la aplicación.• Navegar al conjunto de marcos en tiempo de ejecución desde un enlace o usando el método Redirect en el

código.

7.3.4 Comprobar el soporte del navegador para marcosAntes de empezar a hacer un uso intensivo de marcos en su aplicación debe saber que las primeras versiones

de algunos navegadores no los soportaban. Si un cliente que utiliza uno de estos navegadores solicita una página quecontiene marcos el navegador mostrará una página en blanco o se bloqueará.



MCAD/MCSD

142

Para detectar si un navegador soporta marcos antes de mostrar un conjunto de marcos use la propiedad Fra-mes del objeto Browser . Por ejemplo, el siguiente código muestra o un conjunto de marcos o una página HTMLsencilla, dependiendo del soporte para marcos del navegador.

Visual Basic .NETPrivate Sub butDisplayPage_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butDisplayPage.Click' Si el navegador cliente soporta marcos muestra el conjunto de marcos.If Request.Browser.Frames Then

Server.Transfer("frames.htm")' Si no, muestra una versión diferente.Else

Server.Transfer("noframes.htm")End If

End Sub

Visual C#private void butDisplayPage_Click(object sender, System.EventArgs e){

// Si el navegador cliente soporta marcos muestra el conjunto de marcos.if (Request.Browser.Frames)

Server.Transfer("frames.htm");// Si no, muestra una versión diferente.else

Server.Transfer("noframes.htm");

}

También puede crear contenido alternativo dentro de <HTML> según el soporte para marcos usando el ele-mento <NOFRAMES>. Este elemento lo soporta Internet Explores en versiones 3.0 y posteriores y es parte de laespecificación HTML 4.0.

El código que genera Visual Studio cuando se crea un conjunto de marcos contiene automáticamente un ele-mento <NOFRAMES> de esta forma:

<frameset rows="64,*"><frame name="banner" src="Banner.aspx" scrolling="no" noresize><frameset cols="150,*">

<frame name="contents" src="Contents.aspx"><frame name="main" src="Body.aspx">

</frameset>

<noframes><p>This HTML frameset displays multiple Web pages. To view thisframeset, use a Web browser that supports HTML 4.0 and later.</p>

</noframes></frameset>

Puede modificar el texto para proporcionar contenido alternativo o una versión sin marcos de la página.

7.3.5 Apuntar a un marco desde un enlaceCada marco de un conjunto de marcos actúa como una ventana de navegador independiente. Una vez que se

muestra una página en un marco los enlaces de esta página se muestran dentro del mismo marco.

Para enlazar entre páginas mostradas en marcos añada un atributo TARGET al enlace. Por ejemplo, el si-guiente HTML muestra unas serie de enlaces dirigidos al marco principal (“main”) del conjunto:

<h3>Contenido</h3><P><A href="Cuerpo1.aspx" target="main">Cuerpo 1</A></P><P><A href="Cuerpo2.aspx" target="main">Cuerpo 1</A></P><P><A href="Cuerpo3.aspx" target="main">Cuerpo 1</A></P>

Cuando se pulsa sobre alguno de estos enlaces el contenido del marco llamado “main” cambia.

No se puede apuntar a un marco usando Redirect , Transfer o Execute en el código. Para navegar entre marcossolo puede usar enlaces HTML o controles de servidor Hyperlink.

7.4 Secuencias de comandos de clienteASP.NET proporciona un conjunto completo de herramientas de programación para crear aplicaciones Web

que corren en el servidor, de modo que ¿por qué preocuparse de las secuencias de comandos en el cliente?. Porquelas secuencias de comandos tienen acceso directo al navegador del cliente, lo que hace posible hacer cosas que no se

pueden hacer desde el servidor. Por ejemplo, puede usar secuencias de comandos de cliente para:

143

• Controlar la ventana del navegador. No puede controlar el navegador desde el código de servidor. Paraabrir nuevas ventanas, establecer el foco dentro de una ventana, navegar entre marcos, navegar dentro delhistorial y ejecutar otras tareas relacionadas con el navegador debe usar secuencias de comandos de cliente.

• Responder inmediatamente a sucesos de paso del ratón. El código de servidor solo puede responder a su-cesos después de que se envíe la página al servidor; el código de cliente puede responder a los sucesos de pá-gina cuando se producen.

• Iniciar el sistema de correo del cliente. Vea la lección 2 de este capítulo.

En esta lección aprenderá cómo añadir secuencias de comandos a formularios Web y páginas HTML en Vi-sual Studio para crear código que se ejecute en el ordenador cliente.

7.4.1 Antes de usar secuencias de comandosLas secuencias de comandos de cliente causan tres temas de los que hay que estar precavidos.

• No todos los navegadores soportan secuencias de comandos.• Solo Internet Explorer soporta VBScript.• Las secuencias de comandos provocan problemas de seguridad.

Como no todos los navegadores soportan secuencias de comandos, debe comprobar las posibilidades del na-vegador antes de mostrar páginas que contengan secuencias de comandos de cliente. El siguiente procedimiento desuceso Page_Load comprueba si un navegador soporta secuencias de comandos y si no lo hace redirige a los usua-rios a una página que recomienda la descarga de una nueva versión.


ByVal e As System.EventArgs) Handles MyBase.LoadIf Request.Browser.VBScript Then

Response.Redirect("VBScripts.htm")Exit Sub

ElseIf Request.Browser.JavaScript ThenResponse.Redirect ("JScripts.htm")

ElseResponse.Redirect("NoScripts.htm")

End IfEnd Sub

Visual C#

private void Page_Load(object sender, System.EventArgs e){if (Request.Browser.VBScript) Response.Redirect("VBScripts.htm");else if (Request.Browser.JavaScript) Response.Redirect("JScripts.htm");else Response.Redirect("NoScripts.htm");

}

Otro tema a tener en cuenta con las secuencias de comandos de cliente es la seguridad. Este tema tiene dosaspectos. Primero, las secuencias de comandos no son seguras – las puede ver o copiar cualquiera que visite la apli-cación. Segundo, las secuencias de comandos pueden potencialmente transmitir virus; por tanto, algunos usuariosconfiguran sus navegadores para que desactiven las secuencias de comandos.

Las propiedades VBScript y JavaScript del objeto Browser devolverán True incluso aunque se desactiven lassecuencias de comandos. Para comprobar si están activadas hay que ser un poco listo. El siguiente HTML comprueba si las secuencias de comandos están activadas intentando ejecutar una. Si están activadas se redirige al usuario a

otra página y nunca ve el mensaje:<html>

<script>window.navigate("scripts.aspx")

</script><head>

<title>Scripts</title></head><body MS_POSITIONING="FlowLayout">

<h2>Secuencias de Comandos Desactivadas.</h2><p>Sus opciones de seguridad especifican que su navegador no ejecutesentencias de comandos, por tanto no podrá ver la página solicitada.Reactive las secuencias de comandos e inténtelo de nuevo.</p>

</body></html>



MCAD/MCSD

144

7.4.2 Seleccionar un lenguaje de secuencias de comandosLas secuencias de comandos se pueden escribir en VBScript o en JScript. Los lenguajes de secuencias de

comandos se diferencias de los compilados, como Visual Basic .NET o C#, en:

• No son compilados. Los interpreta el navegador en tiempo de ejecución.• Son un “subconjunto seguro” de su lenguaje madre. No permiten crear o borrar archivos en el disco del

usuario ni realizar tareas con riesgo evidente de colgar el ordenador del usuario..

VBScript y JScript con funcionalmente equivalentes – sediferencian solo en la sintaxis y las palabras clave. En general,los programadores de C# están más cómodos usando JScript porque sigue los convenios de C; los programadores VisualBasic están más cómodos con VBScript porque están muy rela-cionados. Sin embargo, solo Internet Explorer soporta VBScript, por lo que si su aplicación tiene que correr en otros navegadoresdeberá usar JScript.

Si es programador de Visual Basic probablemente no legustará el hecho de que JScript diferencia mayúsculas y minús-culas. En JScript todas las palabras clave, variables, referenciasa objeto, métodos y propiedades se deben escribir usando co-rrectamente mayúsculas y minúsculas.

Para más información sobre lenguajes de secuencia decomandos vea los temas de la ayuda de Visual Basic relativos aJScript y VBScript.

7.4.3 DOMEl modelo de objetos de documento (DOM, Document

Object Model) se compone de los objetos que proporciona elnavegador para usar en las secuencias de comandos. Estos obje-tos permiten controlar la ventana del navegador, la página (odocumento) actual y objetos de la página. La figura 7.1 muestralos objetos que proporciona DOM.

La explicación de todos los objetos en DOM está fueradel alcance de este libro. Sin embargo, hay una gran cantidad deinformación en el tema de Referencia DHTML de la ayuda deVisual Studio. Este tema y las referencias a las que enlaza son parte de la ayuda en línea de Web Workshop.

7.4.4 Añadir secuencias de comandos en líneaLas páginas Web pueden incluir secuencias de comandos en línea como parte de su contenido o como proce-

dimientos que se ejecutan en respuesta a sucesos. Las secuencias de comandos en línea se ejecutan en el momentoen que el navegador las encuentra. El último ejemplo de la sección anterior 7.4.1 muestra este funcionamiento redi-rigiendo al navegador a una nueva página si permite secuencias de comandos. Si se ejecuta correctamente la secuen-cia de comandos el usuario nunca ve el mensaje relativo a la desactivación de secuencias de comandos.

Si una secuencia de comandos en línea hace referencia a un elemento de la página este elemento debe apare-cer antes de que la secuencia de comandos lo nombre. Por ejemplo, el siguiente HTML muestra dos cajas de texto yusa una secuencia de comandos para mover el cursor a la segunda.

VBScript<HTML>

<body language="vbscript"><form id="Form1" method="post" runat="server">

<P><asp:TextBox id="txtFirstName" Runat="server"></asp:TextBox></P><P><asp:TextBox id="txtLastName" Runat="server"></asp:TextBox></P><script>window.document.all("txtLastName").focus()</script>

</form></body>

</HTML>

Fig 7. 1: J erarquía de Objetos DOM

145

JScript<HTML>

<body language="javascript"><form id="Form1" method="post" runat="server">

<P><asp:TextBox id="txtFirstName" Runat="server"></asp:TextBox></P><P><asp:TextBox id="txtLastName" Runat="server"></asp:TextBox></P><script>window.document.all["txtLastName"].focus()</script>

</form></body>

</HTML>

Las secuencias de comandos en línea también se pueden usar como atributos de elementos HTML que ejecu-tan acciones, como el control HTML Button. Por ejemplo, el siguiente HTML crea un botón que abre una página deayuda en una nueva ventana.

<button id="butHelp" onclick="window.open('help.aspx', 'help','height=200,width=300')">Ayuda</button>

Observe que la secuencia de comandos anterior es independiente de lenguaje. En otras palabras, funcionarátanto si el atributo language del elemento <body> es VBScript como si es JScript. Para usar un lenguaje de secuen-cia de comandos diferente al establecido en el elemento <body> debe usar el atributo language del elemento<script >. Por ejemplo, la siguiente secuencia de comandos muestra una lista de niveles de encabezado:

VBScript

<HTML><script language="vbscript">For i = 1 to 6

document.write("<h" & i & ">")document.write("H" & i)document.write("</h" & i & "><br>")

Next</script>

</HTML>

JScript<HTML>

<script language="javascript">for (i = 1; i <= 6; i++){

document.write("<h" + i + ">");

document.write("H" + i);document.write("</h" + i + "><br>");

}</script>

</HTML>

7.4.5 Respuesta a sucesos con secuencia de comandosLas secuencias de comandos también definen procedimientos que responden a sucesos de página, como carga

de la ventana, pulsación de botones y paso del ratón sobre objetos.

Para crear un procedimiento de suceso de secuencia de comandos siga estos pasos:

1. Usando Visual Studio cree o abra la página en la que quiere incluir las secuencias de comandos de cliente. La página puede ser un formulario Web (.aspx) o una página HTML (.htm).

2. Cambie a la vista HTML de la página.3. En la lista desplegable en la parte superior izquierda de la página seleccione el objeto para el que quiere aña-dir el procedimiento

4. En la lista desplegable de la parte superior derecha de la página seleccione el suceso al que quiere que el có-digo responda.

5. Visual Studio crea un bloque de secuencia de comandos que contiene un procedimiento de suceso vacío, co-mo este.

VBScript<script id=clientEventHandlersVBS language=vbscript></script>

MCAD/MCSD

146

JScript<script id=clientEventHandlersJS language=javascript></script>

El código que se añada al procedimiento de suceso se ejecutará cuando se produzca el suceso de página. Por

ejemplo, el siguiente código cambia el cursor del ratón al símbolo de mano cuando el usuario mueve el cursor por encima.

VBScriptSub butRunScript_onmouseover

butRunScript.style.cursor = "hand"End Sub

JScriptfunction butRunScript_onmouseover() { butRunScript.style.cursor = "hand"; }

Los procedimientos de cliente pueden detectar una amplia variedad de sucesos, incluyendo pulsación de te-clas, sucesos de paso de ratón, pulsaciones, cargas y descargas. A diferencia de los sucesos de servidor, los sucesosde cliente no proporcionan argumentos directamente. En su lugar se usa el método event del objeto window paraobtener valores. Por ejemplo, el siguiente procedimiento para el suceso mousemove muestra las coordenadas del

cursor en la barra de estado del navegador.VBScriptSub document_onmousemove

window.status = window.event.clientX & ", " & window.event.clientYEnd Sub

JScriptfunction window_onmousemove() {

window.status = window.event.clientX + ", " + window.event.clientY;}

El código de los procedimientos de cliente puede obtener y establecer los valores que muestran los controlesde servidor y HTML de la página. Esto significa que puede obtener valores del usuario y proporcionar respuestas sinenviar la página de vuelta al servidor. Por ejemplo, el siguiente código HTML define una página que juega un senci-

llo juego con el usuario – sin ningún envío al servidor.VBScript<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><html>

<head><title>EventScript</title><meta name="vs_defaultClientScript" content="VBScript"><meta name="vs_targetSchema"

content="http://schemas.microsoft.com/intellisense/ie5"><meta name="GENERATOR" content="Microsoft Visual Studio.NET 7.0"><meta name="ProgId" content="VisualStudio.HTML"><meta name="Originator" content="Microsoft Visual Studio.NET 7.0"><script id="clientEventHandlersVBS" language="vbscript">

Sub butRunScript_onclick

' Muestra un mensaje en un área de texto.sMessage = "Estoy pensando un número entre 0 y 9. "sMessage = sMessage & "Pulse una tecla numérica para adivinar."txtMessage.value = sMessage' Inicializa el generador de números aleatorios.Randomize' Obtiene un número aleatorio y lo guarda en un campo oculto.hidNumber.value = Int(9 * Rnd)

End Sub

147

Sub document_onkeypress' Si la tecla corresponde al número, muestra el mensaje de éxito.if (window.event.keyCode - 48) = CInt(hidNumber.value) then

txtMessage.value = "¡Correcto!"' Si no, indica la respuesta correcta.else

txtMessage.value = "Falló. El número era: " & hidNumber.valueend if

End Sub

</script></head>

<body MS_POSITIONING="FlowLayout"><p><textarea id="txtMessage"></textarea></p><P><INPUT type="button" id="butRunScript" value="Ejecutar Script"

NAME="butRunScript"></P><INPUT id="hidNumber" type="hidden" name="Hidden1">

</body></html>

JScript<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" ><HTML>

<HEAD>

<META NAME="GENERATOR" Content="Microsoft Visual Studio 7.0"><TITLE></TITLE><meta name="vs_defaultClientScript" content="JavaScript"><meta name="vs_targetSchema"

content="http://schemas.microsoft.com/intellisense/ie5"><meta name="GENERATOR" content="Microsoft Visual Studio.NET 7.0"><meta name="ProgId" content="VisualStudio.HTML"><meta name="Originator" content="Microsoft Visual Studio.NET 7.0"><script id=clientEventHandlersJS language=javascript>



</script>

</HEAD><BODY language=javascript onmousemove="return window_onmousemove()"onkeypress="return window_onkeypress()"><p><textarea id="txtMessage" style="WIDTH: 200px; HEIGHT: 88px"

rows="5" cols="22" NAME="txtMessage"></textarea></p><P><INPUT type="button" id="butRunScript" value="Ejecutar Script"

NAME="butRunScript" language=javascript onmouseover="returnbutRunScript_onmouseover()" onclick="return butRunScript_onclick()"></P>

<P><INPUT id="hidNumber" type="hidden" name="Hidden1"></P></BODY>

</HTML>

7.5 Consumir servicios Web XML

Los servicios Web XML son componentes de lógica de negocio a los que se puede acceder en Internet. Con-sumir un servicio Web sencillamente significa utilizarlo desde una aplicación. En esta lección aprenderá como loca-lizar un servicio Web, hacer referencia a él y usarlo desde una aplicación Web.



MCAD/MCSD

148

7.5.1 Encontrar servicios Web XMLLos servicios Web XML se hacen públicos en Internet usando un registro de descripción, descubrimiento e

integración universal (UDDI, Universal Description, Discovery and Integration) . Actualmente Microsoft e IBMadministran los dos nodos UDDI disponibles. Los negocios registran sus servicios Web en estos nodos de forma quelos clientes (Vd. y yo) pueden localizar los servicios Web que quieren usar.

Hay muchas formas diferentes para buscar servicios Web XML en Internet. La forma más sencilla es selec-cionar Servicios Web XML en la página Inicio de Visual Studio .NET.

El elemento Servicios Web XML en la página de inicio le permite localizar servicios Web XML por catego-ría general o por tarea que realiza, como calendario, financiera, matemática o clima. Los botones de opción Buscar en sobre la caja Categoría permite buscar servicios Web XML puestos en producción (presumiblemente depurados y probados) o aún en desarrollo.

7.5.2 Usar un servicio Web XMLUsar un servicio Web es muy similar a usar un componente .NET o COM. Se establece una referencia a la

clase, se crea una instancia de un objeto a partir de la clase y después se usan los métodos y propiedades de la clasedesde el código. Hay varias formas de establecer una referencia a un servicio Web XML desde Visual Studio .NET.Tal vez la más sencilla sea hacerlo desde la página de inicio:

1. Localice el servicio Web que quiere utilizar pulsando el enlace Servicios Web XML en la página Inicio.2. Pulse el enlace Agregar como referencia Web al proyecto actual bajo la descripción del servicio. Visual Stu-

dio añade una referencia en la sección Referencias Web del Explorador de soluciones,

Para usar la referencia en el código:

1. Cree un nuevo objeto a partir de la clase del servicio Web. El nombre de clase del servicio Web se muestraen la carpeta Referencias Web del Explorador de soluciones.

2. Use las propiedades y métodos del servicio Web a partir del nuevo objeto. Las características de autocomple-tar y de inspector de objetos de Visual Studio funcionan con las clases de servicio Web, por lo que el uso desus propiedades y métodos es igual que el de cualquier otra clase.

Nota: El siguiente ejemplo depende de la disponibilidad de un sitio Web de un tercero. En el momen-to de escribirse este libro este sitio estaba disponible, pero no se puede garantizar su disponibi-lidad futura.

Por ejemplo, el siguiente código usa el servicio Web de comprobación de tarjetas de crédito CDYNE para va-lidar un número de tarjeta de crédito escrito en una caja de texto.

Visual Basic .NETPrivate Sub butCheck_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butCheck.ClickDim wsCheck As New com.cdyne.secure.LUHNChecker()Dim wsValid As com.cdyne.secure.ReturnIndicatorwsValid = wsCheck.CheckCC(txtNumber.Text)lblMsg.Text = wsValid.CardType & " " & wsValid.CardValid.ToString()

End Sub

Visual C#private void butCheck_Click(object sender, System.EventArgs e){

com.cdyne.secure.LUHNChecker wsCheck = new com.cdyne.secure.LUHNChecker();

com.cdyne.secure.ReturnIndicator wsValid;wsValid = wsCheck.CheckCC(txtNumber.Text);lblMsg.Text = wsValid.CardType + " " + wsValid.CardValid.ToString();

}

7.5.3 Uso de servicios Web XML desde secuencias de comando de clienteEn algunos casos tiene más sentido llamar a un servicio Web XML desde secuencias de comandos de cliente

que desde el código de servidor. Un servicio Web XML puede tardar mucho tiempo en responder – no tiene sentidohacer que el servidor espere la respuesta cuando lo único que va a hacer es pasarla al cliente.

Para usar un servicio Web XML desde secuencias de comandos de cliente siga estos pasos:

1. Cree una clase de estilo para el comportamiento WebService (Webservice.htc)2. Añada a la página un elemento HTML que use la clase creada en el paso 1.

3. Escriba procedimientos de secuencia de comandos para inicializar y llamar a los métodos del servicio WebXML usando el comportamiento.




149

El siguiente HTML crea una clase de estilo webservice, la inicializa y llama a un servicio Web para mostrar una cita diaria cuando el usuario pulsa Mostrar cita.

VBScript<HTML>

<HEAD><title>WebForm2</title><style>.webservice { BEHAVIOR:url(webservice.htc) }</style><script language="VBScript">

Dim iCallIDSub init(control, wsAddress, name)

control.useService wsAddress, nameEnd Sub

Function getResult()if window.event.result.error And _

(iCallID = window.event.result.id) ThenDim xfaultcode, xfaultstring, xfaultsoapxfaultcode = window.event.result.errorDetail.codexfaultstring = window.event.result.errorDetail.stringxfaultsoap = window.event.result.errorDetail.raw' Muestra información del error.alert("Error " & xfautlcode & " │ " & xfaultstring & " │ " & _

xfaultSoap)ElsegetResult = window.event.result.value

End IfEnd Function

Sub getQuote()' Inicializa el servicio Web en el control seleccionado.init ws, "http://webservice.effective-web.net/globalself/globalselfDailyThought.WSDL", "DailyQuote"' Llama a un método dentro del servicio WebiCallID = ws.DailyQuote.callService("getTodaysQuote")' onresult Muestra el resultado en el elemento div ws.

End Sub</script>

</HEAD><body>

<form id="WebForm2" method="post" runat="server"><h2>Uso de servicios Web desde código de cliente </h2><div id="ws" class="webservice"

onresult="ws.innerText = getResult()"></div><br><input type="button" onclick="getQuote()" value="Ver Cita">

</form></DIV>

</body></HTML>

JScript<HTML>

<HEAD><title>WebForm2</title><style> .webservice { BEHAVIOR:url(webservice.htc) }</style><script language="JScript">

var iCallID;

function init(control, wsAddress, name){control.useService(wsAddress, name);

}

function getResult(){if((event.result.error)&&(iCallID==event.result.id)) {

var xfaultcode = event.result.errorDetail.code;var xfaultstring = event.result.errorDetail.string;var xfaultsoap = event.result.errorDetail.raw;// Muestra información de error.

alert("Error " + xfautlcode + " │ " + xfaultstring + " │ "+ xfaultSoap);

}



MCAD/MCSD

150

else return event.result.value;}

function getQuote(){// Inicializa el servicio Web en el control seleccionado.init(ws, "http://webservice.effective-web.net/globalself/

globalselfGlobalSelf.WSDL", "DailyQuote");// Llama a un método del servicio Web.iCallID = ws.DailyQuote.callService("getTodaysQuote");

// onresult muestra el resultado en el elemento div ws.}</script>

</HEAD>

<body><form id="WebForm2" method="post" runat="server">

<h2>Uso de servicios Web desde código de cliente.</h2><div id="ws" class="webservice" onresult="ws.innerText = getResult();">

</div><br><input type="button" onclick="getQuote()" value="Ver Cita">

</form></DIV></body>

</HTML>

Para más información sobre el uso de servicios Web XML desde código cliente vea la ayuda de Visual Stu-dio, tema Comportamiento WebService.

7.6 Resumen• Las cookies le permiten guardar información sobre un usuario concreto de modo invisible. Se pueden usar

para guardar la información directamente en el ordenador del usuario o indirectamente mediante un identifi-cador único que se utiliza para recuperar información de usuario desde un conjunto de datos almacenado enel servidor.

• Use la propiedad Cookies del objeto Browser para comprobar si un navegador acepta cookies antes de inten-tar crearlas.

• Use la colección Cookies del objeto Request para recuperar una cookie del usuario. Use la colección Cookies del objeto Response para crear o modificar una cookie en el ordenador del usuario.

• Para borrar una cookie en el ordenador del usuario de el valor Now a la propiedad Expires del objeto Cookie.

• Use el protocolo mailto: para crear un mensaje que se enviará desde el sistema de correo del usuario. El pro-tocolo mailto: se usa como parte de un enlace.• Use las clases MailMessage y SmtpMail para componer y enviar mensajes desde el sistema de correo del ser-

vidor.• Los marcos permiten mostrar varias páginas en una sola ventana del navegador. La presentación y desplaza-

miento de cada marco se controla por separado.• Use la propiedad Frames del objeto Browser para comprobar si un navegador acepta marcos antes de mos-

trarlos.• Los enlaces en un marco pueden mostrar una página en otro marco usando el atributo target . Solo puede con-

trolar los marcos desde enlaces o secuencias de comandos de cliente.• Las secuencias de comandos de cliente permiten controlar la ventana del navegador, responder inmediata-

mente a sucesos que no provocan el envío y realizar otras tareas que no son posibles en código de servidor.• Use las propiedades VBScript o JavaScript del objeto Browser para comprobar si el navegador soporta se-

cuencias de comandos. Use una secuencia de prueba en línea que redirija a los usuario para comprobar si elusuario ha desactivado las secuencias de comandos mediante las opciones de seguridad del navegador.

• Añada procedimientos de suceso de secuencia de comandos a una página HTML para responder a sucesosque se produzcan en el cliente en lugar de en el servidor.

7.7 Práctica: Uso de características avanzadasEn esta práctica va a crear una aplicación que muestra varias páginas usando marcos. Esta aplicación permite

al usuario seleccionar un color de fondo para la aplicación, componer y enviar correo desde el servidor y jugar a un juego sencillo. Esta práctica realiza las siguiente tareas clave:

• Prueba las capacidades del navegador para asegurarnos de que soporta marcos, cookies y secuencias de co-mandos.

• Guarda cookies en el ordenador del usuario y las recupera para configurar el color de fondo de la aplicación.• Envía correo desde el servidor usando objetos MailMessage y SmtpMail.• Muestra páginas en marcos y controla la presentación de estos marcos desde una página Contents.




151

7.7.1 Comprobar el soporte de características avanzadasEn este ejercicio va a crear una página predeterminada para la aplicación que comprueba si el navegador del

usuario acepta cookies, puede mostrar marcos y puede ejecutar secuencias de comandos. Si cualquiera de estas ca-racterísticas no está disponible se muestra el mensaje adecuado.

Una página predeterminada es la que muestra IIS si el usuario llega al directorio de la aplicación Web sinespecificar una página concreta. IIS utiliza los nombres Default.htm y Default.aspx para la página predeterminada,salvo que se cambien para la aplicación mediante IIS.

1. Añada a la aplicación un formulario Web llamado Default.aspx y haga que sea la página de inicio de la apli-cación.

2. Añada al formulario Web el siguiente procedimiento de suceso Page_Load .


ByVal e As System.EventArgs) Handles MyBase.Load' Crea un indicador para saber si se han desactivado características.Dim bProceed As Boolean = True' Comprueba si el navegador acepta cookies.If Request.Browser.Cookies = False Then

Response.Write("Su navegador no acepta cookies.<br>" & _"Cambie su configuración de seguridad para permitirlas.<br><br>")

bProceed = False

End If' Comprueba si soporta secuencias de comandos.If Request.Browser.JavaScript = False Then

Response.Write("Su navegador no soporta secuencias de comandos." & _"Actualice a una versión más actual.<br><br>")

bProceed = FalseEnd If' Comprueba si el navegador soporta VBScript.If Request.Browser.VBScript = False Then

Response.Write("Su navegador no soporta VBScript.<br>" & _"Instale Explorer.<br><br>")

bProceed = FalseEnd If' Si pasa las pruebas, comprueba si las secuencias de comandos están

' activadas probando a ejecutar una.If bProceed Then' Si están desactivadas se ignora esta línea; si están activadas se' muestra el conjunto de marcos.Response.Write("<script>window.navigate('frameset.htm')</script>")Response.Write("La configuración de seguridad de su navegador ha " & _

"desactivado las secuencias de comandos.<br> Cambie esta " & _"configuración.<br><br>")

End IfEnd Sub


// Crea un indicador para saber si se han desactivado características.bool bProceed = true;

// Comprueba si acepta cookies.if (!Request.Browser.Cookies){Response.Write("Su navegador no acepta cookies.<br>" +

"Cambie su configuración de seguridad para permitirlas.<br><br>");bProceed = false;

}// Comprueba si el navegador soporta secuencias de comandos.if (!Request.Browser.JavaScript){

Response.Write("Su navegador no soporta secuencias de comandos.<br>" +"Cambie a una versión más actual.<br><br>");

bProceed = false;}// Comprueba si el navegador soporta VBScript.if (!Request.Browser.VBScript){

Response.Write("Su navegador no soporta VBScript.<br>" +

"Instale Internet Explorer.<br><br>");bProceed = false;

}



MCAD/MCSD

152

// Si pasa las pruebas, comprueba si las secuencias de comandos están// activadas probando a ejecutar una.if (bProceed) {

// Si están desactivadas se ignora esta línea; si están activadas se// muestra el conjunto de marcos.Response.Write("<script>window.navigate('frameset.htm')</script>");Response.Write("La configuración de seguridad de su navegador ha " +

"desactivado las secuencias de comandos.<br> Cambie esta " +"configuración.<br><br>");

}}

3. Añada el siguiente contenido HTML al formulario Web:

<p>Esta aplicación Web utiliza características que no están disponibles en su na-vegador o que han sido desactivadas mediante la configuración de seguridad. Nopuede ejecutar esta aplicación hasta que no actualice su navegador tal como se hadescrito anteriormente. A continuación pulse <a href="default.aspx">aquí</a> para probar de nuevo.</p>

Cuando se carga la página que se ha creado con los pasos anteriores comprueba cada una de las característi-cas avanzadas que un navegador puede o no soportar. Si hay problemas con el uso de alguna de ellas la páginamuestra un aviso de advertencia.

Si no encuentra problemas, el usuario no ve la página predeterminada. En su lugar se le redirige inmediata-mente al conjunto de marcos, que muestra las otras páginas de la aplicación.

7.7.2 Almacenar información de usuarioEn este ejercicio va a crear un formulario Web que permite que el usuario seleccione un color de fondo. El

formulario “recuerda” la selección del usuario entre sesiones guardando en segundo plano una cookie en la máquinadel usuario.

1. Cree un nuevo formulario Web llamado Background.aspx.2. Añada a la página un control de servidor DropDownList que contenga elementos de lista para varios colores.

Este paso es probablemente más fácil en modo HTML que en modo diseño, porque en HTML puede copiar y pegar para crear los elementos rápidamente. El siguiente HTML muestra la definición del DropDownList ysus elementos:<asp:dropdownlist id="drpBackground" AutoPostBack="True" Runat="server"

Width="128px"><asp:ListItem Value="White">Blanco</asp:ListItem><asp:ListItem Value="Silver">Gris</asp:ListItem><asp:ListItem Value="LightSteelBlue">Azul acero claro</asp:ListItem><asp:ListItem Value="Honeydew">Verde claro</asp:ListItem><asp:ListItem Value="Azure">Azulón</asp:ListItem><asp:ListItem Value="Linen">Lino</asp:ListItem><asp:ListItem Value="MintCream">Crema de menta</asp:ListItem>

</asp:dropdownlist>

3. Modifique el elemento <body> del formulario web para indicar un color de fondo usando una vinculacióncon la lista desplegable: <body bgColor="<%# drpBackground.SelectedItem.Value %>">

4. Añada el siguiente código al procedimiento de suceso Page_Load para comprobar una cookie, crearla si noexiste o establecer el color de fondo según la cookie si existe. El procedimiento de suceso Page_Load tam-

bién realiza vinculación de datos para que la página actualice el color de fondo.Visual Basic .NETPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.Load' Primera presentaciónIf IsPostBack = False Then

' Si la cookie no existe la crea.If Request.Cookies("BackgroundColor") Is Nothing Then

' Crea una cookie con el color de fondo predeterminado.Dim cookBackground As New HttpCookie("BackgroundColor", "0")' Configura la cookie para que caduque en un día.cookBackground.Expires = DateTime.Now.AddDays(1)' Añade la cookie al objeto respuesta.Response.Cookies.Add(cookBackground)

Else




153

' Obtiene el color de fondo del usuario a partir de la cookie.drpBackground.SelectedIndex = _

CInt(Request.Cookies("BackgroundColor").Value)End If

End If' Actualiza la vinculación para establecer el color de fondoPage.DataBind()

End Sub

Visual C#private void Page_Load(object sender, System.EventArgs e){// Primera presentaciónif (!IsPostBack){

// Si la cookie no existe la crea.if (Request.Cookies["BackgroundColor"] == null){

// Crea una cookie con el color de fondo predeterminado.HttpCookie cookBackground = newHttpCookie("BackgroundColor", "0");// Configura la cookie para que caduque en un día.cookBackground.Expires = DateTime.Now.AddDays(1);// Añade la cookie al objeto respuesta.Response.Cookies.Add(cookBackground);

}else// Obtiene el color de fondo del usuario a partir de la cookie.

drpBackground.SelectedIndex = Convert.ToInt16(Request.Cookies["BackgroundColor"].Value);

}// Actualiza la vinculación para establecer el color de fondoPage.DataBind();

}

5. Añada el siguiente código para actualizar la cookie mediante el objeto Response cuando el usuario seleccioneun color de fondo de la lista desplegable:

Visual Basic .NETPrivate Sub drpBackground_SelectedIndexChanged( _

ByVal sender As System.Object, ByVal e As System.EventArgs) Handles _drpBackground.SelectedIndexChanged

' Registra la selección de color en una cookie.

Dim cookBackground As New HttpCookie("BackgroundColor")' Configura el valor de la cookie.cookBackground.Value = drpBackground.SelectedIndex' Configura la caducidad de la cookie.cookBackground.Expires = DateTime.Now.AddDays(1)' Añade la cookie al objeto respuesta.Response.Cookies.Add(cookBackground)

End Sub

Visual C#private void drpBackground_SelectedIndexChanged(object sender,

System.EventArgs e){// Registra la selección de color en una cookie.HttpCookie cookBackground = new HttpCookie("BackgroundColor");// Configura el valor de la cookie.

cookBackground.Value = drpBackground.SelectedIndex.ToString();// Configura la caducidad de la cookie.cookBackground.Expires = DateTime.Now.AddDays(1);// Añade la cookie al objeto respuesta.Response.Cookies.Add(cookBackground);

}

7.7.3 Crear un formulario Web para correoEn este ejercicio va a crear un formulario Web que permitirá componer y enviar un mensaje de correo desde

el servidor.

1. Cree un nuevo formulario Web y llámelo Mail.aspx2. Añada el texto y los controles de servidor que se muestran en el siguiente HTML:



MCAD/MCSD

154

<P>De: <asp:TextBox ID="txtFrom" Runat="server" Width="376px"></asp:TextBox><asp:RequiredFieldValidator ID="vldtxtFrom" ControlToValidate="txtFrom"

Runat="server" ErrorMessage="Campo indispensable."></asp:RequiredFieldValidator><br>A: <asp:TextBox ID="txtTo" Runat="server" Width="377px"></asp:TextBox>

<asp:RequiredFieldValidator ID="vldTo" ControlToValidate="txtTo"Runat="server" ErrorMessage="Campo indispensable.">

</asp:RequiredFieldValidator><br>Asunto:<asp:TextBox ID="txtSubject" Runat="server" Width="376px"></asp:TextBox></P><asp:TextBox ID="txtMessage" Runat="server" TextMode="MultiLine" Width="432px"Height="208px"></asp:TextBox><br><asp:Button ID="butSend" Runat="server" Text="Enviar"></asp:Button><input type="reset" id="butReset" value="Cancelar"><br><asp:literal id="litStatus" runat="server"></asp:literal>

Los controles RequiredFieldValidator son necesarios porque antes de poder enviar el mensaje se deben establecer las propiedades From y To del objeto MailMessage.

3. Añada la sentencia Imports o using para poder utilizar el espacio de nombres System.Web.Mail.4. Añada al procedimiento de suceso butSend_Click el siguiente código para crear un objeto MailMessage y en-

viar el mensaje desde el servidor:Visual Basic .NETPrivate Sub butSend_Click(ByVal sender As System.Object, +

ByVal e As System.EventArgs) Handles butSend.ClickDim msgMail As New MailMessage() ' Crea el mensaje.msgMail.From = txtFrom.Text ' Configura las propiedades.msgMail.To = txtTo.TextmsgMail.Subject = txtSubject.TextmsgMail.Body = txtMessage.TextSmtpMail.Send(msgMail) ' Enviar mensaje.

txtTo.Text = "" ' Limpia los campos.txtSubject.Text = ""txtMessage.Text = ""litStatus.Text = "<p>Mensaje enviado.</p>" ' Muestra el éxito.

End Sub

Visual C#private void butSend_Click(object sender, System.EventArgs e){

MailMessage msgMail = new MailMessage(); // Crea el mensaje.msgMail.From = txtFrom.Text; // Configura las propiedadesmsgMail.To = txtTo.Text;msgMail.Subject = txtSubject.Text;msgMail.Body = txtMessage.Text;SmtpMail.Send(msgMail); // Enviar mensaje.txtTo.Text = ""; // Limpia los campos.txtSubject.Text = "";txtMessage.Text = "";litStatus.Text = "<p>Mensaje enviado.</p>"; // Muestra el éxito.

}

5. Añada al procedimiento de suceso Page_Load el siguiente código para limpiar el mensaje de estado si elusuario cancela el envío de un mensaje tras enviar con éxito otro anterior.


ByVal e As System.EventArgs) Handles MyBase.LoadlitStatus.Text = "" ' Limpia el mensaje de estado.

End Sub


litStatus.Text = ""; // Limpia el mensaje de estado.}




155

7.7.4 Crear un interface de usuario basado en marcosEn este ejercicio va a crear un conjunto de marcos que contiene regiones para una tabla de contenidos, una

pancarta y un cuerpo. Creará la página de tabla de contenidos que mostrará las páginas seleccionadas en el marco decuerpo y actualizará el marco de pancarta usando una secuencia de comandos.

1. Cree una nueva página HTML llamada Contents.htm2. Añada a esta página los siguientes enlaces:

<a href="Background.aspx" target="main" onclick="ShowBanner('Elegir Fondo')">

Elegir Fondo</a><br><a href="Mail.aspx" target="main" onclick="ShowBanner('Enviar correo desde el

servidor')">Enviar Correo</a><br><a href="Game.htm" target="main" onclick="ShowBanner('Jugar')">Jugar</a><br>

3. Añada el siguiente procedimiento de secuencia de comandos a la página:VBScript<script language="vbscript">' Actualiza el texto en el marco de pancarta.Sub ShowBanner(Message)

' Escribe texto en el marco de pancarta.parent.frames("banner").document.write("<h2>" & Message & "</h2>")' Cierra el documento para que el siguiente texto reemplace al actual.parent.frames("banner").document.close

End Sub

</script>

JScript<script language="javascript">// Actualiza el texto en el marco de pancarta.function ShowBanner(Message){

// Escribe texto en el marco de pancarta.parent.frames["banner"].document.write("<h2>" + Message + "</h2>");// Cierra el documento para que el siguiente texto reemplace al actual.parent.frames["banner"].document.close();

}</script>

Esta secuencia de comandos muestra un título en el marco de pancarta del conjunto de marcos a partir de ca-da uno de los enlaces creados en el paso anterior.

4. Cree un conjunto de marcos para mostrar las páginas del proyecto. En el menú Proyecto seleccione Agregar nuevo elemento, seleccione Conjunto de marcos en la lista Plantillas y llame al archivo Frameset.htm. Al pulsar Abrir Visual Studio muestra el diálogo Seleccione una plantilla de conjunto de marcos.

5. Seleccione la plantilla Pancarta y Contenido y pulse Aceptar. Visual Studio muestra un nuevo conjunto demarcos vacío en la ventana de diseño.

6. Pulse con el botón derecho del ratón en el marco más a la izquierda y seleccione Establecer página para mar-co. Visual Studio muestra el diálogo Página de selección.

7. Seleccione Contents.htm y pulse aceptar para mostrar la página Contents en el marco.8. Haga que el conjunto de marcos sea la página de inicio de la aplicación. En el explorador de soluciones pulse

con el botón derecho sobre el archivo Frameset.htm y seleccione Establecer como página de inicio.

7.7.5 Práctica extra con secuencias de comandos y cookiesLos ejercicios 1 a 4 han recorrido las tareas aprendidas en este capítulo. Ahora siga por si mismo intentando

completar las siguientes tareas que amplían la aplicación de características avanzadas.

• Añada una secuencia de comandos Window_OnLoad a la página Contents para mostrar un mensaje de bien-venida en el marco de pancarta la primera vez que se muestra la página.

• Añada el formulario Web Adivine el Número creado en el apartado 7.4.5 a la aplicación.• Cree en el formulario de correo una cookie para recordar el campo De introducido por el cliente.• Use el color de fondo seleccionado en la página correspondiente para cambiar el fondo de todas las páginas

del conjunto de marcos.

Cuando termine compare sus resultados con la aplicación Advanced Features incluida en el CD.



1. Escriba el HTML para un enlace que envíe correo cuando el usuario lo pulse



MCAD/MCSD

156

2. Muestre el código que escribe una cookie que contiene el nombre de usuario “Rob Young” y la fecha actualen el ordenador del usuario. Configure la cookie para que permanezca en el ordenador 30 días.

3. ¿Por qué no puede abrir una ventana de navegador desde código de servidor?. ¿Cómo podría mostrar una pá-gina en una nueva ventana con una secuencia de comandos de cliente?

4. ¿Cómo mostraría una página en un marco desde un enlace en otro marco?.




157

8 Mantener la seguridadEn este capítulo aprenderá cómo controlar el acceso a su aplicación Web usando las tres técnicas que propor-

ciona ASP.NET para identificar a los usuarios y permitir que tengan acceso a la aplicación. También aprenderácómo asegurar los datos transmitidos sobre Internet de forma que otros no puedan leerlos.

Este capítulo no proporciona una guía completa de seguridad en redes o en servidor. Este es amplio tema queabarca una gran cantidad de información conceptual o específica del sistema. Lo que hace este capítulo es propor-cionar una guía práctica para implementar seguridad en una aplicación Web usando ASP.NET.

Para completar las lecciones de este capítulo deberá

• Tener acceso a dos ordenadores en una red Windows. Puede ser una red sencilla basada en grupos de trabajo, pero es mejor una basada en dominio.

• Tener privilegios de administrador en un ordenador que funcione como servidor en la red.

Si no tiene acceso a una red Windows puede realizar la mayoría de las tareas de este capítulo usando un úni-co ordenador y ejecutando la aplicación localmente, como se hace en el modo de depuración de Visual Studio, perono podrá comprobar verdaderamente la autenticación de múltiples usuarios.

8.1 Autenticar y autorizar usuariosAutenticación es el proceso de identificar usuarios. Autorización es el proceso de permitir el acceso a los

usuario en base a su identidad. Juntas, la autenticación y la autorización proporcionan los medios para mantener laaplicación Web segura frente a intrusos.

En esta lección aprenderá cómo maneja ASP.NET los usuarios anónimos y verá ls diferentes formas en que puede identificar y autorizar usuarios. Esta información le ayudará a seleccionar una estrategia de autentificaciónsegún el tipo de aplicación que esté creando.

8.1.1 Acceso por uuarios anónimosEl acceso anónimo es la forma en que funcionan la mayoría de los sitios Web públicos – los sitios que con-

tienen información permiten que cualquiera vea la información, de modo que no autentifican a los usuarios. Lasaplicaciones Web ASP.NET proporcionan acceso anónimo a los recursos en el servidor por medio de la impersoni-ficación. La impersonificación es el proceso de asignar una cuenta de usuario a un usuario desconocido.

De forma predeterminada, la cuenta de acceso anónima se llama IUSR_ nombremaquina. Esta cuenta se usa

para controlar el acceso a los recursos en el servidor.Para ver o cambiar los privilegios de acceso de la cuenta de usuario anónima use el elemento Administración

de equipos como indican los siguientes pasos.

1. Entre en el ordenador como administrador.2. En el menú Inicio, Configuración, Herramientas administrativas seleccione Administración de equipos para

ejecutar la consola de administración.3. En la lista de la izquierda seleccione Usuarios locales y grupos y después la carpeta Usuarios para mostrar la

lista de usuarios autorizados en este ordenador.4. En la lista de usuarios a la derecha pulse dos veces sobre la cuenta de usuario anónimo llamada

IUSR_ nombremaquina. La consola de administración muestra las propiedades de la cuenta.5. Pulse sobre la lengüeta Miembro de para ver los grupos a los que pertenece la cuenta. De forma predetermi-

nada los usuarios anónimos pertenecen al grupo Invitados, que tiene privilegios limitados.

Bajo la configuración predeterminada ASP.NET usa la cuenta ASPNET para ejecutar la aplicación Web. Es-to significa que si la aplicación intenta realizar tareas que no están incluidas en los privilegios de la cuenta ASPNETse producirá una excepción de seguridad y se denegará el acceso. El nombre de cuenta también se mostrará en elregistro de sucesos de seguridad en el visor de sucesos.

El acceso de los usuarios anónimos se restringe configurando los permisos de archivo de Windows. Para es-tar seguro su servidor debe usar el sistema de archivos NT (NTFS). Los anteriores sistemas de ficheros FAT oFAT32 no proporcionan seguridad a nivel de fichero. Para más información sobre la configuración de permisos defichero Windows consulte los temas de ayuda de Windows relacionados con seguridad.

8.1.2 Acceso por usuarios autenticadosComo se indicó anteriormente el acceso anónimo es adecuado para información pública. Pero si su aplicación

contiene información privada o realiza tareas restringidas como realizar pedidos querrá autenticar y autorizar usua-

rios individuales.Hay tres formas principales de autenticar y autorizar usuarios dentro de una aplicación Web ASPNET:



MCAD/MCSD

158

• Autenticación Integrada de Windows. Identifica y autoriza a los usuarios en base a la lista de usuarios delservidor. El acceso a los recursos en el servidor se autoriza o deniega en base a los privilegios de la cuentadel usuario. Esto funciona igual que la seguridad habitual de redes Windows.

• Autenticación por Formularios. Dirige a los usuarios a un formulario Web de conexión que recoge sunombre y contraseña y lo autentica contra una lista o base de datos de usuarios mantenida por la aplicación.

• Autenticación Passport. Dirige a los nuevos usuarios a un sitio alojado por Microsoft de modo que puedenregistrar un único nombre de usuario y contraseña que autorizará su acceso a múltiples sitios Web. A losusuarios existentes se les pide su nombre y contraseña Passport, que la aplicación autentica contra la lista de

usuarios de Microsoft Passport.

Cada una de estas aproximaciones, junto con el acceso anónimo, tienen diferentes ventajas. Estos métodosestán adaptados a diferentes tipos de aplicaciones Web, como resume la tabla 8.1.

Tabla 8. 1: Tipos deaplicación Web y técnicas de autenticaciónTipo de Aplicación Tipo de

autenticaciónDescripción

Aplicación InternetPública

Anónimo Método de acceso común para la mayoría de sitios Web. No es necesaria identificación ylos recursos restringidos se aseguran mediante los permisos de archivo NTFS.

Aplicación WebIntranet

Integrada deWindows

La autenticación de Windows autentica a los usuarios mediante el controlador de domi-nio. Los usuarios de red tienen acceso a los recursos de aplicaciones Web como deter-minan sus privilegios de usuario en el servidor.

Aplicación Webcorporativa privada

Integrada deWindows

Los usuarios corporativos pueden acceder a la aplicación web usando sus nombres deusuarios y contraseñas de la red corporativa. Las cuentas de usuario se administran

usando las herramientas de seguridad en red de Windows. Aplicación Webcomercial

Formularios Las aplicaciones que necesitan recoger información para envío y facturación debenimplementar la autenticación por formularios para obtener y almacenar información decliente.

Múltiples aplicacionesWeb comerciales

Passport La autenticación Passport permite que los usuarios se registren una sola vez medianteuna autoridad central. La identidad del usuario está disponible a cualquier aplicación queuse el SDK de Passport. La información de cliente se mantiene en un perfil Passport enlugar de una base de datos local.

Las siguientes secciones describen cómo autenticar y autorizar a los usuarios usando cada una de las tres téc-nicas.

8.1.3 Autenticación con archivos HTM y HTMLLos tres métodos de autenticación ASP.NET se aplican a archivos que son parte de la aplicación Web. Esto

incluye formularios Web (.aspx), módulos (.asax) y otros recursos procesados por medio del ejecutable de la aplica-ción. Esto no incluye automáticamente páginas HTML (.htm o .html). Estas páginas las administra IIS, noASP.NET. Si quiere autenticar a usuarios que accede a páginas HTML dentro de su aplicación usando los modos deautenticación Windows, Forms o Passport debe asignar estos archivos al ejecutable ASP.NET siguiendo estos pasos:

1. En IIS, pulse con el botón derecho del ratón sobre la carpeta que contiene la aplicación Web y seleccionePropiedades. IIS muestra el diálogo Propiedades.

2. Pulse sobre la lengüeta Directorio virtual y el botón Configuración. IIS muestra el diálogo Configuración deaplicación.

3. Pulse Agregar. IIS muestra el diálogo Agregar o modificar asignación de extensión para aplicación.4. Pulse Examinar y seleccione el archivo aspnet_isapi.dll. Este archivo se encuentra en el directorio del marco

de trabajo .NET, cuya ruta será similar a C:\Windows\Microsoft.NET\Framework\numeroversion\5. Escriba .htm en la caja de texto Extensión y pulse Aceptar.6. Repita los pasos 3 a 5 para la extensión .html. Cuando termine pulse Aceptar para cerrar los diálogos de IIS .

8.2 Autenticación de WindowsLa autenticación de Windows usa las características de seguridad integradas en los sistemas operativos Win-

dows NT y XP para autenticar y autorizar usuarios de aplicaciones Web. La ventaja de la autenticación Windows esque la aplicación Web puede usar exactamente el mismo esquema de seguridad que se aplica a la red corporativa – los nombres de usuario, contraseñas y permisos son los mismos para los recursos de red y para las aplicacionesWeb.

8.2.1 Activar la autenticación WindowsLa autenticación Windows es el método predeterminado cuando se crea un nuevo proyecto de aplicación

Web. Para ver cómo funciona siga estos pasos.

1. Cree un nuevo proyecto de aplicación Web. En un proyecto Visual Basic .NET cambie el elemento de autori-

zación para que sea como el siguiente. En un proyecto Visual C# añada este elemento de autorización:<authorization><deny users="?" />

</authorization>

159

2. Añada la siguiente definición de tabla HTML al formulario Web de inicio de la aplicación:<TABLE id="tblUser" >

<TR><TD>Autenticado</TD><TD><span runat="server" id="spnAuthenticated"></span></TD>

</TR><TR>

<TD>Nombre de usuario</TD><TD><span runat="server" id="spnUserName"></span></TD>

</TR><TR>

<TD>Tipo de Autenticación</TD><TD><span runat="server" id="spnAuthenticationType"></span></TD>

</TR></TABLE>

3. Cambie el formulario Web a modo diseño y alada el siguiente código al módulo de código del formularioWeb:Visual Basic .NETPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.LoadspnAuthenticated.InnerText = User.Identity.IsAuthenticatedspnUserName.InnerText = User.Identity.Name

spnAuthenticationType.InnerText = User.Identity.AuthenticationTypeEnd Sub


spnAuthenticated.InnerText = User.Identity.IsAuthenticated.ToString();spnUserName.InnerText = User.Identity.Name;spnAuthenticationType.InnerText = User.Identity.AuthenticationType;

}

4. Ejecute la aplicación.

Cuando se ejecuta el proyecto en local ASP.NET autentica al usuario utilizando el nombre que se utilizó paraentrar en Windows. Cuando se ejecuta de forma remota (como en Internet) ASP.NET muestra un diálogo de co-nexión para pedir el nombre de usuario y contraseña.

Si el nombre de usuario y contraseña están autorizados en el dominio de red ASP.NET autentica al usuario yle autoriza el uso de la aplicación. La aplicación se ejecuta utilizando los permisos de la cuenta del usuario.

Cuando se autoriza a un usuario ASP.NET emite un certificado de autorización en forma de una cookie que persiste durante el tiempo de la sesión del usuario. La sesión de usuario termina cuando el navegador se cierra ocuando la sesión alcanza el tiempo límite de inactividad.

La autenticación integrada de Windows trabaja mejor en una red basada en dominio. Las redes que usan grupos de trabajo en lugar de dominios tienen un uso más limitado de las características de seguridad de red. Las redes basadas en dominio usan un controlador de dominio para identificar y autorizar a los usuarios de la red.

Una de las ventajas principales de la autenticación integrada de Windows es que los usuarios que están co-nectados a la red no tienen que volver a conectarse de nuevo para acceder a la aplicación Web; se les autentica au-tomáticamente. Otra ventaja es que los usuarios corporativos pueden usar los mismos nombres de usuario y contra-

señas de red cuando acceden al sitio Web de forma remota desde casa o durante viajes.La autenticación integrada de Windows también permite establecer otra capa de seguridad permitiendo o

prohibiendo usuarios o grupos de usuarios concretos. Además, la autorización integrada de Windows se superpone acaracterísticas similares que se encuentran en IIS. Las siguientes secciones describen estos temas con más detalle.

8.2.2 Permitir o denegar el acceso a usuarios concretos.Cuando la aplicación usa la autenticación integrada de Windows ASP.NET comprueba la lista de autoriza-

ción del archivo Web.config del proyecto para ver qué usuarios de la red tienen permitido el acceso a la aplicación.Los caracteres asterisco (*) e interrogación (?) tienen un significado especial en la lista de autorización: el carácter *significa todos los usuarios; el carácter ? indica usuarios no autorizados. Por ejemplo, la siguiente lista de autoriza-ción en Web.config exige que todos los usuarios estén autenticados:

<authorization>

<deny users="?" /> </authorization>

Para restringir el acceso a usuarios específicos indique sus nombres separados por comas en un elemento<allow>. Cuando ASP.NET comprueba la lista de autorizaciones en Web.config acepta la primera correspondencia

MCAD/MCSD

160

que coincide. Asegúrese de terminar la lista de autorizaciones con un elemento <deny> para todos los usuarios noaceptados, por ejemplo:

<authorization><allow users="Deanna Meyer, Michael Emanuel" /> <deny users="*" /> 

</authorization>

La lista de autorización anterior solo concede el acceso a dos usuarios, a todos los demás se les deniega.

Además, los dos usuarios autorizados deben tener cuenta con este nombre en el dominio de red.8.2.3 Autorización basada en rol

La autorización basada en rol permite identificar grupos de usuarios para permitir o denegar el acceso segúnsu rol en la organización. En Windows NT y XP los roles corresponden con nombres usados para identificar gruposde usuarios. Windows define varios grupos incorporados, como son Administradores, Usuarios e Invitados. Puedever, modificar o añadir grupos usando la consola de Administración de equipos.

Para permitir o denegar el acceso a ciertos grupos de usuarios añada el elemento <roles> a la lista de autori-zación del archivo Web.config de la aplicación Web. Por ejemplo, la siguiente lista de autorización solo concedeacceso a los usuarios conectados como administradores de red:

<authorization><allow roles="Administradores" /> 

<deny users="*" /> </authorization>

8.2.4 Obtener la identidad del usuarioUna vez que un usuario está autenticado y autorizado la aplicación puede obtener información sobre él usan-

do la propiedad Identity del objeto User . La propiedad Identity devuelve un objeto que incluye información de nombre y rol del usuario, como muestra el siguiente código:


ByVal e As System.EventArgs) Handles MyBase.LoadspnAuthenticated.InnerText = User.Identity.IsAuthenticatedspnUserName.InnerText = User.Identity.NamespnAuthenticationType.InnerText = User.Identity.AuthenticationType

End Sub


spnAuthenticated.InnerText = User.Identity.IsAuthenticated.ToString();spnUserName.InnerText = User.Identity.Name;spnAuthenticationType.InnerText = User.Identity.AuthenticationType;

}

Además, el objeto User proporciona el método IsInRole para determinar el rol del usuario actual:

Visual Basic .NETIf User.IsInRole("Administradores") Then

Hace algoEnd If

Visual C#if(User.IsInRole("Administradores"))// Hace algo.

Estos métodos y propiedades se pueden usar junto con el suceso AuthorizeRequest del módulo Global para personalizar el proceso de autorización del usuario. Por ejemplo, puede usar este método par comprobar el nombredel usuario en un archivo de usuarios en lugar de usar la lista de Web.config.

8.2.5 Configuración de IIS y autenticación WindowsLa configuración de autorización de Web.config se solapa con las opciones disponibles en IIS. Si se configu-

ra la autorización tanto en Web.config como en IIS, se evalúa primero la configuración de IIS y después la deWeb.config. Por lo general, esto significa que se aplica la opción más restrictiva.

Para ver la configuración de autorización en IIS siga estos pasos:

1. En la consola de IIS, pulse con el botón derecho sobre la carpeta de la aplicación Web y seleccione Propieda-des. IIS muestra el diálogo de propiedades de la aplicación.

161

2. Pulse la lengüeta Seguridad de directorios y el botón Modificar en el grupo Control de autenticación y accesoanónimo. IIS muestra el diálogo Métodos de autenticación

El botón Modificar del primer grupo de opciones controla el acceso anónimo por usuarios no autenticados.Quitar la marca es equivalente a especificar <deny users=”?”> en Web.config. Está muy recomendado permitir queIIS controle la contraseña para la cuenta anónima, pero puede ser necesario no hacerlo si la aplicación está distribui-da entre varios servidores.

Las marcas del segundo grupo del diálogo permiten que la aplicación use la autenticación Básica o Implícita

además de la autenticación Windows. Estos métodos proporcionan menos seguridad que la autenticación Windows,de formularios o Passport y se implementan mediante IIS en lugar de ASP.NET.

Puede activar varios métodos de autenticación por medio de IIS. Si se activan varios métodos, puede detectar el que se ha utilizado usando el método AuthenticationType del objeto Identity.

Para más información sobre los modos de autenticación Básico e Implícito consulte la ayuda de IIS.

8.3 Autenticación por formulariosLa autenticación por formularios muestra automáticamente un formulario Web designado para recoger in-

formación de nombre de usuario y contraseña. El código asociado con este formulario autentica y autoriza a losusuarios en base a listas de usuarios guardadas en el archivo Web.config de la aplicación o en una base de datos deusuarios separada.

La ventaja de la autenticación por formularios es que los usuarios no tienen que ser miembros de una red ba-sada en dominio para tener acceso a la aplicación. Otra ventaja es que muchas aplicaciones Web – en concreto sitioscomerciales en que los usuarios piden productos – quieren tener acceso a la información del usuario. La autentica-ción por formularios hace que estos tipos de aplicaciones sean más fáciles de crear.

8.3.1 Activar la autenticación por formulariosLa autenticación por formularios permite crear su propia base de datos de usuarios y validar la identidad de

estos usuarios cuando visitan el sitio Web.

Para usar la autenticación por formularios para identificar y autorizar usuarios siga estos pasos:

1. En Web.config establezca el modo de autenticación como Forms.2. Cree un formulario Web para recoger la información de conexión3. Cree un archivo o base de datos para almacenar los nombres de usuario y contraseñas

4. Escriba código para agregar nuevos usuarios al archivo o base de datos de usuarios5. Escriba código para autenticar a los usuarios contra el archivo o base de datos de usuarios.

Cuando alguien accede a una aplicación Web que usa autenticación por formularios ASP.NET muestra elformulario de conexión especificado en Web.config. Una vez que un usuario está autorizado ASP.NET emite uncertificado de autorización en forma de cookie que persiste el tiempo especificado en la configuración de autentica-ción en Web.config.

La diferencia entre la autenticación integrada de Windows y la autenticación por formularios es que en la se-gunda la aplicación realiza todas las tareas de autenticación y autorización. El programador debe crear formulariosWeb y código para recoger los nombres de usuario y contraseñas y comprobarlos contra una lista de usuarios autori-zados.

La autenticación por formularios usa las clases que se encuentran en el espacio de nombres Sys-

tem.Web.Security. Para usar estas clases en el código debe añadir la sentencia Imports o using al comienzo de cadamódulo que realice autenticación.

Las siguientes secciones describen cómo implementar la autenticación por formularios en la aplicación si-guiente los pasos generales indicados anteriormente en esta sección.

8.3.2 Establecer el modo de autenticación por formularioEl modo de autenticación de una aplicación se establece en el elemento <authorization> del archivo

Web.config. Para que la aplicación utilice autenticación por formulario haga los siguientes cambios:

<authentication mode="Forms" > <forms loginUrl="LogIn.aspx" >

<credentials passwordFormat="Clear"> <user name="June" password="JuneBug"/><user name="Walter" password="Halifax"/>

</credentials></forms>

</authentication>

MCAD/MCSD

162

<authorization><deny users="?" /> 

</authorization>

El anterior fragmento de Web.config muestra un ejemplo simplificado de autenticación por formularios queusa la mayor parte de las opciones predeterminadas e incluye una lista de usuarios. La tabla 8-2 indica todos los posibles atributos para los elementos que componen las opciones de configuración de autenticación por formularios:

Tabla 8. 2: Opciones de configuración de autenticación por formulario en Web.config

Elemento Atributo Descripción<authentication > mode Use el valor Forms para establecer la autenticación por formulario.<forms > name Establece el nombre de la cookie en que se almacena la credencial del usuario. El valor

predeterminado es .authaspx. Si hay en el servidor más de una aplicación que use estaforma de autenticación deberá especificar un nombre diferente para cada una.

loginUrl Establece el nombre del formulario Web que se muestra si el usuario no ha sido autentica-do. Si se omite, el predeterminado es Default.aspx.

protection Establece cómo protege ASP.NET la cookie de autorización almacenada en la máquina delusuario. El predeterminado es All, que encripta y valida los datos. Otros valores posiblesson Encryption, Validation y None

timeout Establece el tiempo en minutos que persiste la cookie de autorización. El valor predetermi-nado es 30. ASP.NET renueva la cookie automáticamente si recibe una petición del usuarioy ha pasado más de la mitad del tiempo asignado.

path Establece la ruta donde se almacena la cookie en la máquina del usuario. El predetermina-do es una barra invertida (\)

<credentials > passwordFormat Establece el algoritmo que se utiliza para encriptar la contraseña de usuario. El predeter-minado es SHA1. Otros posibles valores son MD5 y Clear, que anula la encriptación.

<users > name Indica el nombre de un usuario password Establece la contraseña del usuario.

El elemento <credentials> permite almacenar la lista de usuarios en el archivo Web.config. Esto es cómodo para autenticación sencilla, en la que un administrador añade nuevos usuarios y establece sus contraseñar, pero no esla mejor aproximación si quiere que los usuarios configuren sus propias cuentas o mantengan sus contraseñas.

En estos casos querrá crear un archivo o base de datos de usuarios para almacenar los nombres de usuario ysus contraseñas encriptadas. Usar una base de datos tiene la ventaja añadida de que permite almacenar todo tipo deinformación adicional sobre el usuario, como información de envío e historial de pedidos.

La siguiente sección muestra como autenticar usuarios usando credenciales almacenadas en Web.config. Lassecciones posteriores muestran el método más avanzado (y más complicado) de usar una base de datos.

8.3.3 Crear un formulario Web de conexiónPara autenticar a los usuarios mediante autenticación por formularios necesita crear un formulario Web que

permita que los usuarios se conecten. Este formulario se identifica mediante el nombre indicado en el elemento< forms> en Web.config.

El formulario de conexión puede ser tan sencillo como un par de cajas de texto y un botón, o puede aparecer dentro de otra página con contenido no seguro.

Cuando el usuario pulsa el botón correspondiente la aplicación autentica su nombre de usuario y contraseña,emite un certificado de autenticación y permite el acceso al resto de la aplicación, como muestra el código siguiente.

Visual Basic .NET' Incluya esta línea al comienzo del módulo.Imports System.Web.Security

Private Sub butSignOn_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butSignOn.Click

' Autentica nombre/contraseña en <credentials>.If FormsAuthentication.Authenticate(txtUserName.Text, txtPassword.Text) Then

' Si lo encuentra va a la página de inicio.FormsAuthentication.RedirectFromLoginPage(txtUserName.Text, True)

Else' Si no, elimina la contraseña.txtPassword.Text = ""' Si es el tercer intento, muestra la página de acceso denegado.If CInt(ViewState("Tries")) > 1 Then

Response.Redirect("Denied.htm")Else

' Si no, incrementa el número de intentos.

ViewState("Tries") = CInt(ViewState("Tries")) + 1End If

End IfEnd Sub




163

Visual C#// Incluya esta línea al comienzo del módulo.using System.Web.Security;

private void butSignOn_Click(object sender, System.EventArgs e){// Autentica nombre/contraseña en <credentials>.if (FormsAuthentication.Authenticate(txtUserName.Text, txtPassword.Text))

// Si lo encuentra va a la página de inicio.FormsAuthentication.RedirectFromLoginPage(txtUserName.Text, true);

else{// Si no, elimina la contraseña.txtPassword.Text = "";// Si es el tercer intento, muestra la página de acceso denegado.if (System.Convert.ToInt32(ViewState["Tries"]) > 1)

Response.Redirect("Denied.htm");else

// Si no, incrementa el número de intentos.ViewState["Tries"] = System.Convert.ToInt32(ViewState["Tries"]) + 1;

}}

Hay algunas cuestiones importantes acerca del código anterior.

• La clase FormsAuthentication es parte del espacio de nombres System.Web.Security, de modo que debe in-

cluir o importar el espacio de nombres o calificar completamente las referencias a la clase.• El método Autentícate de la clase FormsAuthentication comprueba el nombre de usuario y la contraseña co-

ntra la lista de usuarios del elemento <credentials> de Web.config.• El método RedirectFromLoginPage de la clase FormsAuthentication muestra la página de inicio de la aplica-

ción. Si los campos de petición de datos están en la página de inicio de la aplicación deberá desactivarlos oindicar de alguna otra forma que la conexiona tenido éxito.

• Si el nombre de usuario y la contraseña no son válidos el código permite al usuario dos intentos más antes demostrar una página de acceso denegado. Esta es una página HTML en lugar de un formulario Web, ya que sedenegará el acceso a todos los formularios Web de la aplicación. Si redirige al usuario a otra página de estaforma asegúrese de que está fuera del alcance de la aplicación.

Use la clase FormsAuthentication para desconectar cuando el usuario termine con la aplicación o cuandoquiera eliminar la cookie de autenticación de su máquina. Por ejemplo, el siguiente código termina el acceso del

usuario a la aplicación y exige que vuelva a conectarse para obtener acceso de nuevo.Visual Basic .NETImports System.Web.Security

Private Sub butSignOut_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butSignOut.Click

' Elimina la cookie de autenticación.FormsAuthentication.SignOut()' Vuelve a la misma página.Response.Redirect("UserInfo.aspx")

End Sub

Visual C#using System.Web.Security;

private void butSignOut_Click(object sender, System.EventArgs e){// Elimina la cookie de autenticación.FormsAuthentication.SignOut();// Redirect Vuelve a la misma página.Response.Redirect("UserInfo.aspx");

}

8.3.4 Autenticar usuarios con una base de datosLas secciones anteriores mostraron cómo autenticar a los usuarios en base a una lista en Web.config. El mé-

todo Autentícate de la clase FormsAuthentication está preparado para leer automáticamente de este archivo. Esto esadecuado si los nombres y contraseñas los crea y mantiene un administrador de sistema, pero si permite que losusuarios creen sus propios nombres de usuario o cambien sus contraseñas necesitará almacenar esta informaciónfuera de Web.config. Esto se debe a que los cambios en este archivo en tiempo de ejecución provocan el reinicio dela aplicación, lo que reinicia todas las variables de estado de aplicación y de sesión utilizadas.

Puede almacenar los nombres de usuario y contraseñas en cualquier tipo de archivo; sin embargo el uso deuna base de datos tiene las siguientes ventajas.



MCAD/MCSD

164

• Los nombres de usuario se pueden usar como clave primaria para almacenar información sobre el usuario.• Las bases de datos pueden proporcionar altas prestaciones para el acceso a los nombres de usuario y contra-

señas.• El añadido, modificación y acceso están estandarizados mediante SQL.

Cuando almacena nombres de usuario y contraseñas en una base de datos tiene la opción de encriptarlosusando el método HashPasswordForStoringInConfigFile. Este método utiliza los algoritmos SHA1 o MD5, y semostrará en el ejemplo del apartado siguiente, dentro de la función auxiliar AddUser .

Las siguientes secciones muestran cómo añadir nuevos nombres de usuario y contraseñas a una base de datossencilla y cómo usar la base de datos para autenticar a los usuarios.

8.3.5 Añadir usuarios a una base de datosPara añadir usuarios a una base de datos recoja su nombre y contraseña en dos TextBox y proporcione un

procedimiento de suceso para añadir el usuario que muestre un mensaje indicando si ha tenido éxito. El siguiente procedimiento de suceso utiliza la función auxiliar AddUser para añadir el nombre de usuario y contraseña a la basede datos.

Visual Basic .NETPrivate Sub butNewUser_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butNewUser.ClickIf AddUser(txtUserName.Text, txtPassword.Text) Then

spnNote.InnerText = "Añadido usuario."ElsespnNote.InnerText = "Nombre de usuario en uso. Elija uno diferente."

End IfEnd Sub

Visual C#private void butNewUser_Click(object sender, System.EventArgs e){

if (AddUser(txtUserName.Text, txtPassword.Text))spnNote.InnerText = " Añadido usuario.";

elsespnNote.InnerText = " Nombre de usuario en uso. Elija uno diferente.";

}

La función auxiliar AddUser que se muestra a continuación encripta la contraseña antes de insertarla junto

con el nombre de usuario en la base de datos usando la sentencia INSERT de SQL. Si el nombre de usuario ya existeen la base de datos el bloque de control de excepciones captura el error y devuelve False para indicar que no se haañadido al usuario.

Visual Basic .NETPrivate Function AddUser(ByVal UserName As String, ByVal Password As String) _

As Boolean' Declara la variable para registrar éxito o fracaso.Dim bSuccess As Boolean' Encripta la contraseña.Password = FormsAuthentication.HashPasswordForStoringInConfigFile _

(Password, "SHA1")' Crea el comando para insertar el nombre de usuario y la contraseña.Dim oleCommand As New OleDbCommand("INSERT INTO Users" + _

" VALUES('" + UserName + "', '" + Password + "')", oledbUsers)

' Captura los errores si existe el registro.Try

oledbUsers.Open() ' Abre la conexión.' Si se añade el registro, indica éxito.If oleCommand.ExecuteNonQuery() Then bSuccess = True

oledbUsers.Close() ' Cierra la conexión.Catch

bSuccess = False ' Si no, indica fracaso.oledbUsers.Close() ' Cierra la conexión.

End Try' Devuelve el estado de éxito/fracaso.Return bSuccess

End Function




165

Visual C#private bool AddUser(string UserName, string Password){

// Declara la variable para registrar éxito o fracaso.bool bSuccess = false;// Encripta la contraseña.Password = FormsAuthentication.HashPasswordForStoringInConfigFile

(Password "SHA1");// Crea el comando para insertar el nombre de usuario y la contraseña.OleDbCommand oleCommand = new OleDbCommand("INSERT INTO Users" +

" VALUES('" + UserName + "', '" + Password + "')", oledbUsers);// Captura los errores si existe el registro.try{

oledbUsers.Open(); // Abre la conexión.if (oleCommand.ExecuteNonQuery() != 0) { // Si se añade, indica éxito.

bSuccess = true;oledbUsers.Close(); // Cierra la conexión.

}}catch{

bSuccess = false; // Si no, indica fracaso.oledbUsers.Close(); // Cierra la conexión.

}return bSuccess; // Devuelve éxito/fracaso.

}

8.3.6 Autenticar usuarios contra una base de datosCuando se autentican usuarios contra Web.config se usa el método Autentícate. Cuando se autentican usua-

rios contra una base de datos se debe escribir el código para localizar y comparar nombres de usuario y contraseñas.El siguiente procedimiento de suceso utiliza la función auxiliar CheckPassword para validar el nombre de usuario ycontraseña antes de autenticar al usuario y permitir el acceso a la aplicación.


ByVal e As System.EventArgs) Handles butSignOn.Click' Si encuentra el nombre y contraseña, autoriza el usuario' y muestra la página de inicio.If CheckPassword(txtUserName.Text, txtPassword.Text) Then

FormsAuthentication.RedirectFromLoginPage(txtUserName.Text, True)

Else' Muestra mensaje.spnNote.InnerText = _

"Nombre de usuario o contraseña incorrectos. Pruebe de nuevo."' Permite tres intentos.ViewState("tries") = ViewState("tries") + 1If ViewState("tries") > 3 Then

Response.Redirect("Denied.htm")End If

End IfEnd Sub


// Comprueba el nombre de usuario y contraseña.

if (CheckPassword(txtUserName.Text, txtPassword.Text))// Si los encuentra, muestra la página de inicio.FormsAuthentication.RedirectFromLoginPage(txtUserName.Text, true);

else{// Si no, limpia la contraseña.txtPassword.Text = "";// Muestra el mensaje.spnNote.InnerText =

"Nombre de usuario o contraseña incorrectos. Pruebe de nuevo.";// Si es el tercer intento muestra la página de denegación de acceso.if (System.Convert.ToInt32(ViewState["Tries"]) > 1)

Response.Redirect("Denied.htm");



MCAD/MCSD

166

else{// Si no, incrementa el número de intentos.ViewState["Tries"] = System.Convert.ToInt32(ViewState["Tries"]) + 1;if (System.Convert.ToInt32(ViewState["Tries"]) > 3)

Response.Redirect("Denied.htm");}

}}

La función auxiliar CheckPassword que se muestra a continuación encripta la contraseña, encuentra el regis-tro correspondiente al nombre de usuario y compara la contraseña encriptada con la que hay en la base de datos. Elacceso a la base de datos se realiza en un bloque de control de excepciones para impedir que conflictos de bloqueo provoquen un mensaje al usuario.

Visual Basic .NETPrivate Function CheckPassword(ByVal UserName As String, _

ByVal Password As String) As Boolean' Declara la variable para indicar éxito/error.Dim bSuccess As Boolean' Encripta la contraseña.Password = _

FormsAuthentication.HashPasswordForStoringInConfigFile(Password, "SHA1")' Crea un comando para obtener la fila de la tabla de usuarios.Dim oleCommand As New OleDbCommand("SELECT * FROM Users" + _

" WHERE UserName='" + txtUserName.Text + "'", oledbUsers)' Comprueba errores al usar la base de datos.Try

oledbUsers.Open() ' Abre la conexión.' Lee el registro del usuario.Dim rdrUsers As OleDbDataReader = oleCommand.ExecuteReader()While rdrUsers.Read()

If Password = rdrUsers.Item("Password") Then bSuccess = TrueEnd WhileoledbUsers.Close() ' Cierra la conexión.

CatchbSuccess = False ' Si no, indica fallo.oledbUsers.Close() ' Cierra la conexión.

End Try

Return bSuccessEnd Function

Visual C#private bool CheckPassword(string UserName, string Password){

// Declara la variable para indicar éxito/error.bool bSuccess = false;// Encripta la contraseña.Password = FormsAuthentication.HashPasswordForStoringInConfigFile(Password,

"SHA1");// Crea un comando para obtener la fila de la tabla de usuarios.OleDbCommand oleCommand = new OleDbCommand("SELECT * FROM Users" +

" WHERE UserName='" + txtUserName.Text + "'", oledbUsers);// Comprueba errores al usar la base de datostry{

oledbUsers.Open(); // Abre la conexión.// Lee el registro del usuario.OleDbDataReader rdrUsers = oleCommand.ExecuteReader();while (rdrUsers.Read())

if (Password == rdrUsers["Password"].ToString()) bSuccess = true;oledbUsers.Close(); // Cierra la conexión.

}catch{bSuccess = false; // Si falla indica error.oledbUsers.Close(); // Cierra la conexión.

}return bSuccess;

}

8.4 Autenticación Passport

La autenticación Passport identifica a los usuarios mediante el servicio de conexión única Microsoft Passport.Passport está pensado para proporcionar a los usuarios de Internet una identidad única que puede usar para visitar una gran variedad de sitios Web que precisan autenticación. La información sobre el usuario está disponible para laaplicación mediante un perfil almacenado por Microsoft.




167

La ventaja de la autorización Passport es que el usuario no tiene que recordar nombres de usuario y contrase-ñas diferentes para varios sitios Web, y que el usuario puede mantener su perfil en un único lugar. La autenticaciónPassport proporciona acceso a otros servicios de Microsoft.

8.4.1 Activar la autenticación PassportLa autenticación Passport utiliza el proveedor de autenticación centralizado de Microsoft para identificar a

los usuarios. Passport proporciona una forma para que los usuarios usen una sola identidad en varias aplicacionesWeb. Para usar la autenticación Passport en su aplicación Web debe instalar el SDK de Passport, que está disponible

en el área de descargas de MSDN en http://msdn.microsoft.com/downloads.

El SDK de Passport es gratuito para desarrollo y pruebas. Para colocar un sitio para uso público debe obtener una licencia anual de Microsoft. Puede encontrar más información sobre licencias en http://www.microsoft.com /myservices/passport .

Cuando un usuario accede a una aplicación que implementa autenticación Passport ASP.NET comprueba siexiste una cookie de autorización Passport en la máquina. Si no la encuentra, dirige al usuario a una página de regis-tro Passport. Una vez que el usuario se registra el servicio Passport lo autentica, guarda la cookie de autenticación enel ordenador del usuario y lo devuelve a la página que solicitó originalmente.

Para usar autenticación Passport siga estos pasos.

1. Instale el SDK de Passport. Passport no está incluido con Visual Studio, aunque el marco de trabajo .NET in-cluye clases para trabajar con él una vez instalado.

2. Establezca Passport como modo de autenticación en Web.config. Deniegue la autorización para usuarios noautenticados.

3. Use el suceso PassportAuthentication_OnAuthenticate para acceder al perfil Passport del usuario para identi-ficarlo y autorizarlo.

4. Implemente un procedimiento de desconexión para borrar las cookies Passport de la máquina del usuario.

Por ejemplo, el siguiente Web.config activa la autenticación Passport y exige que todos los usuarios estén au-tenticados.

<authentication mode="Passport" />

<authorization><deny users="?" /> <! -- Niega usuarios no autenticados -->

</authorization>

Cuando se ejecuta la aplicación localmente con esta configuración automáticamente se le redirige a la páginade entrada de Passport. Si tiene instalada la versión limitada (sin licencia) del SDK Passport la página no es la mis-ma que la que se muestra para un sitio desplegado.

Una vez que el usuario se ha registrado Passport guarda una cookie de autorización en su máquina y redirigeal usuario de vuelta a la página que pidió originalmente. Passport almacena un perfil de información sobre la perso-na. Puede acceder a este perfil desde el suceso PassportAuthentication_OnAuthenticate en el módulo Global.asax,como se muestra a continuación:

Visual Basic .NET' Añadir al comienzo del módulo.Imports System.Web.Security

Private Sub PassportAuthentication_OnAuthenticate(ByVal sender As Object, _ByVal e As PassportAuthenticationEventArgs)

' Obtiene la identidad de sesión Passport si está autenticado.If e.Identity.IsAuthenticated Then

Response.Write("Nombre: " & e.Identity.Item("FirstName") & _" " & e.Identity.Item("LastName") & "<br>")

Response.Write("Dirección: " & e.Identity.Item("City") & _" " & e.Identity.Item("PostalCode") & "<br>")

Response.Write("Email: " & e.Identity.Item("PreferredEmail") & "<br>")Response.Write("Passport ID: " & e.Identity.Name & "<br>")

End IfEnd Sub

Visual C#// Añadir al comienzo del módulousing System.Web.Security;



MCAD/MCSD

168

protected void PassportAuthentication_OnAuthenticate(Object sender,PassportAuthenticationEventArgs e){// Obtiene la identidad de sesión Passport si está autenticado.if (e.Identity.IsAuthenticated) {

Response.Write("Name: " + e.Identity["FirstName"] + " "+ e.Identity["LastName"] + "<br>");

Response.Write("Address: " + e.Identity["City"] + " "+ e.Identity["PostalCode"] + "<br>");

Response.Write("Email: " + e.Identity["PreferredEmail"] + "<br>");

Response.Write("Passport ID: " + e.Identity.Name + "<br>");}

}

Este código muestra el nombre del usuario, su localización e información de identidad de su perfil Passport.Si ha instalado el SDK Passport limitado la información refleja una cuenta de pruebas en lugar de datos reales.

La información de autorización y perfil de Passport se guarda en cinco cookies diferentes en la máquina delusuario. El SDK de Passport exige que se eliminen estas cookies cuando el usuario abandona la aplicación. El si-guiente procedimiento de suceso muestra cómo desconectar borrando las cookies Passport.

Visual Basic .NETPrivate Sub butSignOut_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butSignOut.Click' Desconecta borrando las cookies Passport.

Response.Cookies("MSPProf").Expires = NowResponse.Cookies("MSPAuth").Expires = NowResponse.Cookies("MSPSecAuth").Expires = NowResponse.Cookies("MSPProfC").Expires = NowResponse.Cookies("MSPConsent").Expires = Now' Vuelve a mostrar la página (vuelve a registro).Response.Redirect("UserInfo.aspx")

End Sub

Visual C#private void butSignOut_Click(object sender, System.EventArgs e){

// Desconecta borrando las cookies Passport.Response.Cookies["MSPProf"].Expires = DateTime.Now;Response.Cookies["MSPAuth"].Expires = DateTime.Now;Response.Cookies["MSPSecAuth"].Expires = DateTime.Now;

Response.Cookies["MSPProfC"].Expires = DateTime.Now;Response.Cookies["MSPConsent"].Expires = DateTime.Now;// Vuelve a mostrar la página (vuelve a registro).Response.Redirect("UserInfo.aspx");

}

La autenticación Passport también proporciona características comerciales y de protección de menores adi-cionales que se explican en el SDK.

8.5 Proporcionar comunicaciones segurasHasta ahora hemos tratado la seguridad como un asunto de identificar usuarios e impedir que usuarios no au-

torizados accedan a las aplicaciones Web, pero igualmente importante es asegurar que los datos sensibles enviados através de la red no son leídos por otros.

Para proporcionar comunicaciones seguras en Internet IIS soporta un medio estandarizado de encriptado ydesencriptado de peticiones y respuestas Web. Esta criptografía precisa de una clave de encriptado denominadacertificado de servidor de un tercero independiente llamado Autoridad de Certificación.

8.5.1 Activar la comunicación seguraLa capa de comunicaciones seguras (Secure Socket Layer, SSL) es el medio estándar para asegurar que los

datos enviados sobre Internet no pueden ser leídos por otros. Cuando un usuario solicita una página Web segura elservidor genera una clave de encriptado para la sesión de usuario y encripta los datos de la página antes de enviar una respuesta. En el lado cliente, el navegador usa la misma clave para desencriptar la respuesta y para encriptar nuevas peticiones enviadas a la página.

El uso de SSL en su aplicación precisa una autorización especial de una Autoridad de Certificación reconoci-da. Esta autorización tiene la forma de un certificado de servidor que se instala en IIS para identificar el servidor. La

Autoridad de Certificación licencia certificados de servidor (por una tarifa) y actúa como punto en el que verificar la identidad de su servidor en Internet.

Cuando uniusuario inicia una comunicación segura solicita el certificado de servidor y lo comprueba contrauna lista de sitios de confianza que proporciona la Autoridad de Certificación. Si el certificado de servidor no co-




169

rresponde con alguno de los sitios ya autorizados por el usuario, o si no corresponde a la dirección Web para la quese registró, o si hay algún otro problema con él, el navegador muestra un aviso.

De esta forma la Autoridad de Certificación no solo proporciona encriptado para transmisión de datos segura,sino que también proporciona a los usuarios la seguridad de que el sitio Web es auténtico. La mayor Autoridad deCertificación es VeriSign Inc. En el momento de escribir el libro, además de sus servicios de pago ofrecía certifica-dos de prueba gratuitos para evaluación en http://www.verisign.com.

Para usar SSL en su aplicación Web siga estos pasos:

1. Genere una petición de certificado desde IIS2. Solicite un certificado a una Autoridad de Certificación3. Instale el certificado en el servidor usando IIS4. Instale el certificado en navegadores si está usando un certificado de prueba5. Use el protocolo seguro (https:) cuando acceda a las páginas seguras de la aplicación.

Las siguientes secciones describen estos pasos con mayor detalle.

8.5.2 Generar una petición de certificadoAntes de poder solicitar un certificado a una Autoridad de Certificación debe generar una petición de certifi-

cado desde IIS. La petición de certificado contiene información encriptada sobre el servidor que la Autoridad deCertificación utiliza para identificar el servidor en Internet.

1. Seleccione Sitio Web predeterminado en la lista de carpetas en el lado izquierdo de la ventana de IIS y selec-cione Propiedades en el menú Acción. IIS muestra el diálogo de Propiedades de Sitio Web predeterminado.2. Pulse la lengüeta Seguridad de directorios, y el botón Certificado de servidor. IIS inicia el asistente de certifi-

cado de servidor Web.3. Siga los pasos del servidor pulsando Siguiente en cada pantalla. Las instrucciones del servidor son directas.4. Cuando termine, el asistente crea un archivo de texto encriptado con la extensión .cer. Este archivo es la peti-

ción de certificado que se envía a la Autoridad de Certificación.

IIS exige que se cree el certificado a nivel raíz del servidor antes de que se puedan crear o configurar comu-nicaciones seguras para sitios subordinados del servidor. Por este motivo se selecciona el sitio Web predeterminado(o el sitio Web raíz si lo ha renombrado) en el paso 1. Después de instalar un certificado de servidor en la raíz puederepetir el proceso para sitios subordinados si quiere certificados separados para ellos.

8.5.3 Solicitar un certificadoEl proceso de solicitar un certificado de servidor a una Autoridad de Certificación varía dependiendo de la

Autoridad de Certificación que se seleccione. Como se mencionó anteriormente VeriSign proporciona certificadosde prueba gratuitos, lo que cuadra muy bien con los objetivos de este libro.

Para solicitar un certificado de servidor siga estos pasos.

1. Visite el sitio Web de la Autoridad de Certificación y solicite un certificado de servidor para SSL. Los dife-rentes niveles de seguridad y soporte normalmente se basan en una tarifa anual.

2. Seleccione el tipo de certificado de servidor que quiere solicitar y complete la información de registro de la petición.

3. Copie o envíe por correo electrónico la petición de certificado creada en la sección anterior a la Autoridad deCertificación.

Una vez aprobada la petición, la autoridad de certificación le enviará el certificado de servidor como parte de

un mensaje de correo electrónico. Guarde el certificado como archivo de texto con la extensión .cer cortando y pe-gando en el Block de Notas u otro editor.

8.5.4 Instalar el certificadoDespués de grabar el certificado de servidor puede instalarlo en IIS para activar SSL para sus aplicaciones

Web. Siga estos pasos:

1. Seleccione el sitio Web predeterminado en la lista de carpetas a la izquierda de la ventana de IIS y seleccionePropiedades en el menú Acción. IIS muestra el diálogo de propiedades del sitio Web predeterminado.

2. Pulse en la lengüeta Seguridad de Directorios y en el botón Certificado de Servidor. IIS inicia el Asistente decertificados de servidor.

3. Pulse Siguiente y seleccione Procesar la petición pendiente e instalar el certificado.4. Pulse Siguiente y escriba el nombre del archivo de certificado creado en la sección anterior.

5. Pulse Siguiente y después Finalizar para completar la instalación.



MCAD/MCSD

170

8.5.5 Usar comunicaciones segurasDespués de instalar el certificado de servidor las comunicaciones seguras están activadas para cualquier pá-

gina solicitada mediante el protocolo seguro de transferencia de hipertexto (https).

El protocolo https: es el que inicia la comunicación segura. Cuando se ha comenzado una comunicación se-gura, esta continúa hasta que se especifica un sitio no seguro. Para terminar una comunicación segura hay que indi-car el protocolo http, no basta con utilizar una dirección relativa.

IIS permite que se exija comunicación segura para carpetas o archivos específicos en la aplicación Web. Estoimpide que los usuarios vean accidentalmente (o intencionadamente) una página segura usando el protocolo http: noseguro.

Para exigir comunicación segura para una página Web usando IIS siga estos pasos:

1. Seleccione la carpeta o archivo que exige comunicación segura y Propiedades en el menú Acción. IIS mues-tra el diálogo de Propiedades del archivo o carpeta.

2. Pulse la lengüeta Seguridad de archivo o Seguridad de directorio y el botón Modificar en el grupo Comuni-caciones seguras. IIS muestra el diálogo Comunicaciones seguras.

3. Seleccione Exigir canal seguro (IIS) y pulse Aceptar.

Cuando se exige comunicación segura para una página Web la página no se puede ver mediante el protocolohttp:. El usuario debe escribir el protocolo https: o pulsar en un enlace que lo incluya; en caso contrario se deniegael acceso.

Como la diferencia entre http y https está poco clara para que la recuerden los usuarios es importante propor-cionar un punto de entrada http para la aplicación que dirija a las páginas seguras https. El punto de entrada http puede ser simplemente una página predeterminada que automáticamente redirija al usuario al sitio seguro. La exi-gencia de comunicación segura para un sitio web completo es una forma rápida de reducir el tráfico a cero.

8.6 Resumen• La autenticación es el proceso de identificar a los usuarios. La autorización es el proceso de autorizar el acce-

so a estos usuarios.• El método predeterminado de acceso a la aplicación Web es el acceso anónimo. Los usuarios anónimos ob-

tienen acceso mediante la cuenta de usuario Windows IUSR_nombremaquina.• ASP.NET proporciona tres modos de autenticación diferentes mediante el espacio de nombres Sys-

tem.Web.Security: Windows, Forms y Passport• Las páginas HTML no se incluyen automáticamente en la autenticación ASP.NET. Para asegurar que los

usuarios se autentican antes de poder ver este tipo de archivos use IIS para hacer corresponder las extensio-nes de archivo .htm y .html con el ejecutable ASP.NET.

• Para exigir la autenticación añada el elemento <deny users=”?”> en la sección de autorización deWeb.config. Esto se aplica a los tres modos de autenticación.

• Use el elemento <authorization> para permitir o denegar el acceso a los usuarios bajo autenticación Win-dows.

• Use el elemento <credentials> o una base de datos externa para permite a los usuarios bajo autenticación deformularios.

• Al cambiar el archivo Web.config se reinicia la aplicación Web, por lo que no es buena idea añadir usuariosal elemento <credentials> en tiempo de ejecución. Utilice en su lugar un archivo o base de datos externos pa-ra almacenar los nombres de usuario y las contraseñas.

•

Instale el SDK de Passport para activar las clases Passport en el espacio de nombres System.Web.Security.• Para activar comunicaciones seguras, encriptadas, en Internet instale un certificado de servidor y utilice el

protocolo https.

8.7 Práctica: Crear una aplicación seguraEn esta práctica va a crear una aplicación sencilla que usa autenticación por formularios para identificar y au-

torizar usuarios. La aplicación permite que los nuevos usuarios añadan su nombre de usuario y contraseña y que losexistentes se conecten, y muestra la identidad del usuario una vez que se ha conectado.

8.7.1 Activar la autenticación por formulariosPara activar la autenticación por formularios cree una nueva aplicación ASP.NET y abra el archivo

Web.config generado para el proyecto. Haga al elemento <authentication> los cambios siguientes:

<authentication mode="Forms"><forms loginUrl="LogIn.aspx"><credentials passwordFormat="SHA1"></credentials>

</forms></authentication>

171

La autenticación anterior activa la autenticación por formularios, dirige a los usuarios no autenticados a la página LogIn.aspx y activa el encriptado de contraseñas mediante el algoritmo SHA1. Para exigir la autenticaciónusando esta configuración añada al archivo Web.config el siguiente elemento <authorization>:

<authorization><deny users="?" /> 

</authorization>

La anterior configuración de autorización deniega el acceso a los usuarios no autenticados, forzando la auten-

ticación. Cuando haya hecho los cambios en Web.config puede crear el formulario Web LogIn.aspx para añadir nuevas cuentas y conectar los usuarios existentes.

8.7.2 Crear el formulario Web LogInEn este ejercicio creará un formulario Web llamado LogIn.aspx y un archivo de datos llamado Users.xml que

se usan para autenticar a los usuarios. Como este es un ejemplo simplificado, LogIn.aspx permite que los usuarioscreen una nueva cuenta si no se encuentra su nombre.

En el mundo real se dirigiría a los usuarios a una formularios Web diferente para crear nuevas cuentas o lascrearía un administrador que después enviaría la contraseña por correo al usuario. En ambos casos los conceptos sonlos mismos.

Para crear el archivo de datos Users.xml use Visual Studio o un editor de texto para crear un archivo de textoque contenga la línea:

<users name="" password="" />

El ejemplo usará este archivo como plantilla para guardar los nombres de usuario y contraseñas. Como lascontraseñas estarán encriptadas el primer nombre y contraseña estarán en blanco – se puede borrar esta línea másadelante, cuando se hayan añadido otros nombres de usuario y contraseñas.

A continuación cree el formulario Web LogIn.aspx. Este formulario contiene cajas de texto, validaciones yotros controles, como muestra la siguiente tabla:

Tipo de control Propiedad ValorTextBox ID txtUserNameRequiredFieldValidator ID vldUserName

ControlToValidate txtUserNameErrorMessage El nombre es imprescindible

TextBox ID txtPassword TextMode Password

RequiredFieldValidator ID vldPassword ControlToValidate txtPassword ErrorMessage La contraseña es imprescindible

Button ID butSignOnText Entrar

Button ID butAddUser Text Agregar UsuarioVisible False

Label ID lblStatus

Comience a escribir el código para LogIn.aspx añadiendo la siguiente línea al inicio del módulo de código.

Visual Basic .NETImports System.Web.Security

Visual C#using System.Web.Security;

Añada el siguiente código al suceso Click del control butSignOn para comprobar el nombre y contraseña delusuario e indicar al usuario si no se encuentra el nombre. El procedimiento de suceso usa dos funciones auxiliares:UserExists para comprobar si existe el nombre de usuario en Users.xml y PasswordValid para comprobar si la con-traseña es válida.



MCAD/MCSD

172


ByVal e As System.EventArgs) Handles butSignOn.Click' Comprueba el nombre de usuario.If UserExists(txtUserName.Text) Then

' Comprueba la contraseña (encriptada).If PasswordValid(txtUserName.Text, txtPassword.Text) Then

' Conecta al usuario.FormsAuthentication.RedirectFromLoginPage(txtUserName.Text, True)

Else' Muestra un mensaje de contraseña no válida.lblStatus.Text = "Contraseña no corresponde. Prueba de nuevo."

End IfElse

' Si no encuentra el nombre de usuario ofrece añadirlo.lblStatus.Text =

"Nombre de usuario no existe. Pulse Agregar para añadirlo ahora."' Hace visible el botón Añadir.butAddUser.Visible = True

End If' Control de intentos.Session("Tries") = CInt(Session("Tries")) + 1If Session("Tries") > 2 Then

' Tras el tercer intento niega el acceso.Response.Redirect("Denied.htm")End If

End Sub


// Comprueba el nombre de usuario.if (UserExists(txtUserName.Text))

// Comprueba la contraseña (encriptada).if (PasswordValid(txtUserName.Text, txtPassword.Text))

// Conecta al usuario.FormsAuthentication.RedirectFromLoginPage(txtUserName.Text, true);

else// Muestra un mensaje de contraseña no válida.

lblStatus.Text = " Contraseña no corresponde. Prueba de nuevo.";else{// Si no encuentra el nombre de usuario ofrece añadirlo.lblStatus.Text =

" Nombre de usuario no existe. Pulse Agregar para añadirlo ahora.";// Hace visible el botón Añadir.butAddUser.Visible = true;

}// Control de intentos.ViewState["Tries"] = System.Convert.ToInt32(ViewState["Tries"]) + 1;if (System.Convert.ToInt32(ViewState["Tries"]) > 3)

Response.Redirect("Denied.htm");}

Las funciones UserExists y PasswordValid cargan el archivo Users.xml en un conjunto de datos y buscan en

él un nombre de usuario y contraseña. Si encuentran una correspondencia las funciones devuelven true y en casocontrario false.

Visual Basic .NETPrivate Function UserExists(ByVal UserName As String) As Boolean

' Crea un conjunto de datos para leer el archivo XML.Dim dsUsers As New DataSet()' Control de errores por si falta el archivo.Try

' Construye la ruta del archivo Users.xml.Dim strXMLFile As String = Server.MapPath(Request.ApplicationPath) &_

"\Users.xml"' Lee el archivo.dsUsers.ReadXml(strXMLFile, XmlReadMode.InferSchema)




173

' Para cada fila de la tabla Users.Dim rowUser As DataRowFor Each rowUser In dsUsers.Tables("Users").Rows

' Comprueba si el nombre corresponde.If rowUser("name") = UserName Then

Return TrueExit For

End IfNext

Catch' En caso de error devuelve False.Return False

End TryEnd Function

Private Function PasswordValid(ByVal UserName As String, _ByVal Password As String)

' Crea un conjunto de datos para leer el archivo XML.Dim dsUsers As New DataSet()' Usa control de errores por si falta el archivo.Try

' Construye la ruta del archivo Users.xml.Dim strXMLFile As String = Server.MapPath(Request.ApplicationPath) &_

"\Users.xml"

' Lee el archivo.dsUsers.ReadXml(strXMLFile, XmlReadMode.InferSchema)' Para cada fila de la tabla Users.Dim rowUser As DataRowFor Each rowUser In dsUsers.Tables("Users").Rows

' Comprueba si el nombre corresponde.If rowUser("name") = UserName Then

If rowUser("password") = FormsAuthentication. _HashPasswordForStoringInConfigFile (Password, "SHA1") Then

Return TrueExit For

End IfEnd If

NextCatch

' En caso de error devuelve false.Return False

End TryEnd Function

Visual C#private bool UserExists(string UserName){

// Crea un conjunto de datos para leer el archivo XML.DataSet dsUsers = new DataSet();// Usa control de errores por si falta el archivo.try{

// Construye la ruta del archivo Users.xml.string strXMLFile = Server.MapPath(Request.ApplicationPath) + "\\Users.xml";// Lee el archivo.

dsUsers.ReadXml(strXMLFile, XmlReadMode.InferSchema);// Para cada fila de la tabla Users.foreach (DataRow rowUser in dsUsers.Tables["Users"].Rows)

// Comprueba si el nombre corresponde.if (rowUser["name"].ToString() == UserName) return true;

}catch// En caso de error devuelve false.return false;

// Si ha terminado sin encontrar el nombre, devuelve falsereturn false;

}

private bool PasswordValid(string UserName, string Password){// Crea un conjunto de datos para leer el archivo XML.DataSet dsUsers = new DataSet();



MCAD/MCSD

174

// Usa control de errores por si falta el archivo.try{

// Construye la ruta del archivo Users.xml.string strXMLFile = Server.MapPath(Request.ApplicationPath) + "\\Users.xml";// Lee el archivo.dsUsers.ReadXml(strXMLFile, XmlReadMode.InferSchema);// Para cada fila de la tabla Users.foreach (DataRow rowUser in dsUsers.Tables["Users"].Rows)

// Comprueba si el nombre corresponde.

if (rowUser["name"].ToString() == UserName)if (rowUser["password"].ToString() == FormsAuthentication.

HashPasswordForStoringInConfigFile(Password, "SHA1")) return true;}catch

// En caso de error devuelve false.return false;

// Si termina sin encontrar correspondencia devuelve false.return false;

}

La función PasswordValid del código anterior usa el método HashPasswordForStoringInConfigFile porquelas contraseñas están guardadas usando encriptado. AddUser también usa la misma función cuando guarda la contra-seña en Users.xml como se muestra a continuación.

Visual Basic .NETPrivate Sub butAddUser_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butAddUser.ClickIf AddUser(txtUserName.Text, txtPassword.Text) Then

' Muestra éxito.lblStatus.Text = "Añadido usuario. Pulse Entrar para continuar."' Oculta el botón.butAddUser.Visible = False

Else' Muestra fracaso.lblStatus.Text = "No se pudo añadir el usuario. Elija otro nombre."

End IfEnd Sub

Private Function AddUser(ByVal UserName As String, ByVal Password As String)' Si el usuario existe, devuelve False y termina.

If UserExists(UserName) ThenReturn FalseExit Function

End If' Si no, lo añade al archivo XML.Dim dsUsers As New DataSet()' Usa control de errores por si no existe el archivo.Try

' Construye la ruta del archivo Users.xml.Dim strXMLFile As String = Server.MapPath(Request.ApplicationPath) & _

"\Users.xml"' Lee el archivo.dsUsers.ReadXml(strXMLFile, XmlReadMode.InferSchema)' Crea una nueva fila.

Dim rowUser As DataRow = dsUsers.Tables("users").NewRow()' Establece el nombre de usuario.rowUser("name") = UserName' Establece la contraseña (encriptada).rowUser("password") = FormsAuthentication. _

HashPasswordForStoringInConfigFile(Password, "SHA1")' Añade la fila.dsUsers.Tables("users").Rows.Add(rowUser)' Escribe el conjunto de datos.dsUsers.WriteXml(strXMLFile)Return True

Catch' En caso de error devuelve False.Return FalseEnd Try

End Function




175

Visual C#private void butAddUser_Click(object sender, System.EventArgs e){

if (AddUser(txtUserName.Text, txtPassword.Text)) {// Muestra éxito.lblStatus.Text = "Usuario añadido. Pulse Entrar para continuar.";// Oculta el botón.butAddUser.Visible = false;

}else// Muestra fracaso.

lblStatus.Text = "No se pudo añadir el usuario. Elija otro nombre.";}

private bool AddUser(string UserName, string Password){// Si el usuario ya existe, devuelve False y sale.if (UserExists(UserName)) return false;// Si no, añade el usuario al archivo XML.DataSet dsUsers = new DataSet();// Usa control de errores por si falta el archivo.try{

// Construye la ruta del archivo Users.xml.string strXMLFile = Server.MapPath(Request.ApplicationPath) + "\\Users.xml";// Lee el archivo.dsUsers.ReadXml(strXMLFile, XmlReadMode.InferSchema);// Crea una nueva fila.

DataRow rowUser = dsUsers.Tables["users"].NewRow();// Establece el nombre de usuario.rowUser["name"] = UserName;// Establece la contraseña (encriptada).rowUser["password"] = FormsAuthentication.HashPasswordForStoringInConfigFile

(Password, "SHA1");// Añade la fila.dsUsers.Tables["users"].Rows.Add(rowUser);// Escribe el conjunto de datos.dsUsers.WriteXml(strXMLFile);return true;

}catch// En caso de error devuelve false.return false;

}

8.7.3 Mostrar información de usuarioEn este ejercicio va a crear el formulario Web UserInfo.aspx para mostrar el nombre e información de auten-

ticación del usuario usando el objeto Identity de la clase User. También creará una página HTML para mostrar si sedeniega el acceso. Como la páginas HTML no se incluyen automáticamente en el esquema de autenticación de unaaplicación Web los usuarios podrán acceder a esta página incluso aunque no se autentiquen.

Cree el formulario Web UserInfo.aspx y haga que sea la página de inicio de la aplicación. Los usuarios noautenticados serán dirigidos primero a la página LogIn.aspx, porque esta es la página de conexión indicada enWeb.config. Después de ser autenticados se les dirige a la página de inicio de la aplicación usando el método Redi-rectFromLoginPage.

La página UserInfo.aspx contiene una tabla en la que muestra el nombre e información de autenticación del

usuario y un botón para permitir que el usuario desconecte de la aplicación. La tabla contiene elementos <span>como espacios para los datos de usuario, como muestra el siguiente HTML:

<H2>Autenticación por Formularios</H2><TABLE id="tblUser" borderColor="black" cellSpacing="1" cellPadding="1"

width="500" bgColor="aliceblue" border="1"><TR>

<TD>Autenticado</TD><TD><SPAN id="spnAuthenticated" runat="server"></SPAN></TD>

</TR><TR>

<TD>Nombre de Usuario</TD><TD><SPAN id="spnUserName" runat="server"></SPAN></TD>

</TR><TR>

<TD>Tipo de Autenticación</TD><TD><SPAN id="spnAuthenticationType" runat="server"></SPAN></TD>

</TR>



MCAD/MCSD

176

</TABLE><P><asp:Button id="butSignOut" runat="server" Text="Salir"></asp:Button></P>

El suceso Page_Load del formulario Web obtiene la información de usuario para mostrar, como se ve aquí.


ByVal e As System.EventArgs) Handles MyBase.Load' Muestra información de autenticación del usuario.spnAuthenticated.InnerText = User.Identity.IsAuthenticated()

spnUserName.InnerText = User.Identity.Name()spnAuthenticationType.InnerText = User.Identity.AuthenticationType()End Sub


// Muestra información de autenticación del usuario.spnAuthenticated.InnerText = User.Identity.IsAuthenticated.ToString();spnUserName.InnerText = User.Identity.Name;spnAuthenticationType.InnerText = User.Identity.AuthenticationType;

}

Después de crear el formulario Web UserInfo.aspx agregue a la aplicación una página HTML llamada De-nied.html. Esta es la página que muestra el formulario Web LogIn.aspx si el usuario no introduce un nombre deusuario y contraseña correctos después de tres intentos. Denied.htm incluye un mensaje para el usuario, como mues-

tra el siguiente HTML:<H2>Acceso denegado</H2><p>Para usar esta aplicación debe introducir un nombre de usuario y contraseña vá-lidos</p>

8.7.4 Temas avanzadosLos ejercicios anteriores muestran cómo implementar la autenticación por formularios paso a paso . Para ob-

tener una comprensión completa de otros tipos de autenticación puede experimentar cambiando el modo de autenti-cación en el archivo Web.config de la aplicación.

• Para cambiar a autenticación Windows comente el elemento <authentication> actual en Web.config y añadael que se muestra aquí: <authentication mode="Windows" />

•

Para cambiar a autenticación Passport instale el SDK de Passport y modifique el elemento <authentication>como se muestra a continuación: <authentication mode="Passport" />

Finalmente, como extra, obtenga un certificado de servidor de una Autoridad de Certificación, como Veri-Sign e implemente comunicaciones seguras en la aplicación. Use el protocolos https para activar comunicacionesseguras, como se indica en la lección 8.5.



1. ¿Qué modo de autenticación de ASP.NET está mejor adaptado a identificar y autorizar usuarios pertenecien-tes a una red corporativa?

2. ¿Cuál es la diferencia entre las listas de usuarios para autenticación Windows o de formularios enWeb.config?

3. ¿Cómo se exige la autenticación usando el archivo Web.config?(La respuesta es la misma para todos los mo-dos de autenticación ASP.NET)

4. ¿Cómo proporciona SSL seguridad en una aplicación Web?

5. ¿Cómo se comienza y se termina una comunicación segura mediante SSL?




177

9 Generar y desplegar aplicacionesEn este capítulo aprenderá cómo publicar su aplicación Web terminada en un servidor Web para uso general.

También aprenderá cómo controlar y mantener la aplicación cuando está en uso, de modo que siga comportándose bien al cambiar las demandas de los usuarios.

Para completar este capítulo debe:

• Tener acceso a un servidor Web, ya sea mediante un servicio de alojamiento Web o en su red de área local.• Haber completado con éxito una o más de las aplicaciones Web de este libro.• Estar familiarizado con Internet Information Services (IIS) y la consola de administración de Microsoft (Mi-

crosoft Management Console, MMC).• Tener instalado Microsoft Visual Studio .NET Profesional, Enterprise Developer o Enterprise Architect. Este

requisito solo se aplica a la última lección del capítulo.

9.1 Generar una aplicación WebEn su forma más sencilla, generar una aplicación Web en Visual Studio .NE no precisa casi ningún esfuerzo.

De hecho, la aplicación se genera automáticamente cada vez que se pulsa Iniciar durante el desarrollo y depurado dela aplicación.

Sin embargo, cuando la aplicación está lista para su despliegue hay que ejecutar tres pasos adicionales antesde generarla:

1. Configurar las opciones de generación2. Identificar la aplicación3. Configurar la aplicación

En esta aplicación aprenderá cómo llevar a cabo estas tareas para preparar su aplicación antes del despliegue.

9.1.1 Configurar las opciones de generaciónLas aplicaciones Web tienen dos opciones de generación: depurado (debug) y distribución (release). Para

cambiarla, siga estos pasos:

1. En el menú Generar seleccione Administrador de configuración. Visual Studio .NET muestra el diálogo Ad-ministrador de configuración.

2. Seleccione la opción y pulse Cerrar.3. Abra el archivo Web.config del proyecto y modifique el elemento compilation para que coincida con la op-

ción seleccionada en el paso 2. Por ejemplo, para una generación de distribución:

<compilation defaultLanguage=”vb” debug=”false” />

Al seleccionar la opción de depurado se genera un archivo de base de datos de programa (.pdb) que contieneinformación sobre los símbolos que se usan dentro de la aplicación cuando se compila el proyecto. Visual Studio.NET usa la base de datos de programa para controlar los valores de variables, establecer puntos de interrupción yevaluar los miembros de la clase Debug.

Si se selecciona la opción de distribución no se genera este archivo, desactivando los miembros de la clase Debug y haciendo que se ignoren los puntos de interrupción. Como las generaciones para distribución no tienen quecontrolar esta información extra se ejecutan más rápido que las de depurado.

La opción de generación de la aplicación y el valor en Web.config deben coincidir. No hay ninguna ventajaen tener uno en depurado y otro en distribución; Visual Studio .NET no cambia automáticamente uno cuando secambia el otro.

9.1.2 Identificar la aplicaciónAntes de desplegar una aplicación debe incluir información sobre la misma, como su título, autor y versión.

Esta información se muestra cuando los usuarios ven las propiedades de versión del ensamblado (.dll) de la aplica-ción en Windows.

Para identificar la aplicación abra el archivo AssemblyInfo y escriba la información de la aplicación en losatributos del ensamblado. Por ejemplo, los siguientes atributos establecen el nombre de producto e información deversión:

Visual Basic .NETImports System.ReflectionImports System.Runtime.InteropServices



MCAD/MCSD

178

' La información general de un ensamblado se controla mediante el siguiente' conjunto de atributos. Cambie estos atributos para modificar la información' asociada con un ensamblado.

' Repase los valores de los atributos del ensamblado

<Assembly: AssemblyTitle("Web Flyer Storefront")><Assembly: AssemblyDescription("Low-price reservation finder.")><Assembly: AssemblyCompany("Contoso Ltd. ")><Assembly: AssemblyProduct("Web Flyer")>

<Assembly: AssemblyCopyright("2002")><Assembly: AssemblyTrademark("Web Flyer is a trademark of Contoso Ltd.")><Assembly: CLSCompliant(True)>

' El siguiente GUID es para el ID de la librería de tipos si' este proyecto se expone a COM<Assembly: Guid("CE84F243-D7D9-4B7E-B43B-520A0D6B9B30")>

' La información de versión de un ensamblado consta de los siguientes cuatro' valores:'' Versión principal' Versión secundaria' Versión de compilación' Revisión

'' Puede especificar todos los valores o usar los valores predeterminados (número' de versión de compilación y de revisión)' usando el símbolo '*' como se muestra a continuación:

<Assembly: AssemblyVersion("2.1.*")>

Visual C#using System.Reflection;using System.Runtime.CompilerServices;

//// La información general de un ensamblado se controla mediante el siguiente// conjunto de atributos. Cambie estos atributos para modificar la información// asociada con un ensamblado.//

[assembly: AssemblyTitle("Web Flyer Storefront")][assembly: AssemblyDescription("Low-price reservation finder.")][assembly: AssemblyConfiguration("")][assembly: AssemblyCompany("Contoso Ltd.")][assembly: AssemblyProduct("Web Flyer")][assembly: AssemblyCopyright("2002")][assembly: AssemblyTrademark("Web Flyer is a trademark of Contoso Ltd.")][assembly: AssemblyCulture("")]

//// La información de versión de un ensamblado consta de los siguientes cuatro// valores://// Versión principal// Versión secundaria

// Versión de compilación// Revisión//// Puede especificar todos los valores o usar los valores predeterminados// (número de versión de compilación y de revisión)// usando el símbolo '*' como se muestra a continuación:

[assembly: AssemblyVersion("2.1.*")]

En el archivo AssemblyInfo se generan automáticamente dos elementos de información:

• El atributo Guid , para identificar el ensamblado ante componentes COM. Solo necesita cambiar este númerosi rompe la compatibilidad con versiones anteriores el ensamblado eliminando o cambiando significativa-mente objetos y miembros públicos usados por componentes COM.

• El atributo AssemblyVersion actualiza automáticamente el número de versión de compilación, indicado por

un asterisco (*). Puede añadir niveles de versión o eliminar el número de compilación si quiere.




179

9.1.3 Configurar la aplicaciónLas aplicaciones Web utilizan archivos de texto para configuración (.config) que determinan la forma en que

se ejecutan. El archivo de configuración de una aplicación Web (Web.config) reside en el directorio raíz de la apli-cación, pero su función en realidad es reemplazar la configuración heredada de las siguientes localizaciones:

• El archivo Machine.config localizado en el directorio Windows\Microsoft.NET\Famework\ versión \ config. Establece la configuración base para todos los ensamblados .NET que corren en el ordenado.

• El archivo Web.config localizado en el directorio raíz de IIS. Establece la configuración base para todaslas aplicaciones Web y sustituye las opciones establecidas en Machine.config.

• Cualquier archivo Web.config encontrado en los directorios superiores de la aplicación. Estas opcionesse heredan de los archivos Web.config encontrado a lo largo de la ruta de la aplicación.

El archivo Web.config utiliza elementos XML para controlar diferentes aspectos de la aplicación Web, comoindica la tabla 9.1. Como estos elementos utilizan sintaxis XML diferencian mayúsculas y minúsculas y se debenescribir tal cual se muestran.

Tabla 9. 1: Atributos de Web.configElemento Uso Para más información:

compilation Indicar el tipo de generación/compilación: build o release Apartado 9.1.1customErrors Mostrar sus propias páginas de error en respuesta a códigos de respuesta HTTP. Capítulo 6authentication Establecer el tipo de autenticación usado para identificar a los usuarios. Capítulo 8authorization Indicar nombres o funciones de usuario autorizados para ejecutar la aplicación. Capítulo 8

trace Activar el seguimiento par ayudar a diagnosticar errores o ajustar prestaciones. Capítulo 6sessionState Determinar cómo guarda ASP.NET las variables de estado de sesión. Sección 9.3 y Capítulo 3.globalization Establecer información cultural para aplicaciones localizadas Capítulo 15

Cuando se hacen cambios en el archivo Web.config de una aplicación IIS reinicia automáticamente la aplica-ción y aplica los cambios. Esto tiene el efecto colateral de reiniciar las variables de estado Application y Session, loque puede afectar negativamente a los usuarios.

Por razones de seguridad, no se puede acceder al archivo Web.config desde un navegador. Si un usuario soli-cita este archivo recibirá un mensaje de error de acceso denegado.

9.2 Desplegar una aplicación WebDesplegar una aplicación Web significa instalar la aplicación en el servidor donde se va a ejecutar. Como las

aplicaciones Web corren en servidores normalmente no necesitan un programa de instalación. En esto las aplicacio-

nes Web se diferencian mucho de las aplicaciones Windows, que se distribuyen a los usuarios en CD-ROM u otromedio y que usan un programa de instalación para instalar y registrar componentes en la máquina del usuario.

En esta lección aprenderá cómo desplegar una aplicación Web terminada en un servicio de alojamiento o ensu propio servidor. También aprenderá acerca de IIS y la configuración de seguridad que necesitan las aplicacionesWeb.

9.2.1 Uso de las herramientas desSubidaSi se registró en un servicio de alojamiento Web ASP.NET como se indicó en el Capítulo 1 puede instalar su

aplicación Web en el servidor de alojamiento directamente desde Visual Studio .NET.

Para instalar su aplicación en un servicio de alojamiento desde Visual Studio .NET siga estos pasos:

1. Abra el proyecto que quiere instalar usando Visual Studio .NET2. En la página de inicio de Visual Studio .NET pulse Alojamiento Web.3. En la página de alojamiento Web pulse la lengüeta Premier Providers o Additional Providers4. En la sección de la página de proveedores que incluya a su proveedor pulse Subir directamente a su cuenta;

Visual Studio muestra la página de subida de su proveedor.5. Siga las instrucciones en la página del proveedor. Estas instrucciones varían ligeramente entre proveedores.

9.2.2 Alojamiento en su propio servidor Si su aplicación está pensada para ejecutarse como parte de una red local o si tiene acceso a su propio servi-

dor Web público instale su aplicación en el servidor siguiendo estos pasos:

1. Use IIS para configurar un directorio virtual para la aplicación.2. Copie la aplicación Web al directorio virtual3. Añada los componentes .NET compartidos a la caché de ensamblados global del servidor.4. Configure los permisos de seguridad del servidor para permitir que la aplicación acceda a los recursos nece-

sarios.Las siguientes secciones describen estos pasos con mayor detalle.



MCAD/MCSD

180

9.2.3 Configurar un directorio virtualLas aplicaciones ASP.NET corren bajo IIS, de modo que antes de que el servidor pueda alojar aplicaciones

ASP.NET tienen que estar instalados tanto IIS como el marco de trabajo Microsoft .NET. ASP.NET necesita lassiguientes versiones de los componentes:

• IIS versión 5.0 o posterior • Marco de trabajo .NET de la misma versión que el utilizado para compilar el ensamblado de la aplicación.

Los discos de distribución de Visual Studio .NET incluyen herramientas para configurar los componentes deservidor necesarios. Cuando haya confirmado que los componentes correctos están instalados en el servidor cree undirectorio virtual para la aplicación siguiendo estos pasos:

1. Usando el explorador de Windows, cree un directorio físico en el servidor para guardar la aplicación2. Usando IIS inicie el Asistente para creación de directorio virtual para crear el nuevo directorio virtual corres-

pondiente a la dirección física creada en el paso 1. En el Capítulo 2 se cubre en detalle este asistente.

9.2.4 Copiar la aplicaciónLos límites de una aplicación Web los define su estructura de directorios. Esto significa que una aplicación

comienza en su directorio raíz y se extiende a todos sus directorios subordinados. De esta forma, instalar una aplica-ción Web es tan sencillo como arrastrar los archivos y subdirectorios desde su directorio de desarrollo hasta su ubi-cación física en el servidor.

En general, los archivos de contenido de una aplicación Web se pueden organizar en subdirectorios de laforma que se quiera. Sin embargo, hay que seguir un par de convenios:

• El ensamblado (.dll) de la aplicación se encuentra en el subdirectorio /bin.• La página de inicio de la aplicación por lo general se denomina Default.aspx o Default.htm.

El que su aplicación use o no una página predeterminada lo impone la configuración de IIS. Una página pre-determinada permite que IIS muestre una página si el usuario no especifica una en su petición.

Nota: No confunda la página predeterminada de IIS con la página de inicio de una aplicación de for-mularios Web en Visual Studio .NET. Visual Studio .NET necesita que se designe una páginade inicio para cada proyecto de modo que el entorno de desarrollo sepa qué página mostrar ri-mero durante el depurado. Esta configuración no tiene efecto en la configuración de página deinicio de IIS.

9.2.5 Instalar componentes compartidos.Si su aplicación usa componentes compartidos con otras aplicaciones en el mismo servidor, como controles

de servidor personalizados, estos componentes se deben instalar en el servidor. Hay tres formas de hacerlo, depen-diendo del tipo de componente.

• Para componentes COM. Copie el componente al servidor y regístrelo usando las herramientas de COM.• Para componentes .NET con nombre débil. Copie el componente al directorio /bin de la aplicación.• Para componentes .NET con nombre fuerte. Instale el componente el en caché de ensamblados global del

servidor.

Los componentes COM por lo general proporcionan un programa de configuración para instalarlos en el sis-tema o eliminarlos de él. Si el componente no proporciona un programa de configuración puede copiarlo en el ser-vidor y registrarlo usando la utilidad RegSvr32 de MFC. Por ejemplo: RegSvr32 MiComponente.dll

Los nombres de componentes .NET tienen dos formas: débil y fuerte. Esta distinción se refiere a cómo se al-macenan los nombres dentro del ensamblado. Los nombres débiles no se garantiza que sean únicos y por tanto no se pueden compartir sin que exista la posibilidad de causar conflictos. Los nombres fuertes están firmados digitalmentey proporcionan una clave pública que asegura que no hay conflictos. Aún más, los componentes .NET con nombrefuerte no pueden llamar a código no administrado (como componentes COM), evitando conflictos potenciales conlas dependencias.

Los componentes .NET con nombre débil se deben copiar individualmente al directorio /bin de las aplicacio-nes Web en las que se usan. Los componentes .NET con nombre fuerte se pueden copiar en el caché de ensambladosglobal.

El caché de ensamblados global es un subdirectorio especial dentro del directorio Windows que almacenalos componentes .NET compartidos. Cuando se abre el directorio Windows Explores inicia una extensión del shell

de Windows llamada Visor del caché de ensamblados (ShFusion.dll).Puede instalar los componentes .NET con nombre fuerte arrastrándolos al Visor del caché o usando la her-

ramienta del caché (GacUtil.exe) de la forma: GacUtil -1 MisControlesServidor.dll

181

9.2.6 Asignar privilegios de seguridad.De forma predeterminada el proceso de trabajo de ASP.NET corres usando la cuenta ASPNET, que se crea

cuando se instala el marco de trabajo .NET. Esta cuenta tiene privilegios limitados, lo que puede provocar errores dedenegación de permiso si su aplicación escribe archivos o intenta leeros fuera de los límites de la aplicación actual.

Si su aplicación necesita privilegios adicionales tiene tres opciones:

• Conceder al usuario ASPNET el acceso a los archivos necesarios. Para usar esta opción el servidor tiene que

tener NTFS como sistema de ficheros.• Cambiar el grupo al que pertenece ASPNET• Utilizar impersonación para ejecutar el proceso bajo otro usuario.

Para conceder al usuario ASPNET acceso a un archivo o directorio siga estos pasos:

1. En el explorador de Windows seleccione Opciones de carpeta en el menú Herramientas. Windows muestra eldiálogo Opciones de carpeta.

2. Pulse la lengüeta Ver y quite la marca en Usar compartición simple de archivos en la parte inferior de la lista.3. En el Explorador de Windows pulse con el botón derecho sobre el archivo o directorio sobre el que quiere

conceder acceso y seleccione Propiedades. Windows muestra el diálogo Propiedades.4. Pulse sobre la lengüeta Seguridad y pulse Agregar para añadir el usuario ASPNET a la lista de usuarios y

grupos.5. Seleccione las cajas de marca en la lista de permisos para otorgar los accesos necesarios. Pulse Aceptar para

hacer losPara cambiar el grupo al que pertenece el usuario ASPNET siga estos pasos.

1. En el menú Inicio seleccione Herramientas administrativas y después Administración de equipos. Windowsmuestra la consola de administración de equipos.

2. Seleccione Usuarios locales y grupos y después Usuarios en la lista de la izquierda.3. Pulse con el botón derecho sobre la cuenta de usuario ASPNET y seleccione Propiedades. La consola de ad-

ministración muestra las propiedades de la cuenta.4. Pulse sobre la lengüeta Miembro de y después Agregar para añadir el usuario ASPNET a un nuevo grupo.

Pulse Aceptar para hacer los cambios y cerrar los diálogos.

Si agrega el usuario ASPNET al grupo Administradores la aplicación Web obtendrá privilegios completossobre el servidor; sin embargo esto origina un riesgo de seguridad porque usuarios externos podrán manipular la

aplicación para atacar al servidor.Para usar la impersonación para ejecutar el proceso ASP.NET como un usuario diferente de ASPNET utilice

el atributo impersonation del elemento identity en el archivo Web.config de la aplicación. Por ejemplo, la siguienteentrada hace que la aplicación se ejecute bajo el usuario WebFlyr:

<identity impersonate=”true” name=”localhost\WebFlyr” password=”hpB14dq1” />

Si la aplicación usa autenticación Windows también puede usar impersonación para pasar la identidad deusuarios autenticados al servidor. Por ejemplo, es siguiente fragmento de Web.config dice a la aplicación que use los permisos del usuario que se conectó:

<identity impersonate="true" /> 

<authorization><deny users="?" /> 

</authorization>Para más información sobre autenticación de usuarios vea el capítulo 8.

9.3 Mantener una aplicaciónDespués de desplegar una aplicación Web necesita controlar cómo se comporta en el servidor. En este mo-

mento pueden aparecer muchos temas, debido al número de usuarios que acceden a la aplicación, la impredeciblenaturaleza de la interacción de los usuraos y la posibilidad de un ataque malicioso.

El mantenimiento de una aplicación desplegada es una tarea continua que implica tres pasos principales:

• Controlar la aplicación respecto a errores, prestaciones y seguridad.• Reparar los problemas que se descubran.• Ajustar la aplicación para que responda al tráfico de usuario.

En esta lección aprenderá cómo realizar estas tareas, así como algunas técnicas de optimización.



MCAD/MCSD

182

9.3.1 Controlar el servidor Después de que la aplicación se haya desplegado necesita controlar el servidor donde se ejecuta para detectar

y corregir problemas relacionados con la seguridad, prestaciones y errores no previstos. Windows proporciona lossiguientes añadidos a la MMC para controlar los sucesos de seguridad, prestaciones y error:

• Visor de Sucesos. Recoge los sucesos de aplicación, sistema y seguridad que se producen en el sistema. Useesta herramienta para ver lo que sucede actualmente en el servidor y obtener información específica sobre unsuceso concreto.

• Registro de Alertas y Rendimiento. Permite crear nuevos sucesos que se mostrarán en el Visor de sucesos yhacer un seguimiento de contadores de sucesos con el tiempo para mostrarlo gráficamente o como informe.

Los siguientes apartados describen con más detalle cómo usar estas herramientas.

Ver SucesosUtilice el Visor de sucesos para ver los sucesos de aplicación, sistema y seguridad tal cual se produzcan.

Para ejecutar el Visor de sucesos selecciónelo en Herramientas administrativas. Windows muestra el aña-dido Visor de sucesos en la consola de administración.

El Visor de sucesos muestra sucesos generales de aplicación, sistema y seguridad a tres niveles: informa-ción, advertencia y error. Para ver información sobre un suceso concreto pulse dos veces sobre él.

Puede usar el visor de sucesos para echar un vistazo de lo que está ocurriendo en el servidor u obtener de-

talles sobre un suceso concreto. Para crear nuevos sucesos o hacer un seguimiento a lo largo del tiempo necesita-rá el Registro de alertas y rendimiento.

Definir nuevos sucesosEn muchos casos los sucesos estándar de sistema, aplicación y seguridad no le indican lo que realmente

quiere saber. Por ejemplo, puede que quiera saber cuándo el número de usuarios conectados a la aplicación ex-cede de 1.000, cuándo se produce una excepción no controlada dentro de la aplicación. Para añadir sucesos comoestos a los registros de contador y seguimiento use el añadido Registro de alertas y rendimiento de MMC. Paraejecutar este añadido pulse dos veces sobre Rendimiento en Herramientas administrativas.

El Registro de alertas y rendimiento permite crear archivos de seguimiento que registran la actividad en elservidor y crear alertas que lanzan sucesos en el Visor de sucesos. Usando esta herramienta puede controlar unaamplia variedad de información sobre el servidor, las aplicaciones que aloja y los usuarios conectados.

Tal vez la mejor forma de comprenderlo sea añadir un suceso para controlar en su propio sistema, comodescriben los siguientes pasos:

1. En la ventana Rendimiento seleccione Alertas en Registros y alertas de rendimiento en el panel izquierdo2. En el menú Acción seleccione Nueva alerta. Verá el diálogo Nueva Alerta.3. Escriba un nombre para identificar la alerta y pulse Aceptar. MMC muestra un diálogo para configurar la

alerta.4. Agregue un suceso para controlar pulsando Agregar. Verá el diálogo Contadores seleccionados.5. Seleccione el elemento hardware o aplicación a controlar en la lista desplegable Objeto de rendimiento. La

lista de contadores se actualiza con los elementos aplicables al objeto seleccionado. Pulse Agregar para aña-dir el contador seleccionado a la alerta. Pulse Cerrar cuando termina.

6. Establezca el criterio que lanza la alerta en el diálogo de configuración escribiendo un número en la caja detexto Límite.

7. Pulse la lengüeta Acción para especificar la acción que debe realizar el servidor cuando se produzca la alerta.

De forma predeterminada el servidor registra la alerta como suceso que se puede ver en el Visor de sucesos.También la puede enviar por correo o escribirla en un registro.

8. Cuando termine pulse Aceptar. La alerta aparece en la lista Alertas.

De forma predeterminada el añadido comienza a controlar la alerta inmediatamente. Puede detener o re-iniciar el control pulsando con el botón derecho sobre la alerta y eligiendo Detener o Iniciar.

Windows lanza la alerta siempre que se cumple el criterio. Para algunos contadores, como los de error,esto significa que después de que se lance la alerta por primera vez se lanza tras cada intervalo. Como la cuentade errores no se reinicia, una vez que se alcance el límite siempre lo supera. Para estas alertas debe ser muy cui-dadoso con la acción que especifique – el envío de correo en respuesta a una cuenta de errores puede provocar un montón de mensajes redundantes.

Crear registros de sucesos

Definir un nuevo suceso creando una alerta es una buena forma de ser notificado en el momento en que se produce un problema o se degrada el rendimiento, pero para hacer un seguimiento de errores y rendimiento debecrear un registro de sucesos. Los registros de sucesos permiten obtener información sobre una amplia variedadde sucesos en el tiempo y mostrar la información gráficamente o en forma de texto.




183

Para crear un registro de suceso siga estos pasos:

1. En el panel izquierdo de la ventana de Rendimiento seleccione Registros de contador, en Registros y aler-tas de rendimiento.

2. En el menú Acción seleccione Nueva configuración de registro. Se muestra el diálogo Nueva configura-ción de registro.

3. Escriba el nombre del registro y pulse Aceptar. Se mostrará la caja de propiedades del registro.4. Puse Agregar para añadir los elementos que se van a controlar en el archivo de registro. Verá el diálogo

Contadores seleccionados. Estos contadores funcionan igual que para las alertas.5. Pulse la lengüeta Archivos de registro para especificar el formato del archivo que se va a crear.6. Los archivos de registro se pueden grabar en formato binario, de texto o de base de datos. Pulse Aceptar

cuando termine; el registro se añadirá a la lista de Registros de contador.

Como con las alertas, el añadido empieza a controlar el nuevo registro inmediatamente. Puede detener oreiniciar el control pulsando con el botón derecho sobre el registro y seleccionando Detener o Iniciar.

Ver registros de sucesosDe forma predeterminada el añadido de Registros y alertas de rendimiento graba los archivos de registro

en el directorio raíz PerfLogs. Para ver el archivo de registro desde dentro del añadido:

1. Seleccione Monitor del sistema en el panel izquierdo de la ventana Rendimiento. Verá el monitor del sis-tema con las estadísticas de rendimiento actuales.

2. Pulse el botón Ver datos del archivo de registro en la barra de herramientas. El añadido mostrará el diálo-

go Propiedades del Monitor del Sistema5.3. Seleccione Archivos de registro y pulse Agregar para especificar un archivo para abrir. El añadido mues-

tra el diálogo Seleccionar archivo de registro.4. Seleccione un archivo de registro a abrir en la carpeta PerfLogs y pulse Abrir para añadirlo al monitor.5. Puse la lengüeta Datos en el diálogo Propiedades del monitor del sistema para agregar elementos del re-

gistro al gráfico.6. Pulse Aceptar para cerrar el diálogo Propiedades del monitor del sistema. El añadido mostrará el archivo

de registro en forma de gráfico.7. Pulse el botón Ver informe en la barra de herramientas para ver el archivo como texto en lugar de gráfi-

camente.

Más información: Los añadidos Visor de sucesos y Registros y alertas de rendimientos de la MMC proporcionan una forma para controlar la salid de un servidor, detectar errores de aplicación,

identificar conflictos de recursos y predecir necesidades de hardware futuras. Para más infor-mación sobre estas tareas vea la ayuda en línea que incluye cada uno de los añadidos.

9.3.2 Reparar aplicacionesDespués de que una aplicación esté desplegada puede repasarla y revisarla sin reiniciar el servicio o IIS.

Para reparar una aplicación Web desplegada copie el nuevo ensamblado (.dll) y/o archivos de contenido(.aspx, .ascx, etc.) al directorio de aplicación en el servidor. ASP.NET reinicia automáticamente la aplicación cuan-do se reemplaza el ensamblado; no necesita instalar o registrar el ensamblado en el servidor.

Las aplicaciones Web ASP.NET también tienen una capacidad limitada para repararse a si mismas medianteel reciclado de procesos. El reciclado de procesos es la técnica de cerrar y reiniciar un proceso de trabajo ASP.NET(aspnet_wp.exe) que ha quedado inactivo o está consumiendo recursos excesivos. Puede controlar cómo se reciclanlos procesos ASP.NET mediante atributos del elemento processModel en el archivo Machine.config, como semuestra a continuación en negrita.

<processModelenable="true"timeout="Infinite"

idleTimeout="Infinite"shutdownTimeout="0:00:05"requestLimit="Infinite"

requestQueueLimit="5000"restartQueueLimit="10" memoryLimit="60"

webGarden="false"cpuMask="0xffffffff"userName="machine"

5 Cuando hice la prueba, el sistema solo me presentó un diálogo para seleccionar un archivo de registro. El resto del procedimientoestá traducido literalmente, sin probar. (N. del T.)



MCAD/MCSD

184

password="AutoGenerate"logLevel="Errors"clientConnectedCheck="0:00:05"comAuthenticationLevel="Connect"comImpersonationLevel="Impersonate"responseRestartDeadlockInterval="00:09:00"responseDeadlockInterval="00:03:00"

maxWorkerThreads="25" maxIoThreads="25"/>

La tabla 9.2 describe los atributos de processModel que se relacionan con el reciclado de procesos.

Tabla 9. 2: Atributos de reciclado de procesos Atributo Determina

timeout La cantidad de tiempo (hh:mm:ss) antes de que se cierre y reinicie el proceso. Use estaconfiguración para reciclar un proceso automáticamente tras un cierto número de peticionescomo medida preventiva.

shutDownTimeOut Tiempo que tiene cada proceso para cerrarse a sí mismo. Tras este tiempo el sistema termina elproceso si sigue en ejecución.

requestLimit Número de peticiones acoladas que se sirven antes de que se cierre y reinicie el proceso. Useesta opción de la misma forma que el atributo timeout .

restartQueueLimit Número de peticiones en cola que se retienen mientras se cierra y reinicia el proceso.memoryLimit Porcentaje de memoria física que se permite consumir al proceso ASP.NET antes de que se

cierre y se inicie uno nuevo. Esta opción ayuda a prevenir que el exceso de uso de memoriadegrade el servidor.

responseRestartDeadlockInterval Tiempo que se espera antes de reiniciar un proceso que se ha cerrado por bloqueo. Esta opciónnormalmente es de varios minutos para impedir que aplicaciones con problemas seriosbloqueen el servidor.

responseDeadlockInterval Tiempo que se espera antes de reiniciar un proceso bloqueado. El proceso se reinicia si tienepeticiones en cola y no responde dentro de este límite de tiempo.

9.3.3 Afinar aplicaciones desplegadasLas aplicaciones Web ASP.NET tienen una serie de configuraciones que se pueden controlar para afinar el

rendimiento cuando están desplegadas.

• Use las Extensiones de servidor de FrontPage para controlar cómo se almacenan las páginas en caché en lamemoria del servidor.

• Use la configuración de aplicación en IIS para controlar el nivel de protección de la aplicación.• Use los atributos del elemento processModel en el archivo Machine.config del servidor para controlar el nú-

mero de hebras y el comportamiento de agotamiento de tiempo que proporciona el servidor a las aplicacionesWeb.

• Use los atributos del elemento sessionState en el archivo Web.config de la aplicación para controlar cómo seguarda la información de estado de sesión.

Las siguientes secciones discuten cada una de estas técnicas.

9.3.4 Configurar las opciones de CachéLas aplicaciones Web ASP.NET pueden guardar documentos que se solicitan con frecuencia en la memoria

del servidor para acelerar el acceso a estos elementos. El almacenamiento de elementos de esta forma se denominacaché.

Para configurar el uso de caché para una aplicación Web:

1. Configure las Extensiones de servidor de FrontPage para la aplicación:• Seleccione la aplicación Web. En el menú Acción seleccione Todas las tareas y después Configurar Ex-

tensiones de servidor. IIS muestra el asistente para nueva subweb.• Recorra el asistente pulsando Siguiente y siguiendo las instrucciones, bastante sencillas.

2. En IIS, pulse con el botón derecho sobre la aplicación Web y pulse Propiedades. IIS muestra el diálogo de propiedades de la aplicación

3. Pulse la lengüeta Extensiones de servidor y seleccione el número de páginas que contiene su aplicación en lalista desplegable Rendimiento.

4. Las extensiones de servidor de FrontPage proporcionan opciones de caché predeterminadas para aplicacionesWeb en base al número de documentos (archivos .aspx o .htm) que contienen. Como alternativa puede establecer su propia configuración de caché seleccionando Usar configuración predeterminada en la lista desple-gable Rendimiento. IIS muestra el diálogo Rendimiento. Haga sus cambios y pulse Aceptar.

El cambio en la configuración de caché es un acto de equilibrio. Si se guarda demasiada información en ca-ché se reduce la cantidad total de memoria disponible para ejecutar la aplicación. Si se guarda demasiado poca sonnecesarios más accesos a disco para recuperar los documentos pedidos.




185

9.3.5 Cambiar el nivel de protecciónComo se mencionó en el Capítulo 2, IIS puede ejecutar una aplicación Web como un proceso dentro del pro-

pio IIS, como proceso separado agrupado con otras aplicaciones Web o como proceso aislado. A mayor nivel deaislamiento, más fiable es la ejecución de la aplicación, porque está más protegida contra otros procesos que puedencontener errores o mostrar otros fallos.

Sin embargo, un mayor aislamiento también ralentiza la ejecución de una aplicación Web, porque las llama-das a procedimientos deben cruzar límites de proceso. Como con el caché, es un asunto de equilibrio: fiabilidad

frente a velocidad.

Para cambiar el nivel de protección de una aplicación siga estos pasos:

1. Pulse con el botón derecho sobre la aplicación en IIS y seleccione Propiedades. IIS muestra el diálogo Pro- piedades de la aplicación.

2. En la lista desplegable Protección de aplicación seleccione Bajo, Medio o Alto para especificar el nivel de protección. Pulse Aceptar.

9.3.6 Ajustar los atributos de processModelLos atributos del elemento processModel en el archivo Machine.config proporcionan control sobre ciertos

aspectos del rendimiento, como el número máximo de aplicaciones que se ponen en cola, cuánto se espera antes decomprobar si un cliente está conectado y cuantas hebras se permiten por procesador. Al final de la página 189 hayun ejemplo de este elemento, y la tabla 9-3 describe los atributos relativos al rendimiento:

Tabla 9. 3: Atributos de rendimiento Atributo Determina

requestQueueLimit Número de solicitudes que se permite poner en cola antes de que ASP.NET devuelva un código derespuesta 503 (Servidor ocupado) a las nuevas peticiones.

clientConnectedCheck Tiempo (hh:mm:ss) que se espera antes de comprobar si un cliente sigue conectado.maxWorkerThreads Número máximo de hebras por procesadormaxIOThreads Número máximo de hebras de entrada/salida por procesador.

En general, reducir estos números permite que el servidor maneje menos clientes más rápidamente. Incre-mentando estos valores se permiten más clientes y más peticiones en cola, pero ralentiza la respuesta.

9.3.7 Ajustar los atributos de sessionStateEl almacenamiento de información de estado para cada sesión de cliente toma tiempo. Si su aplicación Web

no usa variables de estado de sesión, debe desactivar el seguimiento de este estado.

Para desactivar el estado de sesión de el valor Off al atributo mode del elemento sessionState en el archivoWeb.config.

9.3.8 Consejos de optimizaciónPiense en el afinado como en hacer ajustes en una aplicación desplegada que no afectan al código. La opti-

mización por lo general hace referencia a escribir código de forma que se ejecute más rápidamente o consuma me-nos recursos. En general, la optimización simplemente refleja buenas prácticas e programación que se han aprendidohasta ahora en este libro. Algunos de los puntos más importantes son:

• Desactive el depurado para las aplicaciones en explotación. El código compilado con opción Release seejecuta más rápido que el compilado con la opción Debug.

• Evite viajes de ida y vuelta entre el cliente y el servidor. ASP.NET utiliza el envío al servidor para proce-sar los sucesos de servidor en una página. Intente diseñar los formularios Web de forma que los datos esténcompletos antes de que el usuario los envíe al servidor. Puede usar controles de validación para asegurarse deque los datos están completos en el lado cliente antes de enviar la página.

• Desactive el estado de sesión si no es necesario. En algunos casos puede diseñar su código para usar otrastécnicas, como cookies, para almacenar datos de cliente.

• Desactive ViewState para los controles de servidor que no necesitan retener sus valores. • Use procedimientos almacenados en la base de datos. Los procedimientos almacenados se ejecutan más

deprisa que las consultas desde la aplicación.• Use SqlDataReader en lugar de conjuntos de datos para recuperación de datos de solo avance. Este

componente es más rápido y consume menos memoria que crear un conjunto de datos.

Cuando se aplican estos consejos de optimización hay que dejarse guiar por el sentido común. Por ejemplo, sinecesita retener datos sobre una sesión de cliente, utilice el estado de sesión en lugar de implementar su propia solu-ción para hacer lo mismo.



MCAD/MCSD

186

9.4 Desplegar entre varios servidoresLas aplicaciones Web que sirven a un gran número de usuario o que manejan gran cantidad de datos necesi-

tan tener la capacidad de crecer según aumenten las demandas de los usuarios. La capacidad de crecer de una aplica-ción se llama escalabilidad. Las aplicaciones Web soportan este concepto mediante su capacidad para correr envarios procesadores y tener sus procesos distribuidos entre varias CPU y/o varios servidores.

Una aplicación Web que corre en un único servidor con varias CPU se denomina jardín Web (Web garden)en la documentación de ASP.NET. Una aplicación que corre en varios servidores se denomina granja Web (Web

farm). En esta lección aprenderá cómo activar su aplicación Web para que utilice estas configuraciones de servidor.

9.4.1 Crecer con varios procesadoresSi su servidor tiene varios procesadores puede especificar que ASP.NET corra sobre todas o algunas de las

CPU mediante el atributo webGarden del elemento processModel en el archivo Machine.config del servidor. Latabla 9.4 describe los atributos de processModel que se relacionan con jardines Web.

Tabla 9. 4: Atributos de jardín Web Atributo Determina

webGarden Déle el valor true para ejecutar las aplicaciones Web ASP.NET en más de un procesador de este servidor.cpuMask Especifica qué CPU,s deben utilizar la aplicaciones Web ASP.NET. El valor 0xffffffff ejecuta las aplicaciones en todas

las CPU,s.

El atributo cpuMask es una máscara de bits que ASP.Net usa para activar (1) o desactivar (0) cada CPU del

servidor. Por ejemplo, el número binario 1101 activa ASP.NET sobre los procesadores 0, 2 y 3 en una máquina concuatro procesadores, dejando el 1 libre. El número binario 1101 corresponde con el valor hexadecimal 0x0000000d.

La ejecución de ASP.NET sobre varios procesadores hace necesario tomar ciertas medidas para poder manejar la información de Application y Session. Vea Compartir Información de Estado, más adelante en esta lección.

9.4.2 Crecer con varios servidoresPara que varios servidores manejen las peticiones para una sola dirección HTTP deberá instalar balance de

cargas en su red. Los servicios de balance de cargas se pueden proporcionar mediante hardware o software.

Tanto Windows 2000 Advanced Server como Windows 2000 Datacenter incluyen software de balance decargas (NLB6) para distribuir las peticiones entre varios servidores. Vea el tema Proveedor de balance de cargas enla red en la ayuda de Visual Studio .NET para ver cómo instalar y usar esta herramienta.

Cuando está activado el balance de cargas en la red, puede instalar su aplicación Web en varios servidores ylas peticiones de los clientes se dirigirán automáticamente al servidor menos ocupado en un momento dado.

La ejecución de una aplicación Web en varios servidores hace necesario tomar ciertas medidas para poder manejar la información de Application y Session. Vea la siguiente sección.

9.4.3 Compartir información de estadoTanto en un jardín Web como en una granja Web las peticiones de los clientes se dirigen al proceso

ASP.NET que esté actualmente menos ocupado. Esto significa que un único cliente puede interactuar con diferentesCPU,s o servidores a lo largo de su sesión. Esto tiene las siguientes implicaciones para las variables de estado deaplicación y de sesión:

• Las variables de estado de aplicación son únicas para cada instancia separada de la aplicación Web. Los clientes pueden compartir información mediante Application si la aflicción Web se ejecuta en un jardín

Web o granja Web.• Las variables de estado de forma predeterminada se almacenan en proceso. Para activar el estado de se-

sión en una granja Web o jardín Web tiene que especificar un proveedor de estado de sesión.

Las siguientes secciones exploran estos temas con mayor detalle.

Compartir estado de aplicaciónPara compartir datos entre varias sesiones en un jardín o granja Web debe guardar y recuperar la informa-

ción usando un recurso disponible para todos los procesos. Esto se puede hacer mediante un archivo XML, una base de datos o algún otro recurso usando métodos estándar de acceso a archivo o base de datos.

Compartir estado de sesiónASP.NET proporciona dos formas integradas para compartir la información de estado de sesión dentro de

un jardín o granja Web. Puede compartir el estado de sesión usando:

6 Network Load Balancing




187

• Un servidor de estado, especificado por una dirección de red. Esta técnica es sencilla de implementar y no hace necesario instalar SQL Server.

• Una base de datos SQL, especificada por una conexión SQL. Esta técnica proporciona el mejor rendi-miento para almacenar y recuperar la información de estado.

Para compartir estado de sesión usando un servidor de estado siga estos pasos:

1. En el archivo Web.config de la aplicación configure los atributos mode y stateConnectionString del ele-mento sessionState. Por ejemplo, la siguiente configuración usa el servidor de estado con la dirección IP

192.168.1.102, en el puerto 42:<sessionState mode="StateServer"

stateConnectionString="tcpip=192.168.1.102:42"sqlConnectionString="data source=192.168.1.102;user id=sa;password="cookieless="false"timeout="20"

/>2. Ejecute la utilidad aspnet_state.exe en el servidor de estado de sesión. Esta utilidad se instala en el direc-

torio \Windows\Microsoft.NET\Framework\versión cuando se instala la edición Professional o EnterpriseArchitect de Visual Studio .NET.

Para compartir estado de sesión usando una base de datos SQL Server siga estos pasos:

1. En el archivo Web.config de la aplicación configure los atributos mode y sqlConnectionString del ele-mento sessionState. Por ejemplo, la siguiente configuración usa el servidor SQL Server con la direcciónIP 192.168.1.102:<sessionState mode="SQLServer"

stateConnectionString="tcpip=192.168.1.102:42"sqlConnectionString="data source=192.168.1.102;user id=sa;password="

cookieless="false"timeout="20"

/>2. Ejecute la utilidad InstallSqlState.sql en el servidor de estado de sesión. Esta utilidad instalada la base de

datos SQL que comparte la información de estado de sesión entre procesos. La utilidad se instala en el di-rectorio \Windows\Microsoft.NET\Framework\versión cuando se instala la edición Professional, Enter- prise Developer o Enterprise Architect de Visual Studio .NET

9.5 Resumen• Antes de generar una aplicación para distribución configure la opción generar como Release y el atributo de-

bug en Web.config como False.• Utilice el archivo AssemblyInfo.vb o AssemblyInfo.cs para identificar el ensamblado de la aplicación y pro-

porcionar información de versión.• Para desplegar una aplicación use las herramientas de subida de Visual Studio .NET o sencillamente copie el

ensamblado y los archivos de contenido de la aplicación al servidor.• Configure los privilegios de seguridad de la cuenta de usuario ASPNET para permitir que su aplicación Web

escriba archivos o acceda a otros recursos con restricciones de seguridad en el servidor.• Después del despliegue controle la aplicación Web usando los añadidos Visor de sucesos y Registros de aler-

tas y rendimiento de MMC.• Puede reparar aplicaciones Web subiendo nuevas versiones del ensamblado o archivos de contenido de la

aplicación al servidor.• Las aplicaciones Web con problemas de memoria u otros pueden repararse a si mismas mediante el reciclado

de procesos de ASP.NET.• Utilice las extensiones de servidor de FrontPage para mejorar el rendimiento de una aplicación Web guar-

dando en caché las páginas de uso frecuente.• Para activar un jardín Web use los atributos del elemento processModel en el archivo Machine.config del

servidor.• Para activar una granja Web use un balanceador de carga para distribuir las peticiones entre varios servido-

res.• Tanto en los jardines como en las granjas Web comparta la información de estado de sesión configurando el

elemento sessionState en el archivo Web.config de la aplicación.

9.6 Práctica: Generar y distribuir una aplicación WebEn esta práctica va a preparar una aplicación Web para su distribución, la va a desplegar en un servidor y

controlará y afinará su rendimiento. Antes de comenzar seleccione una de las aplicaciones que ha completado a lolargo del libro – o alguna que haya terminado por si mismo – para usarla en los ejercicios siguientes.



MCAD/MCSD

188

Esta práctica trata materia que se aplica a todos los tipos de aplicaciones Web, por lo que será más interesantesi elige una que quiera compartir con otros o esté interesado en usar Vd. mismo en Internet.

9.6.1 Preparar la aplicaciónEn este ejercicio va a generar una versión de distribución de la aplicación Web. Use lo que aprendió en la

lección 1 para completar las siguientes tareas:

1. Identifique la aplicación y establezca su número de versión en el archivo AssemblyInfo.vb o AssemblyIn-

fo.cs.2. Cambie el valor del atributo debug del elemento de compilación a False en el archivo Web.config de la apli-cación.

3. Configure la opción de generación de la aplicación como Release4. Genere la aplicación.

9.6.2 Despliegue la aplicaciónLa forma de desplegar la aplicación depende del tipo de servidor del que disponga. Si está alojando su apli-

cación mediante un servicio de alojamiento Web como se trató en el capítulo 1, use las herramientas de subida deVisual Studio .NET para enviar la aplicación al servicio de alojamiento.

Si está alojando las aplicaciones en su propio servidor use lo que aprendió en la lección 2 de este capítulo pa-ra realizar estas tareas:

1. Cree un directorio virtual para la aplicación usando IIS en el servidor.2. Copie la aplicación al directorio virtual.3. Vea las opciones de seguridad en el servidor para comprobar que la cuenta de usuario ASPNET tiene permi-

sos para realizar las tareas que precise la aplicación.4. Si es necesario, conceda los permisos sobre los recursos utilizados por la aplicación.5. Ejecute la aplicación desde el servidor para verificar que su configuración de seguridad permite que la apli-

cación se ejecute correctamente.

9.6.3 Comprobar el rendimiento de la aplicaciónEn este ejercicio va a usar el agregado de alertas y rendimiento de MMC para mantener un registro del núme-

ro de peticiones procesadas por ASP.NET y trazar un gráfico que compare estas peticiones con la actividad del pro-cesador en el servidor.

Utilice lo que aprendió en la lección 3 para llevar a cabo estas tareas:1. Ejecute el agregado de alertas y rendimiento de MMC y conecte con el servidor sobre el que corre la aplica-

ción Web. Si alojó la aplicación en un servicio de alojamiento Web no podrá conectar con el servidor, en sulugar, ejecute la aplicación en local en su máquina de desarrollo y conecte con esta máquina.

2. Cree un nuevo registro de contador llamado “Ejercicio 3”.3. Añada al registro los contadores de la siguiente tabla:

Objeto Contador

Procesador %Tiempo de procesador Aplicaciones ASP.NET Peticiones anónimas ASP.NET Aplicaciones en ejecución ASP.NET Procesos de trabajo en ejecución

4. Inicie el registro y deténgalo tras unos minutos para recoger datos sobre el servidor.5. Seleccione el monitor del sistema en el agregado y cambie las propiedades del monitor para ver los archivos

de registro:• Pulse con el botón derecho en el monitor del sistema y seleccione Propiedades en el menú emergente.• Pulse la lengüeta Origen y seleccione Archivos de registro. Pulse Agregar para añadir los archivos de re-

gistro al monitor.• Pulse sobre la lengüeta Datos y pulse Agregar para añadir los contadores ASP.NET al monitor • En la lengüeta Datos establezca la escala de cada contador ASP.NET a 10• Pulse Aceptar para ver el registro como gráfico.

6. En el monitor del sistema seleccione Informe para ver el registro en forma de texto.7. Experimente con otros contadores, como errores de aplicaciones ASP.NET, aciertos de caché, etc.

9.6.4 Afinar la aplicaciónEn este ejercicio va a instalar las extensiones de servidor de FrontPage y configurar las opciones de caché pa-

ra la aplicación Web. De forma predeterminada Visual Studio .NET instala las extensiones cuando se instalan los

componentes .NET. Si ha alojado su aplicación en un servicio de alojamiento Web no podrá realizar estas tareassobre la aplicación desplegada porque no tendrá acceso físico al servidor. En su lugar, use la versión local de laaplicación, como en el ejercicio anterior.




189

Use lo que aprendió en la lección 3 para realizar las siguientes tareas:

1. Ejecute IIS e instale las extensiones de servidor de FrontPage en el directorio virtual que contiene la aplica-ción.

2. En IIS, vea las propiedades del directorio virtual y pulse la lengüeta Extensiones del servidor.3. En la lista desplegable Rendimiento selección para menos de 100 páginas y pulse Aceptar.4. Vuelva a ejecutar el registro de contador creado en 9.6.3 para ver si puede detectar cambios en el servidor.

9.7 RepasoLas siguientes preguntas están pensadas para reforzar información clave mostrada en este capítulo. Si no escapaz de contestar a una pregunta repase la lección correspondiente e intente de nuevo. Las respuestas se puedenencontrar en el capítulo 16.

1. ¿Bajo qué permisos se ejecutan de forma predeterminada las aplicaciones Web?

2. ¿Por qué es importante el archivo Machine.config para las aplicaciones Web desplegadas?

3. ¿Cómo se configuran las opciones de caché para una aplicación Web?

4. ¿Cómo afecta al estado de sesión de una aplicación Web el despliegue en una granja Web o jardín Web?



MCAD/MCSD

190




191

10 Probar aplicaciones WebEl objetivo de las pruebas de software es asegurar que el producto cubre los requisitos deseados. De esta sen-

tencia se deducen dos precondiciones:

• Sin requisitos no se pueden iniciar las pruebas• Sin objetivos cuantificables no se sabe cuando detener las pruebas.

Por lo general tanto los requisitos de producto como los objetivos se determinan fuera del proceso de desarro-

llo – normalmente por clientes o administración. En este capítulo aprenderá cómo aplicar requisitos de producto para planificar, crear, ejecutar y corregir problemas encontrados en pruebas.


• Tener acceso a un servidor Web – ya sea mediante un servicio de alojamiento o por medio de su red de árealocal – que pueda usar para probar y depurar aplicaciones Web.

• Haber completado y desplegado con éxito una o más de las aplicaciones Web de ejemplo de este libro.• Estar familiarizado con un lenguaje de secuencias de comandos de Windows, como VBScript o JScript.• Tener instalado el centro de pruebas de aplicaciones (Application Center Test, ACT) que se incluye con Vi-

sual Studio .NET Enterprise Architect. Este requisito solo se aplica al material del capítulo que trata las pruebas de carga de aplicaciones Web.

10.1 Crear pruebasTodo el software pensado para consumo público debe sufrir algún nivel de pruebas. Mientras más amplia-

mente se distribuya o más complejo sea el software, más necesarias son las pruebas. Sin pruebas no tiene la seguri-dad de que el software se comportará como se espera.

Para software, pruebas casi siempre significa pruebas automatizadas. Las pruebas automatizadas usan unlenguaje de programación para repetir acciones de usuario grabadas o simular el uso interno de un componente. Las pruebas automatizadas son reproducibles (se puede ejecutar de nuevo la misma prueba) y cuantificables (la pruebatiene éxito o fracasa). Estas dos ventajas son clave para asegurar que el software cumple los requisitos.

En este capítulo aprenderá cómo escribir un plan de pruebas, cómo asegurar que el producto está perfecta-mente probado y cómo crear diferentes tipos de pruebas usando Visual Studio .NET.

10.1.1 Desarrollar un plan de pruebas

El primer paso en las pruebas es desarrollar un plan de prueba basado en los requisitos del producto. Nor-malmente, el plan de pruebas es un documento formal que asegura que el producto cubre los siguientes estándares:

• Está completamente probado: El código no probado añade un elemento desconocido al producto e incre-menta el riesgo de fallo.

• Cumple los requisitos del producto: Para cumplir las necesidades del cliente el producto debe proporcionar las características y comportamiento descritos en la especificación del producto. Por este modito, las especi-ficaciones de producto deben estar claramente escritas y ser bien comprendidas.

• No contiene defectos: Las características deben trabajar dentro de estándares de calidad establecidos, y estosestándares deben indicarse claramente dentro del plan.

Tener un plan de pruebas ayuda a evitar las pruebas ad hoc – el tipo de pruebas que confía en los esfuerzosdescoordinados de los desarrolladores o probadores para asegurar que el código funciona. El resultado de las pruebas as hoc normalmente es desigual y siempre es impredecible. Un buen plan de pruebas responde las siguientes

preguntas:

• ¿Cómo están escritas las pruebas?. Describe las herramientas y lenguajes utilizados para pruebas.• ¿Quién es responsable de las pruebas?. Indica los equipos o individuos que escriben y ejecutan las pruebas.• ¿Cuándo se ejecutan las pruebas?. El plan de pruebas debe basarse en el plan de desarrollo.• ¿Dónde están las pruebas y cómo se comparten los resultados?. Las pruebas se deberían organizar de

modo que se puedan volver a ejecutar de forma regular.• ¿Qué se está probando?. Objetivos cuantificables con fines concretos le permiten saber cuándo ha conse-

guido el éxito.

Algunas de estas preguntas pueden tener más de una respuesta, dependiendo del tipo de prueba. Por ejemplo,a menudo desarrolladores individuales son responsables de escribir el primer nivel de pruebas para su propio código,mientras que un equipo de pruebas separado será responsable de asegurar que todo el código funciona junto. Las

siguientes secciones describen los diferentes tipos de pruebas y las técnicas usadas con Visual Studio .NET paraejecutar estas pruebas.



MCAD/MCSD

192

10.1.2 Tipos de pruebasEl plan de prueba especifica los diferentes tipos de pruebas que se realizarán para asegurar que el producto

cubre los requisitos del cliente y no contiene defectos. La tabla 10.1 describe los tipos de pruebas más habituales.

Tabla 10. 1: Tipos de pruebasTipo de prueba Asegura que

De Unidad Cada fragmento de código independiente funciona correctamente.Integración Todas las unidades funcionan juntas sin errores

Regresión Las características nuevas añadidas no introducen errores en otras características que estén funcionandoCarga (stress) El producto sigue funcionando en condiciones extremas de usoPlataforma El producto funciona en todo el hardware y plataformas hardware de destino

Estos tipos de pruebas se apoyan unos en otros y por lo general se eje-cutan en el orden que muestra la tabla. El proceso de pruebas sigue el procesoque muestra el diagrama 10.1.

El proceso que muestra la figura 10.1 se basa en un diseño de productomodular en el que el producto se desarrollar como un conjunto de componen-tes que se pueden programar, probar, integrar y distribuir individualmente.Esta es la aproximación moderna, y debe mirar con recelo cualquier proyectoque proponga un diseño monolítico en el que la integración y pruebas se ejecu-ten solo al final del ciclo de desarrollo.

10.1.3 Pruebas de unidadUna unidad de producto es el menor fragmento de código que se puede probar de forma independiente. Desde un punto de vista de programaciónorientada a objetos, las clases, propiedades, métodos y sucesos son unidadesindividuales. Una unidad debe pasar su prueba de unidad entes de que se inte-gre en el proyecto.

Las pruebas de unidad normalmente las escribe el desarrollador que programó la unidad, y están escritas en el mismo lenguaje de programaciónque la unidad que se está probando o en un lenguaje de secuencia de comandossimilar, como VBScript. La prueba de unidad puede ser tan sencilla comoobtener y escribir un valor de propiedad, o más complicada. Por ejemplo, una prueba de unidad puede tomar datos sencillos, calcular un resultado y compa-

rarlo con el resultado esperado para comprobar la precisión.Agrupe lógicamente las pruebas de unidad. Las pruebas que comprueban cada propiedad y método de una

clase se pueden incluir en un único procedimiento, que se llama desde una aplicación de pruebas separada. Por ejemplo, el siguiente procedimiento de prueba crea una instancia de la clase FlashCardClass creada anteriormenteen este libro y prueba cada uno de sus propiedades y métodos.

Visual Basic .NETFunction TestFlashCard() As Boolean

'Crea la claseDim FlashCard As New vbFlashCards.FlashCardClass()'Prueba si existe la clase.If IsNothing(FlashCard) Then

Console.WriteLine("FlashCardClass fallida")'Devuelve false y termina.

Return FalseEnd If

'Prueba el método de barajado usando valores máximo y mínimo.FlashCard.Shuffle(Integer.MinValue, Integer.MaxValue)'Prueba propiedades.Dim bResult As Boolean = TrueDim intFirst As Integer = FlashCard.FirstNumberDim intSecond As Integer = FlashCard.SecondNumberDim dblAnswer As Double = intFirst + intSecondIf dblAnswer <> FlashCard.Answer Then

Console.WriteLine("Error: los números no se suman")bResult = False

End If

Fig.10. 1: Ciclo de pruebas




193

'Baraja de nuevo.FlashCard.Shuffle(Integer.MinValue, Integer.MaxValue)'Se asegura de que los nuevos valores son únicos.If intFirst = FlashCard.FirstNumber Then

Console.WriteLine("Aviso: FirstNumber no es único después de barajar")End IfIf intSecond = FlashCard.SecondNumber Then

Console.WriteLine("Aviso: SecondNumber no es único después de barajar ")End If

'Comprueba diferentes operadores.FlashCard.Operation = "-"If FlashCard.FirstNumber - FlashCard.SecondNumber <> FlashCard.Answer Then

Console.WriteLine("Error: operador – no resta.")bResult = False

End IfFlashCard.Operation = "x"If FlashCard.FirstNumber * FlashCard.SecondNumber <> FlashCard.Answer Then

Console.WriteLine("Error: operador x no multiplica.")bResult = False

End IfFlashCard.Operation = "+"If FlashCard.FirstNumber + FlashCard.SecondNumber <> FlashCard.Answer Then

Console.WriteLine("Error: operador + no suma.")

bResult = FalseEnd If'Devuelve éxito/error.Return bResult

End Function

Visual C#static bool TestFlashCardClass(){

//Crea la clasecsFlashCards.FlashCardClass FlashCard = new csFlashCards.FlashCardClass();//Comprueba si existe la clase.if (FlashCard == null){

Console.WriteLine("FlashCardClass falló");//Devuelve false y termina.return false;

}

//Comprueba el método de barajado usando valores mínimo y máximo.FlashCard.Shuffle(int.MinValue, int.MaxValue);

//Prueba propiedades.bool bResult = true;int intFirst = FlashCard.FirstNumber;int intSecond = FlashCard.SecondNumber;double dblAnswer = intFirst + intSecond;if (dblAnswer != (double)FlashCard.Answer()){

Console.WriteLine("Error: los números no se suman");bResult = false;

}

//Baraja de nuevo.FlashCard.Shuffle(int.MinValue, int.MaxValue);

//Se asegura de que los nuevos valores son únicos.if (intFirst == FlashCard.FirstNumber)

Console.WriteLine("Aviso: FirstNumber no es único después de barajar");if (intSecond == FlashCard.SecondNumber)

Console.WriteLine("Aviso: SecondNumber no es único después de barajar");

//Comprueba diferentes operadores.FlashCard.Operation = "-";if (FlashCard.FirstNumber - FlashCard.SecondNumber != FlashCard.Answer()){

Console.WriteLine("Error: operador – no resta.");bResult = false;

}FlashCard.Operation = "x";

if (FlashCard.FirstNumber * FlashCard.SecondNumber != FlashCard.Answer()){Console.WriteLine("Error: operador x no multiplica.");bResult = false;

}



MCAD/MCSD

194

FlashCard.Operation = "+";if (FlashCard.FirstNumber + FlashCard.SecondNumber != FlashCard.Answer()){

Console.WriteLine("Error: operador + no suma.");bResult = false;

}//Devuelve éxito/error.return bResult;

}

El factor más importante en una prueba de unidad es que sea completa. Las pruebas de unidad deben comprobar cada fragmento de código de la aplicación y usar un rango de valores posibles. El ejemplo anterior muestra eluso de un amplio rango pasando MinValue y MaxValue al método Shuffle.

Las pruebas también deben informar de los errores a nivel de unidad de forma que la localización y correc-ción de los problemas sea directa. El ejemplo anterior lo hace mostrando un mensaje en la ventana de salida median-te Console.WriteLine. Como alternativa puede escribir los errores en un registro de prueba mediante De-bug.WriteLine o lanzar alertas usando Debug.Assert .

10.1.4 Pruebas de integraciónLa primera prueba de integración responde a la pregunta “¿se compila la aplicación?”. En este punto un error

de compilación en cualquiera de los componentes puede impedir la continuación de las pruebas de integración. Al-gunos proyectos utilizan compilaciones nocturnas para asegurarse de que el producto siempre se compila.

El problema de compilación más habitual se produce cuando un componente intenta utilizar otro que aún nose ha escrito. Esto sucede con el diseño modular porque los componentes a menudo se crean fuera de secuencia.Este problema se crea mediante la creación de muñones7. Los muñones son componentes no funcionales que proporcionan la definición de clase, propiedad o método que utiliza otro componente. Son una especie de esquema delcódigo que se creará más adelante.

Cuando se han resuelto todos los problemas de compilación, las pruebas de integración se convierten en unaaplicación de las pruebas de unidad, solo que ahora el foco se centra en ver si las unidades trabajan juntas. En este punto es posible encontrarse con dos componentes que necesitan trabajar en conjunto mediante un tercero que no seha escrito aún. Para probar estos dos componentes se crea un controlador 8. Un controlador es sencillamente uncomponente de prueba que asegura que dos componentes funcionan juntos. Más adelante en el proyecto, las pruebasrealizadas con el controlador se pueden ejecutar con el componente real.

Además de muñones y controladores puede que necesite un interface de prueba que le ayude a automatizar

las pruebas de integración de algunos componentes. Un interface de prueba es un conjunto de propiedades y méto-dos públicos que se usan para controlar un componente desde un programa de prueba externo. Por ejemplo, el si-guiente interface de prueba permite la prueba automatizada del formulario Web de la aplicación FlashCard.

Visual Basic .NET#If DEBUG Then

'Interface de pruebas de integración público.Public FirstNumber As StringPublic SecondNumber As String

Public Function TestUI(ByVal Answer As String) As BooleanFirstNumber = lblFirst.TextSecondNumber = lblSecond.Text'Pone la respuesta en txtAnswer.txtAnswer.Text = Answer

'Ejecuta el suceso Changed.txtAnswer_TextChanged(Me, EventArgs.Empty)'Comprueba si es correcto.If lblFeedback.Text = "Correcto" Then

Return TrueElse

Return FalseEnd If

End Function#End If

7 stubs en el original.8 driver en el original




195

Visual C##if DEBUG//Interface de pruebas de integración público.public string FirstNumber;public string SecondNumber;

public bool TestUI(string Answer){FirstNumber = lblFirst.Text;SecondNumber = lblSecond.Text;

txtAnswer.Text = Answer;//Ejecuta el suceso Changed.txtAnswer_TextChanged(this, EventArgs.Empty);//Comprueba si es correcto.if (lblFeedback.Text == "Correcto")

return true;else

return false;}#endif

El código anterior utiliza directivas de procesador #If ... #End If o #if ... #endif para evitar que el interface de prueba se compile en la versión de distribución del producto. Esto es importante porque un interface de prueba expone el funcionamiento interno de la aplicación, que normalmente se quiere mantener privado en la versión final.

10.1.5 Pruebas de regresiónLas pruebas de unidad y de integración forman la base de las pruebas de regresión. Según se escribe y pasa

cada prueba se registra en la biblioteca de pruebas para ejecución de pruebas planificada de forma regular. Si unnuevo componente o un cambio en un componente existente rompe una de las pruebas de unidad o de integraciónexistentes el error se denomina regresión.

Si las pruebas están correctamente diseñadas las pruebas de unidad y de integración informan de sus erroresde forma que es fácil localizar la causa de la regresión. Si la prueba no proporciona una forma sencilla de localizar lacausa puede que necesite mejorar estas pruebas so que necesite escribir nuevas pruebas para capturar la regresión.

La clave del éxito tanto en las pruebas de integración como en las de regresión es ejecutar con frecuencia elconjunto de pruebas completo – si es posible como parte de una compilación nocturna. La detección temprana de loserrores y su resolución en cuanto se producen impide que un error oculte otros.

10.1.6 Pruebas de cargaCuando se despliega una aplicación Web puede ser utilizada por uno o dos clientes a la vez, o puede que re-

ciba miles de peticiones. Para averiguar cómo funcionará esta aplicación en estas condiciones variables necesitarealizar pruebas de carga. Use el centro de pruebas de aplicaciones (ACT) para crear y ejecutar pruebas de carga enuna aplicación Web.

Para usar ACT siga estos pasos:

1. Cree una prueba grabando una sesión de usuario con la aplicación Web usando ACT.2. Establezca las propiedades de nivel de carga y duración de la prueba.3. Ejecute la prueba.

En general, las pruebas de carga no se crean tan temprano ni se ejecutan con tanta frecuencia como las deunidad, integración o regresión. Las siguientes secciones describen con más detalle el procedimiento anterior.

Grabar una prueba de cargaPara grabar una prueba de carga en ACT siga estos pasos.

1. En el menú Acción de ACT seleccione Nueva Prueba. ACT muestra el asistente de nueva prueba.2. Pulse Siguiente. El asistente muestra la página Origen de prueba.3. Seleccione Grabar una nueva prueba y pulse siguiente. El asistente muestra la página Tipo de prueba.4. Pulse siguiente. El asistente muestra la página Explorar Registro.5. Pulse Iniciar grabación. El asistente muestra una ventana de exploración.6. Ejecute las acciones que quiere grabar. Por ejemplo, puede recorrer todas las páginas de la aplicación

Web, ejecutando tareas en todas las páginas.7. En la página de Explorar registro pulse Detener grabación cuando termine de grabar acciones, y pulse Si-

guiente. El asistente muestra la página Propiedades de prueba.8. Escriba un nombre para la prueba y pulse Siguiente. El asistente muestra la página Completar nueva

prueba. Pulse Finalizar para cerrar el asistente.



MCAD/MCSD

196

Establecer propiedades de prueba.Después de grabar una prueba se muestra en la lista de pruebas de ACT. Las pruebas ACT se pueden es-

cribir en VBScript o JScript, pero ACT las graba usando solo VBScript. Después de grabar una prueba establez-ca la carga y duración de la prueba siguiendo estos pasos.

1. En el menú Acción seleccione Propiedades. ACT muestra las propiedades de carga y duración de la prueba.

2. Establezca el nivel de carga para incrementar el número de usuario que acceden a la aplicación Web si-

multáneamente. Establezca la duración para ejecutar la prueba durante un cierto tiempo o para una seriede peticiones. Pulse Aceptar cuando termine.

Ejecutar pruebas de cargaPara ejecutar una prueba de carga en ACT seleccione Iniciar prueba en el menú Acción. ACT muestra el

diálogo Estado de prueba. La ejecución de pruebas con ACT y el análisis de sus resultados se trata en más detalleen la lección 2.

10.1.7 Pruebas de plataformaPara aplicaciones Web las pruebas de plataforma normalmente significan verificar cuatro puntos principales.

• Los formularios Web se muestran correctamente en todos los navegadores soportados y en todas las versio-nes de estos navegadores.

• La aplicación Web gestiona correctamente todas las versiones de navegador no soportadas, por ejemplo mos-

trando instrucciones para la descarga de la versión correcta.• Se pide al cliente que instale los componentes necesarios, como objetos ActiveX o plugins, si no están ya ins-

talados en su ordenador.• La aplicación Web tiene un rendimiento aceptable con las formas de conexión más lentas, como módems.

Para ejecutar pruebas de plataforma necesita configurar un laboratorio de plataformas que contenga ordena-dores representativos de las diferentes configuraciones hardware y software que soporte su aplicación. La verifica-ción de que todos los formularios Web se muestran correctamente precisa de intervención humana. ASP.NET diseñalos controles de forma diferente en diferentes navegadores, de modo que hay que inspeccionar visualmente la apli-cación Web como parte del ciclo de pruebas final.

10.2 Ejecutar pruebasEn la lección anterior aprendió cómo planificar pruebas y cómo crear diferentes tipos de pruebas usando Vi-

sual Studio .NET. En esta lección aprenderá cómo usar estas pruebas y capturar sus resultados.10.2.1 Ejecutar pruebas con ACT

La lección anterior le mostró brevemente cómo crear una prueba de carga y ejecutarla en ACT. Esta seccióndescribe cómo configurar y ejecutar pruebas ACT con más detalle describiendo cómo realizar las siguientes tareas.

• Registrar resultados de pruebas• Configurar las pruebas para usar varias conexiones simultáneas• Ejecutar pruebas con diferentes combinaciones de nombre de usuario y contraseña• Añadir contadores de rendimiento a las pruebas• Imitar diferentes navegadores y diferentes tipos de conexión.

Registrar resultados de pruebasDe forma predeterminada, ACT crea un archivo de registro para cada proyecto de prueba en la carpeta

/Perflogs de la unidad donde está instalado ACT.

Para cambiar la ubicación donde ACT guarda el archivo de registro siga estos pasos.

1. Pulse con el botón derecho en el elemento de proyecto en el panel izquierdo de la ventana de ACT y se-leccione propiedades en el menú emergente. ACT muestra las propiedades del proyecto de prueba.

2. Pulse la lengüeta Depuración y escriba una ubicación en la caja Carpeta para guardar el registro. Pulseaceptar cuando termine.

Los archivos de registro ACT guardan diferentes cantidades de información dependiendo de la configura-ción de TraceLevel. Para cambiar la cantidad de información registrada configure la propiedad TraceLevel delobjeto Test dentro de una secuencia de comandos de prueba. Por ejemplo, la siguiente línea le dice a ACT queregistre todos los mensajes:

VBScriptTest.TraceLevel = -1

JScriptTest.TraceLevel = -1;




197

Tabla 10. 2: Opciones de TraceLevelOpción Registra

-1 Toda la información, incluyendo peticiones enviadas a la aplicación, respuestas desde la aplicación y mensajesescritos por métodos Trace de la secuencia de comandos.

0 Ninguna información – desactiva el registro.1 Peticiones enviadas a la aplicación y respuestas desde la misma.2 Mensajes escritos por los métodos Trace de la secuencia de comandos. Es la opción predeterminada.

Utilice el método Trace del objeto Test para escribir mensajes en el registro desde la secuencia de coman-

dos. Por ejemplo, la siguiente secuencia de comandos escribe un mensaje en el registro si ACT no es capaz deconectar con el servidor.

VBScriptDim g_oConnection

ConectaConServidor

Sub ConectaConServidor()Set g_oConnection = Test.CreateConnection("http://www.contoso.com, 80, false)

If (g_oConnection is Nothing) ThenTest.Trace "Error: Imposible crear conexión con contoso"

End IfEnd Sub

JScript

var g_oConnectionConectaConServidor();

function ConectaConServidor(){g_oConnection = Test.CreateConnection("http://www.contoso.com", 80, false);if (g_oConnection == null)

Test.Trace("Error: Imposible crear conexión con contoso");}

Usar varias conexionesACT puede simular diferentes niveles de carga del servidor añadiendo varias conexiones para usar duran-

te la prueba. De forma predeterminada ACT usa conexión para enviar peticiones a la aplicación Web. Conexio-nes adicionales son equivalentes a usuarios simultáneos adicionales. Para aumentar el número de conexiones uti-lizadas en una prueba:

1. Pulse con el botón derecho sobre el panel derecho de la ventana de ACT y seleccione Propiedades. ACTmuestra las propiedades de la prueba.

2. Cambie el número en el apartado Nivel de carga de la prueba y pulse Aceptar.

Añadir usuarios y contraseñasACT puede proporcionar a una aplicación Web nombres de usuario y contraseñas mediante los grupos de

usuarios guardados con el proyecto de prueba. Esto permite probar cómo autentica una aplicación Web a losusuarios y probar cookies. Para añadir nombres de usuario y contraseñas a un grupo de usuarios:

1. Seleccione Usuarios en el panel izquierdo de la ventana ACT para expandir la lista de grupos de usuarios.2. Seleccione un grupo de usuarios y escriba nombres de usuario y contraseñas en la tabla del panel derecho

de la ventana.3. Pulse con el botón derecho sobre el nombre de la prueba y seleccione Propiedades.4. Pulse la lengüeta Usuarios y marque Especificar usuarios. Pulse Aceptar.

ACT cambia de usuario automáticamente para cada repetición de la prueba y para cada conexión quecrea. También puede cambiar de usuario durante una prueba manualmente usando el método GetNextUser delobjeto Test :

VBScriptSub ChangeUser()

Test.GetNextUserTest.Trace("Next user name: " & Test.GetCurrentUser.Name)

End Sub

JScriptfunction ChangeUser(){

Test.GetNextUser();Test.Trace("Next user name: " + Test.GetCurrentUser.Name);

}



MCAD/MCSD

198

Añadir contadores de rendimientoPuede seguir el rendimiento de una aplicación Web durante una prueba de carga añadiendo contadores de

rendimiento a las propiedades de la prueba. Estos contadores de rendimiento son los mismos que se usaron paracontrolar el rendimiento del servidor en el Capítulo 9, Generar y Desplegar Aplicaciones Web usando el añadidoAlertas y contadores de rendimiento de la MMC. Para añadir contadores de rendimiento a una prueba de carga:

1. Pulse con el botón derecho sobre el elemento prueba en el panel izquierdo de la ventana de ACT y selec-cione Propiedades.

2. Pulse la lengüeta Contadores y Agregar. ACT muestra el diálogo Examinar contadores de rendimiento.3. Seleccione los contadores que quiere controlar y pulse Agregar. Cierre cuando termine.4. Pulse Aceptar.

Cuando se ejecuta una prueba ACT guarda las estadísticas de rendimiento en un archivo XML que semuestra en el panel de resultados de la ventana de ACT.

Imitar tipos de navegador ACT puede imitar varios tipos de navegados modificando la información de agente de usuario que inclu-

ye en la cabecera que envía con cada petición. La prueba Browser Type del proyecto ACTSamples que se instalacon ACT muestra cómo hacerlo.

Puede copiar la prueba Browser Type a sus propios proyectos de prueba para comprobar la compatibili-dad con navegadores y probar si su aplicación responde correctamente a tipos de navegadores no soportados. Sinembargo, como ACT no muestra las respuestas no puede confiar en esta prueba para comprobar visualmente que

su aplicación Web se ve correctamente en diferentes navegadores.

Obtener el contenido de las respuestasACT devuelve la respuesta del servidor en la propiedad Body del objeto Response. Puede usar la función

Instr de VBScript para comprobar si una respuesta contiene el resultado esperado:

VBScriptSet oResponse = oConnection.Send(oRequest)If Instr(oResponse.Body, "Correcto") Then

Test.Trace("Respuesta correcta.")Else

Test.Trace("Respuesta incorrecta.")End If

JScriptoResponse = oConnection.Send(oRequest);if (oResponse.Body.search"Correcto")) Test.Trace("Respuesta correcta.");else Test.Trace("Respuesta incorrecta.");

La búsqueda en Body del proyecto ACTSamples muestra el uso de Instr para localizar elementos en unarespuesta.

Más información: La ayuda en línea de ACT proporciona una referencia completa del modelo de objetos de prueba e incluye información de concepto sobre el uso de ACT para pruebas de cargaen aplicaciones Web.

10.2.2 Ejecutar pruebas con ensamblados .NETACT se escribió principalmente para interactuar con aplicaciones Web mediante peticiones y respuestas. Esto

es adecuado para probar los aspectos de Interface de usuario de una aplicación Web, pero es una limitación cuandose intenta realizar pruebas sobre las clases subyacentes usadas por la aplicación.

Por ejemplo suponga que quiere usar ACT para probar la clase FlashCardClass como se muestra en la lec-ción 1. Probablemente intentaría algo como:

VBScriptTest.TraceLevel = -1

Dim FlashCardSet FlashCard = CreateObject("vbFlashCards.FlashCardClass")

If (FlashCard Is Nothing) ThenTest.Trace("Error: FlashCard no creado.")Test.StopTest

End If

JScriptTest.TraceLevel = -1;




199

var FlashCard;FlashCard = CreateObject("csFlashCards.FlashCardClass");

if (FlashCard == null) {Test.Trace("Error: FlashCard no creado.");Test.StopTest();

}

Lo malo es que esto no funciona. Como las aplicaciones Web están basadas en el marco de trabajo .NET no puede usar sus espacios de nombres como argumento del método CreateObject . Este método espera el ID de pro-grama (progID) de un objeto COM, no un espacio de nombres.

Para usar una secuencia de comandos para probar un ensamblado .NET siga estos pasos:

1. Registre el ensamblado .NET para uso con COM.2. Asegúrese de que la aplicación COM puede usar el ensamblado3. Cree el objeto .NET usando el progID registrado para el ensamblado .NET.

Las siguientes secciones describen estos pasos con más detalle.

Registrar ensamblados .NETPara registrar un ensamblado .NET en la base de datos de registro del sistema use RegAsm.exe. Esta uti-

lidad se instala con el marco de trabajo .NET. Para utilizarla:

1. Inicie una ventana de consola de Visual Studio .NET.

2. En esta ventana vaya al directorio que contiene el ensamblado a registrar y ejecute el comando Re-gAsm.exe ensamblado.dll, donde ensamblado es el ensamblado que se quiere registrar.

RegAsm.exe registra las clases públicas del ensamblado .NET usando su espacio de nombres y nombresde clase como progID.

Localizar el ensamblado .NETDespués de registrar un ensamblado .NET los componentes COM necesitan una forma de encontrarlo.

Hay varias formas de hacerlo, pero estas son las tres más sencillas:

• Instalar el ensamblado en el caché de ensamblados global (GAC)• Copiar el ensamblado en el mismo directorio que el componente COM que lo va a usar • Copiar el componente COM en el directorio donde reside el ensamblado.

Los ensamblados instalados en el GAC están disponibles para todas las aplicaciones en el ordenador. An-tes de poder ser instalados en el caché, los ensamblados deben estar configurados con nombre seguro. Puede ver las instrucciones para configurar ensamblados e instalarlos en el GAC en la ayuda de Visual Studio.

Para ensamblados que no están pensados para compartir con otras aplicaciones la solución más sencilla puede copiar el ensamblado o el componente COM a la carpeta del otro. Esto es particularmente cierto para pruebas, en las que no se quiere que el ensamblado sea de acceso general.

Crear el objeto .NETDespués de registrar un ensamblado .NET y asegurarse de que los componentes COM pueden encontrarlo

puede crear una instancia del objeto .NET usando los métodos de creación del objeto COM, como la funciónCreateObject de VBScript.

Para ver cómo funciona esto con una herramienta de pruebas como Windows Scripting Host siga estos pasos:

1. Registre un ensamblado de aplicación Web tal como se indica en la sección anterior.2. Copie CScript.exe del directorio System32 de Windows al directorio \bin de la aplicación Web. Esta es la

copia de CScript que usaremos para las pruebas; debe estar en el mismo directorio que el ensamblado.NET para que los objetos COM y .NET puedan interactuar.

3. Cree un archivo VBScript o JScript y ejecútelo usando la copia de CScript.exe que creó en el paso 1.

El siguiente código muestra cómo probar FlashCardClass usando Windows Scripting Host:

VBScript' TestFlash.vbs' Pruebas de unidad de FlashCardClassOption Explicit

Dim FlashClass



MCAD/MCSD

200

Set FlashClass = CreateObject("vbFlashCards.FlashCardClass")' Comprueba si se ha creado la clase.If (FlashClass is Nothing) Then

WScript.Echo "Error: no se ha creado FlashCardClass."WScript.Quit

End If' Prueba barajadoFlashClass.Shuffle 1, 1000Dim X, Y

x = FlashClass.FirstNumbery = FlashClass.SecondNumber' Baraja de nuevoFlashClass.Shuffle 1, 1000If (x = FlashClass.FirstNumber) or (y = FlashClass.SecondNumber) Then

WScript.Echo "Advertencia: número no único."End If' Prueba la respuestaIf (FlashClass.FirstNumber + FlashClass.SecondNumber = FlashClass.Answer) Then

WScript.Echo "Correcto: la respuesta suma"Else

WScript.Echo "Error: Respuesta incorrecta."End If

JScript// TestFlash.js// Pruebas de unidad de FlashCardClassvar FlashClass;

FlashClass = new ActiveXObject("vbFlashCards.FlashCardClass");// Comprueba si se ha creado la clase.if (FlashClass == null){

WScript.Echo("Error: No se ha creado FlashCardClass.");WScript.Quit();

}// Prueba barajadoFlashClass.Shuffle(1, 1000);var X, Y;x = FlashClass.FirstNumber;y = FlashClass.SecondNumber;

// Baraja de nuevoFlashClass.Shuffle(1, 1000);if ((x == FlashClass.FirstNumber) ││ (y == FlashClass.SecondNumber))

WScript.Echo("Advertencia: número no único.");// Prueba la respuestaif (FlashClass.FirstNumber + FlashClass.SecondNumber == FlashClass.Answer())

WScript.Echo("Correcto: Respuesta suma");else

WScript.Echo("Error: Respuesta incorrecta.");

Para ejecutar la anterior secuencia de comandos use una línea similar a la siguiente:

@rem VBScriptbin\cscript TestFlash.vbs > logs\FlashErr.log

@rem JScriptbin\cscript TestFlash.js > logs\FlashErr.log

10.2.3 Compilaciones y pruebas desatendidasLa ejecución de pruebas de unidad, integración y carga de forma regular proporciona un aseguramiento de

calidad constante y comprueba regresiones. La mayoría de los desarrolladores ejecutan la compilación y una serie de pruebas cada noche. La ejecución de pruebas nocturnas previene conflictos con conexiones y no disturba el flujo detrabajo mientras que una máquina está dedicada a una compilación. Al ejecutarse de noche estas compilaciones por lo general son desatendidas, lo que significa que no debe haber nadie presente para iniciarlas o controlar su progre-so. Para ejecutar compilaciones y pruebas desatendidas siga estos pasos:

1. Cree un archivo de secuencia de comandos con las órdenes para establecer variables de entorno, compilar y probar que quiera ejecutar.

2. Use el administrador de tareas programadas de Windows para planificar la ejecución de la .

3. Controle los archivos de registro para asegurarse de que la compilación y pruebas tienen éxito.




201

Crear un archivo de comandos.Puede crear un archivo de comandos (.bat) para ejecutar cualquier conjunto de órdenes que quiera. En ge-

neral un archivo de comandos tiene tres secciones:

• Configuración de variables de entorno, como PATH y LIB, necesarias para localizar los componentes uti-lizados en la compilación.

• Ejecutar el entorno de desarrollo de Visual Studio .NET para compilar el ensamblado.• Ejecutar las herramientas de prueba utilizadas para probar el ensamblado.

Las variables de entorno que utiliza Visual Studio .NET se pueden encontrar en el archivo de comandosVsVars.bat que se instala en el directorio Command\Tools del producto. Puede cortar y pegar desde este archivoa su archivo de comandos.

Para ejecutar Visual Studio .NET desde línea de comandos use el comando DevEnv.exe con el archivo desolución del proyecto (.sln). Por ejemplo, la siguiente línea compila la aplicación FlashCards usando la configu-ración Debug y registra todos los errores en el directorio Logs:

DevEnv vbFlashCards.sln /build Debug > Logs\builders.log

Puede reunir todos estos pasos en un único archivo de comando. Por ejemplo, el siguiente archivo confi-gura las variables de entorno, compila una aplicación Web y ejecuta una secuencia de comandos de prueba sobreel ensamblado.

@rem Build.bat

@rem ========================================================================@rem Configuración de entorno tomada de vsvars32.bat@rem ========================================================================@SET VSINSTALLDIR=E:\Program Files\Microsoft Visual Studio .NET\Common7\IDE@SET VCINSTALLDIR=E:\Program Files\Microsoft Visual Studio .NET@SET FrameworkDir=C:\WINDOWS\Microsoft.NET\Framework@SET FrameworkVersion=v1.0.3705@SET FrameworkSDKDir=C:\Program Files\Microsoft Visual Studio.NET\FrameworkSDK@rem Raíz de los archivos comunes de Visual Studio.

@rem Raíz de los archivos instalados del ide de Visual Studio.@rem@set DevEnvDir=%VSINSTALLDIR%

@rem Raíz de los archivos instalados de Visual C++.@rem@set MSVCDir=%VCINSTALLDIR%\VC7

@set PATH=%DevEnvDir%;%MSVCDir%\BIN;%VCINSTALLDIR%\Common7\Tools;%VCINSTALLDIR%\Common7\Tools\bin\prerelease;%VCINSTALLDIR%\Common7\Tools\bin;%FrameworkSDKDir%\bin;%FrameworkDir%\%FrameworkVersion%;%PATH%;@set INCLUDE=%MSVCDir%\ATLMFC\INCLUDE;%MSVCDir%\INCLUDE;%MSVCDir%\PlatformSDK\include\prerelease;%MSVCDir%\PlatformSDK\include;%FrameworkSDKDir%\include;%INCLUDE%@set LIB=%MSVCDir%\ATLMFC\LIB;%MSVCDir%\LIB;%MSVCDir%\PlatformSDK\lib\prerelease;%MSVCDir%\PlatformSDK\lib;%FrameworkSDKDir%\lib;%LIB%

@rem ========================================================================@rem Fin de configuración del entorno@rem ========================================================================

@rem ========================================================================@rem Comandos de compilación del entorno de desarrollo@rem ========================================================================devenv vbBuildSnippet.sln /build debug > logs\builderrs.log@rem ========================================================================@rem Fin de comandos de compilación@rem ========================================================================

@rem ========================================================================@rem Comandos de prueba@rem ========================================================================bin\cscript RunTests.vbs > logs\testerrs.log@rem ========================================================================

@rem Fin de comandos de prueba@rem ========================================================================



MCAD/MCSD

202

Planificación de tareas.Para planificar la ejecución nocturna de un archivo de comandos use el planificador de tareas de Win-

dows. Siga estos pasos:

1. En el panel de control, tareas programadas, pulse Agregar tarea programada. Se abrirá el asistente para ta-ras programadas.

2. Pulse Siguiente y Examinar para seleccionar el archivo de comandos. Cuando haya seleccionado el archi-vo el asistente muestra la página de planificación.

3. Seleccione una opción para indicar cuándo ejecutar la tarea y pulse Siguiente. El asistente muestra la pá-gina de hora.4. Escriba la hora para ejecutar la tarea y pulse Siguiente. El asistente muestra la página de contraseña.5. Escriba el nombre de usuario y contraseña bajo los que se debe ejecutar el comando, pulse Siguiente y

después Finalizar para completar el asistente.

Ver archivos de registroComo las compilaciones y pruebas planificadas con el planificador de tareas corren desatendidas es im-

portante controlar los archivos de registro creados por los comandos en el proceso de compilación. Los coman-dos de compilación y prueba que se mostraron anteriormente usan el operador de redirección (>) para escribir lasalida de los comandos en archivos de registro que se pueden ver en el Block de notas.

10.3 DepuradoLas pruebas son probablemente una de las pocas tareas en las que el fracaso es un tipo de éxito. En esta lec-

ción aprenderá cómo usar estos éxitos para corregir problemas en su aplicación. Los temas que cubre esta lección seapoyan en la discusión de las herramientas de depurado de Visual Studio que se trató en el Capítulo 1, Introduccióna la programación Web. Incluye corrección de problemas concretos que no cubren las pruebas, añadir código dediagnóstico a una aplicación y depurar una aplicación Web que corre en un servidor remoto.

10.3.1 Poner a trabajar los resultados de las pruebasSi ha ejecutado las pruebas de unidad de la aplicación FlashCards en la lección 1 habrá observado que no pa-

sa las pruebas. Esto se debe a que FlashCards es un programa de demostración simplificado, no una aplicación ro- busta pensada para uso comercial.

Sin embargo, los resultados son instructivos. El primer conjunto de errores que se encuentra en las pruebas deunidad de FlashCardClass son desbordamientos al utilizar MinValue y MaxValue enteros para inicializar los núme-ros aleatorios. La suma de dos valores cercanos al valor máximo de entero tiene como resultado un número mayor

que un entero. A continuación se muestra el código relacionadoVisual Basic .NET' Código de pruebaFunction TestFlashCard() As Boolean

'Crea la claseDim FlashCard As New vbFlashCards.FlashCardClass()'Prueba si la clase existe.If IsNothing(FlashCard) Then

Console.WriteLine("FlashCardClass fallida")'Devuelve false y termina.Return False

End If'Prueba método de barajado.FlashCard.Shuffle(Integer.MinValue, Integer.MaxValue)'Prueba propiedades.If (FlashCard.Answer <> FlashCard.FirstNumber + FlashCard.SecondNumber) Then

Console.Write("Error: Respuestas no corresponden")End If

End Function

' Código de FlashCardClass con error.' Calcula la respuesta en base a la operación actual.Public Function Answer() As Integer


Return mintFirstNumber + mintSecondNumber ' Desbordamiento!!!!Case "x", "*"

Return mintFirstNumber * mintSecondNumberCase "-"

Return mintFirstNumber – mintSecondNumber




203

Case ElseReturn 0


Visual C#// Código de prueba.static bool TestFlashCardClass(){

//Crea la clase

csFlashCards.FlashCardClass FlashCard = new csFlashCards.FlashCardClass();//Comprueba si existe la clase.if (FlashCard == null){

Console.WriteLine("FlashCardClass fallida");//Devuelve false y termina.return false;

}//Prueba método de barajado con valores mínimo y máximo.FlashCard.Shuffle(int.MinValue, int.MaxValue);//Prueba propiedades.int intFirst = FlashCard.FirstNumber;int intSecond = FlashCard.SecondNumber;double dblAnswer = intFirst + intSecond;if (dblAnswer != (double)FlashCard.Answer())

Console.WriteLine("Error: los números no suman");

}

// Código de FlashCardClass con error.// Calcula la respuesta en base a la operación actual.public int Answer(){

switch(mstrOp){case "+": return mintFirstNumber + mintSecondNumber; break;case "x": return mintFirstNumber * mintSecondNumber; break;case "*": return mintFirstNumber * mintSecondNumber; break;case "-": return mintFirstNumber - mintSecondNumber; break;default : return 0;

}}

Tiene dos formas de tratar este problema: restringir el rango de valores posibles de las propiedades First-

Number y SecondNumber o cambiar el tipo devuelto por el método Answer . La segunda posibilidad es más obviadesde el punto de vista del usuario porque los enteros son un tipo de entrada habitual y sería difícil explicar porquése usa un tipo menor para estas propiedades.

El siguiente código muestra los cambios en el método Answer que permiten pasar las pruebas de unidad.

Visual Basic .NETPublic Function Answer() As Double


Return CDbl(mintFirstNumber) + CDbl(mintSecondNumber)Case "x", "*"

Return CDbl(mintFirstNumber) * CDbl(mintSecondNumber)Case "-"

Return CDbl(mintFirstNumber) - CDbl(mintSecondNumber)

Case "/"Return CDbl(mintFirstNumber) / CDbl(mintSecondNumber)

Case ElseReturn 0


Visual C#public double Answer(){

switch(mstrOp){case "+": return mintFirstNumber + mintSecondNumber; break;case "x": return mintFirstNumber * mintSecondNumber; break;case "*": return mintFirstNumber * mintSecondNumber; break;case "-": return mintFirstNumber - mintSecondNumber; break;default : return 0;

}}



MCAD/MCSD

204

Si especifica una operación diferente a +. -, * o x surge otro problema con la clase FlashCardClass. La propiedad Operation se limita a devolver 0, lo que resulta un poco tonto. Los siguientes cambios aseguran que solo seusan operaciones válidas:

Visual Basic .NETPublic Property Operation() As String

GetOperation = mstrOp

End Get

Set(ByVal Value As String)If InStr("+-/x*", Value) Then

mstrOp = ValueElse

Throw New Exception("Operador no reconocido")End If

End SetEnd Property

Visual C#public string Operation{

get{return mstrOp;}set{

if (" +-/x*".IndexOf(value, 1) != 0) mstrOp = value;else throw(new Exception("Operador no reconocido"));

}}

Estas correcciones muestran lo importante que es realizar pruebas de unidad antes de comprobar las nuevasclases en el conjunto del proyecto. Cuando una clase es parte de un proyecto mayor es mucho más difícil localizar la causa de un error.

10.3.2 Clases Debug y TraceEl marco de trabajo .NET incluye las clases Debug y Trace en el espacio de nombres System.Diagnostics

como herramientas para ayudarle a capturar errores y comportamientos inesperados de su aplicación. Estas clases permiten mostrar alertas o escribir mensajes basados en los resultados de su aplicación.

La diferencia entre las dos clases es cómo la gestionan las compilaciones definitivas (release). De forma pre-determinada, los métodos y propiedades de Debug se eliminan automáticamente del código en la compilación defi-

nitiva, mientras que los de Trace se mantienen. Esto le da dos niveles de diagnóstico: uno para errores de depuradoanteriores a la distribución y otro para diagnósticos de rendimiento y problemas sobre el terreno.

Como Trace y Debug son parte de un espacio de nombres .NET necesita añadirlo o importarlo antes de utili-zar estas clases.

10.3.3 Mostrar alertas y mensajesEl método Assert de las clases Debug y Trace comprueban un valor y muestran una alerta si es False. Use es-

te método para detener una aplicación cuando hay un resultado inesperado. Por ejemplo, el siguiente código muestrauna alerta si el número mostrado en el formulario FlashCards no se suma tal como se espera:

Visual Basic .NETPrivate Sub txtAnswer_TextChanged(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles txtAnswer.TextChanged

If txtAnswer.Text = FlashCard.Answer ThenlblFeedback.Text = "Correcto"Debug.Assert(CInt(txtAnswer.Text) = CInt(lblFirst.Text) + _

CInt(lblSecond.Text), "los valores del formulario no se suman")'Obtiene otro conjunto de números.FlashCard.Shuffle()'Renueva la presentación para mostrar los nuevos números.RefreshDisplay()'Limpia la respuestatxtAnswer.Text = ""

ElselblFeedback.Text = "Error; pruebe de nuevo."

End IfEnd Sub




205

Visual C#private void txtAnswer_TextChanged(object sender, System.EventArgs e){

if(txtAnswer.Text == FlashCard.Answer().ToString()){lblFeedback.Text = "Correcto";Debug.Assert(Convert.ToInt32(txtAnswer.Text) ==

Convert.ToInt32(lblFirst.Text) + Convert.ToInt32(lblSecond.Text),"Los valores del formulario no se suman");

//Obtiene otro conjunto de números.FlashCard.Shuffle();

//Renueva la presentación para mostrar los nuevos números.RefreshDisplay();//Limpia la respuestatxtAnswer.Text = "";

}elselblFeedback.Text = "Error; pruebe de nuevo.";

}

En una aplicación Web la alerta se muestra en el servidor. Si está ejecutando el servidor en su máquina localesta alerta se ve tal cómo se espera. Si corre en un servidor remoto solo verá la alerta si está asociado al proceso deaplicación que corre en el servidor para depurado remoto, como se indica más adelante.

Para escribir un mensaje sin detener la aplicación use los métodos Write o WriteLine. De forma predetermi-nada estos mensajes se muestran en la ventana de resultados de Visual Studio durante el depurado.

10.3.4 Registrar mensajes de Debug y TracePara registra los mensajes de Debug y Trace en una aplicación desplegada cree una clase TextWriterTrace-

Listener y añádala a la colección Listeners de las clases Debug y Trace. Por ejemplo, el siguiente código dirige losresultados de Debug a la consola del servidor.

Visual Basic .NETDebug.Listeners.Add(New TextWriterTraceListener(Console.Out))Debug.WriteLine("Iniciando pruebas.")

Visual C#Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));Debug.WriteLine("Iniciando pruebas.");

Para escribir mensajes en un archivo en lugar de en la consola especifique un nombre de archivo y use el mé-

todo Flush para escribir la salida. Por ejemplo, el siguiente código escribe un mensaje en el archivo Results.log.Visual Basic .NETDebug.Listeners.Add(New TextWriterTraceListener("Results.log"))Debug.WriteLine("Iniciando pruebas.")Debug.Flush()

Visual C#Debug.Listeners.Add(new TextWriterTraceListener("Results.log"));Debug.WriteLine("Iniciando pruebas.");Debug.Flush();

10.3.5 Depurado remotoEl asistente de instalación de Visual Studio .NET incluye una opción para instalar componentes remotos.

Ejecute la instalación de Visual Studio en el servidor y seleccione la opción Depurado remoto completo. Se instala-rán los componentes necesarios y se configurará el servidor para permitir depurado remoto.

Establecer permisos en el servidor Para poder depurar procesos que corren en el servidor debe tener una cuanta de usuario en él, y esta cuen-

ta debe pertenece al grupo Usuario del depurador. El asistente de instalación de Visual Studio .NET crea estegrupo cuando se instalan los componentes de depurado remoto. Debe asegurarse de que los usuarios que necesi-tan privilegios de depurado en el servidor pertenecen a este grupo.

Asociar a un proceso remotoVisual Studio .NET se puede asociar a procesos que corren en un servidor remoto. Mientras está asociado

al proceso Visual Studio puede recibir mensajes en la ventana de resultados, mostrar alertas del método Assert ,establecer puntos de interrupción, ver variables y recorrer el código que corre en el servidor remoto. Para aso-ciarse a un proceso remoto:

1. En el menú Herramientas pulse Procesos de depuración. Visual Studio muestra el diálogo Procesos.2. De forma predeterminada las aplicaciones Web corren en un proceso llamado aspnet_wp.exe. Seleccioneel proceso remoto que quiere depurar, pulse Asociar y Cerrar.



MCAD/MCSD

206

Cuando está asociado a un proceso remoto Visual Studio .NET puede recorrer el código estableciendo puntos de interrupción. La forma más fácil de hacer esto con una aplicación Web es establecer un punto de inte-rrupción en la función Page_Load para detener la aplicación al inicio de un formulario Web y entonces estable-cer puntos de interrupción o inspecciones en el código remoto como se desee. Para establecer un punto de inte-rrupción en un proceso remoto:

1. Pulse la lengüeta Puntos de interrupción en Visual Studio.2. Pulse el botón Nuevo en la barra de herramientas de puntos de interrupción. Visual Studio muestra el diá-

logo Nuevo punto de interrupción.3. Escriba un nombre de procedimiento en la caja Función y pulse Aceptar. Para aplicaciones Web lo másfácil es detener la aplicación en el procedimiento Page_Load y después agregar los puntos de interrupciónrequeridos.

Cuando se detiene un proceso remoto en un punto de interrupción se pueden usar las herramientas de depurado de Visual Studio .NET para ver variables, recorrer el código o ejecutar comandos tal como se haría conun proceso local

10.4 Resumen• Las pruebas miden la adaptación a los requisitos de producto.• Las pruebas de unidad comprueban que cada fragmento de código funciona correctamente.• Las pruebas de integración comprueban que todos los componentes funcionan en conjunto.•

Las pruebas de regresión aseguran que el nuevo código no introduce errores en el existente.• Las pruebas de carga comprueban que el producto funciona bajo uso extremo.• Las pruebas de plataforma aseguran que una aplicación Web se muestra correctamente y tiene un rendimien-

to aceptable usando diferentes configuraciones de navegador y conexión de red.• Utilice ACT para grabar interacción del usuario con una aplicación Web en VBScript y después reproduzca

esta secuencia de comandos para simular varios usuarios y registrar errores de aplicación y rendimiento delservidor.

• Para probar un ensamblado .NET con Windows Scripting Host registre el ensamblado para uso con COM ycopie CScript.exe al directorio del ensamblado.

• Para ejecutar compilaciones y pruebas desatendidas cree un archivo de comando que contenga los comandosde compilación y las secuencias de comandos de pruebas y planifique el archivo de comandos con el planifi-cador de tareas de Windows.

• Use las clases de diagnóstico Debug y Trace para mostrar condiciones de alerta y de error durante el proceso

de desarrollo.• De forma predeterminada el código escrito con la clase Debug se elimina en las compilaciones finales, mien-

tras que el de la clase Trace se mantiene.• Visual Studio .NET puede asociarse al proceso de una aplicación Web que corra en un servidor remoto para

depurar la aplicación con una configuración real.

10.5 Práctica: Pruebas y depuradoEn esta práctica aplicará las lecciones de este capítulo para repasar un plan de pruebas real, escribir unidades

de prueba para una aplicación de ejemplo, hacer una prueba de carga a una aplicación desplegada y recorrer unaaplicación Web que corre en un servidor remoto usando las herramientas de depurado de Visual Studio .NET.

10.5.1 Repasar un plan de pruebas

Las estrategias y terminología de pruebas cambian de una compañía a otra. En este ejercicio usará un plan de pruebas de su propia compañía para identificar los conceptos tratados en la lección 1. Si no trabaja para una compa-ñía que use planes de prueba busque en Internet usando la frase “plan de pruebas software” (“software test plan”) yelija un plan de pruebas en los resultados.

Usando un plan de pruebas real, destaque cualquier mención a los siguientes elementos:

• Pruebas de unidad• Pruebas de integración• Pruebas Ad hoc.

Vea si puede encontrar las respuestas a las preguntas hechas en la lección 1

• ¿Cómo están escritas las pruebas?• ¿Quién es responsable de las pruebas?• ¿Cuándo se realizan las pruebas?• ¿Dónde se guardan las pruebas y sus resultados?• ¿Qué se está probando?




207

Según este información ¿le da el plan de prueba una idea clara de cómo demostrarán las pruebas que se cumplen los requisitos?

10.5.2 Escribir pruebas de unidadEn este ejercicio usará VBScript o JScript para crear pruebas de unidad para las clases Sphere y Circle que se

derivaron de la clase abstracta Shapes en el capítulo 3, Trabajar con objetos Web. Las pruebas deben verificar quese cumplen las siguientes condiciones:

•

Se pueden crear las clases Circle y Sphere.• Se pueden pasar las clases a procedimientos que acepten el interface IFigure.• Todas las propiedades funcionan con valores mínimos y máximos.• Todos los métodos devuelven los resultados esperados para dos o más casos de prueba.

Para crea las pruebas de unidad:

1. Registre el ensamblado para uso con COM mediante la utilidad RegAsm.exe.2. Copie CScript.exe al directorio que contiene el ensamblado que va a probar 3. Cree las pruebas en VBScript o JScript usando el Block de notas o cualquier otro editor 4. Ejecute las pruebas usando la copia de CScript.exe.

Cuando termine compare sus resultados con los de los archivos de ejemplo del CD-ROM que acompaña allibro.

10.5.3 Crear una prueba de cargaSi tiene Visual Studio .NET Enterprise Architect use ACT para crear una prueba de carga para una aplicación

Web que haya desplegado en un servidor de prueba. Elija la aplicación Web que prefiera, pero siga estos parámetrosde prueba:

1. Registre al menos cinco peticiones diferentes al servidor.2. Agregue contadores de rendimiento para el porcentaje de tiempo de procesador, páginas de memoria por se-

gundo y promedio de longitud de la cola de lectura de disco.3. Registre los resultados en un directorio dentro de la estructura de la aplicación Web.4. Configure las propiedades de la prueba para que se ejecute durante 30 segundos usando 4 conexiones simul-

táneas.5. Ejecute la prueba.6. Vea los contadores de rendimiento del servidor en forma gráfica dentro de ACT.

10.5.4 Recorrer un proceso remotoEn este ejercicio usará Visual Studio .NET para detener y recorrer una aplicación Web en ejecución en un

servidor remoto. Para completar este ejercicio debe pertenecer al grupo Usuarios del depurador del servidor, y estedebe tener instalados los componentes remotos de Visual Studio .NET.

1. Desde su puesto de trabajo acceda a la aplicación Web usando el explorador de Internet. Esto asegura que laaplicación está en ejecución en el servidor cuando se intente asociar con su proceso.

2. En el menú Herramientas de Visual Studio seleccione Procesos de depuración. Seleccione el servidor dondecorre la aplicación, seleccione el proceso de la aplicación (llamado aspnet_wp.exe) y pulse Asociar.

3. Establezca un punto de interrupción en la función Page_Load .4. Cambie al explorador de Internet y pulse Recargar.5. Vuelva a Visual Studio. La aplicación se debe haber detenido en Page_Load .

6. Establezca puntos de interrupción en otros lugares de la aplicación.7. En Visual Studio pulse Continuar para ejecutar hasta el siguiente punto de interrupción.



1. ¿Cómo se relacionan entre sí las pruebas de unidad, integración y regresión?.

2. ¿Por qué tiene más importancia la prueba de carga en una aplicación Web que en una aplicación Windowsindependiente?

3. ¿Cuál es la diferencia entre las clases Debug y Trace?

4. ¿Cuáles son los dos pasos especiales necesarios para asegurar que un componente COM puede usar un componente de un ensamblado .NET?



MCAD/MCSD

208




209

11 Crear controles WebLos controles personalizados extienden las herramientas disponibles para los desarrolladores Web. Usando

controles personalizados puede encapsular aspectos clave del interface visual y lógica de programa que quiere reuti-lizar a lo largo de su aplicación o de su organización. Visual Studio .NET proporciona tres tipos de controles perso-nalizados para uso en aplicaciones Web. En este capítulo aprenderá cómo desarrollar y usar estos tipos de controles:

• Controles de usuario Web: Combinan controles de servidor y HTML existentes usando el diseñador de Vi-

sual Studio para crear unidades funcionales que encapsulan algún aspecto del interface de usuario. Los con-troles de usuario residen en archivos de contenido que se deben incluir en el proyecto en el que se usen.• Controles personalizados compuestos: Crean nuevos controles a partir de controles de servidor y HTML

existentes. Aunque son similares a los controles de usuario, los controles compuestos se crean en código enlugar de visualmente y por tanto se pueden compilar en un ensamblado (.dll) que se puede compartir entrevarias aplicaciones y usar desde la caja de herramientas de Visual Studio.

• Controles de usuario trazados: Crean controles completamente nuevos mediante HTML directo en lugar deusar composición. Estos controles se compilan y se pueden usar desde la caja de herramientas, igual que loscompuestos, pero hay que escribir código extra para tareas que en los compuestos son automáticas.


• Estar familiarizado con el ciclo de vida de una aplicación Web.• Comprender las técnicas de programación orientada a objetos, espacios de nombres e información de estado,

como se indica en el Capítulo 3, Trabajar con objetos Web.• Tener experiencia en el desarrollo de aplicaciones Web con controles de servidor y HTML estándar.

11.1 Crear controles de usuario WebLos controles Web de usuario combinan uno o más controles de servidor o HTML en una página de control

de usuario Web, que a su vez se puede usar en un formulario Web como un control único. Los controles de usuariohacen posible crear un único componente visual que usa varios controles para realizar una tarea concreta.

Una vez creados, los controles de usuario se pueden usar en los formularios Web de un proyecto. Sin embar-go, como no se compilan en ensamblados tienen las siguientes limitaciones que no se encuentran en los demás tiposde controles:

• Debe haber una copia del control en cada proyecto de aplicación Web que lo utilice.• No se pueden cargar en la caja de herramientas de Visual Studio. Se crean arrastrándolos desde el explorador

de soluciones.• El código del control de usuario se inicializa después de que se cargue la página web, lo que significa que los

valores de las propiedades del control de usuario no se actualizan hasta después del suceso Page_Load delformulario Web.

11.1.1 Crear y usar controles de usuarioLa creación y uso de un control de usuario en una aplicación Web tiene cinco pasos:

1. Agregar una página de control Web de usuario (.ascx) al proyecto2. Dibujar el interface de usuario del control en el diseñador 3. Escribir código para crear las propiedades, métodos y sucesos del control4. Usar el control en un formulario Web arrastrándolo desde el explorador de soluciones5. Usar el control en el código del formulario Web declarando el control a nivel de módulo y usando sus méto-

dos, propiedades y sucesos.

11.1.2 Crear un control de usuario y dibujar su interfaceLos controles de usuario se crean a partir de otros controles de servidor y HTML de la caja de herramientas

de Visual Studio. Esto se hace arrastrando los controles a una página de control de usuario, que es sencillamenteotro tipo de archivo en un proyecto de aplicación Web, como un formulario Web o una página HTML. Los controlesde usuario se identifican por la extensión .ascx en su nombre de archivo.

Para crear un control de usuario y agregarlo a su aplicación Web:

1. En el menú Proyecto seleccione Agregar control de usuario Web. Visual Studio muestra el diálogo Agregar nuevo elemento.

2. Escriba el nombre del control de usuario en la caja de texto Nombre. Visual Studio crea una nueva página decontrol de usuario en blanco y la agrega al proyecto.

Después de añadir una página de control de usuario al proyecto cree el interface visual del control añadiendocontroles de servidor o HTML. Los controles de usuario solo permite diseño de flujo, de modo que si quiere colocar



MCAD/MCSD

210

los controles en la página usando rejilla deberá colocar un control HTML Grid Layout Panel para usarlo como con-tenedor para los controles que quiere colocar.

En los siguientes apartados se utilizará un control de usuario llamado Spin con dos botones, cuyo HTML esel siguiente:

<DIV id="pnlGrid" runat="server" style="WIDTH: 20px; POSITION: relative;HEIGHT: 48px" ms_positioning="GridLayout">

<asp:Button id="butUp" Text="^" runat="server" />

<asp:Button id="butDown" Text="v" runat="server" /></DIV>

11.1.3 Escribir las propiedades, métodos y sucesos del controlLos controles que se añaden al control de usuario se manipulan desde el módulo de código del control de

usuario. Esto permite ocultar el funcionamiento interno del control y exponer las tareas que ejecuta como propieda-des, métodos y sucesos.

Para editar el módulo de código del control de usuario pulse dos veces sobre el control. La plantilla que gene-ra Visual Studio para un nuevo control es similar a la de un formulario Web, con las siguientes notables diferencias:

• La clase del control de usuario se declara como MustInherit en Visual Basic o abstract en C#. La clasede control de usuario solo se puede usar como base para una clase derivada. En este caso la clase derivada esel control de usuario creado en el formulario Web.

• La clase del control de usuario se basa en System.Web.UI.UserControl. Esta clase base proporciona elconjunto básico de propiedades y métodos que se usan para crear el control y obtener su configuración detiempo de diseño de sus atributos HTML en el formulario Web.

• El suceso Page_Load del control de usuario se produce cuando lo carga la página que lo contiene. ElPage_Load del control se produce después del Page_Load del formulario Web.

Para crear propiedades y métodos para el control de usuario que pueda usar desde un formulario Web:

1. Cree la propiedad o método público que quiere que esté disponible para el formulario Web contenedor.2. Escriba código para responder a los sucesos que se produzcan para los controles contenidos por el control de

usuario. Estos procedimientos de suceso hacen el grueso del trabajo del control de usuario.3. Si la propiedad o método necesita retener un valor entre presentaciones de la página escriba el código para

guardar y recuperar los valores en ViewState del control.

Por ejemplo, el siguiente código muestra una propiedad Value que devuelve el valor del control Spin creadoen la sección anterior.

Visual Basic .NETPublic Property Value() As Integer

GetReturn ViewState("Value")

End GetSet(ByVal Value As Integer)

ViewState("Value") = ValueEnd Set

End Property

Visual C#public int Value{

get{return Convert.ToInt32(ViewState["Value"]);}set{ViewState["Value"] = value; }}

El usuario cambia el valor del control Spin pulsando en sus botones, de modo que el siguiente código incre-menta o decrementa el valor dependiendo del botón pulsado:

Visual Basic .NETPrivate Sub butDown_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butDown.ClickMe.Value -= 1

End Sub

Private Sub butUp_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butUp.Click

Me.Value += 1

End Sub

Visual C#private void butDown_Click(object sender, System.EventArgs e){this.Value -= 1;}




211

private void butUp_Click(object sender, System.EventArgs e){this.Value += 1;}

11.1.4 Agregar el control a un formulario WebLos controles de usuario se pueden arrastrar directamente desde el explorador de soluciones a un formulario

Web. Cuando se agrega un control de usuario a un formulario Web de esta forma Visual Studio genera una directiva Register y etiquetas HTML para crear el control en el formulario Web.

Por ejemplo, el siguiente código muestra el HTML generado cuando se arrastra el control de usuario Spin a

un formulario Web:<%@ Page Language="vb" AutoEventWireup="false" Codebehind="WebForm1.aspx.vb"Inherits="vbUserSnippet.WebForm1"%><%@ Register TagPrefix="uc1" TagName="Spin" Src="Spin.ascx" %><HTML>

<body><form id="Form1" method="post" runat="server">

<uc1:Spin id="Spin1" runat="server"></uc1:Spin></form>

</body></HTML>

Los controles de usuario pueden existir junto a y coexistir con otros controles en un formulario Web. Por ejemplo, el siguiente HTML muestra el control de usuario Spin junto a un control TextBox:

<%@ Page Language="vb" AutoEventWireup="false" Codebehind="WebForm1.aspx.vb"Inherits="vbUserSnippet.WebForm1"%><%@ Register TagPrefix="uc1" TagName="Spin" Src="Spin.ascx" %><HTML>


<asp:TextBox id="TextBox1" runat="server"></asp:TextBox><uc1:Spin id="Spin1" runat="server" Value="5"></uc1:Spin>

</form></body>

</HTML>

Observe que el control de usuario incluye un atributo para la propiedad Value. Cuando se carga el controlSpin en tiempo de ejecución ASP.NET configura las propiedades del control según los atributos en HTML. Losatributos del control proporcionan una forma de configurar las propiedades desde HTML.

Al colocar el control en un formulario Web observar que el diseñador de formularios Web de Visual Studiono lo muestra como se verá en tiempo de ejecución; en su lugar muestra un control genérico. Es una limitación deVisual Studio – no puede mostrar controles de usuario en modo diseño.

Otra cosa que observará es que el control Spin solo soporta diseño de flujo en el formulario Web. Es una li-mitación del propio control. Para soportar diseño de rejilla y posicionamiento absoluto tiene que añadir código parasoportar el atributo de estilo. Esto ser verá más adelante.

11.1.5 Usar el control en el códigoCuando ha creado un control de usuario y lo ha agregado a un formulario Web puede usarlo desde el módulo

de código del formulario Web siguiendo estos pasos:

1. Declare el control de usuario a nivel de módulo. Por ejemplo, la siguiente línea declara el control de usuario

Spin que se agregó al formulario Web en la sección anterior:Visual Basic .NETProtected WithEvents Spin1 As Spin

Visual C#protected Spin Spin1;

2. Utilice las propiedades, métodos y sucesos del control como haría con cualquier otro. Por ejemplo, el si-guiente procedimiento de suceso muestra el valor del control Spin en una caja de texto:Visual Basic .NETPrivate Sub Page_PreRender(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.PreRenderTextBox1.Text = Spin1.Value

End Sub

Visual C#private void Page_PreRender(object sender, System.EventArgs e){

TextBox1.Text = Spin1.Value.ToString();}



MCAD/MCSD

212

Algo muy importante que hay que observar es que el código anterior usa el procedimiento Page_PreRender del formulario Web, no su procedimiento Page_Load . Si usa Page_Load sólo verá el valor establecido en el atributoHTML Value del control de usuario la primera vez que pulse sobre el control (inténtelo). Esto se debe a que el códi-go del control de usuario no corre hasta que no ha terminado el suceso Page_Load del formulario Web. Los cambiosque se grabaron en el ViewState del control no se cargan hasta que no se ejecuta Page_Load del control.

11.1.6 Añadir sucesos al control de usuarioAdemás de propiedades y métodos los controles de usuario pueden proporcionar sucesos que pueden respon-

der a acciones del usuario en el formulario web. Para añadir un suceso a un control de usuario siga estos pasos:

1. Declare un suceso dentro del módulo de código del control. Por ejemplo, el siguiente código declara un suce-so Click para el control de usuario Spin.Visual Basic .NETPublic Event Click(ByVal sender As System.Object, ByVal e As System.EventArgs)

Visual C#public event EventHandler Click;

2. Cree un método para lanzar el suceso. Este paso facilita que otras clases deriven de esta, ya que pueden susti-tuir este método.Visual Basic .NETProtected Overridable Sub OnClick(ByVal e As EventArgs)

RaiseEvent Click(Me, e)End Sub

Visual C#protected virtual void OnClick(EventArgs e){

if (Click != null)Click(this, e);

}

3. Lance el suceso desde el código del control de usuario. Por ejemplo, el siguiente código lanza el suceso Click siempre que un usuario pulsa uno de los botones del control Spin:Visual Basic .NETPrivate Sub butDown_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butDown.ClickMe.Value -= 1 'Decrementa el valor.OnClick(e) 'Llama al método OnClick.

End Sub

Private Sub butUp_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles butUp.Click

Me.Value += 1 'Incrementa el valor.OnClick(e) 'Llama al método OnClick.

End Sub

Visual C#private void butDown_Click(object sender, System.EventArgs e){

this.Value -= 1; // Decrementa el valorOnClick(e); // Llama al método OnClick.

}

private void butUp_Click(object sender, System.EventArgs e){

this.Value += 1; // Incrementa el valorOnClick(e); // Llama al método OnClick.}

Para utilizar el suceso del control de usuario desde un formulario Web incluya el control de usuario en unformulario Web, como se mostró en las secciones anteriores, y escriba un procedimiento de suceso que responda alsuceso. Por ejemplo, el siguiente código actualiza una caja de texto cuando el usuario pulsa sobre el control Spin:

Visual Basic .NETPrivate Sub Spin1_Click(ByVal sender As Object, ByVal e As System.EventArgs) _

Handles Spin1.ClickTextBox1.Text = Spin1.Value

End Sub

Visual C#

private void Spin1_Click(object sender, System.EventArgs e){TextBox1.Text = Spin1.Value.ToString();}




213

11.1.7 Activar el diseño en rejillaComo ya se ha mencionado los controles de usuario no incorporan soporte para el posicionamiento absoluto

utilizado por el diseño en rejilla de los formularios Web. En ASP.NET los controles soportan posicionamiento abso-luto por medio del atributo style. Para obtener soporte para posicionamiento absoluto en tiempo de diseño sencilla-mente añada un atributo style al HTML del control de usuario en el formulario Web. Por ejemplo, el siguienteHTML crea un control de usuario Spin que puede arrastrar a diferentes ubicaciones en un formulario Web en mododiseño.

<UserControl:Spin id="Spin1" runat="server" Value="5" style="Z-INDEX: 101;LEFT: 248px; POSITION: absolute; TOP: 88px"></UserControl:Spin>

Cuando ejecute la aplicación verá el problema que trae esta solución: en tiempo de ejecución ASP.NET igno-ra el atributo style y coloca el control de usuario Spin usando diseño de flujo.

Para que el atributo style funcione tendrá que agregar una propiedad Style al control de usuario, para estable-cer la posición y tamaño del control según los valores del atributo. Si su control usa un contenedor, como el GridLayout Panel que usa el control de usuario Spin, sencillamente puede pasar el atributo style del control al controlPanel, como muestra el siguiente código.

Visual Basic .NETPublic Property Style() As String

Get'Devuelve el atributo style del panel contenedor del control.

Return pnlGrid.Attributes("style")End GetSet(ByVal Value As String)

'Establece el atributo style del panel contenedor del control.pnlGrid.Attributes("style") = Value

End SetEnd Property

Visual C#public string Style{

get{// Devuelve el atributo style del panel contenedor del control.return pnlGrid.Attributes["style"];

}set{

// Establece el atributo style del panel contenedor del control.pnlGrid.Attributes["style"] = value;

}}

Puede usar esta misma técnica – llamada a veces delegación – para implementar otros atributos estándar decontrol como Visible, Enabled o BackColor . Sencillamente añada al control de usuario una propiedad que pase elvalor del atributo a un control contenedor usando la propiedad Attributes, como muestra el código anterior.

11.2 Crear controles compuestosLos controles compuestos combinan uno o más controles de servidor o HTML en una única clase control,

que se puede compilar junto con otras clases control para crear un ensamblado (.dll) que contiene una librería decontroles personalizados. Una vez creada la librería de controles se puede cargar en Visual Studio .NET y se puede

utilizar de la misma forma que los controles de servidor y HTML estándar.Los controles compuestos son funcionalmente similares a los de usuario, pero residen en sus propios ensam-

blados, de modo que se pueden compartir entre proyectos sin tener que copiarlo en cada uno de ellos. Sin embargo,los controles compuestos son algo más difíciles de crear que los de usuario porque no se pueden dibujar visualmenteen el diseñador de Visual Studio. Tiene muchas más opciones para definir su comportamiento, por tanto los contro-les compuestos son más complejos que los de usuario.

11.2.1 Crear y usar controles compuestosPara crear y usar un control compuesto siga estos seis pasos:

1. Cree una solución que contenga un proyecto de control personalizado.2. Agregue a la solución un proyecto de aplicación Web y establézcalo como proyecto de inicio. Usará el pro-

yecto Web para probar el control personalizado durante el desarrollo.

3. Agregue una referencia de proyecto desde la aplicación Web al proyecto de control personalizado y añadauna directiva Register de HTML y un elemento de control para usar el control en el formulario Web.4. Cree el interface visual del control compuesto añadiendo controles existentes por medio del método Create-

ChildControls del control.



MCAD/MCSD

214

5. Agregue las propiedades, métodos y sucesos que proporcione el control personalizado6. Compile y pruebe el control. Este último paso en realidad es parte de cada uno de los anteriores.

11.2.2 Crear el proyecto de control personalizadoLos controles personalizados son sencillamente clases creadas dentro de un ensamblado. Estas clases control

personalizadas heredan mucho de su comportamiento de la clase WebControl e implementan varios interfaces, dependiendo del tipo de control que se esté creando.

La forma más sencilla de empezar es usar la plantilla de proyecto Biblioteca de controles Web que propor-ciona Visual Studio .NET.

1. En el menú Archivo señale Nuevo y seleccione Proyecto. Visual Studio muestra el diálogo Nuevo Proyecto.2. Seleccione Biblioteca de controles Web en la lista Plantillas, escriba el nombre del proyecto en la caja de tex-

to Nombre y pulse Aceptar. Visual Studio crea un proyecto que contiene el código para un único control per-sonalizado llamado WebControl1.

El código creado sirve como plantilla para crear un nuevo control personalizado. La plantilla incluye una cla-se llamada WebControl1 que contiene una propiedad llamada Text.

Visual Basic .NETImports System.ComponentModelImports System.Web.UI

<DefaultProperty("Text", ToolboxData("{0}:WebCustomControl1 runat=server> _</{0}:WebCustomControl1>")>Public Class WebCustomControl1

Inherits System.Web.UI.WebControls.WebControl

Dim _text As String

<Bindable(True), Category("Appearance"), DefaultValue("")> _Property[Text]() As String

GetReturn _text

End Get

Set(ByVal Value As String)_text = Value

End Set

End PropertyProtected Overrides Sub Render(ByVal output As System.Web.UI.HtmlTextWriter)

output.Write([Text])End Sub

End Class

Visual C#using System;using System.Web.UI;using System.Web.UI.WebControls;using System.ComponentModel;

namepace csCompositeSnippet{///<summary>///Descripción breve de WebCustomControl1

///</summary>

[DefaultProperty("Text"), ToolboxData("<{0}:WebCustomControl1 runat=server></{0}:WebCustomControl1>")]public class WebCustomControl1 : System.Web.UI.WebControls.WebControl{

private string text;

[Bindable(true), Category("Appearance"), DefaultValue("")]public string Text{

get{return text;}set{text = value;}

}

///<summary>///Procesar este control en el parámetro de salida especificado///</summary>

///<param name="output">Programa de escritura HTML para escribir</param>




215

protected override void Render(HtmlTextWriter output){output.Write(Text);

}}

}

El código precedente contiene algunos elementos que puede que no haya visto hasta ahora, La tabla 11.1 des-cribe estos elementos (se muestra la versión Visual Basic, ver en el listado anterior el equivalente C#):

Tabla 11. 1: Plantilla de control personalizadoFragmento Nombre Descripción<DefaultProperty("Text",ToolboxData("{0}: WebCustomControl1runat=server></{0}:WebCustomControl1>")>

Atributos declase

Los atributos de clase determinan las opciones de tiempode diseño del control. Estos valores ayudan a determinar loque aparece en la ventana de propiedades de Visual Studio.NET cuando se selecciona el control en un formulario Web.

System.Web.UI.WebControls.WebControl

Clase base Los controles personalizados derivan de una de las clasesbase de control

<Bindable(True),Category("Appearance"),DefaultValue("")>

Atributos depropiedad

Como los atributos de clase, los atributos de propiedaddeterminan la configuración en tiempo de diseño de unapropiedad.

Property[Text]() As String Definición depropiedad

La definición de propiedad determina lo que hace lapropiedad en tiempo de ejecución. Los corchetes ([])indican que el nombre de la propiedad puede ser unapalabra clave (aunque en este caso no lo es).

Protected Overrides SubRender(ByVal output AsSystem.Web.UI.HtmlTextWriter)

MétodoRender El método Render muestra el control personalizado.Sustituye al del mismo nombre en la clase base.

Las secciones siguiente describe cómo agregar y modificar estas partes para crear un control personalizadocompuesto, pero para una descripción más completa de los atributos vea la ayuda de Visual Studio.

11.2.3 Crear el proyecto de pruebaEl proyecto de control personalizado de la sección anterior tiene como tipo de salida Biblioteca de clases. Es-

to significa que solo se puede utilizar desde otra aplicación – no puede correr como aplicación independiente. Paraejecutar y depurar un control personalizado en Visual Studio .NET debe agregar un segundo proyecto a la soluciónactual.

1. Con el proyecto del control personalizado abierto, en el menú Archivo señale Agregar proyecto y pulse Nue-vo proyecto. Visual Studio muestra el diálogo Nuevo proyecto

2. En la lista de plantillas seleccione Aplicación Web ASP.NET, escriba el nombre del proyecto en la caja Ubi-cación y pulse Aceptar. Visual Studio crea un nuevo proyecto de aplicación Web y lo agrega a la solución.

3. En el explorador de soluciones, pulse con el botón derecho sobre el proyecto de aplicación Web y seleccioneEstablecer como proyecto de inicio. Visual Studio muestra el proyecto de inicio en negrita.

4. En el explorador de soluciones, pulse con el botón derecho en elemento References del proyecto de aplica-ción Web y seleccione Agregar referencia. Visual Studio muestra el diálogo Agregar referencia.

5. Pulse la lengüeta Proyectos para agregar una referencia desde el proyecto de aplicación Web al proyecto delcontrol personalizado y pulse Aceptar. Visual Studio agrega la referencia, como muestra el explorador de so-luciones.

Al establecer una referencia a proyecto tal como se ha descrito se copia el ensamblado del control personali-zado (.dll) al directorio /bin de la aplicación Web. Esto hace que el control esté disponible para la aplicación Web.Cualquier cambio en el ensamblado del control se copia automáticamente al directorio /bin de la aplicación.

Durante el desarrollo del control recuerde que los cambios no se actualizan en la aplicación Web hasta que nose genera el control. Esto se produce automáticamente cuando se ejecuta la aplicación, pero no cuando se cambiadesde el control a la aplicación de prueba en modo diseño. Para ver los cambios al control en modo diseño debegenerarlo antes de cambiar a la aplicación de prueba.

11.2.4 Agregar el control personalizado al proyecto de pruebaPara probar y depurar el control personalizado durante el desarrollo debe agregar una instancia del control a

un formulario Web de la aplicación de prueba creada en el paso anterior.

1. En la aplicación Web de prueba muestre un formulario Web y cambie al modo HTML.2. Añada en la parte superior del formulario una directiva Register . Por ejemplo, la siguiente directiva registra

el ensamblado de control personalizado llamado CompositeControls:<%@ Register TagPrefix="Custom" Namespace="vbCompositeSnippet"

Assembly="vbCompositeSnippet" %>3. Cree una instancia del control personalizado en el formulario Web usando sintaxis HTML. Por ejemplo, el

siguiente HTML crea una instancia de WebCustomControl1 creado en la sección anterior:<Custom:WebCustomControl1 id="custTest" runat="server" />



MCAD/MCSD

216

La tabla 11-2 muestra el significado de los tres atributos de la directiva Register cuando se aplican a controles personalizados.

Tabla 11. 2: Atributos de la directiva Register Atributo Significado

TagPrefix Este nombre indica el grupo al que pertenece el control. Por ejemplo, el prefijo de etiqueta para los controles deservidor ASP.NET es “asp”. Este prefijo se usa para crear un convenio de nombres para organizar sus controlespersonalizados.

Namespace Nombre de proyecto y espacio de nombres dentro del ensamblado del control personalizado que contiene los

controles a registrar. Visual Basic .NET usa el nombre de proyecto como espacio de nombres implícito, por lo quepara controles escritos en Visual Basic .NET use el nombre de proyecto. Assembly Nombre del ensamblado (.dll) que contiene los controles personalizados. La aplicación Web debe hacer referencia

al ensamblado del control. Como se dijo anteriormente, la referencia al ensamblado mantiene una copia del mismoen el directorio /bin de la aplicación Web.

El atributo TagPrefix de la directiva Register compone la primera parte del nombre que se usa en el elementoHTML del control personalizado. La segunda parte es el nombre del proyecto y nombre de clase del control dentrodel ensamblad. TagPrefix="Custom" y el nombre de clase WebCustomControl1 significan que el control personali-zado se crea usando un elemento HTML <Custom:WebCustomControl1… />.

Los controles personalizados pueden existir junto con otros controles e interactuar con ellos en una páginaWeb. Por ejemplo, el siguiente HTML muestra el control personalizado WebControl1 junto con un control Button:

<%@ Page Language="vb" AutoEventWireup="false" Codebehind="Default.aspx.vb"Inherits="vbCompositeSnippet.WebForm1"%>

<%@ Register TagPrefix="Custom" NameSpace="vbCompositeSnippet "Assembly="CompositeSnippet" %><HTML><body><form id="Form1" method="post" runat="server">

<asp:button id="butCount" runat="server" /><Custom:WebCustomControl1 id="custTest" runat="server"

Text="Esto es un control personalizado" /></form></body></HTML>

Observe que el control personalizado incluye un atributo para la propiedad Text . Los atributos HTML delcontrol proporcionan una forma de establecer las propiedades del control desde HTML. A diferencia de los contro-les e usuario los controles personalizados se muestran correctamente en el diseñador de Visual Studio.

Otra cosa que debe observar sobre los controles personalizados es que cuando se seleccionan en el diseñador de Visual Studio sus propiedades aparecen en la ventana de propiedades.

Para usar el control personalizado en el código basta hacer referencia a él como haría con cualquier otro con-trol. Por ejemplo, el siguiente procedimiento de suceso Click de botón incrementa el valor que muestra el control personalizado WebCustomControl1

Visual Basic .NETPrivate Sub butAdd_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butAdd.ClickcustTest.Text = Val(custTest.Text) + 1

End Sub

Visual C#

private void butAdd_Click(object sender, System.EventArgs e){int intText = 0;try

intText = int.Parse(custTest.Text);catch

intText = 0;

intText ++;custTest.Text = intText.ToString();

}

Si se ejecuta la aplicación y se pulsa el botón más de una vez el valor nunca sube de 1. ¿Por qué?. La plantillade control que crea Visual Studio no toma ninguna medida para guardar sus propiedades entre presentaciones de la página. Para esto es necesario añadir código, como se describe en las secciones posteriores.




217

11.2.5 Crear el aspecto del control compuestoEl interface visual de un control compuesto se crea añadiendo controles de servidor o HTML existentes a la

colección Controls en el método CreateChildControls. El método CreateChildControls personalizado sustituye alde la clase base.

El siguiente código muestra cómo crear la apariencia de un control personalizado compuesto. El código creaun control personalizado compuesto llamado MathBox. El control MathBox contiene controles TextBox, Button yLabel que se declaran a nivel de clase, por lo que están disponibles para todos los procedimientos de la misma. El

procedimiento CreateChildControls añade estos controles y algunos controles Literal a la colección Controls paracrear el aspecto del control personalizado.

Visual Basic .NETPublic Class MathBox

Inherits System.Web.UI.WebControls.WebControl

Dim txtMath As New TextBox()Dim butSum As New Button()Dim lblResult As New Label()

Protected Overrides Sub CreateChildControls()txtMath.TextMode = TextBoxMode.MultiLineControls.Add(txtMath)Controls.Add(New LiteralControl("<br>")) 'Salto de línea

butSum.Text = "Suma"Controls.Add(butSum)Controls.Add(New LiteralControl("&nbsp&nbspResultado:&nbsp<b>"))Controls.Add(lblResult)Controls.Add(New LiteralControl("</b>"))

End SubEnd Class

Visual C#public class MathBox : System.Web.UI.WebControls.WebControl{

TextBox txtMath = new TextBox();Button butSum = new Button();Label lblResult = new Label();

private string text;

protected override void CreateChildControls(){txtMath.TextMode = TextBoxMode.MultiLine;Controls.Add(txtMath);Controls.Add(new LiteralControl("<br>")); //Salto de líneabutSum.Text = "Suma";Controls.Add(butSum);Controls.Add(new LiteralControl("&nbsp&nbspResultado:&nbsp<b>"));Controls.Add(lblResult);Controls.Add(new LiteralControl("</b>"));

}}

La clase MathBox del ejemplo anterior se usa como base para el resto de la lección. Si la añade al proyecto decontrol compuesto creado en las secciones anteriores puede añadirla a la aplicación Web de prueba usando la mismadirectiva Register utilizada para WebCustomControl1, y se crea una instancia del control con el HTML:

<Custom:MathBox id="mathTest" runat="server" />

Si añade el control MathBox a un formulario Web en este momento verá que en diseñador aparece solo comouna pequeña caja verde, pero sin embargo en tiempo de ejecución se muestra correctamente. En este punto el controlMathBox no tiene apariencia en tiempo de diseño porque aún no expone propiedades de tiempo de diseño. Lo solu-cionaremos en la siguiente sección.

Cuando crea un control personalizado compuesto no necesita sustituir el método Render . La plantilla de có-digo que genera Visual Studio lo sustituye, por lo que si está usando esta plantilla debe borrar el método Render generado o cambiarlo para que delegue de vuelta a la clase base (haciendo que sea una operación nula) como semuestra a continuación:

Visual Basic .NETProtected Overrides Sub Render(ByVal writer As HtmlTextWriter)

MyBase.Render(writer)End Sub



MCAD/MCSD

218

Visual C#protected override void Render(HtmlTextWriter output){ base.Render(output); }

11.2.6 Crear propiedades y métodosEl control personalizado MathBox toma una lista de números escritos en una caja de texto, los suma y de-

vuelve el resultado. Desde un punto de vista de diseño esto precisa dos propiedades: Values, que contiene un arrayde números, y Result , que contiene la suma de estos números. También implica un método Sum para realizar el cál-culo.

El siguiente código muestra las propiedades Values y Result y el método Sum de MathBox. También incluyeuna propiedad Text por coherencia con los controles de servidor ASP.NET y para simplificar la configuración de untexto predeterminado desde HTML.

Visual Basic .NET'Propiedades y métodos de MathBox.<DefaultValue("")> Property Text() As String

GetEnsureChildControls() 'Se asegura de que existen los controles hijo.Return txtMath.Text 'Devuelve el texto del control TextBox.


EnsureChildControls() 'Se asegura de que existen los controles hijo.txtMath.Text = Value 'Establece el texto del control TextBox.

End SetEnd Property

Property Values() As String()Get

EnsureChildControls()Return txtMath.Text.Split(Chr(13)) ' devuelve un array de cadenas

End GetSet(ByVal Value() As String)

EnsureChildControls()txtMath.Text = String.Join(Chr(13), Value) 'Configura el TextBox desde array

End SetEnd Property

ReadOnly Property Result() As String

GetEnsureChildControls ()Return lblResult.Text 'Devuelve el resultado desde la etiqueta.

End GetEnd Property

Sub Sum()EnsureChildControls()If txtMath.Text.Length Then ' Si hay texto en el TextBox.

Dim arrNums As String() ' Divide el texto en una array línea a línea.arrNums = txtMath.Text.Split(Chr(13))Dim strCount As String, dblSum As DoubleFor Each strCount In arrNums ' Suma los elementos del array.

Try ' Ignora entrada no numéricasdblSum += Convert.ToDouble(strCount)

CatchEnd TryNextlblResult.Text = dblSum.ToString ' Muestra el resultado en la etiqueta.

ElselblResult.Text = "0"

End IfEnd Sub




219

Visual C#//Propiedades y métodos de MathBox.[DefaultValue("0")]public string Text{

get{EnsureChildControls(); //Se asegura de que existen los controles hijoreturn txtMath.Text; //Devuelve el texto del TextBox.

}set{

EnsureChildControls(); //Se asegura de que existen los controles hijo

txtMath.Text = value; //Establece el texto en el TextBox}

}

char[] strSep = {'\r'};

public string[] Values{get{

EnsureChildControls();return txtMath.Text.Split(strSep); //Devuelve un array de cadenas.

}set{

EnsureChildControls();txtMath.Text = String.Join(" ", value); //Establece contenido del TextBox

}

}public string Result{

get{EnsureChildControls();return lblResult.Text; // Devuelve el resultado desde la etiqueta.

}}

public void Sum(){EnsureChildControls();if (txtMath.Text.Length != 0){ //Si hay texto en el TextBox.

string[] arrNums; //Divide el texto en un array línea a línea.arrNums = txtMath.Text.Split(strSep);double dblSum = 0;foreach (string strCount in arrNums){ //Suma los elementos el array.

try{dblSum += Convert.ToDouble(strCount);} //Ignora no numéricoscatch{}

}lblResult.Text = dblSum.ToString(); //Muestra el resultado en la etiqueta.

}elselblResult.Text = "0";

}

La sentencia EnsureChildControls en el código asegura que se han instanciado los controles hijo. Se usa enun control compuesto antes de hacer referencia a los controles que contiene.

Después de añadir propiedades y métodos al control compuesto vuelva a generar el control para actualizar suensamblado. En este punto el control compuesto debe aparecer en modo diseño. Si el control no aparece en mododiseño normalmente puede hacerlo aparecer dando un valor a una de sus propiedades modificadas, por ejemplo:

<Custom:MathBox id="mthTest" runat="Server" Text="0" />

Como los controles compuestos usan el método Render de su clase base soportan de forma automática el po-sicionamiento absoluto con disposición en rejilla. En otras palabras, puede arrastrar controles compuestos a diferen-tes posiciones de un formulario Web y se verán allí en tiempo de ejecución.

11.2.7 Control de sucesosHasta ahora, MathBox puede aceptar valores, realizar cálculos y mostrar y resultado. Pero si se pulsa el botón

no hace nada.

Para activar el botón siga estos pasos:

1. Añada un controlador de suceso para el suceso Click del botón al procedimiento CreateChildControls usandoel método AddHandler .

2. Cree un procedimiento para controlar el suceso. Este procedimiento debe tener los mismos argumentos y tipos de retorno que el suceso Click del botón.



MCAD/MCSD

220

El siguiente código muestra los añadidos al control MathBox en negrita. Observe que el procedimiento desuceso simplemente llama al método Sum creado anteriormente para ejecutar el cálculo y mostrar el resultado.

Visual Basic .NETProtected Overrides Sub CreateChildControls()

' Añade los controles subordinados al control compuesto.' Configura la propiedad TextMode y añade la caja de texto.txtMath.TextMode = TextBoxMode.MultiLineControls.Add(txtMath)

Controls.Add(New LiteralControl("<br>"))' Configura la propiedad Text y añade el botón.butSum.Text = "Suma"Controls.Add(butSum)' Añade etiquetas y literales para mostrar el resultado.Controls.Add(New LiteralControl("&nbsp&nbspResult:&nbsp<b>"))Controls.Add(lblResult)Controls.Add(New LiteralControl("</b>"))' Añade un control para el suceso de pulsación del botón. AddHandler butSum.Click, AddressOf Me.butSumClicked

End Sub

' Procedimiento de suceso para el botón.Sub butSumClicked(ByVal source As Object, ByVal e As EventArgs)

SUM() 'Llama al método Sum

End Sub

Visual C#protected override void CreateChildControls(){

// Añade los controles subordinados al control compuesto.// Configura la propiedad TextMode y añade la caja de texto.txtMath.TextMode = TextBoxMode.MultiLine;Controls.Add(txtMath);Controls.Add(new LiteralControl("<br>"));// Configura la propiedad Text y añade el botón.butSum.Text = "Suma";Controls.Add(butSum);// Añade etiquetas y literales para mostrar el resultado.Controls.Add(new LiteralControl("&nbsp&nbspResult:&nbsp<b>"));Controls.Add(lblResult);

Controls.Add(new LiteralControl("</b>"));// Añade el controlador de suceso.

butSum.Click += new EventHandler(butSumClicked);

}

void butSumClicked(object sender, EventArgs e){Sum(); // Llama al método Sum.

}

11.2.8 Lanzar sucesosAdemás de controlar el suceso Click del botón es posible lanzar un suceso que se pueda controlar desde el

formulario Web que contiene el control personalizado.

Para lanzar un suceso desde un control personalizado siga estos pasos:

1. Añada una declaración de suceso público a la clase de control personalizado.2. Lance el suceso desde el código dentro del control personalizado usando el método de suceso del control.

El siguiente código muestra cómo declarar y lanzar un suceso desde el interior de la clase del control Math-Box:

Visual Basic .NETEvent Click(ByVal sender As Object, ByVal e As EventArgs) ' Declara un suceso

' Procedimiento de suceso para pulsación del botónSub butSumClicked(ByVal source As Object, ByVal e As EventArgs)

Sum() ' Llama al método Sum.OnClick(EventArgs.Empty) ' Llama al método para lanzar el suceso.

End Sub

Protected Overridable Sub OnClick(ByVal e As EventArgs)RaiseEvent Click(Me, e) ' Lanza el suceso.

End Sub




221

Visual C#public event EventHandler Click; // Declara el suceso.

void butSumClicked(object sender, EventArgs e){Sum(); // Llama al método Sum.OnClick(EventArgs.Empty); // Llama al método de suceso.

}

protected virtual void OnClick(EventArgs e) {Click(this, e); // Lanza el suceso.

}

Para que el suceso Click sea el predeterminado del control añada un atributo DefaultEvent a la declaración dela clase. Un suceso predeterminado es aquel que crea automáticamente Visual Studio cuando se pulsa dos vecessobre el control en el formulario Web. El siguiente código muestra el añadido en negrita:

Visual Basic .NET<DefaultEvent("Click")> Public Class MathBox

Visual C#[DefaultEvent("Click")] public class MathBox : System.Web.UI.WebControls.WebControl

Para usar el suceso de MathBox desde un formulario Web pulse dos veces sobre el control en el formularioWeb de prueba y utilice el siguiente procedimiento de suceso:

Visual Basic .NETPrivate Sub mathTest_Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles mathTest.Click

Response.Write(mathTest.Result)End Sub

Visual C#private void mathTest_Click(object sender, System.EventArgs e){

Response.Write(mthTest.Result.ToString());}

11.2.9 Cambio de tamaño del controlLos controles compuestos manejan automáticamente muchas características de presentación en tiempo de di-

seño y en tiempo de ejecución por medio del método Render de su clase base. Sin embargo, no pueden cambiar

automáticamente el tamaño de sus controles hijos porque no hay una forma razonable de decir qué tipo de compor-tamiento de cambio de tamaño es el adecuado.

Para manejar el cambio de tamaño de controles compuestos siga estos pasos:

1. Sustituya el método Render de la clase base2. Añada código para cambiar el tamaño de los controles hijos como corresponda3. Llame al método Render de la clase base para presentar el control.

El siguiente código cambia el tamaño del control TextBox hijo según el ancho y alto del control MathBox.

Visual Basic .NETProtected Overrides Sub Render(ByVal writer As System.Web.UI.HtmlTextWriter)

EnsureChildControls()' Cambia el ancho de la caja de texto al del control.txtMath.Width = Me.Width

' Cambia la altura de la caja de texto según la del control.txtMath.Height = Unit.Parse(Me.Height.Value butSum.Height.Value)' Dibuja el control.MyBase.Render(writer)

End Sub

Visual C#protected override void Render(HtmlTextWriter output){

EnsureChildControls();// Cambia el ancho de la caja de texto al del control.txtMath.Width = this.Width;// Cambia la altura de la caja de texto según la del control.double dHeight = this.Height.Value - butSum.Height.Value;txtMath.Height = Unit.Parse(dHeight.ToString());// Dibuja el control.base.Render(output);

}



MCAD/MCSD

222

11.2.10 Superclasificar controles de servidor La sección anterior mostró cómo crear un control compuesto a partir de varios controles existentes. Puede

usar las misma técnicas para crear nuevos controles a partir de un único control existente añadiendo propiedades,métodos o sucesos para este control, o cambiando su comportamiento.

Como este tipo de control personalizado se basa solo en un control, puede derivar directamente de la clasedel control en lugar de usar la clase más general WebControl. Los controles personalizados de este tipo en realidadno son controles compuestos – en ocasiones se denominan controles superclasificados.

Por ejemplo, la siguiente clase SuperText crea un control personalizado basado en el control de servidor TextBox y añade un método para ordenar el contenido:

Visual Basic .NETPublic Class SuperText

Inherits System.Web.UI.WebControls.TextBox

Public Sub Sort() ' Nuevo método para la caja de texto.Dim arrText As String() ' Crea un array.arrText = Me.Text.Split(" ") ' Pone las palabras de la caja en el array.Array.Sort(arrText) ' Ordena el array.Me.Text = String.Join(" ", arrText) ' Une la cadena y la pone en la caja.

End SubEnd Class

Visual C#public class SuperText : System.Web.UI.WebControls.TextBox{

public void Sort(){string[] arrText; // Crea un array.char[] strSep = {' '};arrText = this.Text.Split(strSep); // Pone las palabras de la caja en arrayArray.Sort(arrText); // Ordena el array.this.Text = String.Join(" ", arrText); // Une la cadena y la pone en la caja.

}}

Para usar el control en un formulario Web registre el ensamblado del control como muestran los ejemplos an-teriores, e incluya el siguiente HTML en el formulario Web:

<Custom:SuperText id="superTest" runat="server" />

<asp:Button ID="butSort" Runat="server" Text="Sort" />

Para probar el método Sort añada el siguiente código al módulo de código del formulario Web:

Visual Basic .NETPrivate Sub butSort_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles butSort.ClicksuperTest.Sort()

End Sub

Visual C#private void butSort_Click(object sender, System.EventArgs e){superTest.Sort();}

Tanto en tiempo de diseño como de ejecución el control SuperText se comporta igual que una caja de textonormal.

11.3 Crear cont roles personalizados trazadosLos controles personalizados trazados se crean prácticamente desde cero, lo que significa que se tiene control

completo sobre su aspecto y comportamiento. Sin embargo, puesto que no se componen de controles hijos hay queescribir código para realizar las tareas que de otra forma se delegarían a estos.

Los controles compuestos y los trazados están muy relacionados, y esta lección amplía las habilidades apren-didas en la lección 2. Algunos de los temas se aplican por igual a ambos tipos de controles – debe considerar estalección como temas avanzados del desarrollo de controles Web personalizados. Dicho esto, aún hay mucho más queaprender sobre el tema. Para una guía completa del desarrollo de controles Web personalizados vea ASP.NET Server Controls and Components, por Nikhil Kothari y Vandana Datye, Microsoft Press, 2002.

11.3.1 Crear y usar controles trazados

Si ha recorrido los procedimientos de la lección 2 ya ha creado un control personalizado trazado. La plantillade código que genera Visual Studio .NET cuando se crea un proyecto de biblioteca de controles Web es, de hecho,un control trazado. Sin embargo, es un control sencillo que no hace mucho. Puede crear controles más interesantes




223

más rápidamente usando composición, que es por lo que se enseña a crear controles compuestos antes que controlestrazados.

Como los controles trazados son muy similares a los compuestos, las técnicas aprendidas en la lección 2 tam- bién se aplican a esta, con una excepción. En lugar de crear el interface visual del control a partir de otros controleslos controles trazados crean sus interfaces visuales exclusivamente a partir de elementos HTML. Esto significa queno tendrá propiedades, métodos o sucesos incorporados que pueda usar para obtener o mostrar datos; deberá crear-los.

Cuando se crean controles personalizados trazados, los tres primeros pasos son los mismos que se describie-ron en la lección 2 para un control personalizado. Para crear controles personalizados trazados complete estos pasos:

1. Cree una solución que contenga un proyecto de control personalizado2. Añada a la solución un proyecto de aplicación Web y establézcalo como proyecto de inicio. Usará este pro-

yecto para probar el control personalizado durante su desarrollo.3. Añada una referencia de proyecto desde la aplicación Web al proyecto de control personalizado y añada una

directiva Register y un elemento control de HTML para usar el control personalizado en un formulario Web.4. Cree el interface visual del control personalizado sustituyendo el método Render de la clase base.5. Escriba código para guardar valores de propiedades, responder a acciones de usuario y obtener datos del usu-

ario.

Las siguientes secciones describen los dos últimos pasos con mayor detalle. Las dos últimas secciones de lalección muestran cómo añadir controles personalizados terminados a la caja de herramientas y cómo establecer

iconos y etiquetas generadas utilizadas por Visual Studio .NET para los controles. Estas dos últimas secciones seaplican también a controles compuestos.

11.3.2 Crear la apariencia del controlLa apariencia de un control personalizado trazado se crea sustituyendo el método Render de la clase base y

escribiendo en el argumento de salida del método por medio de los métodos de utilidad de HtmlTextWriter . Estosmétodos, resumidos en la tabla 11.3, permiten añadir HTML en el argumento de salida:

Tabla 11. 3: Métodos de utilidad de HtmlTextWriterMétodo Descripción

AddAttribute Añade un atributo HTML al siguiente elemento HTML a trazar.RenderBeginTag Coloca la etiqueta de inicio de un elemento HTML que se escribirá más adelante con WriteLine RenderEndTag Coloca la etiqueta de fin de un elemento HTML y escribe el elemento y los atributos que estén pendientes.

Todos los atributos se eliminan después de ejecutar este método.Write Escribe inmediatamente una cadenaWriteAttribute Escribe inmediatamente un atributo HTML.WriteBeginTag Escribe inmediatamente la etiqueta de inicio de un elemento HTML.WriteEndTag Escribe inmediatamente la etiqueta de fin de un elemento HTML.WriteFullBeginTag Escribe inmediatamente la etiqueta de inicio junto con el ángulo de cierre (>) para el elemento HTML.WriteLine Escribe inmediatamente una línea de contenido. Es equivalente al método Write , pero añade un salto de línea.

Como puede ver probablemente en la tabla 11.3 hay dos aproximaciones para escribir elementos HTML en elargumento de salida. La aproximación más directa es usar los métodos Write para añadir directamente HTML al HtmlTextWriter . Por ejemplo el siguiente código crea un botón que muestra una caja de mensaje cuando el usuariola pulsa.

Visual Basic .NETImports System.ComponentModelImports System.Web.UI

Public Class AlertButtonInherits System.Web.UI.WebControls.WebControl

Protected Overrides Sub Render(ByVal output As System.Web.UI.HtmlTextWriter)' Escribe un títulooutput.Write("<h3>Control trazado</h3>")' Abre una etiqueta input de HTML.output.WriteBeginTag("INPUT")' Escribe algunos atributos.output.WriteAttribute("value", "Botón personalizado")output.WriteAttribute("type", "button")output.WriteAttribute("onclick", "javascript:alert(Yeppaa!')")' Cierra la etiqueta input de HTML (inserta ">").output.WriteEndTag("INPUT")

End Sub

End Class



MCAD/MCSD

224

Visual C#using System;using System.Web.UI;using System.Web.UI.WebControls;using System.ComponentModel;

namespace csRenderedSnippet{public class AlertButton : System.Web.UI.WebControls.WebControl{

protected override void Render(HtmlTextWriter output){

// Escribe un títulooutput.Write("<h3>Control trazado</h3>");// Abre una etiqueta input de HTML.output.WriteBeginTag("INPUT");// Escribe algunos atributos.output.WriteAttribute("value", "Botón personalizado");output.WriteAttribute("type", "button");output.WriteAttribute("onclick", "javascript:alert('Howdy!')");// Cierra la etiqueta input de HTML (inserta ">").output.WriteEndTag("INPUT");

}}

}

Como alternativa, puede diseñar etiquetas y atributos y escribirlos como una sola unidad usando el método

RenderEndTag. El siguiente código muestra el método Render del control personalizado AlertButton escrito usandoesta técnica:

Visual Basic .NETProtected Overrides Sub Render(ByVal output As System.Web.UI.HtmlTextWriter)

output.Write("<h3>Control trazado</h3>") ' Escribe un títulooutput.AddAttribute("value", "Botón modificado") ' Añade atributosoutput.AddAttribute("type", "button")output.AddAttribute("onclick", "javascript:alert('Howdy!')")output.RenderBeginTag("INPUT") ' Abre un input de HTML ("<INPUT").output.RenderEndTag() ' Cierra el input de HTML (">").

End Sub

Visual C#protected override void Render(HtmlTextWriter output){

output.Write("<h3>Control trazado</h3>"); // Escribe un títulooutput.AddAttribute("value", "Botón modificado"); // Añade atributosoutput.AddAttribute("type", "button");output.AddAttribute("onclick", "javascript:alert('Howdy!')");output.RenderBeginTag("INPUT"); // Abre un input de HTML ("<INPUT")output.RenderEndTag(); // Cierra el input de HTML (">")

}

La ventaja de trazar elementos HTML de esta forma es que puede crear los atributos HTML en cualquier sen-tencia.

11.3.3 Guardar configuración de propiedadLos controles compuestos mostrados en la lección 2 guardaban valores de propiedades usando las propieda-

des de los controles contenidos. Como los controles trazados no contienen otros controles, debe usar el ViewState

del control trazado para guardar cualquier valor de propiedad que quiera mantener entre presentaciones de la página.El siguiente código muestra una propiedad Text que retiene su valor entre presentaciones de la página.

Visual Basic .NETProperty Text() As String

GetIf Not IsNothing(ViewState("Text")) Then ' Si se ha establecido

Return ViewState("Text") ' Devuelve su valorElse

Return "" ' Si no, devuelve "".End If


ViewState("Text") = Value ' Guarda el valor de la propiedad.End Set

End Property




225

Visual C#public string Text{

get{if (ViewState["Text"] != null) // Si se ha establecido

return ViewState["Text"].ToString(); // Devuelve el valorelse

return null; // Si no, devuelve "".}set{ViewState["Text"] = value; } // Guarda el valor

}

Al dar valores a ViewState se serializan los datos y se guardan en un campo oculto del formulario Web.Cuando se devuelve la página al servidor, la recuperación de un valor de ViewState recupera y de-serializa losdatos del campo oculto.

ViewState está optimizado para los tipos de datos String, ArrayList y HashTable, pero puede grabar cual-quier tipo de datos que pueda ser serializado o que proporcione un TypeConverter . Para otros tipos de datos pue-de crear su propio código para grabar y recuperar ViewState sustituyendo los métodos SaveViewState y Load-ViewState.

11.3.4 Recuperar texto contenidoLos elementos HTML a menudo contiene texto literal que modifican de alguna forma, como muestran las

etiquetas HTML para poner un texto en negrita: <b>En negrita</b>.

Para obtener el texto que contiene un control personalizado siga estos pasos:

1. Añada un atributo ParseChildren a la definición de la clase del control.2. Implemente el interface INamingContainer 3. Recupere el texto contenido usando la colección Controls.

La siguiente clase de control personalizado muestra cómo recuperar texto entre las etiquetas de comienzo yfinal de un control personalizado para mostrar el texto que contiene en rojo:

Visual Basic .NET' El atributo ParseChildren activa los controles contenidos.<ParseChildren(False)> Public Class Red

Inherits WebControls.WebControl' Este interface hace posible obtener el array Controls.

Implements INamingContainerProtected Overrides Sub Render(ByVal output As System.Web.UI.HtmlTextWriter)

' El texto contenido se devuelve como control Literal.Dim litText As LiteralControl' Obtiene el texto contenido de la colección Controls.litText = Controls(0)' Lo pone en rojo usando el elemento <font>.output.Write("<font color='red'>" & litText.Text & "</font>")

End SubEnd Class

Visual C#[ParseChildren(false)]public class Red : System.Web.UI.WebControls.WebControl, INamingContainer{

// El interface INamingContainer hace posible obtener el array Controls.protected override void Render(HtmlTextWriter output){// El texto contenido se devuelve como control Literal.LiteralControl litText ;// Obtiene el texto contenido de la colección Controls.litText = (LiteralControl)Controls[0];// Lo pone en rojo usando el elemento <font>.output.Write("<font color='red'>" + litText.Text + "</font>");

}}

En un formulario Web, el control personalizado anterior se usaría mediante el siguiente HTML:

<custom:red id="Red1" runat="server">Un texto en rojo</custom:red>

Puede usar la colección Controls para obtener los elementos que existen entre las etiquetas de apertura y cie-

rre del control personalizado, incluyendo otros controles. Por ejemplo, la siguiente clase control agrupa los controlescontenidos en un panel, los centra en la página y los muestra en un fondo rojo:



MCAD/MCSD

226

Visual Basic .NET'El atributo ParseChildren activa los controles contenidos.<ParseChildren(False)> Public Class Center

Inherits WebControls.WebControl' Este interface hace posible obtener el array Controls.Implements INamingContainer

Protected Overrides Sub Render(ByVal output As System.Web.UI.HtmlTextWriter)output.AddAttribute("align", "center") ' Añade atributos al panel.

output.AddStyleAttribute("BACKGROUND-COLOR", "red")output.RenderBeginTag("div") ' Inicia el panelDim ctrItem As Control ' Variable para controles contenidos.For Each ctrItem In Controls ' Para cada control contenido.

ctrItem.RenderControl(output) ' Traza el controlNextoutput.RenderEndTag()

End SubEnd Class

Visual C#[ParseChildren(false)]public class Center : System.Web.UI.WebControls.WebControl, INamingContainer{

// El interface INamingContainer hace posible obtener el array Controls.

protected override void Render(HtmlTextWriter output) {output.AddAttribute("align", "center"); //Añade atributos al paneloutput.AddStyleAttribute("BACKGROUND-COLOR", "red");output.RenderBeginTag("div"); //Inicia el panelforeach (Control ctrItem in Controls) //Para cada control contenido

ctrItem.RenderControl(output); //Traza el controloutput.RenderEndTag();

}}

11.3.5 Responder a acciones de usuarioLos controles personalizados compuestos puede usar los sucesos de sus controles contenidos para responde a

las acciones de usuario, como se mostró en la lección 2. Los controles trazados, en cambio, necesitan dar pasosespeciales para responder a las acciones de usuario. La forma de tratar las acciones de usuario depende del tipo de

suceso:• Los sucesos en caché se pueden lanzar desde el código del control personalizado• Los sucesos con envío se deben lanzar desde el lado cliente usando una secuencia de comandos escrita por el

control personalizado.

Las siguientes secciones muestran cómo lanzar cada uno de estos tipos de sucesos.

Lanzar sucesos en cachéLos sucesos en caché se controlan en el código de servidor del formulario Web cuando se envía el formu-

lario de vuelta al servidor y después de que se hayan controlado los sucesos Page_Load y de envío. Lanzar unsuceso en caché implica dos pasos:

1. Declarar un suceso a lanzar 2. Lanzar el suceso desde algún lugar dentro del código de control personalizado

Por ejemplo, la siguiente clase de control personalizado define un suceso OnChange que se lanza siempreque cambia la propiedad Text :

Visual Basic .NET<DefaultEvent("OnChange")>Public Class RenderText

Inherits WebControls.WebControl

Event Change(ByVal sender As Object, ByVal e As EventArgs)

Property Text() As StringGet

If Not IsNothing(ViewState("Text")) ThenReturn ViewState("Text")

ElseReturn ""

End IfEnd Get




227

Set(ByVal Value As String)ViewState("Text") = ValueOnChange(EventArgs.Empty)

End SetEnd Property

' Método de sucesoProtected Overridable Sub OnChange(ByVal e As EventArgs)

RaiseEvent Change(Me, EventArgs.Empty) ' Lanza el suceso.

End SubProtected Overrides Sub Render(ByVal output As System.Web.UI.HtmlTextWriter)

' Configura los atributos del control input.output.AddAttribute("value", Me.Text)' Crea un elemento control input usando anterior.output.RenderBeginTag("Input")' Cierra el elemento de control input (inserta />).output.RenderEndTag()

End SubEnd Class

Visual C#[DefaultEvent("Change")]public class RenderText : System.Web.UI.WebControls.WebControl{

public event EventHandler Change; // Declara un suceso.

public string Text{get{

if (ViewState["Text"] != null)return ViewState["Text"].ToString();

elsereturn null;

}set{

ViewState["Text"] = value;OnChange(EventArgs.Empty);

}}

protected virtual void OnChange(EventArgs e){

if (Change != null)Change(this, e);

}

protected override void Render(HtmlTextWriter output){// Configura los atributos del control input.output.AddAttribute("value", this.Text);// Crea un elemento control input usando anterior.output.RenderBeginTag("Input");// cierra el control de elemento input (inserta />).output.RenderEndTag();

}}

Lanzar sucesos de envío

Los sucesos de envío hacen que el formulario Web se envíe de vuelta al servidor para procesamiento in-mediato. Se controlan inmediatamente después del suceso Page_Load del formulario Web. Para lanzar un sucesode envío desde un control personalizado siga estos pasos:

1. Implemente el interface IPostBackEventHandler en el control personalizado2. Declare un suceso para lanzar 3. Trace un elemento HTML que pueda responder a sucesos de lado cliente, como onclick .4. Agregue un atributo al elemento HTML que contenga una secuencia de comandos para enviar la página

de vuelta al servidor 5. Lance el suceso desde el método RaisePostBackEvent , que es parte del interface IPostBackEventHandler .

El siguiente código muestra cómo usar estos pasos para lanzar el suceso de envío Click desde un control personalizado.



MCAD/MCSD

228

Visual Basic .NET' Lanza suceso de envío.<DefaultEvent("Click")> Public Class AlertButton

Inherits System.Web.UI.WebControls.WebControl' (1) Interface que permite procesamiento de suceso PostBack.Implements IPostBackEventHandler

' (2) Declara el sucesoEvent Click(ByVal sender As Object, ByVal e As EventArgs)

' (3) Traza un elemento HTML que puede detectar sucesos de usuario.Protected Overrides Sub Render(ByVal output As System.Web.UI.HtmlTextWriter)

' Añade atributos.output.AddAttribute("value", "Botón de envío")output.AddAttribute("type", "button")' (4) Añade atributo para lanzar el suceso en el cliente.output.AddAttribute("onclick", "javascript:alert('Howdy!');" & _

Page.GetPostBackEventReference(Me))' Abre una etiqueta input de HTML (inserta "<INPUT").output.RenderBeginTag("INPUT")' Cierra la etiqueta input de HTML(inserta ">" y escribe atributos).output.RenderEndTag()

End Sub

' Parte del interface IPostBackEventHandler: debe crear este método.Public Sub RaisePostBackEvent(ByVal eventArgument As String) _

Implements System.Web.UI.IPostBackEventHandler.RaisePostBackEventOnClick(EventArgs.Empty) ' (5) lanza el suceso.

End Sub

Protected Overridable Sub OnClick(ByVal e As EventArgs)RaiseEvent Click(Me, EventArgs.Empty) ' Lanza el suceso.

End SubEnd Class

Visual C#// (1) Interface IPostBackEventHandler permite procesar sucesos PostBack.[DefaultEvent("Click")] public class AlertButtonThree :

System.Web.UI.WebControls.WebControl, IPostBackEventHandler{// (2) Declara el suceso de envío

public event EventHandler Click;

// (3) Traza un elemento HTML que puede detectar sucesos de usuario.protected override void Render(HtmlTextWriter output) {

output.Write("<h3>Control trazado</h3>"); // Escribe un título

// Añade atributos.output.AddAttribute("value", "Botón personalizado");output.AddAttribute("type", "button");// (4) Añade atributo para lanzar el suceso en el cliente.output.AddAttribute("onclick", "javascript:alert('Howdy!');" +

Page.GetPostBackEventReference(this));// Abre una etiqueta input de HTML (inserta"<INPUT").output.RenderBeginTag("INPUT");// Cierra la etiqueta input de HTML (inserta ">").

output.RenderEndTag();}

// Parte del interface IPostBackEventHandler: debe crear este método.public void RaisePostBackEvent(string eventArgument){

OnClick(EventArgs.Empty); // (5) Llama al método que lanza el suceso.}

protected virtual void OnClick(EventArgs e) {if (Click != null) Click(this, e); // Lanza el suceso.

}}

Cuando el usuario pulsa sobre el control personalizado anterior en tiempo de ejecución, el suceso onclick del botón ejecuta la siguiente secuencia de comandos:

alert('Howdy!'); //Muestra una caja de mensaje.__doPostBack('winTest',''); //Generado por Page.GetPostBackEventReference(Me);

El método _doPostBack() envía la página de vuelta al servidor, donde la intercepta el método RaisePost- BackEvent del interface IPostBackEventHandler , que a su vez lanza el suceso Click dentro del control.




229

Use el siguiente código para controlar el suceso Click desde el formulario Web:

Visual Basic .NETPrivate Sub altTest_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles altTest.ClickResponse.Write("Botón pulsado")

End Sub

Visual C#

private void altTest(object sender, System.EventArgs e){Response.Write("Botón pulsado");}

11.3.6 Obtener datos desde el usuarioLos controles trazados no retienen automáticamente los datos introducidos por el usuario. Lo puede ver si

crea un control TextBox personalizado trazando un elemento Input de html. Puede escribir en el elemento Input , pero en cuando se envíe la página al servidor todo lo escrito se pierde.

Para obtener datos del usuario siga estos pasos:

1. Implemente el interface IPostBackDataHandler .2. Añada un atributo name que identifique de forma única al elemento HTML del que se van a obtener los da-

tos.

3. Sustituya el método LoadPostBackData del interface IPostBackDataHandler . Use este método para obtener los datos del usuario.4. Sustituya el método RaisePostDataChangedEvent del interface IPostBackDataHandler . No tiene que escribir

código para este método, pero debe sustituirlo porque es parte del interface.5. Lance un suceso para indicar que los datos han cambiado. Este paso es opcional – si no quiere proporcionar

un suceso de cambio para un control no tiene por qué hacerlo.

El siguiente control personalizado muestra cómo usar estos pasos para retener datos introducidos por unusuario en un control TextBox trazado a partir de un elemento Input de HTML:

Visual Basic .NET<DefaultEvent("Change")> Public Class RenderText

Inherits WebControls.WebControl' (1) Interface que permite obtener los datos enviados.Implements IPostBackDataHandler

Event Change(ByVal sender As Object, ByVal e As EventArgs)

Property Text() As StringGet

If Not IsNothing(ViewState("Text")) ThenReturn ViewState("Text")

ElseReturn ""

End IfEnd GetSet(ByVal Value As String)

ViewState("Text") = ValueOnChange(EventArgs.Empty)

End Set

End PropertyProtected Overrides Sub Render(ByVal output As System.Web.UI.HtmlTextWriter)

' Configura los atributos del control Input.output.AddAttribute("value", Me.Text)' (2) Debe definir este atributo para activar los datos enviados.output.AddAttribute("name", Me.UniqueID)' Crea un elemento control Input usando el anterior.output.RenderBeginTag("Input")' Cierra el elemento de control Input.output.RenderEndTag()' Escribe el elemento en el HtmlTextWriter.output.WriteLine()

End Sub

' (3)Obtiene datos desde el usuario. Debe crear este métodoPublic Function LoadPostData(ByVal postDataKey As String, _

ByVal postCollection As _System.Collections.Specialized.NameValueCollection) As Boolean

Implements System.Web.UI.IPostBackDataHandler.LoadPostData



MCAD/MCSD

230

' Si el usuario cambia el valor del input actualiza la propiedad text.If Me.Text <> postCollection(postDataKey) Then

Me.Text = postCollection(postDataKey)' Devolver True llama a RaisePostDataChangedEvent siguiente.Return True

Else' Devolver False no llama a RaisePostDataChangedEvent.Return False

End If

End Function' (4) Sustituye al método RaisePostDataChangedEvent. Debe crear este métodoPublic Sub RaisePostDataChangedEvent() Implements _

System.Web.UI.IPostBackDataHandler.RaisePostDataChangedEvent' (5) Llama al método de suceso. Opcional.OnChange(EventArgs.Empty)

End Sub

' Método de suceso.Protected Overridable Sub OnChange(ByVal e As EventArgs)

' Lanza el sucesoRaiseEvent Change(Me, EventArgs.Empty)

End SubEnd Class

Visual C#// (1) Interface IPostBackDataHandler permite obtener los datos enviados.[DefaultProperty("Text"), DefaultEvent("Change")] public class RenderText :

System.Web.UI.WebControls.WebControl, IPostBackDataHandler{public event EventHandler Change;

[DefaultValue("")]public string Text{get{

if (ViewState["Text"] != null)return ViewState["Text"].ToString();

elsereturn null;

}set{

ViewState["Text"] = value;OnChange(EventArgs.Empty);

}}

protected override void Render(HtmlTextWriter output) {// Configura los atributos del control Input.output.AddAttribute("value", this.Text);// (2) Debe definir este atributo para activar los datos de envío.output.AddAttribute("name", this.UniqueID);// Crea un elemento de control Input usando el anterior.output.RenderBeginTag("Input");// Cierra el elemento de control Input (inserta />).output.RenderEndTag();

}

// (3) Obtiene los datos del usuario. Debe crear este método.public bool LoadPostData(string postDataKey,

System.Collections.Specialized.NameValueCollection postCollection) {// Si el usuario cambia el valor del input actualiza la propiedad text.if (this.Text != postCollection[postDataKey]){

this.Text = postCollection[postDataKey];// Devolver true llama a RaisePostDataChangedEvent.return true;

}else// Devolver false no llama a RaisePostDataChangedEvent.return false;

}

// (4) Sustituye el método RaisePostDataChangedEvent. Debe crear este método.public void RaisePostDataChangedEvent(){

// (5) Llama al método de suceso. Opcional.OnChange(EventArgs.Empty);

}




231

protected virtual void OnChange(EventArgs e) {if (Change != null)

Change(this, e); // lanza el suceso.}

}}

11.3.7 Añadir controles personalizados a la caja de herramientasTras crear y depurar un conjunto de controles personalizados puede agregarlo a la caja de herramientas de

Visual Studio .NET siguiendo estos pasos:

1. En el menú Herramientas seleccione Agregar o quitar elementos del cuadro de herramientas.2. Pulse la lengüeta Componentes de .NET Framework y Examinar. Visual Studio muestra el diálogo Abrir.3. Use el diálogo Abrir para localizar y seleccionar el ensamblado (.dll) que contiene el control personalizado

que se quiere agregar y pulse Abrir. Visual Studio abre el ensamblado y agrega el control que contiene a lalista de controles de la caja de diálogo Personalizar cuadro de herramientas.

4. Pulse Aceptar para cerrar el diálogo.

Cuando agregue controles a la caja de herramientas aparecen en la categoría General cuando Visual Studioesté en modo Diseño.

Para agregar un control personalizado a un formulario Web sencillamente pulse dos veces sobre el control oarrástrelo desde la caja de herramientas al formulario Web. Cuando agregue un control personalizado desde la caja

de herramientas Visual Studio automáticamente añadirá la directiva Register para el control al formulario Web einsertará el HTML para el control personalizado, como se muestra a continuación en negrita:

<%@ Page Language="vb" AutoEventWireup="false" Codebehind="WebForm1.aspx.vb"Inherits="vbRenderedTest.WebForm1"%>

<%@ Register TagPrefix="cc1" Namespace="vbRenderedSnippet" Assembly="vbRenderedSnippet" %>

<HTML><body>

<form id="Form1" method="post" runat="server"><cc1:Chart id="Chart1" runat="server"></cc1:Chart>

</form></body>

</HTML>

11.3.8 Establecer el icono y TagPrefix para controles personalizadosPuede hacer que sus controles muestren un icono propio en la caja de herramientas y usen su propio atributo

TagPrefix en HTML. Si ya ha añadido el control a la caja de herramientas debe descargarlo y volver a agregarlo denuevo en la caja antes de que el cambio surta efecto.

Para agregar un icono propio a la caja de herramientas siga estos pasos:

1. Cree un archivo de mapa de bits de 16x16 que contenga el icono. Guárdelo en el directorio /bin del proyectodel control.

2. Al inicio del módulo de la clase del control use o importe (using o Imports) el espacio de nombres Sys-tem.Drawing.

3. Agregue el atributo ToolboxBitmap a la definición de clase del control. Por ejemplo, la siguiente línea especi-fica un archivo de icono llamado Red para el control personalizado Red.

Visual Basic .NET<ParseChildren(False), ToolboxBitmap("Red")> Public Class Red

Visual C#[ParseChildren(false), ToolboxBitmap("Red")]

4. Vuelva a generar el control.

Para cambiar el TagPrefix utilizado por el control en HTML siga estos pasos

1. Agregue las siguientes líneas al archivo AssemblyInfo del proyecto de control personalizado:Visual Basic .NETImports System.Web.UI

<Assembly: TagPrefix("proyecto.espacionombres", "prefijo")>

Visual C#using System.Web.UI

[assembly: TagPrefix("espacionombres", "prefijo")]



MCAD/MCSD

232

2. Vuelva a generar la página.

En el procedimiento anterior proyecto.espacionombres es el nombre y espacio de nombres del proyecto delcontrol personalizado, y prefijo es el prefijo que se utilizará para los controles contenidos en este espacio de nombres.

11.4 Resumen• Cree controles de usuario dibujando controles de servidor y HTML en una página de control de usuario

(.ascx).• Añada un control de usuario a un formulario Web arrastrándolo desde el explorador de soluciones en lugar de

la caja de herramientas.• Los controles de usuario deben ser parte del proyecto donde se usan y se inicializan después del suceso Pa-

ge_Load del formulario Web que los contiene.• Cree controles compuestos definiendo una clase derivada de la clase base WebControl.• Los controles compuestos están formados a partir de controles HTML y de servidor añadidos por medio del

método CreateChildControls.• Para añadir características a un control de servidor existente superclasifique el control derivando un nuevo

control personalizado a partir de la clase del existente.• Los controles trazados proporcionan más controles sobre el aspecto y comportamiento del control, pero nece-

sitan más programación para manejar las tareas que los controles compuestos normalmente manejan por me-dio de sus controles hijos.

• Use el método Render y los métodos de utilidad de HtmlTextWriter para crear la apariencia de un control personalizado trazado.

• Use el interface IPostBackEventHandler para permitir que un control lance sucesos de envío.• Use el interface IPostBackDataHandler para permitir que un control trazado para obtener datos introducidos

por el usuario en un control en tiempo de ejecución.

11.5 Práctica: Crear cont roles personalizadosEn esta práctica creará un proyecto de aplicación Web para contener los tres controles diferentes creados en

cada uno de los ejercicios. Encontrará este ejemplo con el nombre vbUserControlSample o csUserControlSamplo enel CD-ROM.

11.5.1 Ejercicio 1: Crear un control de usuario AddressBox

En este ejercicio creará una aplicación Web que contiene un control de usuario que obtiene información denombre de usuario y contraseña. Use las capacidades aprendidas en la lección 1 para crear y probar un control deusuario completando las siguientes tareas principales:

1. Cree un proyecto de aplicación Web.2. Agregue un control de usuario (.ascx) que contenga texto y controles para recoger el nombre, dirección, ciu-

dad, estado y código postal.3. Use controles de validación dentro del control de usuario para asegurar que se rellenan los campos requeri-

dos.4. Use un control HTML Grid Layout Panel para dar formato y colocar el texto y los controles dentro del con-

trol de usuario.5. Proporcione un suceso Click que se lance desde el control de usuario una vez una vez validadas las entradas

de datos.6. Proporcione propiedades públicas de solo lectura para devolver la información de dirección desde el control

de usuario.7. Proporcione una propiedad pública Style de lectura y escritura para dar soporte al posicionamiento absoluto

en la rejilla.8. Pruebe el control de usuario añadiéndolo a un formulario Web y accediendo a sus sucesos y propiedades des-

de el código.

Cuando termine (o cuando se atasque) compare sus resultados con el control de usuario AddressBox incluidoen el CD-ROM.

11.5.2 Ejercicio 2: Crear el control personalizado compuesto DigitPadEn este ejercicio va a crear una librería de controles Web que contendrá un control personalizado que permi-

tirá al usuario introducir números pulsando botones. Use las capacidades aprendidas en la lección 2 para crear y probar el control personalizado completando las siguientes tareas principales:

1. Agregue un proyecto de librería de controles Web a la solución creada en el ejercicio anterior.2. Agregue una referencia desde el proyecto de control de usuario al proyecto de librería de controles Web de

forma que pueda probar el control personalizado desde formularios Web del proyecto.




233

3. Cree un control personalizado compuesto que use controles InputButton de HTML para aceptar entradas nu-méricas.

4. Proporcione un suceso de envío que se lance desde el control personalizado una vez completos los datos nu-méricos.

5. Proporcione una propiedad pública de solo lectura que devuelva el número introducido en el control.6. Pruebe el control añadiéndolo a un formulario Web y accediendo a su suceso y propiedades desde el código.

Cuando termine, compare sus resultados con el control personalizado DigitPad incluido en el CD-ROM.

11.5.3 Ejercicio 3: Cree el control personalizado trazado BartChar En este ejercicio añadirá un control trazado personalizado al la librería de controles Web que creó en el ejer-

cicio 2. El control personalizado creará un gráfico de barras sencillo a partir de los números introducidos entre lasetiquetas HTML de inicio y fin del control personalizado. Use las capacidades aprendidas en la lección 3 para completar las siguientes tareas principales.

1. Añada una nueva clase de control personalizado Web al proyecto de librería de controles Web creado en elejercicio anterior.

2. Cree una propiedad Values que recibe un array de datos del texto introducido entre las etiquetas de inicio yfin del control personalizado.

3. Cree una propiedad ChartTitle que configura o devuelve un encabezado mostrado en la parte superior delgráfico.

4. Sustituya el método Render del control para crear un gráfico de barras a partir de los datos de la propiedadValues. Para simplificar la elaboración del diagrama use controles regla horizontal de HTML (<HR>) paracrear el gráfico.

5. Pruebe el control de usuario agregándolo a un formulario Web y accediendo a sus sucesos y propiedadesdesde el código.

Compare sus resultados con el control personalizado BartChar incluido en el CD-ROM



1. Describa brevemente los mejores usos para cada uno de los tres tipos de controles Web completando las si-

guientes frases:Cree un control de usuario si quiere ...

Cree un control personalizado compuesto si quiere ...

Cree un control trazado si quiere ...

2. ¿Qué importancia tiene la derivación para crear controles Web personalizados?

3. ¿Cuál es el método más importante que hay que sustituir cuando se crea un control personalizado compuesto?

4. ¿Cuál es el método más importante que hay que sustituir cuando se crea un control trazado?

5. ¿En que se diferencia lanzar un suceso de vuelta en un control compuesto a hacerlo en un control trazado?



MCAD/MCSD

234




235

12 Trabajar con multimediaUna cosa que hace interesante Internet es la cantidad de tipos de medios que puede presentar un sitio Web.

Texto e imágenes pueden coexistir con música, video y animación. En este capítulo aprenderá como añadir estoselementos a aplicaciones Web ASP.NET y cómo controlar su presentación y reproducción en código.


• Comprender el ciclo de vida de un formulario Web ASP.NET• Saber cómo editar formularios Web en HTML• Estar familiarizado con la creación de secuencias de comandos de cliente en un formulario Web usando

JScript o VBScript.

12.1 Interpretar audioCuando se vuelve a mostrar una página Web que contiene un sonido de fondo el navegador detiene y vuelve

a iniciar la interpretación del sonido. Por este motivo, la técnica de ASP.NET de utilizar el envío de vuelta de la página para interceptar sucesos de cliente en el servidor provoca que el sonido de la página se detenga y reiniciecuando el servidor envía una respuesta. Por tanto por lo general es mejor controlas audio y otro multimedia usandosecuencias de comandos de cliente en lugar de código de servidor.

En el capítulo 7, Programación avanzada de formularios web, aprendió cómo añadir secuencias de coman-dos a un formulario Web para responder a sucesos de cliente y controlar el navegador. En esta lección aprenderá

cómo usar elementos HTML para incluir audio en un formulario Web o una página HTML y cómo controlar repro-ducción de audio usando secuencia de comandos de cliente.

12.1.1 Formas de interpretar audioHay tres formas básicas para interpretar audio en un formulario web ASP.NET:

• Como sonido de fondo usando el elemento HTML bgsound .• Como sonido incrustado usando el elemento HTML embed para insertar el intérprete de medios del usuario

en la página.• Como objeto ActiveX usando el elemento HTML object para insertar un intérprete de medios concreto en

una página.

La primera técnica la soporta la mayor variedad de navegadores y plataformas, pero no permite controlar lareproducción como se puede con el resto. Las siguientes secciones exploran estas técnicas con mayor detalle.

12.1.2 Interpretar sonidos de fondoEl elemento bgsound interpreta un sonido cuando se muestra una página Web. Este elemento no se propor-

ciona como controle HTML, de modo que no aparece en la caja de herramientas de Visual Studio .NET.

Para añadir un sonido de fondo a un formulario web siga estos pasos:

1. En Visual Studio, muestre el formulario Web y cambie a modo HTML2. Inserte un elemento HTML bgsound , por ejemplo, <bgsound src="prueba.wav" id="bgPrueba"

loop="infinite">

Una de las primeras cosas que se observan sobre los sonidos de fondo es que se reinician cada vez que sevuelve a mostrar la página. Esto no es muy preocupante con páginas HTML normales, pero los formularios WebASP.NET se vuelven a mostrar cada vez que se produce un suceso de envío, como al pulsar un botón de servidor.

Si quiere que se interprete un sonido una sola vez la primera vez que se muestre un formulario Web use la propiedad IsPostBack de la página para determinar si se inserta el sonido. Por ejemplo, el siguiente código interpretael sonido solo una vez – la primera vez que se muestra la página.

Visual Basic .NETPrivate Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) _

Handles MyBase.LoadIf Not(IsPostBack) Then

Response.Write("<bgsound src='prueba.wav' id='bgPrueba' loop='1'>")End If

End Sub


if(!IsPostBack)Response.Write("<bgsound src='prueba.wav' id='bgPrueba' loop='1'>");}



MCAD/MCSD

236

Puede usar una técnica similar para interpretar sonidos en respuesta a otros sucesos de página, como pulsa-ciones de botón. Los sonidos de fondo son aditivos – si interpreta más de un sonido a la vez se oirán todos simultá-neamente.

12.1.3 Incrustar sonidosUna de las limitaciones de los sonidos de fondo es que no puede controlarlos una vez que empiezan a sonar.

Los sonidos de fondo comienzan cuando se muestra la página y se detienen cuando terminan o cuando se muestrauna nueva página. Para que el usuario pueda detener, iniciar o cambiar el volumen de sonido, necesita usar el ele-

mento embed de HTML. Por ejemplo, el siguiente HTML incrusta un sonido y muestra el intérprete de medios pre-determinado del usuario en el formulario Web:

<embed src="test.wav" id="wavTest" hidden="false" height="20" width="150"autostart="false" type="audio/wav" loop="true"></embed>

El plug in que muestra el anterior HTML puede cambiar dependiendo puede variar dependiendo de qué in-térprete de audio tenga instalado el usuario.

La incrustación de un sonido permite que el usuario controle la reproducción, pero el desarrollador tiene muy poco control desde el código cliente. Puede ocultar o mostrar el plug in, indicar que repita, cambiar su tamaño y posición, pero esto es todo. Por ejemplo, los siguientes botones HTML ocultan y muestran el plug in:

<input type="button" value="Oculta" id="butHide" onclick="wavTest.hidden='true'"><input type="button" value="Muestra" id="butShow" onclick="wavTest.hidden='false'">

Para iniciar, detener, pausar o enmudecer el sonido desde secuencias de comandos de cliente necesita incluir el sonido como objeto en el formulario Web. La siguiente sección describe cómo hacerlo.

12.1.4 Sonido como objetos ActiveXPuede incluir sonidos en un formulario como objetos ActiveX mediante el elemento object de HTML con la

información de ID de clase adecuada para el intérprete concreto que quiere usar. La inserción de sonidos como obje-tos le da control sobre la reproducción desde secuencias de comandos de cliente usando el elemento como un objeto.

Para incluir un sonido como objeto siga estos pasos:

1. Añada un objeto ActiveX de intérprete de medios en el formulario Web2. Configure las propiedades del objeto ActiveX para que interprete el sonido3. Añada el código para determinar si el sistema del usuario tiene instalado el objeto ActiveX y tomar las accio-

nes adecuadas en caso contrarioLas siguientes secciones describen estos pasos con mayor detalle

Añadir un objeto ActiveX a un formulario WebVarios objetos ActiveX pueden interpretar medios, como sonido, desde el interior de un navegador. Dos

de los más extendidos son Windows Media Player y RealPlayer. Puede añadir cualquiera d estos intérpretes a unformulario web siguiendo estos pasos:

1. Con un formulario Web en modo diseño pulse la lengüeta HTML de la caja de herramientas de VisualStudio, pulse sobre ella con el botón derecho y seleccione Agregar o quitar elementos.

2. Pulse la lengüeta Componentes COM y recorra la lista de componentes instalados. Localice el componen-te que quiere agregar a la caja de herramientas y selecciónelos. Por ejemplo, el objeto RealPlayer se llamaRealPlayer G2 Control; el intérprete de Microsoft se llama Windows Media Player.

3. Pulse Aceptar para cerrar el diálogo. Visual Studio carga los controles en la caja de herramientas.

4. Arrastre el objeto intérprete de medios desde la caja de herramientas al formulario Web. Visual Studio in-serta un elemento object de HTML con id de clase del intérprete y valores de parámetro predeterminados,como muestra el siguiente HTML:

<p>Sonido como objeto Windows Media Player:</p><OBJECT id="objWMPlay" classid="clsid:22D6F312-B0F6-11D0-94AB-0080C74C7E95"

VIEWASTEXT><PARAM NAME="AudioStream" VALUE="-1"><PARAM NAME="AutoSize" VALUE="-1"><PARAM NAME="AutoStart" VALUE="0"><PARAM NAME="AnimationAtStart" VALUE="-1"><PARAM NAME="AllowScan" VALUE="-1"><PARAM NAME="AllowChangeDisplaySize" VALUE="-1"><PARAM NAME="AutoRewind" VALUE="0"><PARAM NAME="Balance" VALUE="0">

<PARAM NAME="BaseURL" VALUE=""><PARAM NAME="BufferingTime" VALUE="5"><PARAM NAME="CaptioningID" VALUE=""><PARAM NAME="ClickToPlay" VALUE="-1">




237

<PARAM NAME="CursorType" VALUE="0"><PARAM NAME="CurrentPosition" VALUE="-1"><PARAM NAME="CurrentMarker" VALUE="0"><PARAM NAME="DefaultFrame" VALUE=""><PARAM NAME="DisplayBackColor" VALUE="0"><PARAM NAME="DisplayForeColor" VALUE="16777215"><PARAM NAME="DisplayMode" VALUE="0"><PARAM NAME="DisplaySize" VALUE="0"><PARAM NAME="Enabled" VALUE="-1">

<PARAM NAME="EnableContextMenu" VALUE="-1"><PARAM NAME="EnablePositionControls" VALUE="-1"><PARAM NAME="EnableFullScreenControls" VALUE="0"><PARAM NAME="EnableTracker" VALUE="-1"><PARAM NAME="Filename" VALUE="test.wav"><PARAM NAME="InvokeURLs" VALUE="-1"><PARAM NAME="Language" VALUE="-1"><PARAM NAME="Mute" VALUE="0"><PARAM NAME="PlayCount" VALUE="1"><PARAM NAME="PreviewMode" VALUE="0"><PARAM NAME="Rate" VALUE="1"><PARAM NAME="SAMILang" VALUE=""><PARAM NAME="SAMIStyle" VALUE=""><PARAM NAME="SAMIFileName" VALUE=""><PARAM NAME="SelectionStart" VALUE="-1"><PARAM NAME="SelectionEnd" VALUE="-1"><PARAM NAME="SendOpenStateChangeEvents" VALUE="-1"><PARAM NAME="SendWarningEvents" VALUE="-1"><PARAM NAME="SendErrorEvents" VALUE="-1"><PARAM NAME="SendKeyboardEvents" VALUE="0"><PARAM NAME="SendMouseClickEvents" VALUE="0"><PARAM NAME="SendMouseMoveEvents" VALUE="0"><PARAM NAME="SendPlayStateChangeEvents" VALUE="-1"><PARAM NAME="ShowCaptioning" VALUE="0"><PARAM NAME="ShowControls" VALUE="-1"><PARAM NAME="ShowAudioControls" VALUE="-1"><PARAM NAME="ShowDisplay" VALUE="0"><PARAM NAME="ShowGotoBar" VALUE="0"><PARAM NAME="ShowPositionControls" VALUE="-1">

<PARAM NAME="ShowStatusBar" VALUE="0"><PARAM NAME="ShowTracker" VALUE="-1"><PARAM NAME="TransparentAtStart" VALUE="0"><PARAM NAME="VideoBorderWidth" VALUE="0"><PARAM NAME="VideoBorderColor" VALUE="0"><PARAM NAME="VideoBorder3D" VALUE="0"><PARAM NAME="Volume" VALUE="0"><PARAM NAME="WindowlessVideo" VALUE="0">

</OBJECT>

<p>Este es el sonido como objeto RealPlayer:</p><OBJECT id="objRPlay" classid="clsid:CFCDAA03-8BE4-11CF-B84B-0020AFBBCCFA"

VIEWASTEXT><PARAM NAME="_ExtentX" VALUE="7938"><PARAM NAME="_ExtentY" VALUE="2646">

<PARAM NAME="AUTOSTART" VALUE="0"><PARAM NAME="SHUFFLE" VALUE="0"><PARAM NAME="PREFETCH" VALUE="0"><PARAM NAME="NOLABELS" VALUE="0"><PARAM NAME="LOOP" VALUE="0"><PARAM NAME="NUMLOOP" VALUE="0"><PARAM NAME="CENTER" VALUE="0"><PARAM NAME="MAINTAINASPECT" VALUE="0"><PARAM NAME="BACKGROUNDCOLOR" VALUE="#000000">

</OBJECT>

Como puede ver en el HTML anterior, diferentes intérpretes tienen conjuntos de parámetros diferentesque los controlan. Desde una perspectiva de programación, es mucho más sencillo seleccionar un intérprete con-creto y pedir al usuario que lo instales que dar soporte a múltiples intérpretes. Muchos usuarios tienen más de unintérprete instalado, de modo que elegir uno u otro no debe ser un gran problema de compatibilidad.



MCAD/MCSD

238

Configurar las propiedades y métodos del intérpreteLos elementos param incluidos en el HTML de un objeto ActiveX representan las propiedades del objeto.

Estas propiedades se usan junto con los métodos y sucesos del objeto para controlar el intérprete desde secuen-cias de comandos de cliente.

Puede ser muy difícil tener buena información de referencia sobre un objeto ActiveX. Una de las formasmás sencillas de aprender sobre las propiedades, métodos y sucesos es añadir una referencia desde al proyectoactual al objeto y usar el inspector de objetos para ver sus miembros.

Para usar las propiedades de un objeto ActiveX desde una secuencia de comandos use los métodos delelemento HTML. Por ejemplo, las siguientes secuencias de comandos para la pulsación de un botón inician y de-tienen la reproducción en Windows Media Player:

<input type="button" value="Start" id="butStart" onclick="objWMPlay.play()"><input type="button" value="Stop" id="butStop" onclick="objWMPlay.stop()">

El objeto RealPlayer utiliza nombres de método ligeramente diferentes:

<input type="button" value="Start" id="butStartPlay"onclick="objRPlay.object.source='test.wav';objRPlay.doplay()">

<input type="button" value="Stop" id="butStopPlay" onclick="objRPlay.dostop()">

Para responder a sucesos de objeto en el cliente cree un controlador de suceso de secuencia de comandos.El siguiente ejemplo muestra un mensaje cuando termina la ejecución del sonido en Windows Media Player:

JScript<SCRIPT FOR="objWMPlay" EVENT="EndOfStream(lResult)" LANGUAGE="Jscript">

alert("Fin de la pieza");</SCRIPT>


Sub objWMPlay_EndOfStream(lResult)alert("Fin de la pieza.")

End Sub</script>

De nuevo, el objeto RealPlayer tiene nombres ligeramente diferentes para el mismo suceso:

JScript

<SCRIPT FOR="objRPlay" EVENT="OnClipClosed()" LANGUAGE="Jscript">alert("Fin de la pieza.");

</SCRIPT>


Sub objRPlay_OnClipClosed()alert("Fin de la pieza.")

End Sub</script>

Puede usar las propiedades, métodos y sucesos del código de servidor. Si embargo, al hacerlo recarga la página Web y por tanto reinicia el sonido, que normalmente no es lo que se quiere.

Instalar objetos ActiveX en el cliente

Utilice al atributo codebase del elemento object para especificar una ubicación desde la que el usuario puede instalar el objeto ActiveX si no existe actualmente en su sistema. El atributo codebase recibe dos argu-mento: el primero es la ubicación desde la que se descargará el control, y el segundo el número de versión delcontrol. Por ejemplo, el siguiente elemento de objeto ActiveX descarga Windows Media Player si el usuario notiene instalada la versión 6.4:

<OBJECT ID="objWMPlayer" classid="CLSID:22D6F312-B0F6-11D0-94AB-0080C74C7E95"CODEBASE="http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=6,4,5,715" VIEWASTEXT>

<PARAM NAME="AutoStart" VALUE="True"><PARAM NAME="FileName" VALUE="test.avi">

</OBJECT>

Cuando el usuario muestra una página con el elemento object anterior el navegador comprueba si en lamáquina del usuario existe la versión indicada; si no, el navegador muestra un diálogo antes de descargar e insta-

lar el objeto. Cuando se instala el objeto se muestra la página y se interpreta el sonido.

239

Control de objetos ActiveX desde Netscape Navigator. Netscape Navigator no soporta objetos ActiveX o el elemento object de HTML. Para incluir sonidos co-

mo objetos dentro de Navigator debe incluirlos como plug incrustado.

Navigator ignora el elemento object , de modo que puede incluir el elemento embed dentro del elementoobject para dar soporte tanto a Microsoft Internet Explorer como a Netscape Navigator en la misma página. Elsiguiente HTML muestra Windows Media Player en ambos navegadores:

<OBJECT ID="objWMPlayer" classid="CLSID:22D6F312-B0F6-11D0-94AB-0080C74C7E95"

CODEBASE="http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=6,4,5,715" type="application/x-oleobject" VIEWASTEXT>

<PARAM NAME="AutoStart" VALUE="False"><PARAM NAME="FileName" VALUE="test.wav"><EMBED type="application/x-mplayer2"

pluginspage="http://www.microsoft.com/Windows/MediaPlayer/"SRC="test.wav"name="objWMPlayer"autostart="0"showcontrols="1"

</EMBED></OBJECT>

Si no está instalado Media Player en Netscape Navigator el código anterior redirige al usuario a la páginade descarga desde la que pueden instalarlo. Para asegurarse de que los usuarios no tienen que reiniciar sus nave-

gadores después de instalar el plug in incluya la siguiente secuencia de comandos tras el objeto en la página:<!—Debe escribirse en JavaScript, ya que Navigator no soporta VBScript --><script language="JavaScript">

// Si el navegador es Netscape Navigator.if ( navigator.appName == "Netscape" ){

// Refresca los plugins recién instalados.navigator.plugins.refresh();

}</script>

Los plug in de Netscape permiten algún control mediante comandos, pero no es coherente con el de Acti-veX. En concreto:

• Se accede a las propiedades mediante métodos Set y Get en lugar de mediante asignación• Los sucesos de plug in se interceptan mediante un proxy applet de Java.

Estos temas de programación, junto con los relativos a la estabilidad del navegador y la dificultad de depurar código diferente para diferentes plataformas limitan la practicabilidad de usar secuencias de comandos conobjetos ActiveX como plug in dentro de Navigator.

Si su aplicación utiliza objetos ActiveX y necesita dar soporte a Netscape Navigator es más práctico in-crustar el objeto como plug in, como se muestra en esta sección, y desactivar los intentos de controlar el objetoen secuencias de comandos. Por ejemplo, el siguiente HTML comprueba si el navegador del usuario es Netsca- pe. Si lo es, el código desactiva los botones que controlan Windows Media Player y muestran en su lugar el in-terface completo del intérprete.

<html><head>

<title>Objetos ActiveX para varios navegadores</title></head><body>

<h2>Uso de objetos ActiveX en varios navegadores</h2><OBJECT ID="objWMPlayer"

classid="CLSID:22D6F312-B0F6-11D0-94AB-0080C74C7E95"CODEBASE="http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=6,4,5,715" type="application/x-oleobject" VIEWASTEXT>

<PARAM NAME="AutoStart" VALUE="False"><PARAM NAME="FileName" VALUE="test.wav"><param name="ShowControls" value="False"><EMBED type="application/x-mplayer2"

pluginspage="http://www.microsoft.com/Windows/MediaPlayer/"SRC="test.wav" name="objWMPlayer" autostart="0"

showcontrols="1"> </EMBED></OBJECT>

MCAD/MCSD

240

<div id="pnlControls">

<script language="JavaScript">

// Si el navegador es Netscape Navigator.if ( navigator.appName == "Netscape" ){

// Refresca plugins recién instalados.navigator.plugins.refresh();// La página termina aquí (sin botones HTML).

alert("Está usando Netscape Navigator. Algunas características deobjetos ActiveX se han desactivado.");

document.all["pnlControls"].setAttribute("disabled","1");}

</script><br><p>Use estos botones para controlar el objeto Media Player.</p><input type="button" value="Iniciar" id="butStart"

onclick="objWMPlayer.Play();" ><input type="button" value="Parar" id="butStop"

onclick="objWMPlayer.stop()" ><input type="button" value="Repetir" id="butRepeat"

onclick="objWMPlayer.PlayCount='2'" ><input type="button" value="Mudo" id="butMute"

onclick="objWMPlayer.Mute=!(objWMPlayer.Mute)" ></div>

</body></html>

12.2 Mostrar videoMuchas de las técnicas usadas para controlar video son las mismas o similares que las que se vieron en la

lección anterior para controlar audio. Como con el audio, al volver a mostrar una página Web se reinicia el video.Por tanto, por lo general es mejor controlar video y responder a los sucesos de video usando secuencias de coman-dos de cliente en lugar de código de servidor.

En esta lección aprenderá cómo incluir video en un formulario Web o página HTML usando elementosHTML y objetos ActiveX. También aprenderá cómo controlar reproducción de video usando secuencias de coman-dos de cliente en JScript y VBScript.

12.2.1 Formas de mostrar videoHay tres formas básicas de mostrar video en un formulario Web:

• Como elemento img de HTML usando el atributo dynsrc.• Como video incrustado usando el elemento embed de HTML para insertar el intérprete de medios predeter-

minado del usuario en la página.• Como objeto ActiveX usando el elemento object de HTML para insertar un intérprete de medios concreto en

la página.

Como con audio, cada una de estas posibilidades tiene ventajas e inconvenientes. Las siguientes seccionesexploran estas técnicas en detalle.

12.2.2 Elemento imgLa forma más sencilla de mostrar video en una página es incluir el video como elemento img de HTML. El

atributo dynsrc del elemento img permite especificar una archivo de video para mostrar en el elemento:

<img dynsrc="clock.avi">

Los controles de servidor Image e ImageButton y los controles HTML Image e Image Button soportan elatributo dynsrc. Por ejemplo, el siguiente HTML muestra un video en un control ImageButton:

<asp:ImageButton id="ImageButton1" dynsrc="clock.avi" runat="server" />

Sin embargo este atributo tiene las siguientes limitaciones:

• Netscape Navigator no lo soporta• Solo acepta AVI• No se puede controlar desde secuencias de comandos de cliente.

12.2.3 Incrustar videosUse el elemento embed de HTML para mostrar un video en un formulario Web con el intérprete de medios

predeterminado del usuario. Por ejemplo, el siguiente HTML incrusta un video en una página:




241

<embed src="clock.avi" id="aviTest" hidden="false" height="200" width="200"autostart="false" type="video/avi" loop="true"></embed>

Los videos incrustados se muestran usando el plugin que esté registrado para este tipo de medio.

Usar el elemento embed para mostrar video tiene las siguientes ventajas:

• Lo soporta la mayoría de los navegadores, incluyendo Internet Explorer y Netscape Navigator • El usuario puede controlar la reproducción usando los controles del intérprete de medios incrustados.•

Se pueden mostrar diferentes formatos de video.La desventaja de usar el elemento HTML embed es que no proporciona el nivel de soporte para secuencia de

comandos que se obtiene con un objeto ActiveX.

12.2.4 Videos como objetos ActiveXComo con sonidos, puede incluir videos como objetos ActiveX en un formulario Web insertando un elemen-

to object de HTML con el ID de clase adecuado. Insertar videos como objetos le da el control de la reproduccióndesde secuencias de comandos de cliente usando el elemento como objeto.

Para mostrar un video como ActiveX se usan los mismos procedimientos que con un sonido. La diferencia esque el parámetro FileName indica un video y no un sonido. Por ejemplo, el siguiente HTML muestra un video comoobjeto AciveX de Windows Media Player 9.

<OBJECT id="objWMPlay" classid="clsid:22D6F312-B0F6-11D0-94AB-0080C74C7E95"

CODEBASE="http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=6,4,5,715" type="application/x-oleobject" VIEWASTEXT>

<PARAM NAME="AutoStart" VALUE="0"><PARAM NAME="EnableTracker" VALUE="-1"><PARAM NAME="Filename" VALUE="clock.avi"><PARAM NAME="Mute" VALUE="0"><PARAM NAME="ShowControls" VALUE="-1"><PARAM NAME="ShowAudioControls" VALUE="-1"><PARAM NAME="ShowDisplay" VALUE="0"><PARAM NAME="ShowGotoBar" VALUE="0"><PARAM NAME="ShowPositionControls" VALUE="-1"><PARAM NAME="ShowStatusBar" VALUE="0"><PARAM NAME="ShowTracker" VALUE="-1"><PARAM NAME="VideoBorderWidth" VALUE="0">

<PARAM NAME="VideoBorderColor" VALUE="0"><PARAM NAME="VideoBorder3D" VALUE="0"><PARAM NAME="Volume" VALUE="0"><PARAM NAME="WindowlessVideo" VALUE="0">

</OBJECT>

Puede controlar la reproducción de video del objeto ActiveX Windows Media Player usando las mismas propiedades y métodos que usaba para controlar la reproducción de audio en las lecciones anteriores. Por ejemplo, lossiguientes botones permiten iniciar, detener, pausar y enmudecer el video:

<input onclick="objWMPlay.object.play()" type="button" value="Start"><input onclick="objWMPlay.stop()" type="button" value="Stop"><input onclick="objWMPlay.PlayCount='2'" type="button" value="Repeat"><input onclick="objWMPlay.mute=!objWMPlay.mute" type="button" value="Mute"><input onclick="objWMPlay.showcontrols='false'" type="button"

value="Hide Controls">Para responder a los sucesos de Media Player cree secuencias de comandos como hizo para audio. Por ejem-

plo, la siguiente secuencia de comandos de cliente muestra una caja de mensaje cuando el usuario detiene el video.

JScript<SCRIPT language="Jscript" event="PlayStateChange(iState)" for="objWMPlay">

if (iState==2) alert("Video Detenido.");</SCRIPT>

VBScript<script language="vbscript">Sub objWMPlay_PlayStateChange(iState)

if iState=2 then alert("Video detenido.")End Sub</script>

9 Estos parámetros corresponden a la versión 6.4. Vea la página siguiente para versiones posteriores.



MCAD/MCSD

242

12.2.5 Objetos ActiveX en Netscape Navigator Como se mencionó en la lección anterior Netscape Navigator no soporta objetos ActiveX o el elemento ob-

ject de HTML. Para incluir videos en Netscape Navigator deberá hacerlo como plugins incrustados. Para ello siga elmismo procedimiento que se mostró en la lección anterior para controlar sonidos ActiveX dentro de Netscape Navi-gator.

12.2.6 Versiones de Windows Media Player

Hasta ahora, en los ejemplos de audio y video para Windows Media Player hemos usado la versión 6.4, aun-que ya se distribuye la 8.010. Hay un par de razones para esto:

• La versión 6.4 tienen un plugin equivalente para soporte de Netscape Navigator • La versión 7.0 y posteriores no se pueden instalar en sistemas operativos anteriores de Microsoft, como Win-

dows 95 o NT 4.

Si la compatibilidad con sistemas operativos anteriores no es una preocupación probablemente querrá usar laversión actual. Para incluir el Windows Media Player actual en un formulario Web use el siguiente elemento object :

<OBJECT id="Player" height="240" width="320"classid="CLSID:6BF52A52-394A-11d3-B153-00C04F79FAA6" VIEWASTEXT>

<PARAM NAME="URL" VALUE="clouds.avi"><PARAM NAME="rate" VALUE="1"><PARAM NAME="balance" VALUE="0">

<PARAM NAME="currentPosition" VALUE="0"><PARAM NAME="defaultFrame" VALUE=""><PARAM NAME="playCount" VALUE="1"><PARAM NAME="autoStart" VALUE="-1"><PARAM NAME="currentMarker" VALUE="0"><PARAM NAME="invokeURLs" VALUE="-1"><PARAM NAME="baseURL" VALUE=""><PARAM NAME="volume" VALUE="50"><PARAM NAME="mute" VALUE="0"><PARAM NAME="uiMode" VALUE="full"><PARAM NAME="stretchToFit" VALUE="0"><PARAM NAME="windowlessVideo" VALUE="0"><PARAM NAME="enabled" VALUE="-1"><PARAM NAME="enableContextMenu" VALUE="-1"><PARAM NAME="fullScreen" VALUE="0">

<PARAM NAME="SAMIStyle" VALUE=""><PARAM NAME="SAMILang" VALUE=""><PARAM NAME="SAMIFilename" VALUE=""><PARAM NAME="captioningID" VALUE="">

</OBJECT>

Media Player versión 7 tiene un ID de clase y un modelo de objeto diferentes a los de la versión 6.4. Por ejemplo, en lugar de usar la propiedad Filename para especificar un video usa la propiedad URL.

La última versión (en el momento de escribir el original la 8.0) no tiene un archivo .cab que se pueda instalar usando el atributo codebase. En su lugar es necesario comprobar si el Media Player está instalado y si no lo estádirigir a los usuarios a la situación desde pueden instalarlo. Por ejemplo, el siguiente código comprueba si está insta-lado Media Player versión 7.0 o posterior y dirige al usuario al sitio de descarga de Microsoft si no es así.

JScript<script language="JavaScript">// Usa control de excepciones para vers si se pudo crear el intérprete.try{

if(document.objWMPlayer.object.enabled); // Si funciona, no hace nada.}catch(ex){ // Si hay error, pide al usuario que lo instale.

document.writeln("<p>No tiene la versión actual de Media Player.");document.writeln("<a href='http://www.microsoft.com/windows/windowsmedia/download

/'>Pulse aquí</a> para instalarlo.</p>");}</script>

10 Y la 9.0




243


' Usa control de excepciones para probar si se puede crear el intérprete.On Error Resume Next ' Si funciona, no hace nada.If Document.objWMPlayer.enabled then x=0If Err Then ' Si hay error pide al usuario que lo instale.

document.writeln("<p>No tiene la versión actual de Media Player.")document.writeln("<a href='http://www.microsoft.com/windows/windowsmedia/" & _

"download/'>Pulse aquí</a> para instalarlo.</p>")

End IfOn Error Goto 0

</script>

La versión 7 de Windows Media Player tiene una amplia información de referencia en la ayuda en línea deVisual Studio.

12.3 Animar páginas WebLas páginas Web a menudo usan texto en movimiento para atraer la vista del usuario hacia anuncios, aclarar

algo o sencillamente divertir. Puede usar una amplia variedad de técnicas para crear contenido animado para la Web.Esta lección le presenta las técnicas principales, compara sus ventajas y desventajas y muestra cómo usarlas.

12.3.1 Formas de mostrar animaciones

Hay varias formas de mostrar animaciones. La tabla 12.1 compara las ventajas y desventajas de las más co-munes.

Tabla 12. 1: Técnicas de animaciónTécnica Ventajas Desventajas

Elemento marquee deHTML

• Usa etiquetas y atributos HTML sencillos• No precisa código de secuencia de comandos

• Disponible solo en Internet Explorer• Número de efectos limitado

Archivos GIF animados • Se puede usar en cualquier elemento HTML queadmita un gráfico

• No precisa código.

• Los archivos crecen al aumentar la complejidady el tamaño

• Se debe descargar el archivo entero antes demostrarse

• No se puede controlar la reproducciónObjetos ActiveX o pluginsincrustados en una página

• Puede crear presentaciones animadas complejas• Puede comenzar antes de que termine la

descarga (soporte de streaming)• Herramientas de tercero para creación y

presentación ampliamente disponibles• Puede interactuar con el usuario• Pueden ser controlados por secuencias de

comandos de cliente.

• Precisa que los usuarios tengan instalado elobjeto ActiveX o el plugin

• Es posible que el creador de contenido necesiteadquirir una licencia y aprender el uso de laherramienta.

Secuencias de comandosde cliente

• Puede controlar cualquier elemento de lapágina.

• Si escribe JScript, el código es soportado por lamayoría de navegadores.

• Los efectos que puede crear solo con código sonlimitados.

• El código se puede volver muy complejo y difícilde mantener.

• La sincronización de efectos es difícil y compleja.HTML + TIME • Usa un lenguaje estándar basado en XML.

• Puede controlar cualquier elemento de la páginausando animación basada en tiempo.

• Se puede combinar con secuencias de comandosde cliente para añadir interactividad

• Netscape Navigator no lo soporta• No puede ver los efectos en la vista de diseño

de Visual Studio – debe editar en HTML

12.3.2 Animar TextoEl elemento marquee de HTML anima cualquier elemento que contenga desplazándolo hacia arriba, abajo,izquierda o derecha. Se usa normalmente para mostrar avisos que deben captar la atención. Por ejemplo, el siguienteHTML muestra el texto “Mírame” en colores contrastados botando de izquierda a derecha en pantalla.

<marquee bgcolor="red" scrollamount="10" behavior="alternate" direction="right"loop="true">

<h1 style="COLOR:Yellow">Mírame</h1></marquee>

También puede usar el elemento marquee para revelar texto desplazándolo a través de una ventana de vista.El siguiente HTML desplaza una lista de créditos; los créditos empiezan en la parte inferior de la marquesina, subeny desaparecen por arriba:

<marquee scrollamount="1" behavior="scroll" direction="up" loop="false">

<h2>Créditos</h2><p>Gracias a los siguientes participantes(me niego a traducir esta chorrada):</p><p>Denise Smith - trusted friend and advisor.</p><p>Alan Steiner - original party animal.</p>



MCAD/MCSD

244

<p>Will Shakespeare - lead grammarian.</p><p>Gary Yukish - thanks for the spell check. </p><p>Karin Zimprich - who invented the four-point seat belt.</p>

</marquee>

Los desarrolladores pueden anidar elementos marquee para crear diferentes efectos visuales. Por ejemplo, elsiguiente HTML muestra una pelota que bota en un marco.

<marquee scrollamount="10" behavior="alternate" direction="up" loop="true"><marquee scrollamount="5" behavior="alternate" direction="right" loop="true">

<img src="circles.gif"></marquee>

</marquee>

El elemento marquee incluye un suceso onbounce que se puede usar para crear más efectos. Por ejemplo, elsiguiente marquee muestra una pelota que bota cada vez menos hasta que rueda y se detiene:

<marquee id="mrqVert" scrollamount="10" behavior="alternate" direction="down"loop="true" height="400" onbounce="OnBounce()">

<marquee id="mrqHoriz" scrollamount="5" behavior="alternate" direction="right"loop="true">

<img src="circles.gif"></marquee>

</marquee>

VBScript<script language=vbscript>bOdd=0Sub OnBounce()

x = document.all("mrqVert").height ' Obtiene la alturabOdd = Not bOdd ' Cambia el indicador de boteif x > 100 then

if bOdd then ' Si abajo es impar bota.document.all("mrqVert").height = x – 20 ' Reduce altura en cada bote.

end ifelse

document.all("mrqVert").scrollamount=0 ' Detiene el movimientodocument.all("mrqHoriz").scrollamount=0

end ifEnd Sub</script>

JScript<script language=JavaScript>var bOdd=0;function OnBounce(){

x = document.all["mrqVert"].height; // Obtiene la alturabOdd = !bOdd; // Cambia el indicador de bote.if (x > 100)

if (bOdd) // Si abajo es impar bota.document.all["mrqVert"].height = x - 20; // Reduce altura en cada bote.

else{document.all["mrqVert"].scrollamount=0; // Detiene el movimiento.document.all["mrqHoriz"].scrollamount=0;

}}</script>

12.3.3 Animar gráficos sencillosLa forma más sencilla de animación para la Web es el GIF animado. Los archivos GIF pueden contener va-

rias imágenes que puede combinar usando una herramienta como Microsoft PhotoDraw para crear una única imagenen movimiento.

Usando Microsoft PhotoDraw u otra herramienta puede agregar imagines como fotogramas a la animación,establecer cuanto tiempo se muestra cada fotograma y configurar otros atributos de la animación. Después de haber creado el archivo GIF puede usarlo dentro de cualquier elemento HTML que acepte un gráfico.

Los GIF animados también se pueden combinar con otras técnicas de animación, como el elemento marquee.

Por ejemplo, el siguiente HTML muestra un avión animado que vuela alrededor de la pantalla del navegador.




245

<marquee behavior="scroll" direction="down" height="800" width="800"><marquee behavior="alternate" direction="right">

<img src="airplane.gif"></marquee>

</marquee>

12.3.4 Mostrar animaciones como objetos o pluginsHay varios objetos ActiveX o plugins de navegador que puede usar para crear presentaciones animadas sobre

la Web. Dos de las más ampliamente usadas son Macromedia ShockWave y Windows Media Player.Estros objetos ActiveX y plugins usan diferentes técnicas para presentar animaciones, y todos tienen docu-

mentación que discute cómo usarlos y crear presentaciones. Vea en la lección 1 información sobre cómo agregar objetos ActiveX y plugins a la página Web.

12.3.5 Animar con secuencias de comandos de clienteComo las secuencias de comandos de cliente pueden controlar cualquier elemento de un formulario Web,

puede usarlos para animar estos elementos ocultándolos y mostrándolos o moviéndolos. Por ejemplo, el siguienteHTML y secuencia de comandos de cliente crea una imagen animada que sigue al cursor por la ventana del navega-dor.

<html><body MS_POSITIONING="GridLayout" onmousemove="OnMove()">

<img id="imgPlane" src="circles.gif" height="20" width="20"style="Z-INDEX: 101; LEFT: 1px; POSITION: absolute; TOP: 1px">

VBScript<script language="vbscript">iCount = 0 ' Variables globales.x = 0y = 0xImg = 0yImg = 0Sub OnMove()

if iCount > 0 then exit sub' Obtiene las coordenadas del ratón.xMouse = window.event.clientxyMouse = window.event.clienty

' Obtiene las coordenadas de la imagen.xImg = document.all("imgPlane").style.getAttribute("LEFT",0)yImg = document.all("imgPlane").style.getAttribute("TOP",0)' Convierte las coordenadas de cadena a número.xImg = cint(left(xImg,len(xImg) -2))yImg = cint(left(yImg,len(yImg) -2))' Cierra la distancia entre los dos conjuntos de coordenadas.x = (xMouse - xImg) / 4y = (yMouse - yImg) / 4' Lanza cada .1 secgundos.window.setInterval "MoveImg", 100, "VBScript"window.setInterval "MoveImg", 200, "VBScript"window.setInterval "MoveImg", 300, "VBScript"window.setInterval "MoveImg", 400, "VBScript"window.setInterval "MoveImg", 500, "VBScript"

End Sub

Sub MoveImg()if iCount < 5 then iCount = iCount + 1 else iCount = 0' Mueve el elemento IMG para seguir al ratón.document.all("imgPlane").style.setAttribute "LEFT", xImg + x, 0document.all("imgPlane").style.setAttribute "TOP", yImg + y, 0

End Sub</script>

JScript<script language="JScript">// Variables globales.var iCount = 0;var x = 0;

var y = 0;var xImg = 0;var yImg = 0;



MCAD/MCSD

246

function OnMove(){if (iCount > 0 ) return;// Obtiene las coordenadas del ratón.xMouse = parseInt(window.event.clientX);yMouse = parseInt(window.event.clientY);// Obtiene las coordenadas de la imagen.xImg = document.all["imgPlane"].style.getAttribute("LEFT",0);yImg = document.all["imgPlane"].style.getAttribute("TOP",0);// Convierte las coordenadas de cadena a número.

xImg = parseInt(xImg);yImg = parseInt(yImg);// Cierra la distancia entre dos conjuntos de coordenadas.x = (xMouse - xImg) / 4;y = (yMouse - yImg) / 4;// Lanza cada .1 segundos.window.setInterval ("MoveImg()", 100, "JavaScript") ;window.setInterval ("MoveImg()", 200, "JavaScript") ;window.setInterval ("MoveImg()", 300, "JavaScript") ;window.setInterval ("MoveImg()", 400, "JavaScript") ;window.setInterval ("MoveImg()", 500, "JavaScript") ;

}

function MoveImg(){if (iCount < 4) iCount ++;

else iCount = 0;// Mueve el elemento IMG para seguir al ratón.document.all["imgPlane"].style.setAttribute ("LEFT", xImg + x, 0);document.all["imgPlane"].style.setAttribute ("TOP", yImg + y, 0);

}</script>

El código anterior muestra tanto la potencia como la dificultad de usar secuencias de comandos de cliente pa-ra animar elementos HTML: puede controlar cualquier elemento de cualquier forma. Pero es muy difícil sincronizar las animaciones.

El ejemplo anterior usa el método setInterval para coordinar la animación, haciendo que la imagen se muevaun cuarto de la distancia cada décima de segundo. En la práctica el efecto es muy interesante, pero no resulta suave.Para resolver realmente este problema necesita poder coordinar sucesos usando el propio HTML. La siguiente sec-

ción explica como hacerlo usando una extensión del HTML estándar.12.3.6 Animar con HTML+TIME

Hasta ahora, nuestra discusión sobre audio, video y animación ha carecido de un elemento importante: tiempo. Los estándares originales de HTML no preveían la necesidad de sincronizar sucesos en la página, pero la sincro-nización es la clave para crear y presentar medios basados en tiempo, como audio, video y animación.

Para resolver este problema el consorcio WWW (W3C) ha generado el estándar SMIL, lenguaje de integra-ción de multimedia sincronizado11. Internet Explorer implementa este estándar bajo el nombre HTML+TIME.

HTML+TIME permite coordinar sucesos temporizados en una página para crear presentaciones multimedia.Los sucesos se pueden producir en líneas de tiempo secuenciales, paralelas o exclusivas.

HTML+TIME precisa Internet Explorer 5.5 o posterior para su ejecución. Las siguientes secciones describecómo usar HTML+TIME en un formulario Web o página HTML.

12.3.7 Uso de HTML+TIMEPara usar HTML+TIME en un formulario Web o página HTML siga estos pasos:

1. Añada al elemento HTML de la página un atributo espacio de nombres XML (XMLNS). El siguiente HTMLdeclara el espacio de nombres HTML+TIME para una página:<HTML XMLNS:t ="urn:schemas-microsoft-com:time">

2. Añada un estilo para definir el comportamiento de tiempo para elementos HTML en la página. La siguientedefinición de estilo establece el comportamiento predeterminad (mostar/ocultar) para la clase time:<style>

.time {behavior: url(#default#time2);}</style>

3. Añada una directiva IMPORT para importar el espacio de nombres XML declarado previamente en la pági-na. El siguiente HTML importa el espacio de nombres HTML+TIME:

11 Synchronizer Multimedia Integration Languaje




247

<?IMPORT namespace="t" implementation="#default#time2">4. Cree una línea de tiempo para los elementos que quiere controlar usando elementos HTML+TIME. Por

ejemplo, el siguiente HTML establece una línea de tiempo secuencial para el elemento que le sigue:<t:SEQ>

5. Establezca los atributos de tiempo para los elementos HTML que quiere controlar. Por ejemplo, el siguienteHTML muestra una línea de texto durante dos segundos.<DIV CLASS="time" DUR="2">Este texto desaparece en dos segundos</DIV>

El siguiente HTML reúne todos los pasos anteriores para mostrar una línea de texto que cambia cada dos se-

gundos hasta que se muestra la última línea. Los elementos HTML+TIME se muestran en negrita para destacar loscambios que hay que hacer en un formulario Web o página HTML normal.

<html XMLNS:t ="urn:schemas-microsoft-com:time"><head>

<title>HTMLTIME</title><meta name="GENERATOR" content="Microsoft Visual Studio.NET 7.0"><meta name="CODE_LANGUAGE" content="Visual Basic 7.0"><meta name="vs_defaultClientScript" content="JavaScript"><meta name="vs_targetSchema"content="http://schemas.microsoft.com/intellisense/ie5"><style>

.time {behavior: url(#default#time2);}</style>

</head><body MS_POSITIONING="GridLayout">

<form id="Form1" method="post" runat="server"><?IMPORT namespace="t" implementation="#default#time2"><t:SEQ> <DIV CLASS="time" DUR="2">Estas palabras se muestran</DIV><DIV CLASS="time" DUR="2">secuencialmente, una línea cada vez</DIV><DIV CLASS="time" DUR="2">para que todo quede más claro.</DIV><DIV CLASS="time">¿Te acuerdas de lo que he dicho?</DIV></t:SEQ>

</form></body>

</html>

La ventana de diseño de Visual Studio no soporta la directiva IMPORT . Solo puede ver los elementos

HTML+TIME desde Visual Studio ejecutando la aplicación. Si quiere crear o ajustar elementos en la página usandola ventana de diseño de Visual Studio comente temporalmente la directiva IMPORT antes de cambiar a diseño.

Con la directiva IMPORT comentada los elementos HTML+TIME no aparecerán y los elementos HTML or-dinarios no mostrarán sus atributos de tiempo; sin embargo, podrá añadir y modificar otros elementos de la página.

12.3.8 Crear líneas de tiempoEn la sección anterior el elemento t:SEQ de HTML+TIME crea una línea de tiempo secuencial. Como sugie-

re el nombre, los sucesos en una línea de tiempo secuencial se producen uno tras otro tal como determina el atributode duración ( DUR).

Además de líneas de tiempo secuenciales puede crear líneas de tiempo exclusivas ( t:EXCL) y paralelas(t:PAR). Las líneas de tiempo exclusivas muestran un elemento cada vez tal como determina el atributo BEGIN delelemento. Si un segundo elemento empieza antes de que termine la duración del primero, el segundo sustituye al

primero. Por ejemplo, el siguiente fragmento HTML muestra cada línea por turno durante dos segundos. El atributo DUR esencialmente se ignora hasta la última línea, que se muestra durante tres segundos.

<t:EXCL><DIV CLASS="time" BEGIN="0" DUR="3">Estas palabras se muestran</DIV><DIV CLASS="time" BEGIN="2" DUR="3">usando una línea de tiempo exclusiva.</DIV><DIV CLASS="time" BEGIN="4" DUR="3">Cada línea tiene su momento de inicio.</DIV><DIV CLASS="time" BEGIN="6" DUR="3">¿Te acuerdas de lo que he dicho?</DIV></t:EXCL>

Las líneas de tiempo paralelas pueden mostrar más de un elemento a la vez. Cada elemento usa tanto el atributo BEGIN como el atributo DUR para determinar cuándo comienza y durante cuanto tiempo se muestra. Por ejemplo, el siguiente HTML muestra cada línea por turno durante tres segundos. En algunos momentos se muestrandos líneas a la vez:



MCAD/MCSD

248

<t:PAR><DIV CLASS="time" BEGIN="0" DUR="3">Estas palabras se muestran</DIV><DIV CLASS="time" BEGIN="2" DUR="3">usando una línea de tiempo paralela.</DIV><DIV CLASS="time" BEGIN="4" DUR="3">Se muestra más de una línea.</DIV><DIV CLASS="time" BEGIN="6" DUR="3">a la vez.</DIV></t:PAR>

Otra diferencia entre las líneas de tiempo secuenciales y los otros dos tipos es que los elementos de una líneade tiempo secuencial se reemplazan uno al anterior. En el primero de los dos ejemplos anteriores cada elemento se

muestra en la misma línea de la página. En los ejemplos de línea de tiempo paralela y exclusiva cada elemento apa-rece en su propia línea.

Las líneas de tiempo se pueden anidar de modo que una línea de tiempo maestra controle varias subordina-das. Por ejemplo, el siguiente HTML muestra cada una de las tres líneas de tiempo secuencialmente:

<h1>Demo líneas de tiempo</h1><t:SEQ>

<h2 CLASS="time" DUR="2">Línea de tiempo secuencial</h2><t:SEQ>

<DIV CLASS="time" DUR="2">Estas palabras se muestran</DIV><DIV CLASS="time" DUR="2">secuencialmente, línea a línea</DIV><DIV CLASS="time" DUR="2">para dejar este punto claro.</DIV><DIV CLASS="time" DUR="2">¿Puedes recordar lo que he dicho?</DIV>

</t:SEQ>

<h2 CLASS="time" DUR="2">Línea de tiempo exclusiva</h2><t:EXCL>

<DIV CLASS="time" BEGIN="0" DUR="3">Estas palabras se muestran usando</DIV><DIV CLASS="time" BEGIN="2" DUR="3">una línea de tiempo exclusiva.</DIV><DIV CLASS="time" BEGIN="4" DUR="3">Cada línea tiene su tiempo de inicio</DIV><DIV CLASS="time" BEGIN="6" DUR="3">¿Puedes recordar lo que he dicho?</DIV>

</t:EXCL><h2 CLASS="time" DUR="2">Línea de tiempo paralela</h2><t:PAR>

<DIV CLASS="time" BEGIN="0" DUR="3">Estas palabras se muestran usando</DIV><DIV CLASS="time" BEGIN="2" DUR="3">una línea de tiempo paralela.</DIV><DIV CLASS="time" BEGIN="4" DUR="3">Se muestra más de una línea</DIV><DIV CLASS="time" BEGIN="6" DUR="3">a la vez.</DIV>

</t:PAR><h2 CLASS="time" DUR="4">Esto es todo</h2>

</t:SEQ>

12.3.9 Contenedores de tiempoLos elementos t:SEQ, t:EXCL y t:PAR mostrados anteriormente crean una línea de tiempo para los elementos

que se encuentran entre sus etiquetas de comienzo y fin. También puede crear líneas de tiempo dentro de elementosHTML individuales usando el atributo TIMECONTAINER. Por ejemplo, el siguiente HTML es equivalente al ejemplo de línea de tiempo secuencial en la sección precedente.

<DIV class="time" timeContainer="seq"><DIV CLASS="time" DUR="2">Estas palabras se presentan</DIV><DIV CLASS="time" DUR="2">secuencialmente, una línea cada vez</DIV><DIV CLASS="time" DUR="2">para dejar cada punto más claro.</DIV><DIV CLASS="time" DUR="2">¿Puedes recordar lo que he dicho?</DIV>

</DIV>

El atributo TIMECONTAINER facilita la creación de líneas de tiempo porque se puede añadir a contenedoresHTML existentes, como elementos div, form o body. También facilitan la creación de líneas de tiempo separadas para elementos individuales de una página. Por ejemplo, el siguiente HTML usa una línea de tiempo separada parala última línea mostrada en la marquesina.

<marquee CLASS="time" TIMECONTAINER="seq" REPEATCOUNT="indefinite"behavior=alternate>

<h2 CLASS="time" DUR="2">Estas palabras se presentan</h2><h2 CLASS="time" DUR="2">secuencialmente, una línea cada vez</h2><h2 CLASS="time" DUR="2">para dejar cada punto más claro.</h2><h2 TIMECONTAINER="seq" CLASS="time" DUR="2">

<div class="time" dur="1">¿Puedes recordar lo que he dicho?</div><div class="time" dur="1">Porque yo ya lo he olvidado.</div>

</h2></marquee>




249

12.3.10 Animar atributosEl comportamiento predeterminado de una línea de tiempo es mostrar u ocultar elementos. Puede crear otros

efectos usando el elemento t:ANIMATE para cambiar los atributos de un elemento en un momento especificado. Por ejemplo, el siguiente HTML cambia el texto del elemento span de “fin” a “principio” cada cuarto de segundo.

<t:ANIMATE targetelement="sEnd" attributename="innerHTML" from="fin" to="principio"dur=".25" repeatcount="indefinite" />

<h2>Este es el <span id="sEnd">fin</span>.</h2>

Puede usar transiciones de color usando el elemento t:ANIMATECOLOR. Por ejemplo, el siguiente HTMLfunde el texto de encabezado de amarillo a rojo en un periodo de 5 segundos:

<t:ANIMATECOLOR targetElement="hEnd" attributeName="color" from="yellow" to="red"start="2" dur="5" fill="hold"><h2 id="hEnd" style="color:black">Este es el <span id="sEnd">fin</span>.</h2>

El elemento t:ANIMATEMOTION se usa para mover elementos en una página. Por ejemplo, el siguienteHTML mueve un encabezado desde las coordenadas de rejilla (400, 400) a (1, 1):

<t:ANIMATEMOTION targetElement="hEnd" from="400,400" to="1,1" start="2" dur="5"fill="hold"><h2 id="hEnd" style="position:absolute;color:black">Este es el <span id="sEnd">

fin </span>.</h2>

Puede mover elementos respecto a sus posiciones iniciales usando el atributo BY del elementot:ANIMATEMOTION en lugar del atributo TO. Como alternativa puede crear una ruta para el elemento usando losatributos VALUES o PATH . El atributo VALUES acepta una cadena de pares de coordenadas. Por ejemplo, el si-guiente HTML mueve un encabezado alrededor de un cuadrado de 200 por 200.

<t:ANIMATEMOTION targetElement="hEnd" values="1,200;200,200;200,1;1,1;1,200"start="2" dur="5" fill="hold"><h2 id="hEnd" style="position:absolute;color:black">Este es el <span

id="sEnd">fin</span>.</h2>

El atributo PATH recibe como argumento una cadena que contiene comandos de gráficos de vectores escala- bles (SVG12) que permiten mover elementos usando coordenadas absolutas o relativas. Por ejemplo, el siguienteHTML mueve un encabezado en una ruta triangular.

<t:ANIMATEMOTION targetElement="hEnd" path="M 0 200 h 200 v -200 z" start="2"

dur="10" repeatcount="indefinite"><h2 id="hEnd"style="position:absolute;color:black">Este es el <spanid="sEnd">fin</span>.</h2>

12.3.11 Controlar audio, video y otros mediosHTML+TIME proporciona elementos para audio, video, imagen fija y medios genéricos temporizados. Sin

embargo, todos estos elementos actualmente son equivalentes al elemento t:ANIMATION . Puede usar etiquetas propias de cada medio si cree que esto documenta mejor su código o espera algún beneficio de versiones futuras deHTML+TIME.

Los elementos t:AUDIO, t:VIDEO, t:MEDIA, t:IMG y t:REF se usan exactamente igual que el elementot:ANIMATION . Por ejemplo, el siguiente HTML hacer sonar un pitido cada dos segundos:

<t:AUDIO src="beep.wav" hasaudio="True" dur="2" repeatcount="indefinite" />

Igualmente, el siguiente HTML cambia entre dos imágenes cada cinco segundos:<t:par REPEATCOUNT="indefinite" >

<t:IMG src="gondola.jpg" style="position:absolute;" begin="0" end="5" ><t:IMG SRC="bridge.jpg" style="postion:absolute;" begin="5" end="10" >

</t:par>

No es realment necesario usar t:IMG o el equivalente t:ANIMATE en el ejemplo anterior porque una etiqueta<img class=”time” > haría lo mismo. Sin embargo, los elementos HTML+TIME permiten añadir transiciones queno están disponibles con el elemento img. El siguiente HTML añade transiciones a los cambios de imagen:

<t:seq REPEATCOUNT="indefinite" ><t:IMG src="gondola.jpg" style="position:absolute;" DUR="5"

FILL="transition" timecontainer="par" ><t:TRANSITIONFILTER TYPE="fade" mode="in" begin="0" end="1"/>

<t:TRANSITIONFILTER TYPE="fade" mode="out" begin="4" end="5" /></t:IMG>

12 Scalable Vector Graphics



MCAD/MCSD

250

<t:IMG SRC="bridge.jpg" style="postion:absolute;" DUR="5" FILL="transition"timecontainer="par" ><t:TRANSITIONFILTER TYPE="clockwipe" mode="in" begin="0" end="1" /><t:TRANSITIONFILTER TYPE="clockwipe" mode="out" begin="4" end="5" />

</t:IMG></t:seq>

Más información: HTML+TIME permite controlar el ritmo de la animación, las transiciones entreimágenes y muchos otros aspectos de la animación que no se tratan en esta lección. Para más

información vea el tema de ayuda HTML+TIME en la ayuda en línea de Visual Studio.

12.4 Resumen• Use sucesos y secuencias de comandos de cliente para controlar multimedia, puesto que el código de servidor

precisa que se vuelva a mostrar la página, haciendo que el medio se reinicie.• El elemento bgsound de HTML interpreta audio como sonido de fondo.• Use el atributo dynsrc del elemento img de HTML para mostrar vídeo sin tener la capacidad de controlar la

reproducción.• El elemento embed de HTML reproduce audio o video usando el intérprete de medios predeterminado del

usuario.• Incluya audio o video como objeto ActiveX usando el elemento object de HTML. Puede controlar la repro-

ducción de un objeto ActiveX usando secuencias de comandos de cliente.

• Añada objetos ActiveX a la caja de herramientas de Visual Studio .NET y arrástrelos al formulario Web paraobtener el id de clase correcto y los atributos predeterminados para el objeto.• Use el atributo codebase del elemento object de HTML para comprobar automáticamente si el cliente tiene la

versión adecuada de un objeto ActiveX instalada e instalarla automáticamente si no.• Los archivos gif animados y el elemento marquee de HTML ofrecen formas sencillas para crear animación.• Las secuencias de comandos de cliente pueden animar cualquier elemento de un formulario Web y pueden

responder a suceso de usuario, pero presentan problemas cuando se intenta sincronizar sucesos.• Sincronice sucesos multimedia en Internet Explorer usando HTML+TIME, que es la implementación por

Microsoft del estándar SMIL.• HTML+TIME le permite: Crear diferente tipos de líneas de tiempo en una página Web Especificar el orden, temporización y duración de sucesos dentro de una línea de tiempo- Controlar los atributos, color y posición de los elementos en respuesta a estos sucesos con tiempo.

12.5 Práctica: Crear una aplicación mult imediaEn esta aplicación va a crear una práctica que contiene dos formularios Web o páginas HTML. La primera

muestra el uso de sonido y movimiento, y la segunda demuestra el uso de HTML+TIME para crear una presentaciónde diapositivas de texto.

Estos ejemplos son intencionadamente sencillo para mostrar lo que se puede hacer aplicando correctamentela técnica multimedia adecuada.

12.5.1 Ejercicio 1: Usar sonido y movimientoEn este ejercicio va a crear un formulario Web o página HTML que muestre un GIF animado que bota en

torno a la pantalla e interpreta un sonido cuando bota. Utilice lo que ha aprendido en las lecciones 1, 2 y 3 para crear un formulario Web o página HTML que realice las siguientes tareas principales:

1. Muestre un archivo .gif animado como elemento img de HTML2. Mueva el .gif animado alrededor de la pantalla usando elementos marquee de HTML anidados.3. Incluya botones que permitan al usuario controlar la velocidad del movimiento.4. Use un objeto ActiveX de Windows Media Player para interpretar un sonido en respuesta a un suceso de bo-

te.5. Compruebe si el navegador del usuario es Internet Explorer, y si no lo es indique al usuario que algunas ca-

racterísticas de la página no están disponibles.

Cuando termine compare sus resultados con el ejemplo multimedia incluido en el CD-ROM del libro.

12.5.2 Ejercicio 2: Mostrar una presentación de diapositivasEn este ejercicio va a crear un formulario Web o página HTML que usa HTML+TIME para mostrar una pre-

sentación animada. Use lo que ha aprendido en las lecciones 1, 2 y 3 para crear un formulario Web o página HTMLque realice las siguientes tareas principales:

1. Prepare la página para HTML+TIME añadiendo las directivas correspondientes de espacio de nombres, estiloe IMPORT.




251

2. Cree una línea de tiempo que muestre tres textos secuencialmente.3. Cree líneas de tiempo paralelas entre los dos primeros textos para mostrar tres elementos de lista4. Cree una línea de tiempo secuencial con el último texto para contar hacia atrás de 5 a 1.5. Navegue a otra página cuando termine la línea de tiempo.

Cuando termine compare su resultado con el ejemplo incluido en el CD-ROM.

12.6 Repaso

Las siguientes preguntas están pensadas para reforzar información clave mostrada en este capítulo. Si no escapaz de contestar a una pregunta repase la lección correspondiente e intente de nuevo. Las respuestas se puedenencontrar en el capítulo 16.

1. ¿Por qué normalmente se controla el multimedia desde secuencias de comandos de cliente en lugar de códigode servidor?

2. ¿Qué elementos HTML de sonido y video soportan la mayoría de los navegadores?

3. ¿Cómo se da soporte a los usuarios de Netscape Navigator desde dentro de un elemento de objeto ActiveX?

4. ¿Qué característica principal proporciona HTML+TIME que no está disponible con otras técnicas de anima-ción?

5. Indique dos formas de crear una nueva línea de tiempo usando HTML+TIME



MCAD/MCSD

252

253

13 Dar formato a salida de aplicación WebASP.NET proporciona dos formas complementarias para dar formato a la salida de una aplicación Web:

• Usar hojas de estilo en cascada (CSS13) para controlar el aspecto de los elementos en un formularioWeb. Estos estilos pueden establecer el color, tamaño, fuente y comportamiento de los elementos HTML enuna página Web.

• Usar transformaciones de lenguaje de marcas extensible (XSLT14) para convertir información de un

archivo XML en salida HTML y colocar esta información en una página Web. XSLT pone datos del ar-chivo XML en elementos HTML y aplica estilos a estos elementos.

En este capítulo aprenderá cuándo y cómo usar cada una de estas técnicas en una aplicación web.


• Saber cómo crear formularios Web usando el modo HTML en Visual Studio.NET• Estar familiarizado con los elementos HTML usados para crear formularios Web y páginas HTML.

13.1 Hojas de estilo en cascadaLas hojas de estilo en cascada reúnen y organizan toda la información de formato aplicada a elementos

HTML en un formulario Web. Como mantiene esta información en un único sitio facilitan ajustar la apariencia delas aplicaciones Web.

Visual Studio .NET incluye herramientas de edición de estilos, junto con una hoja de estilos predeterminadaque se crea como parte de cada nuevo proyecto de aplicación Web. En esta lección aprenderá cómo usar las herra-mientas de Visual Studio .NET para modificar la hoja de estilos predeterminada, anexar la hoja de estilos a formula-rios Web y cambiar de hoja de estilos en tiempo de ejecución.

13.1.1 Cómo funcionan los estilosComo se mencionó al inicio de esta lección las hojas de estilo almacenan el formato en un único lugar: el ar-

chivo CSS. Sin embargo, el formato se puede aplicar a tres niveles dentro de una aplicación. Antes de comenzar atrabajar con hojas de estilo debe comprender cómo afectan al formato los estilos definidos a diferentes niveles. Latabla 13.1 describe estos niveles y dicen cómo se aplican a los elementos en un formulario Web.

Tabla 13. 1: Niveles de estiloNivel Definido en Se aplica a

Global Archivo de hoja de estilos Todas las páginas que hacen referencia a la hoja de estilosPágina Elemento head de la página Todos los elementos de la páginaEn línea El propio elemento HTML Solo al elemento actual

Estos tres niveles siguen reglas de precedencia similares a los niveles de alcance con los que ya está familia-rizado como programador. El formato en línea tiene preferencia sobre el formato de página, que a su vez tiene prefe-rencia sobre el global. Estas reglas de precedencia son el motivo de que la hojas de estilo se denominen en cascada.

El siguiente HTML muestra la aplicación de los tres niveles de estilo:

<HTML><HEAD>

<title>WebForm1</title><LINK REL="stylesheet" TYPE="text/css" HREF="Styles.css">

<style>p {

font-family: 'Comic Sans MS', Lucida Sans, sans-serif;font-size: medium;

}</style>

</HEAD>

<body><p>El alineamiento es de la hoja de estilo.</p><p>La fuente es del estilo en el elemento head de la página.</p>

13 Cascading Style Sheets14 Extensible Stylesheet Language Transformation

MCAD/MCSD

254

<p style="FONT-SIZE: large; FONT-STYLE: italic">La cursiva es del estilo en

línea.</p></body>

</HTML>

p{

font-size: small;

text-align: center;}

El ejemplo anterior muestra cómo se pueden aplicar atributos de estilo a un mismo elemento a diferentes ni-veles. El atributo font-size se aplica a los tres niveles, pero solo se ven los efectos de las configuraciones a nivel página y en línea porque la configuración de página tiene prioridad sobre la configuración a nivel hoja de estilo. Losatributos text-align, font-family y font-style se definen una sola vez cada uno, de modo que sus efectos se suman.

Almacenar las definiciones de estilo en un archivo de hoja de estilo en lugar de localmente en cada formula-rio Web o en línea en cada elemento HTML tiene un par de ventajas:

• El formato se mantiene en un solo lugar, de modo que los cambios se hacen una sola vez para toda la aplica-ción.

• Se pueden mantener varios conjuntos de reglas de estilo paralelas en hojas de estilo separadas para dar for-mato a salida en diferentes dispositivos o con diferentes necesidades de usuario. Por ejemplo, una aplicación

puede tener hojas de estilo estándar, con tipos grandes y para impresión que los usuarios pueden seleccionar en tiempo de ejecución.

Consejo: Por lo general, debe usar los estilos en página y en línea solo cuando tenga una razón verda-deramente buena para sustituir los estilos globales. Confiar mucho en los estilos en página y enlínea puede hacer difícil mantener el formato en una aplicación Web.

13.1.2 Usar hojas de estilo con formularios WebCuando se crea una nueva aplicación Web Visual Basic .NET Visual Studio .NET crea automáticamente una

hoja de estilo llamada Styles.css. Sin embargo, Visual Studio .NET no usa esta hoja de forma automática en losformularios Web o páginas HTML que se creen.

Para usar la hoja de estilo debe añadir un elemento de enlace en la sección head de la página:

<LINK REL="stylesheet" TYPE="text/css" HREF="Styles.css" />

Importante: Sólo los proyectos Visual Basic se crean con una hoja de estilo. Para proyectos C# de- berá crear la hoja de estilo desde cedo o cortar y pegar el contenido de la hoja predeter-minada creada en un proyecto Visual Basic.

13.1.3 Modificar estilosPara cambiar la apariencia de los estilos en una hoja de estilos use el generador de estilos. Los cambios en la

hoja de estilos cambian la apariencia de todos los formularios Web que hacen referencia a la misma. Para modificar un estilo:

1. Abra la hoja de estilos en Visual Studio. Verá las definiciones de estilos en la ventana de documento y un es-quema de la hoja de estilos en la ventana de herramientas.

2. Seleccione el estilo a modificar en la ventana de herramientas. Verá la definición del estilo en la ventana dedocumento.3. Pulse con el botón derecho sobre la definición de estilo o sobre el estilo en la ventana de herramientas y se-

leccione Generar estilo. Se abrirá el asistente Generador de estilo.4. Use el generador de estilo para componer el formato que quiere añadir o modifique el estilo existente. Cuan-

do termine pulse aceptar.

Cuando cierre el generador de estilo verá que se han añadido los atributos nuevos o modificados en la defini-ción de estilo.

13.1.4 Añadir estilosHasta ahora hemos cread estilos aplicados usando nombres de elemento HTML. CSS usa el nombre de ele-

mento para localizar el formato predeterminado que se aplica a cada elemento. Sin embargo, también puede aplicar estilos usando nombres de clase o ID de elemento.

Los nombres de clase le permiten aplicar un mismo estilo a diferentes elementos o diferentes estilos a unmismo elemento, dependiendo de cómo se use el elemento. Los ID de elemento le permite aplicar un estilo a unúnico elemento en uno o más formularios Web.




255

Para añadir un estilo:

1. Abra la hoja de estilo, pulse con el botón derecho en la ventana de documento o la de herramientas y selec-cione Agregar regla de estilo. Se abre el asistente Agregar regla de estilo.

2. Seleccione el tipo de estilo que quiere crear. Puede crear estilos que se aplican a elementos HTML, class oID,s de elemento específicos. Seleccione el elemento o escriba el nombre de clase o ID y pulse el botón agre-gar (>) para añadir el elemento a la regla de estilo.

3. Repita el paso 2 para cada elemento al que quiere aplicar el estilo.

13.1.5 Usar clases de estiloLas clases de estilo le permiten aplicar el mismo formato a diferentes elementos HTML en un formulario

Web. Cuando crea una regla de estilo para una clase Visual Studio .NET añade una definición en la hoja de estilosusando un identificador .nombreclase:

.emphasis{

font-style: italic;}

El estilo anterior pone en cursiva todos los elementos que usan la clase .emphasis.

La clase de estilo se aplica a elementos HTML usando el atributo class y a los controles de servidor usando elatributo CssClass. El siguiente HTML muestra la diferencia en negrita:

<p>Este es un párrafo que contiene <span class="emphasis">énfasis</span>.</p><asp:TextBox ID="Text1" Runat="server" CssClass="emphasis">Texto</asp:TextBox>

13.1.6 Crear estilos para elementos concretosTambién puede crear estilos para elementos concretos en un formulario web en base al ID del elemento. Los

ID de elemento deben ser únicos para cada elemento de una página, de modo que el formato establecido por un IDde elemento solo se puede aplicar a un elemento de cada página. Cuando se crea una regla de estilo para un ID deelemento Visual Studio .NET añade a la hoja de estilo una definición de estilo usando un identificador #idElemento:

#inserted{

text-decoration: underline;}#deleted

{text-decoration: line-through;

}

Las definiciones de estilo anteriores dan formato subrayado a los elementos con el ID inserted y tachado a loselementos con el ID deleted .

Los estilos aplicados en Visual Studio .NET no siempre se muestran correctamente en el diseñador de formu-larios. Si no ve el formato aplicado a un estilo concreto intente lo siguiente:

• Asegúrese de que ha grabado la hoja de estilo• Cambie entre vista HTML y vista Diseño en el formulario Web.• Pulse con el botón derecho sobre el formulario Web y seleccione Ver en explorador.

13.1.7 Crear estilos anidadosSi examina las definiciones de estilos en la hoja de estilos predeterminada Styles.css observará que algunasdefiniciones de estilo recogen varios nombres de elemento. Estas definiciones establecen qué formato usar paraelementos anidados. Por ejemplo, los siguientes estilos especifican diferentes tipos de viñetas para listas anidadas nonumeradas:

UL LI{list-style-type: square ;

}

UL LI LI {list-style-type: disc;

}

UL LI LI LI{

list-style-type: circle;}

Para crear sus propios estilos anidados añada varios elementos en la jerarquía de la regla de estilo en el diálo-go Agregar regla de estilo.



MCAD/MCSD

256

13.1.8 Cambiar la hoja de estilo en ejecuciónComo se mencionó anteriormente, puede crear varias hojas de estilo y permitir que el usuario seleccione qué

estilo utilizar en tiempo de ejecución para dar formato al formulario Web para imprimir o para proporcionar caracte-rísticas como versiones con tipos grandes de formularios Web.

Para cambiar de hoja de estilo automáticamente cuando se imprima un formulario Web use el atributo media del elemento de enlace de la hoja de estilo para especificar la hoja de estilo que se utilizará para imprimir y para pantalla. Por ejemplo, los siguientes elementos de enlace aplican formato de la hoja de estilo predeterminada cuando

se muestra el formulario en pantalla, pero usan le estilo Print.css cuando el usuario imprime el formulario:<LINK REL="stylesheet" TYPE="text/css" HREF="Styles.css" media="screen"><LINK REL="stylesheet" TYPE="text/css" HREF="Print.css" media="print">

Para cambiar entre hojas de estilo en tiempo de ejecución cree una secuencia de comandos de cliente paracambiar el elemento href del elemento de enlace de la hoja de estilo. Por ejemplo, el siguiente HTML crea un for-mulario Web que cambia entre las hojas de estilo Styles.css y BigType.css cuando el usuario pulsa un enlace:

VBScript<HTML>

<HEAD id="myhead"><title>ChangeSheets</title><LINK ID="ScreenStyle" REL="stylesheet" TYPE="text/css" HREF="Styles.css"><script language="vbscript">

Sub SwitchSheets()If document.all("ScreenStyle").GetAttribute("HREF") = "Styles.css" then

document.all("ScreenStyle").SetAttribute "HREF", "BigType.css", 0else

document.all("ScreenStyle").SetAttribute "HREF", "Styles.css", 0end if

End Sub</script>

</HEAD><body>

<form id="Form1" method="post" runat="server"><h2>Cambio de hoja de estilo en tiempo de ejecución </h2><p>Esta página aparece usando la hoja de estilo predeterminada.</p><p><a onclick="SwitchSheets" href="#">Pulse aquí

</a> para cambiar entre la versión normal y la de tipos grandes.</p></form>

</body></HTML>

JScript<HTML>

<HEAD><title>ChangeSheets</title><LINK ID="ScreenStyle" REL="stylesheet" TYPE="text/css" HREF="Styles.css"

media="screen"><LINK ID="PrintStyle" REL="stylesheet" TYPE="text/css" HREF="Print.css"

media="print"><script id=clientEventHandlersJS language=jscript>

function SwitchSheets(){

if (document.all["ScreenStyle"].getAttribute("HREF") == "Styles.css")document.all["ScreenStyle"].setAttribute ("HREF", "BigType.css", 0);else

document.all["ScreenStyle"].setAttribute ("HREF", "Styles.css", 0);}

</script></HEAD><body MS_POSITIONING="FlowLayout">

<FORM id="Form1" method="post" runat="server"><h2>Cambio de hoja de estilo en tiempo de ejecución </h2><p>Esta página aparece usando la hoja de estilo predeterminada.</p><p><a onclick="SwitchSheets" href="#">Pulse aquí

</a> para cambiar entre la versión normal y la de tipos grandes.</p><A href="Behave.aspx">Siguiente>></A></FORM>

</body></HTML>




257

13.1.9 ComportamientosAdemás de dar formato los estilos también pueden definir comportamientos que los elementos HTML mues-

tran en tiempo de ejecución. Los comportamientos son un tipo de formato dinámico: como el contenido Web nosiempre es estático las hojas de estilo usan comportamientos para definir cambios dinámicos.

Si ha leido el Capítulo 12, Trabajar con multimedia estará familiarizado con los comportamientos. Las ani-maciones HTML+TIME usan la clase time para aplicar animaciones a elementos HTML en una página, como se veaquí:

<style>.time {behavior: url(#default#time2);}

</style>

La propiedad behavior importa archivos de comportamiento que contienen código JScript o VBScript quecontrola lo que hace el comportamiento. EL tema Librería de Comportamientos en la ayuda de Visual Studio .NET proporciona una serie de comportamientos de ejemplo que puede descargar y usar en su propio código.

Por ejemplo, el siguiente HTML importa el archivo de comportamiento de ejemplo Movible.htc y lo usa paracrear un párrafo que el usuario puede arrastrar a una nueva ubicación en el formulario Web en tiempo de ejecución.

<HEAD><title>Comportamiento</title><style>

.movable {behavior: url(behaviors/movable.htc); CURSOR: move;mv--boundary: 0 800 600 0}</style>

</HEAD><body>

<form id="Form1" method="post" runat="server"><p class="movable">Puede arrastrar este texto por la pantalla.</p>

</form></body>

</HTML>

En el HTML anterior la definición de estilo para la clase movable incluye el URL del archivo de comporta-miento, el estilo de cursor que debe utilizar y los límites a que se confinan los elementos. El estilo se aplica por elatributo class del elemento p. En tiempo de ejecución el usuario puede arrastrar el párrafo por la pantalla.

El comportamiento movable se puede aplicar a cualquier elemento de un formulario Web, incluyendo contro-les de servidor. Algunos comportamientos, sin embargo, solo se pueden aplicar a ciertos tipos de controles. Por ejemplo, el comportamiento ColorPick del siguiente código se puede aplicar solo a los controles HTML campo detexto (elementos input de tipo text ).

<HTML xmlns:control><HEAD>

<title>Comportamiento</title><style>.color { BEHAVIOR: url(behaviors/ColorPick.htc) } </style>

</HEAD><body>

<form id="Form1" method="post" runat="server"><p>Use el selector de color para cambiar el fondo:</p><input ID="ColorPic" type="text" class="color" value="#fFFf00"

onchange="document.bgColor=ColorPic.value;" style="cp--grid-size:2">

</form></body>

</HTML>

El anterior HTML muestra una paleta de colores sobre la que puede pulsar el usuario para cambiar el color defondo en tiempo de ejecución.

Finalmente, algunos comportamientos crean sus propios tipos de elementos que se pueden usar en un formu-lario Web. Por ejemplo, el comportamiento de ejemplo Slider crea un elemento deslizante que puede usar para obte-ner entrada del usuario. Para usar el control Slider primero debe añadir un atributo xmlns al elemento html del for-mulario Web para declarar el nombre del control:

<HTML xmlns:control><HEAD>

<title>Comportamiento</title>

<style>control\:slider { BEHAVIOR: url(behaviors/slider.htc) } </style></HEAD>



MCAD/MCSD

258


<control:slider ID="Slider" onchange="alert(Slider.value)"STYLE="sl--orientation:horizontal"></control:slider>

</form></body>

</HTML>

El HTML anterior crea un control deslizador que muestra el valor del control cuando el usuario lo arrastra.

Importante: Aunque puede usar comportamientos que crean controles en formularios web, normal-mente es mejor idea crear controles personalizados para tareas que no realizan los con-troles de servidor estándar o controles HTML. Los controles creados por comportamien-tos no se muestran correctamente en la ventana del diseñador de Visual Studio .NET yno proporcionan propiedades y métodos que estén disponibles con facilidad en el códigode servidor. Los controles personalizados si proporcionan estas ventajas.

13.2 Transformaciones XSLEn esta lección aprenderá sobre el uso de XSL para transformar archivos XML usando expresiones escritas

en el lenguaje de rutas de XML (XML Path Language, XPath).

13.2.1 Cómo funcionan las transformaciones XSL

Las transformaciones XSL usan el control de servidor XML para generar salida con formato a partir de unarchivo de entrada XML usando un conjunto de reglas almacenado en un archivo de descripción XSL. El archivoXSL es similar al archivo CSS sobre el que aprendió en la lección anterior – proporciona las reglas de formato quese aplican a la salida que se muestra en el formulario web. A diferencia de los archivos CSS, sin embargo, XSL puede colocar elementos en cualquier parte del formulario Web y ejecutar operaciones lógicas, como repetición yoperación condicional.

Puede pensar en los archivos XSL como en una capa de formato inteligente que complementa – no reemplaza – a CSS. Use XSL para colocar datos estructurados en un formulario Web, y CSS para establecer la apariencia delos elementos dentro de esta capa.

Para realizar una transformación XSL sobre un formulario Web siga estos pasos:

1. Añada un control de servidor XML a un formulario Web.

2. Indique en la propiedad DocumentSource del control el archivo XML al que se va a dar formato3. Indique en la propiedad TransformSource el archivo XSL que se usará para dar formato a la salida.

En tiempo de ejecución el control de servidor XML procesa la entrada XML usando la descripción XSL para proporcionar salida con formato.

13.2.2 Crear un archivo XMLLos archivos XML son una forma de describir datos estructurados en formato de texto. XML identifica los

elementos de datos usando etiquetas <elemento> … </elemento> muy similares a las de HTML. Pero a diferencia deHTML las reglas de XML son estrictas:

• Cada elemento debe tener una etiqueta de apertura y una de cierre. En HTML hay etiquetas que puedenusarse sin cerrar. Esto no se permite en XML.

• Los nombres de etiquetas de elemento diferencian mayúsculas y minúsculas. En HTML <P> y < p> son

equivalentes, en XML constituyen etiquetas diferentes.• Los valores de atributos siempre deben ir entre comillas dobles. En HTML se pueden omitir las comillas

para atributos numéricos, en XML deben usarse siempre.• Los elementos anidados deben cerrarse antes que el elemento contenedor.

Estas estrictas reglas permiten que XML tenga una importante capacidad que HTML no tiene: en XML pue-de definir sus propias etiquetas y puede asignar a estas etiquetas el significado que prefiera.

Cuando cree un nuevo archivo XML es una buena idea escribir primero las etiquetas y estructura que usará alo largo del documento. Esto le ahorra el problema de intentar reetiquetar elementos si descubre que ha olvidadoalgo. Por ejemplo, el siguiente XML describe datos de un libro de cocina que usaremos como ejemplo durante estalección:

<cookbook>

<title></title><subtitle></subtitle><description></description>




259

<recipe><title></title><subtitle></subtitle><description></description><servings></servings><ingredients>

<ingredient><name></name><quantity></quantity>

</ingredient><ingredient>

<name></name><quantity></quantity>

</ingredient></ingredients><instructions>

<introduction></introduction><step></step><step></step><step></step><summary></summary>

</instructions></recipe>

</cookbook>

Los datos para cada uno de estos elementosirán entre cada una de las etiquetas de comienzo yde fin. Los que es importante observar en este punto es la estructura del archivo y que los nombres de elemento describen el contenido del ele-mento y no su formato. Etiquetando el contenido puede aplicar formato basado en contenido usandoXSL.

La estructura XML es estrictamente jerár-quica. XML se refiere a los elementos en esta jerarquía como nodos. Los nodos tienen relacio-

nes padre-hijo que se identifican usando el lenguaje de rutas XML (XPath), como muestra la figura13.1.ç

XML está bien adaptado para datos estructurados como datos de bolsa, información de empleados, inventariode productos, estado de pedidos y otros datos que estamos acostumbrados a tratar de forma ordenada. XML no está bien adaptado para información que usa organización creativa o a la medida.

13.2.3 Crear un archivo XSLEl archivo XSL proporciona el diseño y la lógica que transforma los datos almacenados en un archivo XML

en la salida que se ve en un formulario Web. Para crear un archivo XSL en Visual Studio seleccione Agregar nuevoelemento en el menú Proyecto, elija Archivo XSLT en la lista de plantillas y pulse Abrir.

El archivo XSL contiene sentencias de plantilla que seleccionan los elementos a importar del archivo XML.

Cada plantilla incluye elementos HTML estándar para aplicar formato a los elementos importados del archivo XML.Por ejemplo, la siguiente plantilla XSL convierte los elementos title, subtitle e introduction del libro de cocina de unarchivo XML a elementos h1, h2 y p de HTML.

<?xml version="1.0" encoding="UTF-8" ?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/cookbook"><xsl:apply-templates select="cookbook" /><h1><xsl:value-of select="title" /></h1><h3><xsl:value-of select="subtitle" /></h3><hr /><p><xsl:value-of select="introduction" /></p><hr /><h2><xsl:text>Recipes</xsl:text></h2><xsl:apply-templates select="recipe" />

</xsl:template></xsl:stylesheet>

El ejemplo anterior usa los elementos y atributos XML que se resumen en la tabla 13.2.

Fig.13. 1: Nodos XML



MCAD/MCSD

260

Tabla 13. 2: Elementos XSL básicosElemento Atributos Se usa para

xsl:stylesheet version Identificar la versión de XSL que se está usando. La versión en uso en el momento de escribir eltexto original era la 1.0

xmlns:xsl Especificar los prefijos para elementos en el archivo XSLxsl:template match Definir una plantilla para un nodo XMLxsl:apply-templates select Aplicar una plantilla al nodo seleccionadoxsl:value-of select Recuperar el valor de un nodo XML o evaluar una expresión XPathxsl:text Incluir texto o caracteres de espacio en blanco literalmente en la salida.

Los elementos XSL mostrados realizan las tareas mínimas para mostrar datos con XSL: definen una plantilla,importan datos a la plantilla, muestran valores desde XML e insertan texto literal. Todas estas son tareas que serealizan más fácilmente usando HTML ordinario y hojas de estilo, pero el uso de XSL tiene dos ventajas:

• Puede cambiar la posición del elemento (diseño de página) en el archivo XSL sin tener que cambiar los da-tos.

• Puede realizar tareas lógicas sobre los datos, como bucles y procesamiento condicional.

Las siguientes secciones discuten estas ventajas.

13.2.4 Cambiar el diseñoEl diseño de página se cambia en XSL moviendo elementos en el archivo XSL. Por ejemplo, el siguiente

XSL muestra el XML del libro de cocina en un formato de dos columnas y muestra el subtítulo antes del título:

<?xml version="1.0" encoding="UTF-8" ?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:template match="/cookbook">

<xsl:apply-templates select="cookbook" /><table>

<tr><td width="300">

<h3><xsl:value-of select="subtitle" /><xsl:text>...</xsl:text></h3><h1><xsl:value-of select="title" /></h1>

</td><td width="500">

<xsl:text>recipe text goes here..</xsl:text></td>

</tr>

<tr><td width="300">

<hr /><xsl:value-of select="introduction" /><hr />

</td><td width="500"></td>

</tr></table>

</xsl:template></xsl:stylesheet>

13.2.5 Incluir otras plantillas

Un archivo XSL puede contener muchas plantillas. Se define una plantilla XSL para cada nodo XML quetiene un formato único. Por ejemplo, el libro de cocina XML mostrado anteriormente en esta lección se podría orga-nizar en cuatro plantillas:

• La plantilla principal da formato al título y descripción del libro y proporciona un punto de inicio. La ejecu-ción de XSL comienza con esta plantilla porque selecciona el nodo raíz (match=”/cookbook”)

• La plantilla de receta (recipe) da formato a las recetas incluidas en el libro.• La plantilla de ingredientes (ingredients) da formato a la lista de ingredientes• La plantilla de instrucciones (instructions) da formato a los pasos que sigue a la lista de ingredientes

Use el elemento xsl:apply-templates para aplicar una plantilla a un nodo. Por ejemplo, el siguiente XSL apli-ca las plantillas de ingredientes e instrucciones a partir de la plantilla de recetas, que a su vez se aplica desde la plan-tilla principal. Los enlaces entre plantillas se muestran en negrita:





261

<xsl:template match="/cookbook"><xsl:apply-templates select="cookbook" />

<h1><xsl:value-of select="title" /></h1><h3><xsl:text>...</xsl:text><xsl:value-of select="subtitle" /></h3><hr /><p><xsl:value-of select="introduction" /></p><hr />

<xsl:apply-templates select="recipe" />

</xsl:template>

<xsl:template match="recipe"><h3><xsl:value-of select="title" /></h3><p><xsl:value-of select="description" /></p><p><b><xsl:text>Serves: </xsl:text></b><i><xsl:value-of select="servings" /></i></p><xsl:apply-templates select="ingredients" />

<xsl:apply-templates select="instructions" />

</xsl:template>

<xsl:template match="ingredients"><ul>

<li><xsl:value-of select="ingredient/name" /><xsl:text> </xsl:text><b><xsl:value-of select="ingredient/quantity" /></b></li>

</ul></xsl:template>

<xsl:template match="instructions"><p><xsl:value-of select="introduction" /></p><ol>

<li><xsl:value-of select="step" /></li></ol><p><xsl:value-of select="summary" /></p>

</xsl:template>

</xsl:stylesheet>

Pero de esta forma solo se muestra un ingrediente y una instrucción. Tal como están escritas las plantillas procesan un solo nodo cada una. Para repetir tareas necesita usar los elementos de bucle de XML, tal como indica lasiguiente sección.

13.2.6 Repetir tareasPara dar formato a elemento repetitivos en un archivo XML, como elementos de lista o de tabla, use el ele-

mento XSL xsl:for-each. Este elemento selecciona el nodo repetido y aplica el XSL que contiene a cada una de susapariciones, como se muestra a continuación:

<xsl:for-each select="ingredient"><xsl:value-of select="name" /><br />

</xsl:for-each>

El XSL anterior incluye en la salida el nombre de cada nodo de ingrediente repetido. Para hacer referencia al propio nodo repetido use el identificador <;&QD>.<;&QD > de XPath. Por ejemplo, el siguiente XSL incluye en lasalida el texto de todos los nodos de paso repetidos en el XML:

<xsl:for-each select="step"><xsl:value-of select="." /><br />

</xsl:for-each>

El siguiente XSL usa el elemento xsl:for-each (en negrita) para mostrar todas las recetas, ingredientes y pa-sos en el libro de cocina:


<xsl:template match="/cookbook"><xsl:apply-templates select="cookbook" />

<h1><xsl:value-of select="title" /></h1><h3><xsl:text>...</xsl:text><xsl:value-of select="subtitle" /></h3><hr /><p><xsl:value-of select="introduction" /></p>

<hr />

MCAD/MCSD

262

<xsl:for-each select="recipe"><xsl:apply-templates select="." />

</xsl:for-each>

</xsl:template>

<xsl:template match="recipe"><h3><xsl:value-of select="title" /></h3><p><xsl:value-of select="description" /></p><p><b><xsl:text>Serves: </xsl:text></b>

<i><xsl:value-of select="servings" /></i></p><xsl:apply-templates select="ingredients" /><xsl:apply-templates select="instructions" />

</xsl:template>

<xsl:template match="ingredients"><ul>

<xsl:for-each select="ingredient"><li><xsl:value-of select="name" />

<xsl:text> </xsl:text>

<b><xsl:value-of select="quantity" /></b></li></xsl:for-each>

</ul></xsl:template>

<xsl:template match="instructions">

<p><xsl:value-of select="introduction" /></p><ol>

<xsl:for-each select="step"><li><xsl:value-of select="." /></li>

</xsl:for-each>

</ol><p><xsl:value-of select="summary" /></p>

</xsl:template>

</xsl:stylesheet>

13.2.7 Insertar enlaces y otros elementos HTMLUse el elemento xsl:element para componer elementos HTML que contienen atributos, como enlaces, contro-

les de servidor u otros controles HTML. Por ejemplo, el siguiente XSL crea un enlace que devuelve al usuario a la

parte superior de la página:<xsl:element name="a">

<xsl:attribute name="name"><xsl:text>#top</xsl:text>

</xsl:attribute><xsl:text>Volver al inicio.</xsl:text>

</xsl:element>

En tiempo de ejecución el XSL anterior genera la siguiente salida:

<a href="#top">Volver al inicio.</a>

Puede acoplar este XSL con una función generate-id de XPath para crear automáticamente una tabla de con-tenidos para su documento que vincule con ubicaciones dentro del documento, como muestra en negrita el siguienteXSL:

<xsl:template match="/cookbook"><h1><xsl:value-of select="title" /></h1><h3><xsl:text>...</xsl:text><xsl:value-of select="subtitle" /></h3><hr /><p><xsl:value-of select="introduction" /></p><hr /><h4>Contents</h4>

<xsl:apply-templates mode="contents" select="recipe" />

<xsl:for-each select="recipe"><xsl:apply-templates select="." />

</xsl:for-each></xsl:template>

263

<xsl:template match="recipe">

<xsl:element name="a"><xsl:attribute name="name">

<xsl:value-of select="generate-id(title)" />

</xsl:attribute><h3><xsl:value-of select="title" /></h3>

</xsl:element>

<p><xsl:value-of select="description" /></p>

<p><b><xsl:text>Serves: </xsl:text></b><i><xsl:value-of select="servings" /></i></p><xsl:apply-templates select="ingredients" /><xsl:apply-templates select="instructions" />

</xsl:template>

<xsl:template mode="contents" match="recipe"><xsl:element name="a">

<xsl:attribute name="href">

<xsl:text>#</xsl:text><xsl:value-of select="generate-id(title)" />

</xsl:attribute><xsl:value-of select="title" />

</xsl:element>

<br /></xsl:template>

La función generate-id de XPath genera un identificador único para el nodo XML que se la pasa como argu-mento. El ID tiene la forma XSLTnombrenodo# , donde # es un entero de 12 dígitos.

13.2.8 Ordenar elementosUse el elemento xsl:sort para ordenar elementos dentro de otro elemento XSL. Por ejemplo, el siguiente XSL

ordena la tabla de contenidos creada en la sección anterior.

<h4>Contenido</h4><xsl:apply-templates mode="contents" select="recipe">

<xsl:sort select="title" order="ascending" /></xsl:apply-templates>

El elemento xsl:sort se puede incluir en elementos xsl:apply-templates como muestra el ejemplo anterior, oen elementos xsl:for-each.

13.2.9 Tareas condicionalesXSL incluye dos conjuntos de elementos para realizar tareas condicionales. Use xsl:if para evaluar una sola

condición, y xsl:choose conteniendo elementos xsl:when y xsl:otherwise para evaluar varias condiciones. La tabla13.3 resume los elementos condicionales:

Tabla 13. 3: Elementos XSL condicionalesElemento Atributos Se usa para

xsl:if test Probar una expresión lógica y procesar los elementos contenidos si el resultado es cierto.xsl:choose Prueba varias condiciones usando elementos xsl:when y xsl:otherwise . Es el equivalente a un Select

Case en VB.NET o switch en C#

xsl:when test Prueba una expresión lógica dentro de un elemento xsl:choose , y si el resultado es cierto procesa el

resultado y sale del elemento xsl:choose . Es el equivalente de las sentencias Case .xsl:otherwise Procesa el elemento contenido si no es cierto ninguno de los xsl:when del xsl:choose . Es equivalente a

Case Else en VB.NET o default en C#El atributo test de los elementos condicionales evalúa una expresión XPath para determinar si el XSL conte-

nido en el elemento condicional se debe procesar. Por ejemplo, el siguiente XSL crea una tabla de contenido si haymás de cuatro recetas en el libro de cocina.

<xsl:if test="count(recipe) > 4"><h4>Contenido</h4><xsl:apply-templates mode="contents" select="recipe" />

</xsl:if>

El XSL anterior utiliza la función Count para devolver el número de nodos receta en el libro de cocina. Si lacuenta es mayor de cuatro se envía a la salida el encabezado Contenido y se procesa la plantilla contents. En casocontrario se omiten los contenidos.

De forma similar puede usar funciones XPath dentro de elementos xsl:choose para cambiar la salida en basea diferentes condiciones. Por ejemplo, el siguiente XSL inserta un salto de línea tras cada cuatro elementos de con-tenido, en caso contrario los separa por un espacio en blanco:



MCAD/MCSD

264

<xsl:template mode="contents" match="recipe"><xsl:element name="a">

<xsl:attribute name="href"><xsl:text>#</xsl:text><xsl:value-of select="generate-id(title)" />

</xsl:attribute><xsl:value-of select="title" />

</xsl:element><xsl:choose>

<xsl:when test="position() mod 4 = 0"><br />

</xsl:when><xsl:otherwise>

<xsl:text> </xsl:text></xsl:otherwise>

</xsl:choose></xsl:template>

El XSL anterior usa la función position de XPath para devolver la posición del nodo actual dentro de la co-lección de nodos. También usa el operador mod de XPath para decir si la posición actual es divisible por cuatro.

Más información: Si siente que solo hemos arañado la superficie de lo que se puede hacer con XSL,tiene razón. XSL y XPath son lenguajes de pleno derecho. La lección anterior da información sufi-ciente para empezar, pero para una información completa vea la documentación del SDK de XML deMicrosoft incluida en la ayuda en línea de Visual Studio .NET. Entre los libros de Microsoft Press quetratan este tema se incluyen XML Step by Step Second Edition, por Michael J. Young y XML Pro-gramming (Core Reference) por R. Allen Wyke, Sultan Rehman y Brad Leuden.

13.3 Resumen• Los estilos siguen un orden de precedencia en base a dónde se aplican: local (aplicado en un elemento), pági-

na (aplicado dentro del elemento head de una página) y global (aplicado mediante una hoja de estilo).• Use el elemento link dentro del elemento head de un formulario Web para anexar una hoja de estilo.• Use el asistente de generación de estilos de Visual Studio .NET para modificar estilos existentes.• Use el asistente Agregar regla de estilo de Visual Studio .NET para crear un nuevo estilo.• Cree una clase estilo para aplicar el mismo formato a diferentes tipos de elementos.• Use el atributo CssStyle para aplicar una clase de estilo a un control de servidor. Use el atributo class para

aplicar una clase de estilo a un elemento HTML.• Las transformaciones XSL convierten archivos de entrada XML en HTML por medio del control de servidor

XML.• XML organiza los datos en un conjunto de nodos jerárquico.• Las plantillas XSL aplican formato a nodos dentro de un archivo XML.• Use el elemento xsl:value-of para recuperar datos desde un nodo XML.• Use el elemento xsl:text para incluir texto literal y caracteres de espacio en blanco en la salida XSL.• Use el elemento xsl:for-each para repetir tareas para listas, tablas y otros nodos repetidos dentro de un archi-

vo XML.• Use los elementos xsl:if , xsl:choose, xsl:when y xsl:otherwise para realizar procesamiento condicional dentro

de XSL.

13.4 Lab: Crear el libro de recetasEn este laboratorio va a crear un único formulario Web que usa una hoja de estilos modificada, proporcionauna hoja de estilo con tipos ampliados para usuarios con problemas visuales y usa XML con transformaciones XSL para dar formato a la información. También se le sugerirá que aplique sus conocimientos de XML a datos del mundoreal con los que ya esté familiarizado.

13.4.1 Ejercicio 1: Crear y anexar una hoja de estiloUse los conocimientos adquiridos en la lección 1 para crear su propia hoja de estilo basada en la predetermi-

nada que crea Visual Studio .NET. Como el estilo (y el gusto) son temas personales, puede hacer los cambios suge-ridos en los siguientes pasos o desarrollar su propio aspecto único.

1. Haga los siguientes cambios, o lo que prefiera, en la hoja de estilo predeterminada (Styles.css):• Cambie la fuente predeterminada en todos los encabezados a Comic Sans MS.•

Cambie la fuente predeterminada para el texto a Lucida Sans-Serif.• Añada una imagen de fondo a la página desde la hoja de estilo.• Cambie el color de los encabezados y líneas de separación (HR) para que contrasten con el fondo.




265

2. Cuando termine de modificar la hoja de estilo anéxela a un formulario Web añadiendo el correspondienteelemento link en el elemento head .

3. Añada texto y encabezados al formulario para probar la apariencia del formulario Web.4. Vea el formulario Web en el navegador y ajuste la hoja de estilo hasta que esté a gusto con el aspecto del

formulario web.

13.4.2 Ejercicio 2: Proporcionar hojas de estilo alternativasEn este ejercicio va a crear una hoja de estilo alternativa que muestra los encabezados y texto con una fuente

alternativa de mayor tamaño para que el formulario Web sea legible para usuarios con problemas visuales. Tambiénagregará un control de cliente que permita al usuario cambiar a esta hoja de estilo en tiempo de ejecución.

1. Añada una nueva hoja de estilo vacía al proyecto. Llámela BigType.css.2. Corte y pegue los contenidos de la hoja de estilos predeterminada (Styles.css) a BigType.css. Si está usando

Visual C#, tendrá que coger la hoja de estilo desde un proyecto Visual Basic .NET y añadirla a su proyectoVisual C#.

3. En BigType.css, cambie el tamaño de fuente del elemento body a large.4. En el formulario Web creado en el ejercicio 1 añada un atributo ID y un atributo media al elemento link que

enlaza la hoja de estilos predeterminadas, con los valores ScreenStyle y screen respectivamente.5. Añada otro elemento link para usar la hoja de estilo predeterminada para impresión, con ID=PrintStyle y me-

dia=print .6. En el formulario Web creado en el ejercicio 1 añada un enlace con un suceso onclick para cambiar entre la

hoja de estilo predeterminada y BigType.css:<a onclick="SwitchSheets()" href="#">Pulse aquí </a> para cambiar entre laversión estándar y con tipos grandes.

7. Añada la siguiente secuencia de comandos de cliente para cambiar entre hojas de estilo.VBScript<script language="vbscript"> ' Cambia entre hojas de estilo.Sub SwitchSheets()

If document.all("ScreenStyle").GetAttribute("HREF", 0) = "Styles.css" thendocument.all("ScreenStyle").SetAttribute "HREF", "BigType.css", 0

elsedocument.all("ScreenStyle").SetAttribute "HREF", "Styles.css", 0

end ifEnd Sub</script>

JScript<script id="clientEventHandlersJS" language="jscript">function SwitchSheets(){

// Cambia entre hojas de estilo.if (document.all["ScreenStyle"].getAttribute("HREF") == "Styles.css")

document.all["ScreenStyle"].setAttribute ("HREF", "BigType.css", 0);else

document.all["ScreenStyle"].setAttribute ("HREF", "Styles.css", 0);}</script>

8. Muestre el formulario Web en el navegador y pruebe el cambio entre hojas de estilo. Ajuste BigType.css paralograr el mejor aspecto.

13.4.3 Ejercicio 3: Transformación XSLEn este ejercicio va a añadir al formulario Web creado en el ejercicio 1 un control XML de servidor. Confi-gurará las propiedades DocumentSource y TransformSource del documento con los archivos XML y XSL utilizadosen la lección 2, que se incluyen en los ejemplos que acompañan al libro.

1. En el formulario de los ejercicios anteriores, borre el texto de ejemplo usado para probar las hojas de estilo.Mantenga el enlace y la secuencia de comandos añadidos en el ejercicio 2.

2. Añada un control de servidor tras el enlace:<asp:Xml id="XmlTransform" runat="server" DocumentSource="" TransformSource="" />

3. Copie los archivos de ejemplo cook.xml y cook.xsl al directorio del proyecto.4. Configure la propiedad DocumentSource del control XML como cook.xml y la propiedad TransformSource

como cook.xsl.5. Muestre el formulario Web en el navegador para confirmar que las transformaciones XML funcionan correc-

tamente.



MCAD/MCSD

266

13.4.4 Ejercicio 4: Por si mismoPiense formas de aplicar XML con transformaciones XSL a los datos que presenta actualmente en la Web

con HTML. Usar XML para etiquetar contiendo es una tarea mucho más conceptual que usar HTML directamente para dar formato al contenido, y cuesta acostumbrarse. Tal vez la mejor forma de aprender es intentarlo por si mis-mo, usando datos del mundo real con los que está familiarizado, tal como se describe en los siguientes pasos.

1. Elija un proyecto sencillo, como un formulario de pedido o una lista de direcciones y cree un archivo XMLsencillo basado en los datos.

2. Cree un archivo XSL que contenga plantillas para transformar el archivo XML en HTML.3. Cree un formulario Web que use un control XML para realizar la transformación.4. Durante este trabajo, piense sobre las siguientes cuestiones:

• ¿Cómo se determina la jerarquía de nodos?• ¿Cuáles son las ventajas de crear colecciones dentro de la jerarquía? Por ejemplo:

<elementos><elemento>Elemento 1</elemento><elemento>Elemento 2</elemento>

</elementos>

• ¿Cómo se aprovechan sus capacidades de programación de base de datos y orientada a objetos al escribir XML?

13.5 Repaso


1. ¿Cuál es la ventaja de usar CSS en lugar de estilos en línea para dar formato a una aplicación Web?

2. ¿Por qué crearía un estilo para una clase en lugar de para un elemento HTML?

3. ¿Cómo se relacionan entre sí CSS y XSL cuando se trata de dar a una aplicación Web?

4. ¿Cuáles son las diferencias entre HTML y XML?




267

14 Proporcionar ayudaEn este capítulo aprenderá sobre las diferentes formas en que puede mostrar ayuda al usuario en una aplica-

ción Web. Aprenderá cómo usar HTML Help Workshop para crear archivos de ayuda compilados, y cómo mostrar estos archivos desde una aplicación Web de forma interactiva.

Antes de comenzar este capítulo debe estar familiarizado con HTML y la creación de formularios web enmodo HTML.

14.1 Añadir ayuda a aplicaciones WebLas aplicaciones Web pueden mostrar ayuda de varias formas: como etiquetas de controles, como formula-

rios Web o páginas HTML o como archivos de ayuda HTML compilados. En esta lección aprenderá a usar estasdiferentes técnicas en sus formularios Web.

14.1.1 Etiquetas de ayuda (ToolTip)Un ToolTip es un mensaje breve y descriptivo que se muestra cuando un usuario coloca el puntero del ratón

sobre un control y lo deja allí un par de segundos. Estos mensajes se usan en aplicaciones Windows para proporcio-nar información útil sobre botones de barra de herramientas y otros controles gráficos cuyo significado de otra for-ma puede no ser evidente. En cierto sentido, las etiquetas de ayuda son subtítulos para quienes no entienden losiconos.

La mayor parte de los controles de servidor tienen una propiedad ToolTip en la que se puede establecer elmensaje que quiere que se muestre. En tiempo de ejecución ASP.NET genera la propiedad ToolTip como atributode título del control, que Internet Explorer muestra como etiqueta de ayuda. Solo Internet Explorer muestra los atributos de título como etiqueta de ayuda.

Los controles HTML no incluyen una propiedad ToolTip. En su lugar puede usar directamente el atributo ti-tle. El siguiente HTML muestra la diferencia entre configurar la etiqueta de ayuda para un control de servidor y paraun control HTML:

<asp:Button id="butOK" runat="server" Text="Aceptar"ToolTip="Enviar el pedido."></asp:Button>

<INPUT type="reset" value="Cancelar" title="Cancelar el pedido.">

No todos los controles tienen una propiedad ToolTip o title. En concreto, los controles de servidor Drop-DownList y ListBox no tienen ninguno de los dos.

14.1.2 Mostrar ayuda como formulario Web o HTMLProbablemente la forma más sencilla de mostrar contenido de ayuda sea crearlo como formulario Web o pá-

gina HTML. Los archivos de ayuda pueden residir en la misma carpeta de proyecto que la aplicación Web o en unacarpeta subordinada.

Para mostrar la ayuda en el navegador se usan enlaces u otros controles, igual que con cualquier otra página,con una diferencia importante: normalmente querrá mostrar la ayuda en una ventana separada, o en un marco distin-to al resto de la aplicación Web.

Al mostrar la ayuda en una ventana de navegador diferentes se conserva la posición del usuario en la aplica-ción Web y se permite que compare la información de ayuda con la tarea que está realizando.

Para mostrar ayuda en una ventana diferente use el método open del objeto window de cliente, como muestrael siguiente enlace:

<a href="#" onclick="window.open('topic1.aspx', 'helpwin').focus()">Pulse aquí para ayuda.</a>

El HTML anterior usa el suceso onclick para mostrar un tema de ayuda en una nueva ventana de navegador sobre la ventana de la aplicación Web. Al dar al atributo href el valor # sencillamente se enlaza con la ubicaciónactual en la aplicación Web, en lugar de redirigir al usuario a una nueva. El primer argumento del método open especifica el tema de ayuda que se va a mostrar; el segundo da nombre a la nueva ventana, de forma que los siguien-tes temas de ayuda se dirijan a esta misma. Finalmente, el método focus asegura que la ventana de ayuda se muestraencima de la aplicación Web.

Otros enlaces de ayuda en la aplicación web pueden usar la misma secuencia de comandos onclick para mos-trar temas diferentes en la misma ventana. Si su aplicación incluye más de un enlace de ayuda por formulario Webes buena idea poner la secuencia de comandos en un procedimiento y llamarla desde es procedimiento onclick , como

aquí:



MCAD/MCSD

268

VBScript<HTML>

<HEAD><title>WebForm1</title><script language="vbscript">

' Muestra un formulario Web o página HTML en una pequeña ventana de' navegador y pasa el foco a esta ventana.Sub ShowHelp(topicName)

Dim HelpWindow

' Muestra el tema en una ventana con nombre.Set HelpWindow = window.open(topicName, "helpwin", "left=600, height=300,

width=200")' Muestra la ventana encima.HelpWindow.focus

End Sub</script>

</HEAD><body>

<h2>Muestra ayuda en una nueva ventana </h2><A onclick="ShowHelp('topic1.aspx')" href="#">Pulse para ayuda.</A><BR><A onclick="ShowHelp('topic2.aspx')" href="#">Pulse para más ayuda.</A>

</body></HTML>

JScript<HTML>

<HEAD><script language="jscript">

// Muestra un formulario Web o página HTML en una pequeña ventana de// navegador y pasa el foco a esta ventana.function ShowHelp(topicName){

var HelpWindow;// Muestra el tema en una ventana con nombre.HelpWindow = window.open(topicName, "helpwin", "left=600, height=300,

width=200");// Muestra la ventana encima.HelpWindow.focus();

}

</script></HEAD><body>

<h2>Muestra ayuda en una nueva ventana </h2><A onclick="ShowHelp('topic1.aspx')" href="#">Pulse para ayuda.</A><BR><A onclick="ShowHelp('topic2.aspx')" href="#">Pulse para más ayuda.</A>

</body></HTML>

Dentro del tema de ayuda puede usar puede usar el método close del objeto window para incluir un enlaceque cierre la ventana de ayuda:

<a href="#" onclick="window.close()">Pulse para cerrar la ayuda.</a>

Hay otras formas de mostrar ayuda en una ventana con nombre, como usar el atributo target de un enlace.Sin embargo, estas técnicas hace más difícil asegurar que la ventana de ayuda se muestra por encima de la ventanade la aplicación.

14.1.3 Mostrar ayuda HTMLPuede usar el método showHelp del objeto window para mostrar archivos de ayuda HTML, archivos HTML

ordinarios o formularios Web usando el visor de ayuda HTML (hh.exe). Un archivo de ayuda consiste en archivosde tema escritos en HTML que se han compilado en un único archivo comprimido que proporciona característicasadicionales.

El método showHelp muestra temas de ayuda en el visor de ayuda HTML, que de forma predeterminada semuestra sobre la ventana del navegador .

Para mostrar un formulario Web o página HTML usando showHelp especifique el nombre de archivo como primer argumento del método:

<a href="#" onclick="window.showHelp('Topic1.aspx')">Ayuda</a>

El HTML anterior muestra el formulario Web Topic1.aspx cuando el usuario pulsa el enlace. Este archivo noes un archivo de ayuda compilado – es sencillamente un tema de ayuda escrito usando ASP.NET. El uso de show-




269

Help le da la ventaja de que la ventana siempre está por encima de la aplicación Web – incluso aunque la aplicacióntenga el foco.

El método showHelp también puede mostrar temas de archivos de ayuda compilados. Estos archivos se componen de páginas HTML que se compilan en un único archivo (.chm) usando HTML Help Workshop. Cuando setrabaja con archivos de ayuda compilados showHelp identifica el tema usando un ID de contexto que se hace corresponder con un nombre de archivo de tema durante la compilación.

Para mostrar un tema de ayuda de un archivo de ayuda compilado especifique el nombre de archivo y el del

tema como primer argumento de showHelp:<a href="#" onclick="window.showHelp('c:\\Help\\HelpSample.chm')">Ayuda</a><br>

El HTML anterior muestra el archivo compilado llamado HelpSample.chm. Observe que el archivo de ayudacompilado se debe descargar y almacenar en la máquina del usuario. El uso de archivos de ayuda compilados tienelas siguientes ventajas sobre los formularios Web o páginas HTML en archivos separados:

• Tamaño reducido. La compilación comprime los temas de forma que su tamaño total es mucho menor queel total de los orígenes de ayuda individuales.

• Contenido, índice y búsqueda. HTML Help Workshop incluye herramientas para crear estas característicasy añadirlas a su sistema de ayuda.

• Presentación incrustada. El control ActiveX HTML y el applet Java permiten mostrar la ayuda dentro de laventana de navegador en lugar de en una ventana separada.

• Facilidad de localización. Como la ayuda HTML hace corresponder los nombres de archivo de tema conidentificadores de contexto es posible tener varios archivos de ayuda compilados escritos en diferentes idio-mas que usen los mismos identificadores de contexto.

La compilación de ayuda HTML tiene algunas limitaciones de las que debe estar avisado:

• Los archivos fuente deben estar en formato HTML. Los formularios Web no se pueden compilar en ar-chivos .chm.

• El archivo compilado se debe descargar completo en la máquina del usuario. Si el archivo de ayuda esmuy grande y los usuarios están conectados mediante módem puede tomar mucho tiempo cargar la ayuda la primera vez. Una vez descargado el archivo de ayuda el acceso es muy rápido.

Las siguientes lecciones tratan con más detalle la creación de archivos de ayuda compilados y su uso desdeaplicaciones Web.

14.2 HTML Help WorkshopMicrosoft Visual Studio .NET incluye HTML Help Workshop, que se instala en una ubicación separada en la

máquina del desarrollador. En esta lección aprenderá cómo usar HTML Help Workshop para crear un archivo deayuda compilado que incluya una tabla de contenidos, índice y capacidades de búsqueda de texto completas.

14.2.1 Crear ayuda HTMLUn archivo de ayuda HTML se compone de páginas HTML individuales, cada una de las cuales representa

un único tema. Cada tema de ayuda puede incluir palabras clave que se incluyen en el índice y referencias cruzadascon otros temas. Los proyectos de ayuda HTML incluyen los tipos de archivo que describe la tabla 14.1:

Tabla 14. 1: Archivos de proyecto de ayuda HTML Archivo Extensión Se usa para

Tema de ayuda htm Crear contenido que se mostrará en la ayuda.Proyecto hhp Definir cómo se compila el proyecto y qué archivos de tema de ayuda, contenido e índice incluye.Contenido hhc Crear una tabla de contenidos para el archivo de ayuda.Índice hhk Crea un índice para el archivo de ayudaLista de detenciónde búsqueda

stp Excluir palabras concretas de las búsquedas

Compilado chm Distribuye la ayuda terminada.

HTML Help Workshop proporciona herramientas para organizar, editar y compilar estos archivos. De forma predeterminada. Visual Studio .NET instala HTML Help Workshop en Archivos de Programa\HTML Help Works-hop.

Para crear un nuevo proyecto de ayuda HTML siga estos pasos:

1. Desde el menú File de HTML Help Workshop seleccione New. HTML Help Workshop inicia el asistente

New Project.2. El asistente permite convertir un proyecto WinHelp existente o crear un nuevo proyecto. Pulse Next para

crear un nuevo proyecto. El asistente muestra la página Destination.



MCAD/MCSD

270

3. Escriba la ubicación y nombre del archivo de proyecto que quiere crear y pulse Next. El asistente muestra la página Existing Files

4. Seleccione las cajas correspondientes a los archivos de contenido, índice o tema que ya haya creado y pulsesiguiente. Si selecciona alguno de estos archivos existentes el asistente le pide la localización de cada uno delos tipos de archivos seleccionado. En caso contrario crea un nuevo archivo de proyecto vacío.

El uso de HTML Help Workshop es asombrosamente sencillo. Se usan las lengüetas Project, Contents e In-dex del panel izquierdo para editar los contenidos de los archivos de proyecto, contenidos e índice. Los botones e la

parte superior del panel crean nuevos archivos, abren archivos existentes, compilan el proyecto, muestran el proyec-to compilado y muestran la ayuda de HTML Workshop.

Para añadir archivos de tema al proyecto de ayuda:

1. Pulse New en la parte superior de la ventana, seleccione HTML File y especifique un título para el tema. ElWorkshop creará un nuevo archivo de tema de ayuda.

2. Guarde el archivo HTML y pulse Add/Remove Topic Files en el lado izquierdo de la lengüeta Project. Seabre el diálogo Topic Files.

3. Pulse Add y seleccione los archivos para añadir al proyecto. Pulse OK.4. Pulse OK de nuevo para cerrar el diálogo Topic Files. El Workshop añade el archivo al proyecto.

HTML Help Workshop proporciona solo capacidades básicas de edición de texto. Por lo general se crearánlos archivos de tema de ayuda en un editor HTML completo y se usará el Workshop para crear el archivo de proyec-to y compilar la ayuda.

14.2.2 Opciones de proyectoLas opciones de proyecto de ayuda se muestran en la lengüeta Project de HTML Help Workshop. Estas op-

ciones se guardan en el archivo de proyecto de ayuda (.hpp) en texto plano y se pueden modificar usando HTMLHelp Workshop o un editor de texto como el Block de notas.

Para establecer las opciones de proyecto en HTML Help Workshop, en la lengüeta Project pulse Change Pro- ject Options. El Workshop muestra el diálogo Project Options.

Las opciones de proyecto permiten especificar un título para el proyecto de ayuda, información de interna-cionalización, cómo se crean los archivos de contenido e índice, si se soporta búsqueda y otras características. Estoselementos se encuentran en la sección Options del archivo de proyecto. Por ejemplo, las siguientes opciones de proyecto crean automáticamente archivos de índice y de contenido cuando se compila un archivo de ayuda llamadoHelpSample.chm, que muestra el título HTML Help Sample:

[OPTIONS]Auto Index=YesAuto TOC=9Compatibility=1.1 or laterCompiled file=HelpSample.chmContents file= Contents.hhcDefault topic=topic1.htmDisplay compile progress=NoFull text search stop list file=Search.stpIndex file=Index.hhkLanguage=0x409 English (United States)Title=HTML Help Sample

El archivo de proyecto también incluye una sección FILES que indica los archivos de temas de ayuda a com-

pilar. El orden de los archivos en esta sección determina el orden de elementos en el archivo de contenido cuando seselecciona tabla de contenidos automática (Auto TOC) en la sección OPTIONS. Por ejemplo, los siguientes archivosde tema aparecen en orden secuencial en Contents:

[FILES]topic1.htmtopic1a.htmtopic1b.htmtopic2.htmtopic3.htm

14.2.3 Tablas de contenidoCuando se genera una tabla de contenido automáticamente HTML Help Workshop utiliza el nivel de encabe-

zado del tema y su orden en la sección FILES del archivo de proyecto para determinar cómo se organiza la tabla de

contenido.

Workshop pone los encabezados < H1> en el nivel superior, los < H2> bajo estos, y así hasta encontrar unnuevo < H1>. Si tiene varios niveles de encabezado en un mismo tema el Workshop crea elementos Contents subor-

271

dinados para cada uno de estos encabezados – incluso aunque representen un mismo tema de ayuda. Por este motivoes mejor usar un único elemento de encabezado HTML por tema de ayuda cuando se generan los contenidos auto-máticamente.

El Workshop guarda la tabla de contenidos generada en un archivo HTML. Puede generar una tabla de con-tenidos automática, desactivar Auto TOC en el archivo de proyecto y después editar el archivo generado para perso-nalizar la tabla de contenidos. Para editar la tabla de contenidos pulse la lengüeta Contents en HTML Help Works-hop.

Puede que haya observado que en la tabla de contenidos automática los iconos para los temas de nivel supe-rior no son coherentes. Algunos muestran un libro y otros una página. Para cambiar el icono que muestra un tema:

1. Seleccione el tema de contenido, pulse Edit Selection y la lengüeta Advanced. El Workshop muestra el diá-logo Table of Contents Entry

2. Seleccione la imagen que quiere usar en la caja de lista Image Index y pulse OK.

El archivo de contenido se guarda como HTML con elementos OBJECT para especificar los elementos decontenido:

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN"><HTML>

<HEAD><meta name="GENERATOR" content="Microsoft® HTML Help Workshop 4.1">

</HEAD><BODY>

<UL><LI>

<OBJECT type="text/sitemap"><param name="Name" value="Topic1"><param name="Local" value="topic1.htm">

</OBJECT><UL>

<LI><OBJECT type="text/sitemap">

<param name="Name" value="Topic 1.a"><param name="Local" value="topic1a.htm">

</OBJECT>

<UL><LI><OBJECT type="text/sitemap">

<param name="Name" value="Topic 1.a.i"><param name="Local" value="topic1ai.htm">

</OBJECT><LI>

<OBJECT type="text/sitemap"><param name="Name" value="Topic 1.a.ii"><param name="Local" value="topic1aii.htm">

</OBJECT></UL><LI>

<OBJECT type="text/sitemap"><param name="Name" value="Topic 1.b">

<param name="Local" value="topic1b.htm"><param name="ImageNumber" value="1">

</OBJECT></UL><LI>

<OBJECT type="text/sitemap"><param name="Name" value="Topic 2"><param name="Local" value="topic2.htm">

</OBJECT><UL>


<param name="Name" value=""><param name="Local" value="topic2.htm">

</OBJECT>

MCAD/MCSD

272


<param name="Name" value="Topic 2.a"><param name="Local" value="topic2a.htm">

</OBJECT><LI>

<OBJECT type="text/sitemap"><param name="Name" value="Topic 2.b"><param name="Local" value="topic2b.htm">

</OBJECT></UL><LI>

<OBJECT type="text/sitemap"><param name="Name" value="Topic 3"><param name="Local" value="topic3.htm"><param name="ImageNumber" value="1">

</OBJECT></UL>

</BODY></HTML>

Los elementos de lista HTML determinan la jerarquía de los elementos en la tabla de contenidos. Los ele-mentos objeto determinan el título, icono, ubicación y otra información sobre el enlace. Por ejemplo, el siguienteelemento de contenido enlaza con una página New Products y abre la página en una nueva ventana:

<OBJECT type="text/sitemap"><param name="Name" value="New Products"><param name="Local" value="http://www.mycompany.com/newproducts.htm"><param name="WindowName" value="NewWindow"><param name="Comment" value="Sample of text/sitemap params"><param name="New" value="1"><param name="ImageNumber" value="7">

</OBJECT>

14.2.4 ÍndiceHTML Help Workshop puede crear un archivo de índice a partir de elementos objeto introducidos en los ar-

chivos de tema. Dentro de un archivo de tema se crea una entrada de índice como objeto ActiveX con un classID concreto:

<Object type="application/x-oleobject"classid="clsid:1e2a7bd0-dab9-11d0-b93a-00c04fc99f9e">

<param name="Keyword" value="Index Item 1"><param name="Keyword" value="Index Item 1, Subitem a"><param name="Keyword" value="Index Item 1, Subitem b">

</OBJECT>

El HTML anterior crea tres entradas de índice para este enlace al archivo de tema.

HTML Help Workshop no guarda automáticamente entradas de índice de los archivos de tema en el archivode índice; pero puede añadir entradas para ayudar a organizar o complementar las entradas automáticas. El archivode índice (.hhk) y las entradas de índice de tema se añaden juntas para crear el índice mostrado en el archivo deayuda compilado. Por ejemplo, el siguiente archivo de índice se combina con las entradas automáticas para crear uníndice:

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN"><HTML>

<HEAD><meta name="GENERATOR" content="Microsoft® HTML Help Workshop 4.1">

</HEAD><BODY>

<UL><LI>

<OBJECT type="text/sitemap"><param name="Name" value="Index Item 1"><param name="Name" value="Topic 1.b"><param name="Local" value="topic1b.htm">

</OBJECT>




273


<param name="Name" value="Index Item 2"><param name="Name" value="Topic 2.a"><param name="Local" value="topic2a.htm">

</OBJECT></UL>

</BODY></HTML>

14.2.5 Referencias cruzadasHay tres formas de hacer referencias cruzadas entre temas de ayuda:

• Usar enlaces HTML para crear un enlace desde un tema de ayuda a otro. Los enlaces permiten relaciones unoa uno.

• Usar el comando Related Topics para crear un enlace desde un tema a una lista de archivos de tema relacio-nados

• Usar enlaces asociativos ( ALink ) para crearn enlaces desde un tema a una lista de temas relacionados en basea las palabras clave en estos archivos de tema.

Como ya sabe crear enlaces (a estas alturas mejor que sepa) las siguientes secciones tratan cómo añadir temasrelacionados y cómo crear enlaces asociativos.

Temas relacionadosPuede añadir temas relacionados como referencia cruzada o enlace.

• Para añadir una referencia cruzada de temas relacionados a un tema de ayuda inserte un control ActiveXde ayuda HTML en el archivo de tema. Por ejemplo, el siguiente elemento objeto muestra un botón quelista dos temas relacionados como opciones de menú emergente:

<OBJECT id=hhctrl type="application/x-oleobject"classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11"codebase="hhctrl.ocx#Version=4,74,9273,0"width=100height=100>

<PARAM name="Command" value="Related Topics, MENU"><PARAM name="Button" value="Text:Related Topics"><PARAM name="Item1" value="Topic 2;Topic2.htm">

<PARAM name="Item2" value="Topic 3;Topic3.htm"></OBJECT>

• Para mostrar temas relacionados como enlace en lugar de cómo botones especifique un parámetro Text enlugar de un parámetro Button en el elemento objeto. Por ejemplo, el siguiente HTML muestra los temasrelacionados anteriores como enlace:

<OBJECT id= hhctrl type="application/x-oleobject"classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11"codebase="hhctrl.ocx#Version=4,74,9273,0"width=100height=100>

<PARAM name="Command" value="Related Topics, MENU"><PARAM name="Text" value="Text:Related Topics"><PARAM name="Item1" value="Topic 2;Topic2.htm">

<PARAM name="Item2" value="Topic 3;Topic3.htm"></OBJECT>

Enlaces asociativosLos enlaces asociativos hacen referencia a palabras clave en lugar de a nombres de archivo concretos. Por

este motivo son útiles para referencias cruzadas entre archivos de ayuda HTML – no es necesario saber cómo sellaman los archivos de tema dentro de un archivo compilado, solo es necesario saber qué palabras clave se usan.Los enlaces asociativos también son útiles dentro de un mismo archivo de ayuda – los nombres de archivo pue-den cambiar durante el desarrollo, y es más fácil mantener una lista de palabras clave que actualizar nombres dearchivo en referencias cruzadas.

Una referencia cruzada asociativa tiene dos partes:

• Las palabras clave introducidas en los archivos de tema de destino proporcionan los destinos con los que

enlazan las referencias.• El enlace en el archivo de tema de origen proporciona el origen desde el que enlaza la referencia cruzada.



MCAD/MCSD

274

Para crear palabras clave de enlace asociativo inserte un elemento objeto en el tema objetivo. Por ejemplo, el siguiente elemento objeto crea la palabra clave “Link1”:


<param name="ALink Name" value="Link1"></OBJECT>

Los enlaces asociativos son muy similares a las palabras claves que se usan para indexar la ayuda HTML,

pero no aparecen en el índice. El motivo es permitir que la indexación y las referencias cruzadas se mantengan por separado.

Para crear un enlace con temas que contienen una palabra clave concreta inserte un objeto ActiveX deayuda HTML en el archivo de tema que hace la referencia. Por ejemplo, el siguiente elemento objeto muestrauna lista de referencias cruzadas en un menú emergente cuando el usuario pulsa el control:


<PARAM name="Command" value="ALink, menu"><PARAM name="Button" value="Text:See Also"><PARAM name="Flags" value=",,1">

<PARAM name="Item1" value=""><PARAM name="Item2" value="Link1"></OBJECT>

Para mostrar los enlaces asociativos como enlace en lugar de como botón omita el parámetro Button en elelemento objeto y llame al suceso Click del objeto desde el enlace. Por ejemplo, el siguiente HTML muestra losenlaces cuando el usuario pulsa el enlace See Also:


<PARAM name="Command" value="ALink, menu"><PARAM name="Flags" value=",,1">

<PARAM name="Item1" value=""><PARAM name="Item2" value="Link1"></OBJECT>

<a href="#" onclick="hhctrl.Click()">See also</a>

14.2.6 BúsquedaPara permitir búsquedas de texto completas en un archivo de ayuda seleccione Compile Full-Text Search In-

formation en la lengüeta Compiler del diálogo Project Options.

Cuando se activa la búsqueda de texto HTML Help Workshop crea una tabla de concordancia de todas las palabras de los archivos de tema e incluye esta tabla en el archivo compilado. Como esta tabla hace referencia atodas las palabras de todos los archivos puede ser muy grande. Para controlar el tamaño de esta tabla puede omitir palabras que no son útiles en la búsqueda. Por ejemplo, puede omitir artículos, conjunciones, pronombres personales

y números.Para omitir palabras en una búsqueda de texto completa:

1. Cree un archivo de texto que contenga las palabras a omitir 2. Pulse Change Project Optionse en la lengüeta Project de HTML Help Workshop3. En la lengüeta Compiles del diálogo Project Options escriba el nombre del archivo de lista de palabra a omi-

tir en la caja de texto Full Text Search Stop List.

Cuando un usuario intenta buscar una palabra que está incluida en la lista de exclusión la ayuda HTMLmuestra una caja de mensaje que indica que no se puede realizar la búsqueda.

14.2.7 Compilar y previsualizar Para compilar un proyecto de ayuda HTML seleccione una de estas dos posibilidades:

• En la lengüeta Project de HTML Help Workshop pulse Save All Files And Compile• Use el compilador de ayuda HTML (hhc.exe) desde línea de comandos. Por ejemplo, el comando

hhc.exe HelpSample.hhp compila el proyecto de ayuda HelpSample.hhp.




275

Para previsualizar un proyecto de ayuda HTML compilado seleccione una de estas dos opciones.

• Pulse el botón View Compiled File en la parte superior de HTML Help Workshop y seleccione el nombredel archivo compilado.

• Pulse dos veces sobre el archivo compilado (.chm) en Windows.

Importante: No puede volver a compilar un archivo de ayuda mientras está abierto para visualiza-ción. Debe cerrar el archivo compilado antes de volver a compilar.

14.3 Enlazar ayuda HTML con formularios WebEn esta lección aprenderá cómo mostrar ayuda HTML desde un formulario Web. Esta lección amplía las téc-

nicas mostradas brevemente en la Lección 1 mostrando las diferentes formas en que se puede mostrar ayuda HTML,describiendo las diferencias entre ayuda compilada y no compilada y explicando cómo hacer que la ayuda respondaa acciones de usuario en una aplicación Web.

14.3.1 Mostrar el visor de ayuda HTMLComo se mostró en la Lección 1 la ayuda HTML se muestra en el visor de ayuda HTML usando el método

showHelp. La forma de usar showHelp depende de si la ayuda está compilada.

• La ayuda no compilada se puede mostrar usando la dirección del tema de ayuda en Internet:<a href="#" onclick="window.showHelp('Topic1.htm')">Ayuda</a>

•

La ayuda compilada se debe copiar localmente antes de que se puedan mostrar los temas usando showHelp:<a href="#" onclick="window.showHelp('c:\\Help\\HelpSample.chm')">Ayuda</a>

El visor de ayuda se muestra con un aspecto diferente según la ayuda esté no compilada. La ayuda compiladamuestra contenido, índice y búsqueda, mientras que la no compilada solo muestra el tema de ayuda solicitado.Usando ayuda compilada obtiene las características completas del sistema de ayuda HTML; sin embargo, el usuario primero debe descargar el archivo de ayuda compilada.

Para descargar un archivo de ayuda compilado a la máquina del usuario cree un enlace al archivo y propor-cione al usuario instrucciones sobre donde guardarlo. Por ejemplo, el siguiente HTML crea un enlace que descargael archivo HelpSample.chm e instruye al usuario para que lo guarde en un directorio concreto:

<a href="HelpSample.chm">Pulse aquí</a> para descargar el archivo de ayuda deejemplo y guárdelo en el directorio C:\Help de su ordenador.</p>

Cuando el usuario pulse el enlace anterior el navegador pregunta al usuario si quiere abrir o guardar el archi-vo de ayuda. Cuando el usuario guarda el archivo en el directorio indicado el método showHelp puede mostra lostemas que contiene.

14.3.2 Mostrar ayuda HTML en el navegador El método showHelp no es la única forma de mostrar archivos de ayuda compilados. También puede mostrar-

los en el navegador usando URL,s desde dentro del propio archivo de ayuda. El navegador no puede mostrar lascaracterísticas de índice, contenido o búsqueda, pero puede abrir temas del archivo compilado a través de Internet,que es algo que showHelp no puede hacer.

Para mostrar un archivo de ayuda compilado en el navegador cree un enlace usando el URL del archivo detema dentro del archivo compilado. Por ejemplo, el siguiente enlace muestra Topic1.htm en una nueva ventana delnavegador.

<a href="ms-its:http://www.mycompany.com/Help/HelpSample.chm::/topic1.htm"target="HelpWin">Ayuda</a>

El enlace anterior usa el protocolo incrustable ms-its: y la sintaxis de ruta de ayuda para mostrar un archivode tema desde dentro de un archivo compilado guardado en la Web. El protocolo ms-its: lo proporciona InternetExplorer desde la versión 4.0 en adelante. La sintaxis de ruta de ayuda HTML tiene la forma archivocompila-do::/archivotema, donde archivocompilado es el URL del archivo de ayuda compilado y archivotema es el nombreel archivo HTML del tema dentro del archivo compilado.

14.3.3 Ayuda sensible a contextoSi está mostrando ayuda compilada en el visor de ayuda puede usar identificadores de contexto para identifi-

car los temas dentro del archivo de ayuda y asociarlos con tareas de la aplicación Web. Este tipo de ayuda se deno-mina sensible a contexto como porque el tema mostrado depende del contexto (o tarea) dentro de la aplicación.

Aplicar ayuda sensible a contexto dentro de una aplicación Web presenta un par de retos:• Aunque puede capturar la tecla de ayuda (F1) mediante el suceso onkeydown y la propiedad win-

dow.event.keyCode no puede cancelar la acción predeterminada para F1 dentro de Internet Explorer, que con-siste en mostrar la ayuda de Internet Explorer.



MCAD/MCSD

276

• El argumento contextID para el método showHelp no funciona desde un formulario Web o página HTML.

Para resolver estos problemas debe elegir un mecanismo diferente a F1 para mostrar ayuda dentro de su apli-cación Web, y debe usar la sintaxis de ruta de ayuda HTML para mostrar el tema adecuado. El siguiente HTML usael suceso onfocus para mostrar diferentes temas de ayuda según el usuario se mueve entre los controles de un formu-lario Web.

VBScript<HTML>

<HEAD><title>Context Help</title><script language="vbscript">

Dim LastTopic

Sub ShowContextHelp(Topic)If (document.all("chkHelp").checked And LastTopic <> Topic) Then

' Muestra ayuda para este contexto.window.showHelp "c:\help\HelpSample.chm::/" & Topic' Guarda el nombre del temaLastTopic = Topic

End IfEnd Sub

</script></HEAD>

<body onfocus="ShowContextHelp('Topic1.htm')><form id="WebForm2" method="post" runat="server">

<H2>Ayuda sensible a contexto </H2><INPUT onfocus="ShowContextHelp('Topic2.htm')" type="text"><BR><INPUT onfocus="ShowContextHelp('Topic3.htm')" type="button" value="Button"><BR><INPUT id="chkHelp" type="checkbox" name="chkHelp">Mostrar ayuda al usuario.

</form></body>

</HTML>

JScript<HTML>

<HEAD><title>Context Help</title><script language="jscript">

var LastTopic;

function ShowContextHelp(Topic){if ((document.all("chkHelp").checked) && (LastTopic != Topic)){

// Muestra ayuda para este contexto.window.showHelp("c:\\help\\HelpSample.chm::/" + Topic);// Guarda el nombre del tema.LastTopic = Topic;

}}

</script></HEAD><body onfocus="ShowContextHelp('Topic1.htm')>

<form id="WebForm2" method="post" runat="server"><H2>Ayuda sensible a contexto </H2><INPUT onfocus="ShowContextHelp('Topic2.htm')" type="text"><BR><INPUT onfocus="ShowContextHelp('Topic3.htm')" type="button" value="Button"><BR><INPUT id="chkHelp" type="checkbox" name="chkHelp">Mostrar ayuda al usuario.

</form></body>

</HTML>

El control CheckBox permite que el usuario active la ayuda. En tiempo de ejecución el procedimiento Show-ContextHelp muestra el tema de ayuda para cada elemento de la página cuando el elemento recibe el foco.

14.4 Resumen• Puede proporcionar ayuda al usuario dentro de su aplicación Web usando etiquetas de ayuda, formularios

Web o páginas HTML o ayuda HTML.• La ayuda HTML proporciona capacidades de contenido, índice y búsqueda.




277

• Use el método showHelp del objeto window en secuencias de comandos de cliente para mostrar el visor deayuda HTML.

• Use el objeto ActiveX de ayuda HTML para añadir palabras clave de índice, enlaces con temas relacionadosy enlaces asociativos a los temas de ayuda.

• Para mostrar archivos e ayuda compilados desde una aplicación Web primero debe descargar el archivo a lamáquina del usuario.

14.5 Lab: Crear y usar un archivo de ayuda HTMLEn este laboratorio va a crear un archivo de ayuda compilado que contendrá varios temas, con tabla de conte-

nido, índice y búsqueda. Después lo enlazará con una aplicación Web.

14.5.1 Ejercicio 1: Crear un proyecto de ayudaEn este ejercicio va a usar las capacidades que aprendió en la lección 2 para crear un nuevo proyecto de

HTML Help Workshop, crear cinco temas de archivo de ayuda y añadir estos archivos al proyecto de ayuda. Paraque el ejercicio se mantenga sencillo el contenido de los archivos de tema de ayuda es mínimo, aunque puede incluir el contenido adicional que quiera.

1. Inicie HTML Help Workshop. Seleccione New en el menú File, seleccione Project en el diálogo New y sigael asistente para crear un proyecto vacío llamado HelpDemo en su ordenador.

2. Cree cinco nuevos archivos HTML llamados Topic1 a Topic5. Añada a los archivos un elemento <title> conel nombre del archivo, y un encabezado con el nivel indicado por el número del archivo (<h1> a <h5>) y el

mismo contenido.3. Añada todos estos archivos de tema al proyecto.

14.5.2 Ejercicio 2: Activar contenidos, índice y búsquedaEn este ejercicio continuará usando las capacidades que aprendió en la lección 2 para generar automática-

mente las características de contenido, índice y búsqueda cuando se compile el proyecto.

1. En la diálogo de opciones del proyecto de ayuda pulse la lengüeta Files y marque las opciones para crear au-tomáticamente un archivo de contenido e incluir las palabras clave en el índice, y escriba los nombres paralos archivos de contenido e índice.

2. Pulse la lengüeta Compiler en las opciones del proyecto y marque Compile Full-Text Search Information.Pulse Aceptar.

3. En la lengüeta Project de HTML Help Workshop pulse Save All Files and Compile. El Workshop genera el

contenido, índice e información de búsqueda, compila el archivo y muestra un informe de resultado.4. Pulse View Compiled File en la barra de herramientas de HTML Help Workshop, escriba el nombre y ubica-ción del archivo HelpDemo.chm en el diálogo View Compiled File y pulse View. El Workshop muestra elarchivo de ayuda compilado.

14.5.3 Ejercicio 3: Añadir palabras clave al índiceEn este ejercicio va a añadir palabras clave de índice a los archivos de tema de ayuda y volverá a compilar el

archivo de ayuda para crear entradas de índice automáticas.

1. En el HTML Help Workshop abra el archivo de tema Topic2.htm e inserte una nueva línea en el cuerpo.2. En el menú Edit seleccione Compiler Information. Workshop muestra el diálogo Compiler Information.3. Pulse Add y escriba “Item1” como nombre de la palabra clave de índice que va a agregar al tema y pulse

OK. Pulse Aceptar para cerrar el diálogo Compiler Information y añadir la entrada a Topic2.htm. El siguienteHTML muestra el texto generado que se ha añadido a Topic2.htm:


<param name="Keyword" value="Item1"></OBJECT>

4. Copie el fragmento anterior en cada uno de los restantes archivos de tema. Agregue o cambie los parámetrosde la palabra clave para crear palabras clave diferentes. Por ejemplo, el siguiente HTML inserta tres palabrasclave de índice en un archivo de tema:


<param name="Keyword" value="Item1"><param name="Keyword" value="new"><param name="Keyword" value="improved">

</OBJECT>5. Vuelva a compilar y ver el archivo de ayuda. Compruebe la lengüeta Índice.



MCAD/MCSD

278

14.5.4 Ejercicio 4: Enlazar ayuda con un formulario Web.En este ejercicio va a usar lo que aprendió en la lección 3 para enlazar con la ayuda compilada creada en el

ejercicio anterior desde un formulario web sencillo.

1. Cree un nuevo proyecto de aplicación web vacío llamado vbHelpDemo o csHelpDemo.2. Añada el siguiente HTML a WebForm1 para indicar al usuario cómo descargar el archivo de ayuda y propor-

cionar una forma para mostrar ayuda en el formulario Web.<p>Para usar ayuda con este formulario Web:</p>

<ol><li><a href="HelpDemo.chm">Pulse aquí</a> para descarga la ayuda.</li><li>Guarde el archivo en el directorio c:/help de su ordenador.</li><li>Después use los botones siguientes para mostrar los temas de ayuda.</li>

</ol><INPUT type="button" value="Ver ayuda"

onclick="window.showHelp('c:\\help\\HelpDemo.chm')"><br><INPUT type="button" value="Show Topic3"

onclick="window.showHelp('c:\\help\\HelpDemo.chm::/Topic3.htm)"><br><INPUT type="button" value="Show Topic5"

onclick="window.showHelp('c:\\help\\HelpDemo.chm::/Topic5.htm)">3. Copie el archivo compilado creado en el ejercicio anterior al directorio del proyecto de aplicación Web.4. Ejecute la aplicación Web. Después de descargar el archivo de ayuda, al pulsar los botones se debe mostrar

esta.



1. ¿En qué atributo del HTML mostrado por ASP.NET se convierte la propiedad ToolTip de un control de ser-vidor?

2. ¿En que se diferencia mostrar ayuda HTML usando el método showHelp del objeto window de mostrarla enuna ventana del navegador?.

3. ¿Cómo se añaden palabras clave de índice a un tema de ayuda?.




279

15 Globalizar Aplicaciones WebGlobalización es el proceso de crear una aplicación que cubre las necesidades de usuarios de diferentes cul-

turas. Este proceso implica más que la simple traducción de elementos del interface de usuario a varios lenguajes – también incluye utilizar formatos de moneda y de fecha y hora correctos, calendario, dirección de escritura, reglasde ordenación y otros aspectos. La acomodación de estas diferencias culturales en una aplicación se denomina loca-lización.

Afortunadamente, el marco de trabajo .NET facilita sustancialmente las tareas de localización haciendo quesus clases de formato, fecha/hora, ordenación y otras tengan en cuenta la cultura. Usando clases del espacio de nombres System.Globalization puede establecer la cultura actual de su aplicación y gran parte del trabajo se hace auto-máticamente.

En este capítulo aprenderá cómo detectar la cultura de un usuario y crear respuestas adecuadas, desde la redi-rección del usuario a una aplicación Web diferente localizada a manejar las diferencias culturales dentro del códigoy mostrar un interface de usuario localizado.

Antes de completar este capítulo debe estar familiarizado con HTML y con la creación de formularios Weben modo HTML.

15.1 Seleccionar un métodoAntes de comenzar el proceso de localización necesita comprender las ventajas e inconvenientes de los dife-

rentes métodos para globalizar aplicaciones Web. En esta lección aprenderá tres formas diferentes de estructurar suaplicación para globalización. Estos métodos están organizados de más sencillo a más complejo. El último de ellosse trata en más detalle en la lección 2.

15.1.1 Formas de globalizar aplicaciones WebHay varios métodos para crear aplicaciones Web que soporten varias culturas. Cada método se basa en las

herramientas de globalización que proporciona el marco de trabajo .NET. Seleccione uno de ellos o una combina-ción de varios según las necesidades de su aplicación, como describe la tabla 15.1

Tabla 15. 1: Métodos de globalizaciónMétodo Descripción Mejor para

Detectar yredirigir

Cree una aplicación Web separada para cada cultura, detecte lacultura del usuario y redirija la petición a la aplicación adecuada.

Aplicaciones con mucho contenido de textoque necesita traducción y pocos componentesejecutables.

Ajuste en tiempode ejecución

Cree una sola aplicación Web que detecte la cultura del usuario yajuste su salida en tiempo de ejecución usando especificadotesde formato y otras herramientas.

Aplicaciones sencillas con cantidad decontenido limitada.

Ensambladossatélite

Cree una sola aplicación Web que guarda cadenas dependientesde la cultura en archivos de recursos que se compilan enensamblados satélite. En tiempo de ejecución detecte la culturadel usuario y cargue las cadenas desde el ensamblado adecuado.

Aplicaciones que generan contenido entiempo de ejecución o tienen grandescomponentes ejecutables.

Los tres métodos anteriores dependen de la detección de la cultura del usuario en tiempo de ejecución y laformación de una respuesta en base a esta información. Las siguientes secciones muestran con mayor detalle cómodetectar la cultura del usuario y responder usando cada uno de estos métodos. Estas secciones también proporcionanmayor detalle sobre las ventajas relativas de cada método.

15.1.2 Detectar la cultura del usuarioEl marco de trabajo .NET proporciona componentes para soporte de varias culturas y lenguajes en el espacio

de nombres System.Globalization. Las clases CultureInfo, Calendar y de comparación que se usan a lo largo de estecapítulo son parte de este espacio de nombres. Importe o use el espacio de nombres para poder usar sus clases sinnecesidad de calificar las referencias.

ASP.NET usa la propiedad UserLanguages del objeto Request para devolver una lista de las preferencias deidioma del usuario. El primer elemento del array devuelto por esta propiedad es el lenguaje actual del usuario. Puedeusar este valor para crear una instancia de la clase CultureInfo que represente la cultura actual del usuario.

Para obtener la cultura del usuario en tiempo de ejecución siga estos pasos.

1. Obtenga la propiedad UserLanguages del objeto Request .2. Use el valor devuelto con la clase CultureInfo para crear un objeto que represente la cultura del usuario ac-

tual.

Por ejemplo, el siguiente código obtiene la cultura del usuario y muestra el nombre en inglés y el nombreabreviado en una etiqueta la primera vez que se muestra la página.



MCAD/MCSD

280


Handles MyBase.Load' Se ejecuta la primera vez que se muestra la página.If Not IsPostBack Then

Dim sLang As String' Obtiene el lenguaje preferido del usuario.sLang = Request.UserLanguages(0)' Crea un objeto CultureInfo con él.

Dim CurrentCulture As New CultureInfo(sLang)lblCulture.Text = CurrentCulture.EnglishName & ": " & CurrentCulture.Name

End IfEnd Sub


// Se ejecuta la primera vez que se muestra la páginaif (!IsPostBack) {

// Obtiene el lenguaje preferido del usuario.string sLang = Request.UserLanguages[0];// Crea un objeto CultureInfo con él.CultureInfo CurrentCulture = new CultureInfo(sLang);lblCulture.Text = CurrentCulture.EnglishName + ": " + CurrentCulture.Name;

}

}

Consejo: La propiedad Name de la clase CultureInfo y los valores del array UserLanguages usan di-ferentes esquemas de capitalización. Si compara los dos valores asegúrese de convertir la propiedad Name a minúsculas.

15.1.3 Redirigir a una aplicación específica de culturaConceptualmente, la redirección es la forma más sencilla de tratar con múltiples culturas. Cuando un usuario

solicita la página predeterminada de la aplicación se detecta la cultura y se redirige la respuesta a la aplicación Webcorrespondiente.

Este método tiene algunas ventajas además de su simplicidad conceptual:

• El contenido se mantiene separado, de modo que permite que diferentes aplicaciones presenten información

muy diferente, si es necesario.• Se puede dirigir a los usuarios automáticamente a sitios que probablemente estén geográficamente cercanos,

de forma que se puedan cubrir mejor sus necesidades.• Los archivos de contenidos (formularios Web y páginas HTML, por ejemplo) se pueden crear adecuadamen-

te en el lenguaje natural sin la complejidad de incluir cadenas de recursos.

Mantener el contenido por separado se adapta mejor a aplicaciones Web que presentan grandes cantidades decontenido que se debe traducir o cambiar de alguna otra forma. El uso de este método precisa que la parte ejecutablede la aplicación Web se compile y distribuya por separado para cada sitio Web específico de cultura. Esto exige másesfuerzo para mantener la coherencia y depuración de problemas entre sitos Web.

Redirección basada en el lenguaje principalTanto el array UserLanguages del objeto Request como la propiedad Name de la clase CultureInfo de-

vuelven información de cultura en dos partes: las dos primeras letras son código de lenguaje; las dos últimascontienen un código de región. Por ejemplo tanto inglés americano (en-US) como inglés británico (en-GB) usaninglés, pero muestran signos de moneda y orden de fecha diferentes.

Para redirigir peticiones según el lenguaje solamente:

1. Obtenga el lenguaje preferido del usuario o su CurrentCulture como se mostró anteriormente.2. Extraiga las dos primeras letras del valor devuelto.3. Compare estas letras con la lista de códigos de lenguaje.

Por ejemplo, el siguiente código detecta el lenguaje del usuario y lo redirige a uno de los diferentes sitiosespecíficos de lenguaje:




281


ByVal e As System.EventArgs) Handles MyBase.LoadDim sLang As String' Obtiene el idioma preferido del usuario.sLang = Request.UserLanguages(0)' Obtiene los dos primeros caracteres del lenguaje.sLang = sLang.Substring(0, 2)' Redirige al usuario según su cultura.

Select Case sLangCase "en" ' Sitio USA

Response.Redirect("http://www.contoso.com/usa")Case "es" ' Sitio español

Response.Redirect("http://www.contoso.com/es")Case "de" ' Sitio alemán

Response.Redirect("http://www.contoso.com/de")Case "zh" ' Sitio chino

Response.Redirect("http://www.contoso.com/zh")Case Else ' Sitio USA

Response.Redirect("http://www.contoso.com/usa")End Select

End Sub


// Obtiene el idioma preferido del usuario.string sLang = Request.UserLanguages[0];// Obtiene los dos primeros caracteres del lenguaje.sLang = sLang.Substring(0, 2);// Redirige al usuario según su cultura.switch (sLang){

case "en": // Sitio USAResponse.Redirect("http://www.contoso.com/usa"); break;

case "es": // Sitio españolResponse.Redirect("http://www.contoso.com/es"); break;

case "de": // Sitio alemán.Response.Redirect("http://www.contoso.com/de"); break;

case "zh": // Sitio chino.

Response.Redirect("http://www.contoso.com/zh"); break;default: // Sitio USA.Response.Redirect("http://www.contoso.com/usa"); break;

}}

Vea en el tema Clase CultureInfo en la ayuda de Visual Studio .NET el listado de códigos de lenguaje ycultura.

Configurar la cultura en Web.configUtilice el elemento globalization del archivo Web.config para crear una aplicación Web específica de una

cultura. El atributo cultura de este elemento determina cómo trata la aplicación Web los diferentes temas depen-dientes de la cultura, como formato de fecha, moneda y número.

Como una aplicación Web solo puede tener un archivo Web.config al establecer el atributo cultura se

hace la aplicación específica de cultura. Todas las peticiones y respuestas se manejarán usando la cultura especí-fica indicada.

Por ejemplo, la siguiente entrada en Web.config hace que todas las peticiones y respuestas de la aplica-ción se controlen utilizando Árabe (Arabia Saudi).

<globalization requestEncoding="utf-8" responseEncoding="utf-8" culture="ar-SA"/>

En tiempo de ejecución la aplicación muestra los formatos de fecha, moneda y número según indica elatributo culture del elemento globalization. Sin embargo, la página no se muestra en formato de derecha a iz-quierda como ser podría esperar para el árabe. Para mostrar la página correctamente debe establecer el atributodir del elemento body de la página: <body dir="rtl">. Puede usar este atributo individualmente en paneles,cajas de texto u otros controles.

15.1.4 Ajustar a la cultura actual en tiempo de ejecuciónDe forma predeterminada, las aplicaciones Web se ejecutan en el servidor usando una cultura neutral. Cultu-

ra neutral representa lenguajes generales, como inglés o español, en lugar de un lenguaje y región específicos.Cuando se establece el atributo culture para una aplicación Web en Web.config ASP.NET asigna esta cultura a



MCAD/MCSD

282

todas la hebras que se ejecuten para esta aplicación Web. Las hebras son la unidad básica a la que el servidor asignatiempo de procesador – ASP.NET mantiene varias hebras para una aplicación Web dentro del proceso de trabajoaspnet_wp.exe.

Al usar Web.config para configurar la cultura se crea una asociación estática entre la aplicación y una culturaconcreta. Como alternativa puede establecer la cultura dinámicamente en tiempo de ejecución usando la propiedadCurrentCulture de la clase Thread :

Visual Basic .NETImports System.GlobalizationImports System.Threading

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) _Handles MyBase.Load

Dim sLang As String' Obtiene el lenguaje preferido del usuario.sLang = Request.UserLanguages(0)' Configura la cultura de la hebra para que corresponda con la del usuario.Thread.CurrentThread.CurrentCulture = New CultureInfo(sLang)

End Sub

Visual C#using System.Globalization;using System.Threading;

private void Page_Load(object sender, System.EventArgs e){// Obtiene el idioma preferido del usuario.sLang = Request.UserLanguages[0];// Configura la cultura de la hebra para que corresponda con la del usuario.Thread.CurrentThread.CurrentCulture = new CultureInfo(sLang);

}

El código anterior detecta la cultura del usuario y configura la de la hebra actual para que corresponda.ASP.NET a partir de ahora dará formato a fechas, moneda y números usando la cultura del usuario.

• Todas las culturas comparten el mismo código de aplicación, de modo que no es necesario volver a compilar y distribuir para cada cultura.

• La aplicación reside en una única dirección Web – no necesita redirigir a los usuarios a otras aplicaciones.• El usuario puede elegir de entre una serie de culturas disponibles.

La configuración dinámica de la cultura se adapta mejor a aplicaciones Web sencillas que no contienen gran-des cantidades de texto que se debe traducir a lenguajes diferentes. Para proporcionar grandes cantidades de textotraducido en una única aplicación Web use el método descrito en la sección Ensamblados satélite más adelante.

Establecer la cultura actualEl siguiente código muestra las ventajas principales de configurar la cultura dinámicamente a nivel de

hebra. La primera vez que se carga la página el código crea una lista de todas las culturas disponibles y la guardaen una lista desplegable. Cuando el usuario selecciona una cultura de la lista el código la asigna a la hebra actualy ASP.NET muestra el formulario Web usando la cultura seleccionada:

Visual Basic .NETImports System.GlobalizationImports System.Threading


' Añade culturas a la lista la primera vez que se muestra la página.If Not IsPostBack Then' Crea un array de culturas específicas.Dim arrCultures() As CultureInfo = _

CultureInfo.GetCultures(CultureTypes.SpecificCultures)Dim item As CultureInfo' Para cada cultura específicaFor Each item In arrCultures

' Añade el nombre de la cultura como elemento en la lista.drpCulture.Items.Add(New ListItem(item.EnglishName, item.Name))' Si el elemento es la cultura actual de la hebra lo selecciona.If item.Name = Thread.CurrentThread.CurrentCulture.Name Then

drpCulture.SelectedIndex = drpCulture.Items.Count - 1End If

NextEnd If

End Sub




283

Private Sub drpCulture_SelectedIndexChanged(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles drpCulture.SelectedIndexChanged

' Cambia la cultura e la hebra actual según la selección.Thread.CurrentThread.CurrentCulture = New _

CultureInfo(drpCulture.SelectedItem.Value)' Obtiene la cultura del elemento seleccionado.Dim SelectedCulture As New CultureInfo(drpCulture.SelectedItem.Value)

End Sub

Private Sub Page_PreRender(ByVal sender As Object, _ByVal e As System.EventArgs) Handles MyBase.PreRender' Muestra el nombre nativo de la cultura en el encabezado.head1.InnerHtml = Thread.CurrentThread.CurrentCulture.NativeName' Muestra fecha, moneda y números con formato de la cultura.Label1.Text = DateTime.Now.ToString("F")Label2.Text = 1234567890.ToString("C")Label3.Text = 1234567890.ToString("N")

End Sub

Visual C#using System.Globalization;using System.Threading;

private void Page_Load(object sender, System.EventArgs e){// Añade culturas a la lista la primera vez que se muestra la página.if (!IsPostBack){

// Crea un array de culturas específicas.CultureInfo[] arrCultures =

CultureInfo.GetCultures(CultureTypes.SpecificCultures);// Para cada cultura específicaforeach (CultureInfo item in arrCultures){

// Añade el nombre e la cultura como elemento de la lista.drpCulture.Items.Add(new ListItem(item.EnglishName, item.Name));// Si el elemento es la cultura actual de la hebra lo selecciona.if (item.Name == Thread.CurrentThread.CurrentCulture.Name)

drpCulture.SelectedIndex = drpCulture.Items.Count - 1;}

}}

private void drpCulture_SelectedIndexChanged(object sender,System.EventArgs e){

// Cambia la cultura de la hebra actual según la selección.Thread.CurrentThread.CurrentCulture = new

CultureInfo(drpCulture.SelectedItem.Value);// Obtiene la cultura del elemento seleccionado.CultureInfo SelectedCulture = new

CultureInfo(drpCulture.SelectedItem.Value);}

private void Page_PreRender(object sender, System.EventArgs e){// Muestra el nombre nativo de la cultura en el encabezado.head1.InnerHtml = Thread.CurrentThread.CurrentCulture.NativeName;// Muestra fecha, moneda y número en formato de la cultura.Label1.Text = DateTime.Now.ToString("F");Label2.Text = 1234567890.ToString("C");Label3.Text = 1234567890.ToString("N");

}

El código anterior establece el encabezado y el texto de etiqueta en el suceso PreRender de forma que elcambio de cultura tenga lugar antes de que se guarde el texto en estos controles. El método ToString utiliza espe-cificadores de formato para cada cadena según la cultura actual. Para más información sobre especificadores deformato vea la ayuda en línea de Visual Studio.

Cuando el usuario selecciona una nueva cultura en la lista desplegable el encabezado, calendario, fecha,moneda y número se traducen automáticamente.

Responder a la cultura de la hebraTambién puede obtener la cultura bajo la que se está ejecutando una aplicación Web usando la propiedad

CurrentCulture de la hebra. Por ejemplo, el siguiente código muestra en un formulario Web un panel usando elformato de derecha a izquierda si la cultura actual es árabe o hebrea.



MCAD/MCSD

284


ByVal e As System.EventArgs) Handles MyBase.Load' Obtiene la cultura de la hebra actual.Dim CurrentCulture As CultureInfo = Thread.CurrentThread.CurrentCulture' Obtiene el lenguaje primario.Dim sLang As String = CurrentCulture.Name.Substring(0, 2)' Si es árabe o hebreo muestra de derecha a izquierda.If sLang = "ar" or sLang = "he" Then

panel1.Attributes.Add("dir", "rtl")End If

End Sub


// Obtiene la cultura de la hebra actual.CultureInfo CurrentCulture = Thread.CurrentThread.CurrentCulture;// Si es árabe o hebreo muestra de derecha a izquierda.string sLang = CurrentCulture.Name.Substring(0, 2);if ((sLang == "ar") ││(sLang == "he"))

Panel1.Attributes.Add("dir", "rtl");}

15.1.5 Ensamblados satéliteLas secciones anteriores han mostrad cómo manejar las diferencias culturales en una única aplicación Web,

pero se ha omitido un detalle importante: ¿cómo se maneja el contenido traducido?.

Los ensamblados satélite permiten guardar las cadenas traducidas para cada cultura en un archivo de ensamblado separado solo de recursos que se puede cargar automáticamente según la configuración de la propiedad Cu-rrentUICulture. El uso de ensamblados satélite proporciona las mismas ventajas que ajustar la cultura en tiempo deejecución, además de simplificar la presentación de contenido de varios orígenes traducidos. La siguiente leccióndescribe cómo crear y usar ensamblados satélite.

15.2 Crear y usar ensamblados satéliteLos ensamblados satélite son archivos de ensamblado (.dll) que contienen recursos localizados para una

aplicación. Cada archivo ensamblado satélite contiene los recursos para una cultura. Una aplicación puede tener varios ensamblados satélite dependiendo de cuántas culturas soporte la aplicación.

En esta lección aprenderá cómo preparar una aplicación Web para usar ensamblados satélite, cómo guardar elementos de interface localizados dentro de un ensamblado satélite y cómo cargar y mostrar elementos desde elensamblado satélite en tiempo de ejecución.

15.2.1 Cómo funcionan los ensamblados satéliteLos proyectos de aplicación Web usan ensamblados satélite para guardar cadenas traducidas, gráficos y otros

aspectos dependientes de cultura del interface de usuario de una aplicación. Para crear los propios ensamblados seusa el administrador de recursos. En tiempo de ejecución la aplicación Web carga las cadenas traducidas en el for-mulario Web en base a la propiedad CurrentUICulture de la hebra actual.

Para usar ensamblados satélite:

1. Configure los atributos id y runat para todos los elementos de interface de usuario de su aplicación que nece-

siten traducción. Los controles de servidor tienen estos atributos de forma predeterminada, pero tendrá queañadirlos a los elementos HTML si quiere cargar en ellos cadenas traducidas.

2. Cree un archivo de recursos predeterminado que contenga las cadenas predeterminadas para mostrar en el in-terface de usuario si la cultura del usuario no se especifica o reconoce. De a este archivo la extensión .resx, por ejemplo cadenas.resx

3. Cree archivos de recursos que contengan las cadenas traducidas que se mostrarán para cada lenguaje generalque soporta su aplicación Web. Coloque el código de lenguaje entre el nombre de archivo y la extensión, por ejemplo: cadenas.es.resx.

4. Opcionalmente, cree archivos de recursos que contengan las cadenas traducidas para cada cultura específicaque soporte su aplicación Web. Añada el código de región a continuación del código de lenguaje, separado por un guión, por ejemplo: cadenas.es-MX.resx

5. Escriba código para cargar los recursos para el formulario Web usando la clase ResourceManager .6. Escriba código para detectar la cultura del usuario y configure de forma correspondiente las propiedades Cu-

rrentCulture y CurrentUICulture de la clase Thread . La propiedad CurrentCulture determina cómo da for-mato ASP.NET a las fechas, moneda y números; la propiedad CurrentUICulture determina qué ensambladosatélite se usa cuando se cargan cadenas traducidas.




285

7. Escriba código para obtener las cadenas de los archivos de recursos y muéstrelos en elementos del formularioWeb.

Las siguientes secciones describen estos pasos en mayor detalle.

15.2.2 Preparar los elementos HTML para recursosLos recursos de ensamblados satélite se cargan en los elementos de formulario web en el servidor. Por tanto,

debe asegurarse de que todos los elementos de su formulario Web tienen atributos id y runat que los hacen disponi-

bles para el código de servidor. De forma predeterminada, los controles ASP.NET tienen estos atributos, pero loselementos HTML no.

Por ejemplo, el siguiente HTML muestra un formulario Web sencillo con encabezado, texto y algunos con-troles. Para que los elementos del formulario puedan usar recursos hay que añadir las partes en negrita:

<%@ Page Language="vb" AutoEventWireup="false" Codebehind="WebForm1.aspx.vb"Inherits="vbSatelliteSnippet.WebForm1"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML>

<HEAD><title>WebForm1</title></HEAD><body>

<form id="Form1" method="post" runat="server"><h1 id="head1" runat="server">Encabezado de ejemplo</h1><p id="p1" runat="server">Texto de introducción.</p>

<span id="sp1" runat="server">Escriba un número: </span><asp:TextBox ID="txtCurrency" Runat="server" /><br><span id="sp2" runat="server">Cantidad en moneda local: </span><asp:Label ID="lblCurrency" Runat="server" /><br><br><asp:Button ID="butOK" Text="OK" Runat="server" /><input id="butCancel" runat="server" type="button"

onclick="txtCurrencty.value=''" value="Cancelar"></form>

</body></HTML>

Los atributos id y runat hacen que Visual Studio .NET maneje estos elementos como controles de servidor.Cuando se cambia de la vista HTML a la vista diseño Visual Studio añade las siguientes declaraciones en el archivode código del formulario:

Visual Basic .NETProtected WithEvents head1 As System.Web.UI.HtmlControls.HtmlGenericControlProtected WithEvents p1 As System.Web.UI.HtmlControls.HtmlGenericControlProtected WithEvents sp1 As System.Web.UI.HtmlControls.HtmlGenericControlProtected WithEvents sp2 As System.Web.UI.HtmlControls.HtmlGenericControlProtected WithEvents butCancel As System.Web.UI.HtmlControls.HtmlInputButton

Visual C#protected System.Web.UI.HtmlControls.HtmlGenericControl head1;protected System.Web.UI.HtmlControls.HtmlGenericControl p1;protected System.Web.UI.HtmlControls.HtmlGenericControl sp1;protected System.Web.UI.HtmlControls.HtmlGenericControl sp2;protected System.Web.UI.HtmlControls.HtmlInputButton butCancel;

Estas declaraciones permiten establecer el valor de los atributos y de innerHTML para estos elementos en

tiempo de ejecución.15.2.3 Crear archivos de recursos

Al utilizar ensamblados satélite para proporcionar cadenas traducidas dentro de una aplicación Web puedecrear tres tipos de archivos de recurso.

Tabla 15. 2: Tipos de archivo de recursos para ensamblados satéliteTipo Extensión Se compila en Proporciona

Predeterminado(Fallback)

.resx Ensamblado ejecutable Cadenas de interface de usuario cuandono se especifica cultura o la aplicaciónWeb no la reconoce.

Específico delenguaje

.codIdioma .resx Ensamblado de recursos en un subdirectorio de binidentificado por el código de idioma

Cadenas traducidas para un idiomaconcreto.

Específico decultura

.codIdioma-

codRegion .resxEnsamblado de recursos en un subdirectorio de binidentificado por el código de idioma y de región.

Cadenas traducidas para un dialectoconcreto de un idioma.

El código de cultura utilizado para identificar los archivos de recursos específicos de lenguaje y cultura se pueden ver en el tema de ayuda de la clase CultureInfo Estos códigos también se usan en la propiedad Name de laclase CultureInfo y el array UserLanguages del objeto Request .



MCAD/MCSD

286

Para agregar archivos de recursos a un proyecto de aplicación Web en Visual Studio .NET siga estos pasos.

1. En el menú Proyecto seleccione Agregar nuevo elemento y en la lista de plantillas seleccione Archivo de re-cursos de ensamblado.

2. Escriba el nombre del archivo que quiere crear y pulse Abrir. Visual Studio crea un nuevo archivo de recur-sos y lo agrega al proyecto

Para introducir en un archivo de recursos cadenas traducidas para el interface del formulario Web:

1. Escriba un identificador de elemento Web en el campo Name del archivo de recursos. El identificador debeser único dentro del alcance de la aplicación, de modo que un convenio del tipo nombreformula-rio.nombreelemento funcionará bien.

2. Escriba la cadena traducida para el elemento en el campo Value del archivo de recursos.

Consejo: El campo nombre dentro de un archivo de recursos diferencia mayúsculas y minúsculas deforma predeterminada. Para evitar errores al localizar recursos en tiempo de ejecución useun esquema de capitalización coherente. Por ejemplo, en esta lección todos los nombres derecursos están en minúsculas.

15.2.4 Cargar archivos de recursosEl marco de trabajo .NET proporciona la administración de recursos como parte del espacio de nombres Sys-

tem.Resources. Para usar las clases de este espacio de nombres sin necesidad de cualificar su nombre completamente

use una sentencia Imports / using al comienzo del formulario Web.Para cargar recursos en un formulario Web cree una instancia de la clase ResourceManager . Por ejemplo, la

siguiente línea carga el archivo de recursos para la aplicación Web.

Visual Basic .NETProtected gStrings As New ResourceManager("vbSatelliteSnippet.strings", _

GetType(WebForm1).Assembly)

Visual C#protected ResourceManager gStrings = new

ResourceManager("csSatelliteSnippet.strings", typeof(WebForm1).Assembly);

El ejemplo anterior carga los recursos guardados en el archivo de ensamblado Strings asociado con el ensamblado padre de Webform1 y guarda el objeto que devuelve en la variable gStrings. Los argumentos para el construc-tor de la clase ResourceManager se describen en la tabla 15.3.

Tabla 15. 3: Argumentos de ResourceManager Argumento Descripción

baseName Espacio de nombres del recurso dentro del proyecto. Para proyectos Visual Basic .NET es nombreproyecto.nombrebaserecurso Para proyectos C# es espacionombresraiz.nombrebaserecurso . La parte nombrebaserecurso omite los códigos de cultura.

assembly Objeto que representa el ensamblado ejecutable actual. Use la propiedad Assembly de la clase Type para obtenerel valor que se le pasa a este argumento.

15.2.5 Leer y configurar la cultura del interface de usuarioComo se mostró en la lección anterior puede obtener la cultura del usuario del array UserLanguages del obje-

to Request , y se configura la cultura actual de la hebra asignando a la propiedad CurrentCulture de la clase Thread .Cuando trabaja con ensamblados satélite necesita dar un paso más: configurar la propiedad CurrentUICulture. Esta propiedad determina qué ensamblado satélite se ursa cuando se cargan cadenas desde el objeto ResourceManager .

Para configurar la cultura actual del interface de usuario para una hebra asigne un valor a la propiedad Cu-rrentUICulture. Por ejemplo, el siguiente código obtiene el lenguaje preferido del usuario y establece tanto la cultu-ra como la cultura de interface de usuario de la hebra actual.


Handles MyBase.LoadIf Not IsPostBack Then

' Obtiene el lenguaje preferido del usuario.Dim sLang As String = Request.UserLanguages(0)' Establece la cultura de la hebra para formato, comparacione, etc.Thread.CurrentThread.CurrentCulture = _

CultureInfo.CreateSpecificCulture(slang)' Establece la cultura del interface para carga de recursos

' desde el ensamblado satéliteThread.CurrentThread.CurrentUICulture = New CultureInfo(slang)End If

End Sub




287


if (!IsPostBack){// Obtiene el lenguaje preferido del usuario.string sLang = Request.UserLanguages[0];// Establece la cultura de la hebra para formato, comparaciones etc.Thread.CurrentThread.CurrentCulture =

CultureInfo.CreateSpecificCulture(sLang);// Establece la cultura del interface para carga de recursos

// desde el ensamblado satélite.Thread.CurrentThread.CurrentUICulture = new CultureInfo(sLang);

}}

En el código anterior, las propiedades CurrentCulture y CurrentUICulture se configuran de forma diferente.CurrentCulture utiliza el método CreateSpecificCulture para asegurar que el objeto devuelto no es una cultura neu-tral. Las culturas neutrales representan lenguajes genéricos en lugar de un lenguaje y región concretos. La propie-dad CurrentCulture no se puede establecer con una cultura neutral porque usa información de región para dar for-mato a moneda, entre otras cosas.

Cuando se ha configurado CurrentUICulture para la hebra, ASP.NET automáticamente seleccionar los recur-sos que corresponden en el orden siguiente:

1. Si se encuentra un ensamblado satélite que corresponde exactamente a la cultura se usan los recursos de esteensamblado.

2. Si se encuentra un ensamblado satélite con una cultura neutral que corresponde al CurrentUICulture actual seusan los recursos de este ensamblado.

3. Si no se encuentra una correspondencia para el CurrentUICulture se usan los recursos del ensamblado prede-terminado ejecutable.

15.2.6 Mostrar cadenas de recursoDespués de completar las tareas anteriores, mostrar cadenas desde un archivo de recurso en un formulario

web es sencillo. Utilice el método GetStrings del objeto ResourceManager para recuperar cadenas y asignarlas a las propiedades Text , value o innerHTML de los elementos del formulario Web.

El siguiente código reúne los pasos anteriores para cargar una archivo de recursos, obtener la cultura delusuario, configurar la cultura de la hebra y mostrar cadenas del archivo de recursos en los controles de servidor y

elementos HTML del formulario Web:Visual Basic .NETImports System.ResourcesImports System.GlobalizationImports System.Threading

' Carga recursos.Protected gStrings As New ResourceManager("vbSatelliteSnippet.strings", _



If Not IsPostBack Then' Obtiene el idioma preferido del usuario.Dim sLang As String = Request.UserLanguages(0)' Establece la cultura de la hebra para formato, comparaciones, etc.Thread.CurrentThread.CurrentCulture = _

CultureInfo.CreateSpecificCulture(sLang)' Establece la cultura del interface para cargar recursos del satélite.Thread.CurrentThread.CurrentUICulture = New CultureInfo(sLang)' Obtiene las cadenas del archivo de recurso.head1.InnerHtml = gStrings.GetString("webform1.head1")p1.InnerHtml = gStrings.GetString("webform1.p1")sp1.InnerHtml = gStrings.GetString("webform1.sp1")sp2.InnerHtml = gStrings.GetString("webform1.sp2")butOK.Text = gStrings.GetString("webform1.butOK")butCancel.Value = gStrings.GetString("webform1.butCancel")

End IfEnd Sub

Visual C#using System.Globalization;using System.Threading;using System.Resources;



MCAD/MCSD

288

private void Page_Load(object sender, System.EventArgs e){if (!IsPostBack) {

// Obtiene el idioma preferido del usuario.string sLang = Request.UserLanguages[0];// Establece la cultura de la hebra para formato, comparaciones, etc.Thread.CurrentThread.CurrentCulture = _

CultureInfo.CreateSpecificCulture(sLang);// Establece la cultura de interface para cargar recursos del satélite.Thread.CurrentThread.CurrentUICulture = new CultureInfo(sLang);

// Obtiene las cadenas del archivo de recursos.head1.InnerHtml = gStrings.GetString("webform1.head1");p1.InnerHtml = gStrings.GetString("webform1.p1");sp1.InnerHtml = gStrings.GetString("webform1.sp1");sp2.InnerHtml = gStrings.GetString("webform1.sp2");butOK.Text = gStrings.GetString("webform1.butOK");butCancel.Value = gStrings.GetString("webform1.butCancel");

}}

En tiempo de ejecución el código anterior muestra las cadenas traducidas desde los archivos de recursos, en base al idioma preferido del usuario.

15.3 Temas de globalización

El marco de trabajo .NET maneja automáticamente muchos aspectos de la globalización, en base a la confi-guración de la propiedad CurrentCulture. Sin embargo, la globalización también afecta a algunas técnicas de pro-gramación básicas. En este capítulo aprenderá algunos aspectos de programación generales en los que necesita pen-sar cuando desarrolle aplicaciones globales. También aprenderá aspectos que surgen cuando se guardan y muestranlos conjuntos de caracteres extendidos usados por algunos lenguajes.

15.3.1 Temas de programación generalEl tema Prácticas recomendadas para desarrollar aplicaciones de uso internacional de la ayuda de Visual

Studio proporciona una lista de tema que se deben considerar cuando se desarrollan aplicaciones que se van a tradu-cir a varios lenguajes. Las siguientes secciones detallan puntos de este tema que son relevantes para aplicacionesWeb.

Ordenar y comparar cadenasLa ordenación y la comparación de cadenas que se realiza usando las clases del marco de trabajo .NET se

ejecuta correctamente en base a la cultura actual. En realidad solo necesita preocuparse de los aspectos de globa-lización cuando implemente sus propias técnicas para estas tareas, por ejemplo sus propios procedimientos deordenación. En estos casos utilice la clase CompareInfo del espacio de nombres System.Globalization para reali-zar comparación de cadenas teniendo en cuenta la cultura.

Controles de validación personalizadaLos controles de servidor de ASP.NET adquieren propiedades específicas en base a la cultura actual. Esto

incluye a los controles de validación. Sin embargo, deberá tener en cuenta los temas de globalización cuandocree controles de validación personalizada.

Por ejemplo, si escribe un procedimiento de validación personalizada que comprueba que la entrada esnumérica no confíe en el valor numérico de los caracteres de entrada. Use en cambio una prueba que tenga encuenta la cultura, como usar la clase Convert dentro de una estructura de control de excepciones para comprobar

si el valor es numérico.Crear cadenas

Como algunos lenguajes leen de derecha a izquierda, y como algunas palabras cambian su significadocuando están próximas a otras, es difícil crear cadenas usando la concatenación de una forma que sirva para to-das las culturas. En cambio, guarde las cadenas completas en un archivo de recursos y recupere las cadenas talcomo sea necesario usando el administrador de recursos.

Obtener subcadenasEn algunos lenguajes los símbolos de carácter (llamados glifos) se componen de dos caracteres. En estos

casos es posible que necesite ajustar cómo obtiene las subcadenas. Por ejemplo, obtener el primer carácter de unarespuesta de usuario puede no ser significativa en algunos casos.

15.3.2 Codificación de caracteres

Los caracteres dentro de cadenas se pueden representar de muchas formas diferentes en un ordenador. Estasformas diferentes de representar caracteres se llama codificación de caracteres porque codifica los caracteres ennúmeros que el ordenador puede comprender.




289

El entorno de ejecución común usa la codificación de caracteres UTF-16, que hace corresponder los caracte-res con números de 16 bit. 16 bit proporcionan espacio suficiente para acomodar los caracteres de casi todos loslenguajes escritos. Desafortunadamente es casi el doble de tamaño de lo que utilizan otros esquemas de codificación,lo que hace que sea menos que óptimo para transmitir caracteres por Internet.

Por tanto, ASP.NET utiliza codificación de caracteres UTF-8 de forma predeterminada cuando interpreta pe-ticiones y compone respuestas. UTF-8 está optimizado para los 127 caracteres ASCII inferiores, lo que significa que proporciona una forma eficaz de codificar lenguajes que usan el alfabeto latino. También proporciona compatibili-

dad con la codificación de caracteres ASCII, lo que significa que los lectores UTF-8 pueden interpretar archivosASCII.

El entorno de ejecución común maneja la conversión entre codificaciones usando clases del espacio de nombres System.Text . Normalmente no necesitará preocuparse de que esto, salvo:

• Si va a grabar un formulario Web o archivo HTML que incluye caracteres extendidos de la codificaciónUTF-8

• Si necesita dar soporte a codificaciones concretas diferentes a UTF-8

Guardar archivos codificadosCuando se crea un formulario Web que contiene caracteres diferentes a los 127 primeros caracteres AS-

CII Visual Studio pregunta si se quiere guardar utilizando codificación. Para guardar un archivo con codifica-ción:

1. En el menú Archivo seleccione Guardar como, pulse la flecha del botón Guardar y seleccione Guardar con codificar. Visual Studio muestra las Opciones avanzadas para guardar.2. Seleccione la codificación y pulse Aceptar

Al guardar el archivo utilizando codificación UTF-8 con firma ASP.NET puede detectar automáticamentela codificación del archivo. Si no elige incluir la firma, o si usa otra codificación, debe especificar el atributo fi-leEncoding en el archivo Web.config:

<globalization requestEncoding="utf-8" responseEncoding="utf-8"fileEncoding="utf-8" />

Usar otras codificacionesDe forma predeterminada las aplicaciones Web interpretan peticiones y componen respuestas usando la

codificación de caracteres UTF-8. Estas opciones predeterminadas se configuran en el elemento globalization del archivo Web.config, como se mostró en la sección anterior.

Si una aplicación Web recibe una petición para una codificación diferente a UTF-8 ASP.NET interpretala petición usando la codificación de la misma. Sin embargo, ASP.NET no genera automáticamente la respuestaen esta codificación.

Para detectar cuándo una petición tiene una codificación específica lea la propiedad ContentEncoding delobjeto Request . Por ejemplo, la siguiente línea muestra la codificación de una petición en un formulario Web:

Visual Basic .NETResponse.Write(Request.ContentEncoding.WebName)

Visual C#Response.Write(Request.ContentEncoding.WebName);

Para especificar una codificación de caracteres para una respuesta configure la propiedad ContentEnco-

ding del objeto Response usando la clase Encoding del espacio de nombres System.Text , o use el valor devuelto por la propiedad ContentEncoding del objeto Request . Por ejemplo, el siguiente código crea una respuesta usan-do la codificación de caracteres shift_JIS :

Visual Basic .NETImports System.TextPrivate Sub Page_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.LoadResponse.ContentEncoding = Encoding.GetEncoding("shift_JIS")Response.Write("Esta respuesta usa la codificación de caracteres: ")Response.Write(Response.ContentEncoding.WebName)

End Sub



MCAD/MCSD

290

Visual C#using System.Text;private void Page_Load(object sender, System.EventArgs e){

Response.ContentEncoding = Encoding.GetEncoding("shift_JIS");Response.Write("Esta respuesta usa la codificación de caracteres: ");Response.Write(Response.ContentEncoding.WebName);

}

Mas Información: Para más información sobre codificación de caracteres vea los siguientes temas de

la ayuda en línea.• Unicode en .NET Framework • Codificar tipos base• Espacio de nombres System.Text

También puede encontrar información en los sitios Web:

• http://www.unicode.org• http://www.w3.org/TR/REC-html40/charset.html

15.4 Resumen• Use el array UserLanguages del objeto Request para detectar la cultura del usuario.•

Configure los atributos culture y uiCulture del elemento globalization en Web.config para crear aplicacionesWeb específicas de una cultura.• El marco de trabajo .NET identifica las culturas usando los códigos de lenguaje y de región que se listan en el

tema de ayuda en línea de la clase CultureInfo.• Configure la cultura que utiliza la aplicación para dar formato a fechas, monedas, números y determinar el la

correlación al ordenar usando la propiedad CurrentCulture de la clase Thread .• Utilice la propiedad CurrentUICulture de la clase Thread para determinar qué ensamblado satélite se usará

para cargar los recursos localizados.• Añada los atributos id y runat a los elementos HTML para poder mostrar cadenas localizadas desde archivos

de recursos en estos elementos en tiempo de ejecución.• Los elementos de un archivo de recursos diferencian mayúsculas y minúsculas y deben tener un nombre úni-

co en el alcance de la aplicación, por lo que se debe usar un convenio de la forma nombreformula-rio.identificador .

• Cuando cree formularios Web que usan caracteres no ASCII guárdelos usando la codificación UTF-8 confirma. Al incluir la firma ASP.NET puede detectar automáticamente la codificación del archivo.

15.5 Práctica: Conversor de monedaEn esta práctica va a crear una sencilla aplicación de conversión de moneda que usa la cultura del usuario pa-

ra determinar el tipo de conversión:

• Una cultura no reconocida convierte de euros a dólares y pesos y muestra el texto en inglés como interface predeterminado.

• Una cultura inglés de Estados Unidos convierte dólares a euros y pesos y muestra un interface en inglés• Una cultura español de Méjico convierte pesos a dólares y euros y muestra un interface en español

15.5.1 Ejercicio 1: Crear el formulario Web del conversor de moneda

La aplicación Web conversor de moneda contiene un único formularios Web que recibe la entrada de una caja de texto y muestra la salida en dos etiquetas cuando el usuario pulsa Aceptar. El formulario Web también incluyeun botón HTML Cancelar que vacía la caja de texto.

Como la aplicación va a estar localizada los elementos HTML del formulario Web deben tener atributos id yrunat de forma que las cadenas de recurso localizadas se puedan cargar en estos controles en el código del servidor.

1. Cree un nuevo proyecto de aplicación Web llamado CurrencyConverter .2. Cambie a la vista HTML y escriba el siguiente código entre las etiquetas < form> y </ form>:

<h1 id="head1" runat="server">Head1</h1><span id="sp1" runat="server">Enter an amount: </span><asp:TextBox ID="txtCurrency" Runat="server" /><br><span id="sp2" runat="server">Amount in: </span><asp:Label ID="lblCurrency1" Runat="server" /><br><span id="sp3" runat="server">Amount in: </span><asp:Label ID="lblCurrency2" Runat="server" /><br><br><asp:Button ID="butOK" Text="OK" Runat="server" /><input id="butCancel" runat="server" type="button"onclick="txtCurrency.Text=''" value="Cancel">




291

3. Cuando termine, cambie de nuevo al modo diseño. Este paso es importante porque genera las declaraciones

de control correctas en el archivo de código.

15.5.2 Ejercicio 2: Crear los archivos de recurso del interface de usuarioEl formulario Web creado en el paso anterior contiene solo entrada falsas para el texto que se mostrará real-

mente en el interface de usuario. Por ejemplo, el encabezado de la página es “Head1”. En este ejercicio va a crear lascadenas que se muestran en lugar de estas entradas falsas en tiempo de ejecución.

1. En el menú Proyecto seleccione Agregar nuevo elemento y en la lista de plantillas elija Archivo de recursosde ensamblado.

2. Añada las entradas de la siguiente tabla al archivo de recursos para crear los valores para el interface prede-terminado:

name value

webform1.head1 Welcomewebform1.sp1 Enter an amount in euros:webform1.sp2 Amount in <b>dollars</b>:webform1.sp3 Amount in <b>pesos</b>:webform1.butOK OK webform1.butCancel Cancel

Deje las tres últimas columnas con su valor predeterminado (null).

3. Cree un nuevo archivo de recursos llamado strings.en-US.resx con las entradas de la tabla siguiente paracrear el interface para usuario de cultura inglés de Estados Unidos:name value

webform1.head1 Welcomewebform1.sp1 Enter an amount in dollars:webform1.sp2 Amount in <b>euros</b>:webform1.sp3 Amount in <b>pesos</b>:webform1.butOK OK webform1.butCancel Cancel

4. Cree otro nuevo archivo de recursos llamado strings.es-MX.resx con las entradas de la tabla siguiente paracrear el interface para usuario de cultura español de Méjico:

name value

webform1.head1 Bienvenidowebform1.sp1 Escriba una cantidad en pesos:webform1.sp2 Cantidad en <b>euros</b>:webform1.sp3 Cantidad en <b>dólares</b>:webform1.butOK Aceptar webform1.butCancel Cancelar

5. Cuando termine pulse Guardar todo para grabar su trabajo.

Puede crear archivos de recursos adicionales para otras culturas si quiere. Incluya el código de cultura en elnombre del archivo, como se ha mostrado en los pasos anteriores. Visual Studio .NET compilará automáticamentelos recursos como ensamblados satélite y los guardará en el sub directorio adecuado cuando se genere la aplicación.

15.5.3 Ejercicio 3: Cargar recursos según la culturaEn este ejercicio va a detectar la cultura del usuario, cargar los recursos y mostrarlos según la cultura del

usuario.

1. Añada las sentencias Imports o using para poder utilizar los espacios de nombres System.Resources, Sys-tem.Globalization y System.Threading.

2. Añada el siguiente código a nivel de clase del formulario Web para cargar los recursos en el objeto Resour-ceManager :

Visual Basic .NETProtected gStrings As New ResourceManager("CurrencyConverter.strings", _


Visual C#protected ResourceManager gStrings = new

ResourceManager("CurrencyConverter.strings", typeof(WebForm1).Assembly);

3. Añada el siguiente código al procedimiento de suceso Page_Load para detectar la cultura del usuario, confi-gurar la cultura de interface de usuario de la hebra y mostrar las cadenas de recurso locales en el interface deusuario:



MCAD/MCSD

292


ByVal e As System.EventArgs) Handles MyBase.LoadIf Not IsPostBack Then

' Obtiene el idioma preferido del usuario.Dim sLang As String = Request.UserLanguages(0)' Configura el UICulture de la hebra para cargar recursos.Thread.CurrentThread.CurrentUICulture = New CultureInfo(sLang)' Configura la cultura de la hebra para formato de fecha/cadena/moneda

Thread.CurrentThread.CurrentCulture = _CultureInfoCreateSpecificCulture(sLang)

' Obtiene las cadenas del archivo de recursos.head1.InnerHtml = gStrings.GetString("webform1.head1")sp1.InnerHtml = gStrings.GetString("webform1.sp1")sp2.InnerHtml = gStrings.GetString("webform1.sp2")sp3.InnerHtml = gStrings.GetString("webform1.sp3")butOK.Text = gStrings.GetString("webform1.butOK")butCancel.Value = gStrings.GetString("webform1.butCancel")

End IfEnd Sub


if (!IsPostBack){

// Obtiene el idioma preferido del usuario.string sLang = Request.UserLanguages[0];// Configura el UICulture de la hebra para cargar recursos.Thread.CurrentThread.CurrentUICulture = new CultureInfo(sLang);// Configurar la cultura para formato de fecha/cadena/moneda.Thread.CurrentThread.CurrentCulture =

CultureInfo.CreateSpecificCulture(sLang);// Obtiene las cadenas del archivo de recursos.head1.InnerHtml = gStrings.GetString("webform1.head1");sp1.InnerHtml = gStrings.GetString("webform1.sp1");sp2.InnerHtml = gStrings.GetString("webform1.sp2");sp3.InnerHtml = gStrings.GetString("webform1.sp3");butOK.Text = gStrings.GetString("webform1.butOK");butCancel.Value = gStrings.GetString("webform1.butCancel");

}

}

Solo tiene que cargar las cadenas de recuso localizadas la primera vez que se muestra la página, como mues-tra el código anterior. ASP.NET retiene el valor de los controles entre presentaciones de página automáticamente.

15.5.4 Ejercicio 4: Conversión dependiente de culturaIgual que muestra un interface diferente para cada cultura, el conversor de moneda también realiza conver-

siones diferentes según la cultura actual. En este ejercicio va a escribir el código que realiza esta tarea.

Añada el siguiente código en el procedimiento de suceso butOK_Click para detectar la cultura actual y reali-zar diferentes conversiones en base a esta información:


ByVal e As System.EventArgs) Handles butOK.Click' Obtiene la cantidad.Dim SrcAmount As Double = Convert.ToDouble(txtCurrency.Text)Dim DestAmount As Double' Variables de cultura para formato de moneda.Dim Europe As New CultureInfo("fr-FR")Dim USA As New CultureInfo("en-US")Dim Mexico As New CultureInfo("es-MX")' Conversiones según la cultura el interface de usuario.Select Case Thread.CurrentThread.CurrentCulture.Name

Case "en-US" 'Convierte desde dólaresDestAmount = SrcAmount * 1.1329lblCurrency1.Text = DestAmount.ToString("C", Europe)DestAmount = SrcAmount * 9.0655lblCurrency2.Text = DestAmount.ToString("C", Mexico)




293

Case "es-MX" ' Convierte desde pesosDestAmount = SrcAmount * 0.125lblCurrency1.Text = DestAmount.ToString("C", Europe)DestAmount = SrcAmount * 0.1103lblCurrency2.Text = DestAmount.ToString("C", USA)

Case Else ' Convierte desde eurosDestAmount = SrcAmount * 8.0021lblCurrency1.Text = DestAmount.ToString("C", USA)DestAmount = SrcAmount * 0.1103

lblCurrency2.Text = DestAmount.ToString("C", Mexico)End Select

End Sub


// Obtiene la cantidad.double SrcAmount = Convert.ToDouble(txtCurrency.Text);double DestAmount;// Variables de cultura para formato de moneda.CultureInfo Europe = new CultureInfo("fr-FR");CultureInfo USA = new CultureInfo("en-US");CultureInfo Mexico = new CultureInfo("es-MX");// Conversiones en base a la cultura del interface de usuario,switch (Thread.CurrentThread.CurrentCulture.Name) {

case "en-US": //Convierte desde dólaresDestAmount = SrcAmount * 1.1329;lblCurrency1.Text = DestAmount.ToString("C", Europe);DestAmount = SrcAmount * 9.0655;lblCurrency2.Text = DestAmount.ToString("C", Mexico);break;

case "es-MX": //Convierte desde pesosDestAmount = SrcAmount * 0.125;lblCurrency1.Text = DestAmount.ToString("C", Europe);DestAmount = SrcAmount * 0.1103;lblCurrency2.Text = DestAmount.ToString("C", USA);break;

default: //Convierte desde eurosDestAmount = SrcAmount * 8.0021;

lblCurrency1.Text = DestAmount.ToString("C", USA);DestAmount = SrcAmount * 0.1103;lblCurrency2.Text = DestAmount.ToString("C", Mexico);break;

}}

El código anterior crea objetos CultureInfo (Europe, USA y Mexico) para cada conversión cultural. Estos objetos proporcionan el formato de moneda adecuado en los métodos ToString. El objeto Europe usa el código decultura para Francia porque este país usa el euro como moneda. No hay un código de cultura para la Unión Europea.

En el ejemplo se incluyen en el código las tasas de cambio. En una situación real no se haría así; esta es unatarea adecuada para un servicio Web. Vea el Capítulo 7, Programación avanzada de formularios Web.

15.6 Repaso


1. ¿Cuál es la diferencia entre la propiedad CurrentCulture y la propiedad CurrentUICulture?

2. ¿Cómo se detecta la cultura del usuario?

3. ¿Qué es una cultura neutral?

4. ¿Cómo afecta la codificación de caracteres a los formatos de archivo?



MCAD/MCSD

294




295

16 Preguntas y respuestasCapítulo 1: Introducción a la Programación Web

1. De tres ejemplos de en que se diferencia una aplicación Web de una aplicación Windows tradicional.

Las aplicaciones Web y las aplicaciones Windows tradicionales tienen las siguientes diferencias:

Característica Aplicación Web ASP.NET Aplicación Windows no administrada Arquitectura Cliente/Servidor Usuario localEjecución Se ejecuta bajo el motor de ejecución común de

lenguajes usando código administradoCorre bajo Windows usando código no adminis-trado

Interface deusuario

El interface de usuario se muestra en un navega-dor Windows usando formularios Web

El interface de usuario lo muestra la aplicaciónusando el API Win32

2. ¿Cuáles son las dos partes del marco de trabajo .NET?

• El motor de ejecución de lenguaje común

• La librería de clases del marco de trabajo .NET

3. ¿Cómo se restablecen las opciones de ventana predeterminadas en Visual Studio .NET?

En el menú Herramientas seleccione Opciones y pulse Restablecer Diseño de Ventanas

4. ¿Por qué no completa automáticamente el editor de código la siguiente línea de código parcial (sólo usuariosde Visual C#)?int intX = system.math

En Visual C# el espacio de nombres System.Math debe llevar mayúsculas para que IntelliSense lo re-conozca

5. ¿Cuándo no puede usar ASP.NET para crear una aplicación?

Cuando está desarrollando para servidores Web que no sean de Microsoft, como Linux/Apache

Capítulo 2: Crear Aplicaciones Web1. Explique donde guarda Visual Studio .NET los proyectos de aplicación Web.

Los proyectos de aplicación Web se guardan en un nuevo directorio virtual para cada proyecto. Laspropiedades de este directorio virtual determinan donde se almacenan los archivos físicamente. Estaspropiedades se pueden ver en IIS

2. Indique las cuatro diferencias principales entre aplicaciones Web y Windows.

• Los formularios Web no pueden usar controles Windows estándar. En su lugar usan controles deservidor, controles HTML, controles de usuario o controles creados específicamente.

• Las aplicaciones Web se muestran en un navegador. Las aplicaciones Windows muestran sus pro-pias ventanas y tienen más control sobre cómo se presentan estas ventanas.

• Los formularios Windows se instancian en el servidor, se envían al navegador y se destruyen inme-diatamente. Los formularios Windows se instancian, existen todo el tiempo que son necesarios y sedestruyen.

• Las aplicaciones web corren en un servidor y se muestran de forma remota en los clientes. Las apli-caciones Windows corren en la misma máquina en que se muestran.

3. Describa el ciclo de vida de una aplicación Web: ¿Cuándo se instancian los formularios Web y durante cuan-

to tiempo existen?Una aplicación Windows se inicia con la primera petición para un recurso dentro de sus límites. Losformularios Web se instancian cuando se solicitan. El servidor los procesa y son abandonados tanpronto como el servidor envía su respuesta al cliente. Una aplicación Web termina después de queterminen todas las sesiones de clientes.

4. ¿Cómo se conservan los datos persistentes, como variables sencillas, en una aplicación Web?

Puede conservar datos en variables de estado, como Application , Session y ViewState .

5. ¿Qué determina los límites de una aplicación Web?

IIS determina los límites de una aplicación Web mediante la estructura de directorios virtuales de laaplicación. El límite de una aplicación Web comienza en el directorio virtual que contiene la página deinicio de la aplicación y termina en el último directorio subordinado o cuando encuentra otra páginade inicio en un directorio subordinado.

Capítulo 3: Trabajar con Objetos Web1. ¿Cómo organiza el marco de trabajo .NET sus clases?



MCAD/MCSD

296

El marco de trabajo .NET utiliza espacios de nombres para organizar sus clases.

2. En Visual Basic .NET ¿Cuál es la diferencia entre un módulo de clase y un módulo de código?

Los módulos de clase se instancian en tiempo de ejecución para crear objetos que proporcionan alma-cenamiento separado para variables y propiedades en cada instancia. Los módulos de código no tieneninstancias, por lo que las variables a nivel de módulo que usan se comparten entre diferentes llamadasa los procedimientos del mismo.

3. En Visual C#, ¿Cómo se declara un método para que esté disponible sin tener que instanciar un objeto de laclase?

Para crear un método que se pueda llamar sin instanciar un objeto declárelo como static .

4. ¿Cómo se llama a un miembro de la clase base desde dentro de una clase derivada?

Para hacer referencia a un método de una clase base en Visual Basic .NET use la palabra clave MyBa- se . Para hacer referencia a un miembro de una clase base en Visual C# use la palabra clave base .

5. ¿Cuáles son los cuatro objetos principales usados en la programación de aplicaciones Web?

Los cuatro objetos principales en la programación de aplicaciones Web son Application , Page , Request y Response .

6. ¿Dónde grabaría los siguientes elementos de datos de modo que sean persistentes entre peticiones a un for-

mulario Web?• Un control creado en tiempo de ejecución

En el objeto ViewState del objeto Page .

• Un objeto que proporciona servicio a todos los usuarios

En el estado de aplicación (Application )

• Preferencias de usuario

En el estado de sesión (Session )

Capítulo 4: Crear un Interface de Usuario1. ¿Cuál es la diferencia principal entre el control de servidor Button y el control HTML Button?

Cuando se pulsa un control de servidor Button lanza un procedimiento de suceso Click en el servidor.El control HTML Button lanza el procedimiento de suceso indicado en su atributo onclick , que correen el cliente.

2. ¿Cómo se consigue que varios controles RadioButton interactúen en un formulario Web de forma que solo se pueda seleccionar uno a la vez?

Indicando un mismo nombre de grupo en la propiedad GroupName de todos ellos.

3. ¿Por qué ASP.NET realiza la validación en el cliente y en el servidor?

La validación en el cliente evita envíos innecesarios al servidor. La validación en el cliente asegura enla mayoría de los casos que los datos son válidos antes de su envío. Sin embargo, como la validación sepuede desactivar (o trucar de forma maliciosa), es necesario volver a validar los datos en el servidor.Esto proporciona la seguridad absoluta de que los datos son válidos a la vez que evita todas las idas yvueltas posibles.

4. ¿Qué tipos de validación debería utilizar para comprobar que un usuario ha introducido un número de clientecorrecto?

Debería usar un RequiredFieldValidator y un RegularExpressionValidator. Si tiene acceso a una listade los números de cliente que se esperan, podría reemplazar el RegularExpressionValidator por unCustomValidator que compruebe la lista.

5. ¿Qué es incorrecto en la siguiente línea de código?

Visual Basic .NETServer.Transfer(“Default.htm”)

Visual C#

Server.Transfer(“Default.htm”)

No se puede usar el método Transfer con páginas HTML; solo funciona con páginas aspx.

6. ¿Por qué no se puede abrir una nueva ventana de navegador mediante código de servidor?




297

El código de servidor se ejecuta en el servidor, mientras que la nueva ventana se crea en el cliente. De-be usar código cliente para las cosas que afecten al cliente, como subir archivos, mostrar nuevas venta-nas o volver atrás en el historial.

Capítulo 5: ADO.NET1. ¿Qué pasos debe seguir y qué objetos debe usar para encontrar rápidamente el número de registros en una ta-

bla de base de datos?

Hay dos formas:

• Use una conexión con base de datos y un objeto Command para ejecutar un comando SQL que de-vuelva el número de filas de la tabla

• Use una conexión con base de datos y un objeto adaptador de datos para crear un conjunto de da-tos para la tabla, y después lea el número de filas del conjunto de datos.

2. ¿En qué se diferencian los conjuntos de datos sin tipo de los conjuntos de datos con tipo, y cuales son lasventajas de los conjuntos de datos con tipo?

Los conjuntos de datos con tipo usan nombres y tipos de datos explícitos para sus miembros, mientrasque los conjuntos de datos sin tipo usan colecciones para referirse a sus miembros. Los siguientesejemplos muestran una referencia con tipo en comparación con una referencia sin tipo en a un elemen-to de datos.

Visual Basic .NET‘ Referencia con tipo a la columna HomePhone de la tabla ContactsDataSet1.Contacts.HomePhoneColumn.Caption = “@Home”‘Referencia sin tipo a la columna HomePhone de la tabla ContactsDataSet1.Tables(“Contacts”).Columns(“HomePhone”).Caption = “@Home”

Visual C#// Referencia con tipo a la columna HomePhone de la tabla ContactsDataSet1.Contacts.HomePhoneColumn.Caption = “@Home”;// Referencia sin tipo a la columna HomePhone de la tabla ContactsDataSet1.Tables[“Contacts”].Columns[“HomePhone”].Caption = “@Home”

Los conjuntos de datos con tipo hacen comprobación de errores en tiempo de diseño. Esta comproba-ción de errores ayuda a capturar errores de tipo y de nombres, que con los conjuntos de datos sin tiposolo se advertirían en tiempo de ejecución.

3. ¿Cómo se reutiliza un componente de conexión de base de datos en una aplicación Web?

Añada el componente de conexión con la base de datos al archivo Global.asax y cree una variable deestado en los procedimientos de suceso Application_Start o Session_Start para compartir la conexióncon los formularios Web de la aplicación.

4. Explique las diferencias entre manejar transacciones a nivel base de datos y a nivel conjunto de datos.

Los conjuntos de datos proporcionan transacciones implícitas, ya que los cambios no se aplican a labase de datos hasta que no se llame al método Update . Para manejar transacciones en un conjunto dedatos lance el método Update y compruebe si hay errores. Si hay errores en Update no se aplican a labase de datos ninguno de los cambios del conjunto de datos. Puede intentar corregir el error y reenviarla actualización , o puede volver atrás los cambios del conjunto de datos usando el método Reject- Changes .

Las bases de datos proporcionan transacciones explícitas mediante el objeto Transaction . Un objetoTransaction se crea a partir de una conexión con base de datos, y a continuación se asigna a los co-mandos que quiere incluir en la transacción mediante la propiedad Transaction del objeto comando.Cuando se ejecutan los comandos sobre la base de datos se comprueba si hay errores. Si se producenerrores puede intentar corregirlos y reenviar el comando o puede restablecer el estado de la base dedatos usando el método RollBack del objeto Transaction . Si no se producen errores puede hacer quelos cambios sean permanentes llamando al método Commit del objeto transacción.

Capítulo 6: Capturar y Corregir Errores1. Explique por qué es importante el control de excepciones en una aplicación terminada.

Cuando se produce una excepción no controlada en una aplicación, la aplicación se detiene – el usuariono puede hacer nada, y todo trabajo que haya hecho antes de la excepción se pierde. El control de ex-cepcione proporciona una forma de interceptar y corregir errores situaciones inusuales que de otraforma causarían estos problemas.

2. Indique dos aproximaciones al control de excepciones en aplicaciones Web ASP.NET



MCAD/MCSD

298

Las excepciones se pueden controlar en bloques de control de excepciones usando las palabras claveTry , Catch , Finally en Visual Basic .NET o try , catch , finally en Visual C#. También se pueden contro-lar usando procedimientos de suceso Error a nivel global, aplicación o página usando los métodos Ge- tLastError y ClearError del objeto Server .

3. Describa el cometido de la páginas de error y por qué son necesarias.

Como las aplicaciones Web corren sobre Internet, algunas excepciones se producen fuera del alcancede la aplicación. Esto significa que la aplicación no puede responder directamente a estas excepciones.

Estos tipos de excepción se identifican mediante códigos de respuesta HTTP, a los que IIS puede res-ponder mostrando páginas de error personalizadas indicadas en el archivo de configuración de la apli-cación Web.config.

4. Explique por qué el seguimiento ayuda con el control de excepciones.

El seguimiento permite registrar sucesos no usuales durante la ejecución de la aplicación, sin que losusuarios lo perciban. Si se produce una excepción no anticipada la aplicación puede escribir un mensa-

je en el registro de seguimiento, lo que ayuda a diagnosticar problemas durante las pruebas y tras eldespliegue.

Capítulo 7: Programación Avanzada de Formularios Web.1. Escriba el HTML para un enlace que envíe correo cuando el usuario lo pulse

<a href=”mailto:[email protected]?SUBJECT=Envío de correo desde

cliente&BODY=Texto del mensaje.”>Enviar correo</a>

2. Muestre el código que escribe una cookie que contiene el nombre de usuario “Rob Young” y la fecha actualen el ordenador del usuario. Configure la cookie para que permanezca en el ordenador 30 días.

Visual Basic .NETDim cookUserInfo As New HttpCookie(“UserInfo”)cookUserInfo(“Name”) = “Rob Young”cookUserInfo(“Time”) = DateTime.Now.ToString()cookUserInfo.Expires = DateTime.Now.AddDays(30)Response.Cookies.Add(cookUserInfo)

Visual C#HttpCookie cookUserInfo = new HttpCookie(“UserInfo”);CookUserInfo[“Name”] = “Rob Young”;

CookUserInfo[“Time”] = DateTime.Now.ToString();CookUserInfo.Expires = DateTime.Now.AddDays(30);Response.Cookies.Add(cookUserInfo);

3. ¿Por qué no puede abrir una ventana de navegador desde código de servidor?. ¿Cómo podría mostrar una pá-gina en una nueva ventana con una secuencia de comandos de cliente?

El código de servidor solo puede ejecutar tareas en el servidor. Para ejecutar una tarea en el ordena-dor del usuario, como abrir una nueva ventana de navegador, el código debe correr en el cliente.

Puede abrir una nueva ventana usando el objeto window de DOM. Por ejemplo, el siguiente botónHTML abre una página de ayuda en una nueva ventana:

<button id=”butHelp” onClick=”window.open(‘help.aspx’, ‘help’,‘height=200,width=300’)”>Ayuda</button>

4. ¿Cómo mostraría una página en un marco desde un enlace en otro marco?.Utilice el atributo target del elemento <a > para especificar el marco en el que mostrar la página. Porejemplo, el siguiente enlace muestra una página en el marco main de un conjunto de marcos:

<a href=”unaPagina.aspx” target=”main”>Muestra la página</a>

Capítulo 8: Mantener la Seguridad.1. ¿Qué modo de autenticación de ASP.NET está mejor adaptado a identificar y autorizar usuarios pertenecien-

tes a una red corporativa?

La autenticación Windows integrada es la mejor adaptada para autenticar usuarios de una red corpo-rativa porque usa las cuentas y permisos que ya existen para los usuarios de red.

2. ¿Cuál es la diferencia entre las listas de usuarios para autenticación Windows o de formularios en

Web.config?Las listas de usuarios para autenticación Windows están incluidas en el elemento <authorization > delarchivo Web.config.




299

Las listas de usuarios para autenticación por formularios se incluyen en el elemento <credentials > delarchivo Web.config, o como parte de un archivo o base de datos de usuarios externo.

3. ¿Cómo se exige la autenticación usando el archivo Web.config?(La respuesta es la misma para todos los mo-dos de autenticación ASP.NET)

Para exigir autenticación incluya el siguiente elemento <authorization >

<authorization><deny users=”?” />

</authorization>

4. ¿Cómo proporciona SSL seguridad en una aplicación Web?

SSL protege los datos intercambiados entre un cliente y una aplicación Web encriptando los datos an-tes de que se envíen a través de Internet

5. ¿Cómo se comienza y se termina una comunicación segura mediante SSL?

Para comenzar una comunicación segura especifique el protocolo https en la dirección, por ejemplo:

<a href=”https://www.contoso.com/segure.htm”>Página segura.</a>

Para terminar una comunicación segura especifique el protocolo http en la dirección, por ejemplo:

<a href=”http://www.contoso.com/Default.htm”>No seguro.</a>

Capítulo 9: Generar y desplegar aplicaciones Web1. ¿Bajo qué permisos se ejecutan de forma predeterminada las aplicaciones Web?

De forma predeterminada las aplicaciones Web corren como el usuario ASPNET, que tiene permisoslimitados equivalentes al grupo Usuarios.

2. ¿Por qué es importante el archivo Machine.config para las aplicaciones Web desplegadas?

El archivo Machine.config controla muchos aspectos de la ejecución de aplicaciones Web, incluyendocómo se reciclan los procesos, que tipos límites se imponen a las colas de peticiones y qué intervalo seusa para comprobar si los usuarios siguen conectados.

3. ¿Cómo se configuran las opciones de caché para una aplicación Web?

Use las extensiones de servidor de FrontPage en IIS para establecer las opciones de caché de página

para una aplicación Web.4. ¿Cómo afecta al estado de sesión de una aplicación Web el despliegue en una granja Web o jardín Web?

Las aplicaciones Web que se despliegan en una granja o jardín Web necesitan identificar un proveedorde estado de sesión en su archivo Web.config. Esto se debe a que las peticiones de un mismo cliente sepueden dirigir a diferentes procesos en el curso de su sesión. El proveedor de estado de sesión permiteque cada proceso diferente acceda al mismo estado de sesión del cliente.

Capítulo 10: Probar aplicaciones Web1. ¿Cómo se relacionan entre sí las pruebas de unidad, integración y regresión?.

Las pruebas de unidad son la base que asegura que cada fragmento de código funciona correctamente.Las pruebas de integración amplían este concepto verificando que los fragmentos funcionan juntos sinerrores. Las pruebas de regresión se componen de las pruebas de unidad y de integración existentes,

que se ejecutan de forma regular para asegurar que el código nuevo no introduce errores en el que yafuncionaba.

2. ¿Por qué tiene más importancia la prueba de carga en una aplicación Web que en una aplicación Windowsindependiente?

Porque las aplicaciones Web pueden ser de uso público en Internet, pueden tener cientos, miles o in-cluso millones de usuarios. Las pruebas de carga permiten simular la demanda esperada para localizarconflictos de recursos, cuellos de botella de rendimiento u otros problemas que no aparecen en laspruebas de un solo usuario.

3. ¿Cuál es la diferencia entre las clases Debug y Trace?

Con la configuración predeterminada del entorno el código que usa la clase Debug se elimina en lacompilación definitiva, mientras que el que usa la clase Trace se mantiene. Por lo demás, las dos clasesson equivalentes.

4. ¿Cuáles son los dos pasos especiales necesarios para asegurar que un componente COM puede usar un componente de un ensamblado .NET?



MCAD/MCSD

300

• Debe registrar el ensamblado .NET en el registro del sistema usando RegAsm.exe• Debe asegurarse de que el componente .COM puede localizar el ensamblado .NET, ya sea colocan-

do el ensamblado .NET en la caché de ensamblados global, o colocando los dos componentes en elmismo directorio, o siguiendo otras reglas de localización de ensamblados.

Capítulo 11: Crear sus propios controles Web1. Describa brevemente los mejores usos para cada uno de los tres tipos de controles Web completando las si-

guientes frases:

Cree un control de usuario si quiere crear rápidamente un grupo de controles que se pueda reutilizar a lolargo de un proyecto para realizar alguna unidad lógica de trabajo.

Cree un control personalizado compuesto si quiere combinar uno o más controles existentes en un ensam-blado compilado que se pueda reutiliza fácilmente en varios proyectos diferentes.

Cree un control trazado si quiere crear un control completamente nuevo que se pueda compilar en un en-samblado para usar en varios proyectos.

2. ¿Qué importancia tiene la derivación para crear controles Web personalizados?

Los controles personalizados, tanto compuestos como trazados, derivan de la clase base WebControl .Esta clase proporciona los métodos que se sustituyen para crear la apariencia del control.

3. ¿Cuál es el método más importante que hay que sustituir cuando se crea un control personalizado compuesto?

El método CreateChildControls se sustituye para añadir controles existentes a un control personaliza-do compuesto.

4. ¿Cuál es el método más importante que hay que sustituir cuando se crea un control trazado?

Cuando se crea un control personalizado trazado se sustituye el método Render .

5. ¿En que se diferencia lanzar un suceso de vuelta en un control compuesto a hacerlo en un control trazado?

En un control compuesto puede usar uno de los controles contenidos para lanzar un suceso de envío.En un control trazado debe implementar el interface IPostBackEventHandler y escribir una secuenciade comandos de lado cliente para lanzar un suceso de envío.

Capítulo 12: Trabajar con multimedia1. ¿Por qué normalmente se controla el multimedia desde secuencias de comandos de cliente en lugar de código

de servidor?Para interceptar sucesos en el servidor es necesario volver a mostrar la página, lo que reinicia la mayorparte de los medios, incluyendo sonido y vídeo.

2. ¿Qué elementos HTML de sonido y video soportan la mayoría de los navegadores?

La mayoría de los navegadores soportan los elementos bgsound , img y embed de HTML.

3. ¿Cómo se da soporte a los usuarios de Netscape Navigator desde dentro de un elemento de objeto ActiveX?

Anidando un elemento embed de HTML que contiene un plugin Netscape equivalente dentro del ele-mento object de HTML para ActiveX. También necesitará modificar o desactivar código de cliente quecontrola el objeto ActiveX si el navegador del usuario es Netscape Navigator.

4. ¿Qué característica principal proporciona HTML+TIME que no está disponible con otras técnicas de anima-ción?

HTML+TIME permite sincronizar sucesos temporizados en una página.

5. Indique dos formas de crear una nueva línea de tiempo usando HTML+TIME

• Usar un elemento de línea de tiempo como t:SEQ , t:EXCL o t:PAR • Añadir un atributo TIMECONTAINER a un elemento HTML estándar.

Capítulo 13: Dar formato a salida de aplicación Web1. ¿Cuál es la ventaja de usar CSS en lugar de estilos en línea para dar formato a una aplicación Web?

El uso de CSS permite mantener el formato por separado del contenido en los formularios Web, demodo que los cambios son más sencillos y es más fácil mantener la coherencia de aspecto.

2. ¿Por qué crearía un estilo para una clase en lugar de para un elemento HTML?




301

Se crean clases de estilo cuando se quiere aplicar el mismo formato a diferentes tipos de elementos de-ntro de una aplicación. Por ejemplo, puede crear una clase de estilo énfasis que aplica el mismo forma-to a cualquier texto, control, encabezado o imagen hacia los que quiere atraer la atención.

3. ¿Cómo se relacionan entre sí CSS y XSL cuando se trata de dar a una aplicación Web?

CSS y XSL son técnicas complementarias para dar formato. CSS determina la fuente, color, tamaño,fondo y otros aspectos de apariencia de los elementos HTML en una página Web. XSL se usa paratransformar archivos XML en salida HTML. De esta forma, XSL controla la posición y apariencia de

elementos en base a su contenido. Juntos, XSL realiza las tareas de alto nivel de composición y diseñomientras que CSS realiza las tareas de bajo nivel de aplicar fuentes, colores y otras características deaspecto.

4. ¿Cuáles son las diferencias entre HTML y XML?

• HTML usa nombres de elemento predefinidos, como < p > y <br >. En XML el usuario crea sus pro-pios nombres de elemento para identificar nodos de datos jerárquicos.

• La sintaxis XML es mucho más estricta que HTML: los elementos siempre deben tener etiqueta decierre, los nombres de elemento diferencian mayúsculas y minúsculas, los valores de los atributossiempre deben ir entre comillas, y los elementos anidados deben terminar dentro de su elementopadre.

• XML identifica los datos conceptualmente en base al contenido de datos, en lugar de en base al tipode formato que se aplica.

Capítulo 14: Proporcionar ayuda al usuario1. ¿En qué atributo del HTML mostrado por ASP.NET se convierte la propiedad ToolTip de un control de ser-

vidor?

En tiempo de ejecución la propiedad ToolTip se convierte en el atributo title .

2. ¿En que se diferencia mostrar ayuda HTML usando el método showHelp del objeto window de mostrarla enuna ventana del navegador?.

El método showHelp no puede abrir ayuda HTML compilada desde una dirección de red; el archivocompilado se debe descargar antes en la máquina del usuario. Puede mostrar ayuda HTML desde unadirección de red en una ventana del navegador, usando el protocolo ms-its . Sin embargo, desde unaventana de navegador no están disponibles de forma automática las características de contenido, índice

y búsqueda.3. ¿Cómo se añaden palabras clave de índice a un tema de ayuda?.

Inserte un elemento objeto en el tema de ayuda usando el control ActiveX ayuda HTML. Por ejemplo,el siguiente elemento objeto añade la palabra clave de índice “números ”


<param name="Keyword" value="numbers"></OBJECT>

Capítulo 15: Globalizar aplicaciones Web1. ¿Cuál es la diferencia entre la propiedad CurrentCulture y la propiedad CurrentUICulture?

La propiedad CurrentCulture afecta a cómo manipula el marco de trabajo .NET las fechas, monedas,

ordenación y formato. La propiedad CurrentUICulture determina qué ensamblado satélite se usacuando se cargan recursos.

2. ¿Cómo se detecta la cultura del usuario?

Utilice el array UserLanguages del objeto Request . El valor del elemento 0 corresponde a un código decultura utilizado por la clase CultureInfo . Por ejemplo:

SLang = Request.UserLanguage(0)

3. ¿Qué es una cultura neutral?

Las culturas neutrales representan lenguajes generales sin diferencias regionales, como la moneda. Porejemplo, el código de cultura “es” representa español.

4. ¿Cómo afecta la codificación de caracteres a los formatos de archivo?

Cuando se usan caracteres no ASCII en un formulario Web debe grabar el archivo con una codifica-ción de caracteres específica, como UTF-8. ASP.NET puede detectar automáticamente la codificación



MCAD/MCSD

desarrollo de aplicaciones web.pdf

Documents