gala-mm081-manual-ts-desarrollo-de-aplicaciones-aspnet-utilizando-la-plataforma-microsoftnet-35-se-diferente-integrate (1)
Anuncio
GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Sé diferente, intégrate… Mm081 Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Autor: Orlando Gutiérrez Fecha: 01/01/2011 1 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 INDICE 1 CONFIGURAR PROVEEDORES DE DATOS: PERSONALIZACIÓN, MIEMBROS, FUENTES DE DATOS, MAPA DEL SITIO, RECURSOS, SEGURIDAD .......................................................................................................................... 5 CONTROLES DE ORIGEN DE DATOS ........................................................................................................ 5 MAPA DEL SITIO .................................................................................................................................. 6 CONTROLES DE EXPLORACIÓN DEL SITIO ............................................................................................... 7 PROTEGER EL ACCESO DE DATOS .......................................................................................................... 8 2 CONFIGURAR LA AUTENTICACIÓN, AUTORIZACIÓN Y LA REPRESENTACIÓN: AUTENTICACIÓN DE FORMULARIOS, AUTENTICACIÓN DE WINDOWS ............................................................................................................... 9 ARQUITECTURA DE SEGURIDAD DE ASP.NET ........................................................................................... 9 AUTENTICACIÓN DE ASP.NET ............................................................................................................... 12 PROVEEDOR DE AUTENTICACIÓN DE WINDOWS...................................................................................... 13 PROVEEDOR DE AUTENTICACIÓN MEDIANTE FORMULARIOS ..................................................................... 14 3 CONFIGURAR PROYECTOS, SOLUCIONES Y CONJUNTOS DE REFERENCIAS: CONJUNTOS LOCALES, CONJUNTOS COMPARTIDOS (GAC), PROYECTOS DE APLICACIONES WEB, SOLUCIONES ............................................. 19 COLOCACIÓN DE ENSAMBLADOS .......................................................................................................... 20 CACHÉ DE ENSAMBLADOS GLOBAL........................................................................................................ 20 4 CONFIGURAR EL ESTADO DE LA SESIÓN UTILIZANDO MICROSOFT SQL SERVER, STATE SERVER O INPROC: CONFIGURACIÓN DEL TIEMPO DE ESPERA; SESIONES SIN COOKIES ...................................................... 21 ESTADO DE SESIÓN DE ASP.NET .......................................................................................................... 21 MODOS DE ESTADO DE SESIÓN ............................................................................................................ 21 MODO EN PROCESO “IN PROC” ............................................................................................................. 22 MODO SERVIDOR DE ESTADO “STATE SERVER” ...................................................................................... 22 MODO SQL SERVER............................................................................................................................. 22 MODO PERSONALIZADO ...................................................................................................................... 24 5 PUBLICAR APLICACIONES WEB: SISTEMA DE ARCHIVOS O HTTP DE VISUAL STUDIO .......................... 25 6 CONFIGURAR CONJUNTOS DE APLICACIONES ..................................................................................... 28 7 COMPILAR UNA APLICACIÓN UTILIZANDO VISUAL STUDIO O HERRAMIENTAS DE LÍNEA DE COMANDO: ASPNET_COMPILER.EXE, COMPILACIÓN JUST-IN-TIME (JIT), ASPNET_MERGE.EXE ................................ 29 HERRAMIENTA DE COMPILACIÓN DE ASP.NET (Aspnet_compiler.exe) ......................................................... 29 HERRAMIENTA DE COMBINACIÓN DE ASP.NET (Aspnet_merge.exe) ........................................................... 33 ARGUMENTOS .................................................................................................................................... 34 OPCIONES ......................................................................................................................................... 34 REALIZAR LA COMPILACIÓN CON EL COMPILADOR Just-In-Time (JIT) ......................................................... 40 8 IMPLEMENTAR CONTROLES ASOCIADOS CON DATOS: DATAGRID, DATALIST, REPEATER, LISTVIEW, GRIDVIEW, FORMVIEW, DETAILSVIEW, TREEVIEW, DATAPAGER.............................................................................. 40 9 CARGAR LOS CONTROLES DEL USUARIO DINÁMICAMENTE.................................................................. 42 10 CREAR Y UTILIZAR CONTROLES PERSONALIZADOS: REGISTRO DE CONTROLES EN UNA PÁGINA, CREACIÓN DE CONTROLES EN PLANTILLA.................................................................................................................... 44 2 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 CONTROL DE SERVIDOR CON PLANTILLA ............................................................................................... 52 11 IMPLEMENTAR LA VALIDACIÓN EN EL CLIENTE Y EN EL SERVIDOR: REQUIREDFIELDVALIDATOR, COMPAREVALIDATOR, REGULAREXPRESSIONVALIDATOR, CUSTOMVALIDATOR, RANGEVALIDATOR ....... 63 VALIDAR LA INFORMACIÓN ESPECIFICADA POR EL USUARIO EN PÁGINAS WEB ASP.NET .............................. 63 TIPOS DE VALIDACIÓN Y CONTROLES.................................................................................................... 65 12 UTILIZAR CONTROLES ESTÁNDAR: BUTTON, TEXTBOX, DROPDOWNLIST, RADIOBUTTON, CHECKBOX, HYPERLINK, WIZARD, MULTIVIEW ........................................................................................................ 66 BUTTON ............................................................................................................................................ 66 13 LEER Y ESCRIBIR DATOS XML: XMLDOCUMENT, XPATHNAVIGATOR, XPATHNODEITERATOR, XPATHDOCUMENT, XMLREADER, XMLWRITER, XMLDATADOCUMENT, XMLNAMESPACEMANAGER ............ 68 14 MANIPULAR LOS DATOS UTILIZANDO LOS OBJETOS DATASET Y DATAREADER .................................. 70 ARQUITECTURA DE ADO.NET ................................................................................................................ 70 15 LLAMAR A UN SERVICIO WINDOWS COMMUNICATION FOUNDATION (WCF) O A UN SERVICIO WEB DESDE UNA PÁGINA WEB ASP.NET: APP_WEBREFERENCES; <SYSTEM.SERVICEMODEL> CONFIGURATION .................................................................................................................................. 71 CONSUMO DE SERVICIOS WCF ............................................................................................................. 71 SERVICIOS WEB ................................................................................................................................. 74 16 IMPLEMENTAR UN CONTROL DATASOURCE: LINQDATASOURCE, OBJECTDATASOURCE, XMLDATASOURCE, SQLDATASOURCE ..................................................................................................... 75 17 VINCULAR LOS CONTROLES A LOS DATOS UTILIZANDO LA SINTAXIS DE UNIÓN DE DATOS (DATA BINDING) ............................................................................................................................................. 77 EL MECANISMO DEL ENLACE A DATOS ................................................................................................... 77 18 CONFIGURAR LA DEPURACIÓN Y LOS ERRORES PERSONALIZADOS. PUEDE INCLUIR, PERO SIN LIMITARSE A ELLO: <CUSTOMERRORS MODE="OFF|ON|REMOTEONLY" />, <COMPILATION DEBUG="TRUE"/> ................................................................................................................................ 80 HABILITAR LA DEPURACIÓN EN ASP.NET ................................................................................................ 80 19 CONFIGURAR UN ENTORNO PARA REALIZAR LA DEPURACIÓN REMOTA ............................................. 82 20 DEPURAR LAS EXCEPCIONES SIN TRAZAR AL UTILIZAR ASP.NET AJAX: MÉTODOS SYS.DEBUG EN EL CLIENTE; CONEXIÓN DE UN PROGRAMA DE DEPURACIÓN A WINDOWS INTERNET EXPLORER ................ 83 21 IMPLEMENTAR EL SEGUIMIENTO DE UNA APLICACIÓN WEB: TRACE.AXD, TRACE=TRUE ON @PAGE DIRECTIVE,<TRACE ENABLED="TRUE"/> .............................................................................................. 89 22 DEPURAR LOS PROBLEMAS DE IMPLEMENTACIÓN: ASPNET_REGIIS.EXE; CREACIÓN DE UNA APLICACIÓN WEB IIS; CONFIGURACIÓN DE LA VERSIÓN DE .NET FRAMEWORK ..................................... 96 aspnet_regiis [opciones] ...................................................................................................................... 96 OPCIONES DE CONFIGURACIÓN............................................................................................................ 97 23 SUPERVISAR APLICACIONES WEB: SUPERVISIÓN DE LA SALUD UTILIZANDO WEBEVENT, CONTADORES DE RENDIMIENTO............................................................................................................ 98 USAR LOS EVENTOS DE SUPERVISIÓN DE ESTADO DE ASP.NET .............................................................. 100 3 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 UTILIZAR EVENTOS WEB Y PROVEEDORES INTEGRADOS ........................................................................ 100 24 IMPLEMENTAR FORMULARIOS WEB UTILIZANDO ASP.NET AJAX: ENABLEPARTIALRENDERING, TRIGGERS, CHILDRENASTRIGGERS, SCRIPTS, SERVICES, UPDATEPROGRESS, TIMER, SCRIPTMANAGERPROXY ...................................................................................................................... 101 CONTROL TIMER ............................................................................................................................... 102 CONTROL UPDATE PANEL ................................................................................................................... 103 ESPECIFICAR LOS DESENCADENADORES (TRIGGERS) DE UPDATEPANEL .................................................. 104 25 INTERACTUAR CON LA BIBLIOTECA EN EL CLIENTE ASP.NET AJAX: OBJETOS JAVASCRIPT OBJECT NOTATION (JSON); TRATAMIENTO DE EVENTOS ASP.NET AJAX ........................................................... 105 INTRODUCCIÓN ............................................................................................................................... 105 UTILIZANDO SINTAXIS JSON CON AJAX ............................................................................................... 106 DEVOLVIENDO DATOS EN UN FORMATO JSON DESDE UN SERVICIO WEB ASP.NET SOBRE HTTP .................. 106 ENTENDIENDO EL PARÁMETRO ‘D’ EN LOS DATOS ASP.NET AJAX JSON .................................................... 107 AJAX DE ASP.NET: INTERIOR DE LA CADENA DE FECHA Y HORA DE JSON ................................................. 107 26 USAR SERVICIOS DE SCRIPTS DE CLIENTE...................................................................................... 108 CONSUMO DE SERVICIOS DE DATOS MEDIANTE LA BIBLIOTECA AJAX DE ASP.NET .................................... 108 USO DE LA CLASE OPENDATACONTEXT ................................................................................................ 108 27 CREAR Y REGISTRAR UN SCRIPT DE CLIENTE: INLINE, ARCHIVO .JS INCLUIDO, RECURSO JAVASCRIPT INCRUSTADO, CREADO DESDE EL CÓDIGO DE SERVIDOR ................................................. 111 28 PROGRAMAR DISPOSITIVOS MÓVILES ............................................................................................ 113 ASP.NET MOBILE WEB FORMS Y COMPATIBILIDAD CON ASP.NET ............................................................. 115 29 ACCESO A LAS CAPACIDADES DEL DISPOSITIVO: TRABAJO CON EMULADORES ............................... 117 30 CONTROLAR EL PROCESAMIENTO ESPECÍFICO DEL DISPOSITIVO: CONTROL DEVICESPECIFIC; FILTROS DE DISPOSITIVO; PLANTILLAS DE CONTROL ......................................................................... 118 31 AGREGAR CONTROLES WEB MÓVILES A UNA PÁGINA WEB: CONTROLES STYLESHEET; CONTROLES LIST; CONTROLES CONTAINER ............................................................................................................ 120 32 IMPLEMENTAR ADAPTADORES DE CONTROL: APP_BROWSERS; PROCESAMIENTO UTILIZANDO CHTMLTEXTWRITER O XHTMLTEXTWRITER .......................................................................................... 121 33 PERSONALIZAR EL DISEÑO Y APARIENCIA DE UNA PÁGINA WEB: CSS, TEMAS Y FUNCIONES, PÁGINAS PRINCIPALES Y ELEMENTOS WEB, APP_THEMES, STYLESHEETTHEME ................................... 129 TEMAS Y MÁSCARAS DE ASP.NET ........................................................................................................ 129 CONTROLES DE SERVIDOR WEB ASP.NET Y ESTILOS DE CSS .................................................................. 132 34 TRABAJAR CON OBJETOS INTRÍNSECOS DE ASP.NET: REQUEST, SERVER, APPLICATION, SESSION, RESPONSE, HTTPCONTEXT................................................................................................................... 135 35 IMPLEMENTAR LA GLOBALIZACIÓN Y ACCESIBILIDAD: ARCHIVOS DE RECURSOS, CONFIGURACIÓN DE CULTURA, REGIONINFO, APP_GLOBALRESOURCES, APP_LOCALRESOURCES, TABINDEX, ALTERNATETEXT , GENERATEEMPTYALTERNATETEXT, ACCESSKEY, LABEL.ASSOCIATEDCONTROLID ..... 137 INFORMACIÓN GENERAL SOBRE LA GLOBALIZACIÓN Y LA LOCALIZACIÓN ................................................ 137 CONCEPTOS COMUNES DE RECURSOS ................................................................................................. 138 4 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 CÓMO: CREAR ARCHIVOS DE RECURSOS PARA SITIOS WEB ASP.NET ...................................................... 140 CREAR UNA APLICACIÓN WEB ACCESIBLE ............................................................................................ 142 CÓMO: CREAR ARCHIVOS DE RECURSOS PARA SITIOS WEB ASP.NET ...................................................... 140 36 IMPLEMENTAR OBJETOS EMPRESARIALES Y CLASES DE UTILIDAD: APP_CODE , CONJUNTOS EXTERNOS........................................................................................................................................... 143 INFORMACIÓN GENERAL SOBRE LA GLOBALIZACIÓN Y LA LOCALIZACIÓN ................................................ 137 37 IMPLEMENTAR EL ESTADO DE SESIÓN, VER EL ESTADO, CONTROLAR EL ESTADO, COOKIES, CACHÉ O ESTADO DE LA APLICACIÓN ............................................................................................................. 145 38 TRATAR EVENTOS Y CONTROLAR EL FLUJO DE PÁGINAS: EVENTOS DE PÁGINA, EVENTOS DE CONTROL, EVENTOS DE APLICACIÓN Y EVENTOS DE SESIÓN, PUBLICACIONES EN VARIAS PÁGINAS; RESPONSE.REDIRECT, SERVER.TRANSFER, ISPOSTBACK, CONFIGURACIÓN DE AUTOEVENTWIREUP IMPLEMENTAR EL CONTROLADOR GENERIC ......................................................................................... 148 MODELO DE EVENTOS DE CONTROL DE SERVIDOR WEB ASP.NET ............................................................ 148 5 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 1 CONFIGURAR PROVEEDORES DE DATOS: PERSONALIZACIÓN, MIEMBROS, FUENTES DE DATOS, MAPA DEL SITIO, RECURSOS, SEGURIDAD Las aplicaciones Web obtienen acceso normalmente a los orígenes de datos para el almacenamiento y la recuperación de datos dinámicos. Se puede escribir código para el acceso a los datos utilizando clases del espacio de nombres System.Data (normalmente denominado ADO.NET) y del espacio de nombres System.Xml. Este enfoque era normal en versiones anteriores de ASP.NET. Sin embargo, ASP.NET también permite realizar el enlace de datos mediante declaración. Este proceso no requiere la existencia de código para los escenarios de datos más comunes, entre los que se incluyen: Seleccionar y mostrar datos. Ordenar, paginar y almacenar datos en memoria caché. Actualizar, insertar y eliminar datos. Filtrar datos utilizando parámetros en tiempo de ejecución. Crear escenarios de detalles maestros utilizando parámetros. ASP.NET incluye dos tipos de controles de servidor que participan en el modelo de enlace de datos declarativo: controles de origen de datos y controles enlazados a datos. Estos controles administran las tareas subyacentes requeridas por el modelo Web sin estado para mostrar y actualizar datos en páginas Web ASP.NET. Por tanto, no es estrictamente necesario conocer los detalles del ciclo de vida de la solicitud de página si sólo se va a realizar el enlace de datos. CONTROLES DE ORIGEN DE DATOS Los controles de origen de datos son controles ASP.NET que administran las tareas de conexión a un origen de datos y de lectura y escritura de datos. Los controles de origen de datos no representan ninguna interfaz de usuario, sino que actúan como intermediarios entre un almacén de datos en particular (como una base de datos, un objeto comercial o un archivo XML) y los demás controles de la página Web ASP.NET. Los controles de origen de datos habilitan un amplio conjunto de funciones para recuperar y modificar datos, entre las que se incluyen la consulta, la ordenación, la paginación, el filtrado, la actualización, la eliminación y la inserción. ASP.NET incluye los controles de origen de datos siguientes: AccessDataSource Permite trabajar con una base de datos de Microsoft Access. LinqDataSource Permite usar Language-Integrated Query (LINQ) en una página web ASP.NET a través de marcado declarativo para recuperar y modificar datos de un objeto de datos. Admite la generación automática de comandos de selección, actualización, inserción y eliminación. El control también admite ordenación, filtrado y paginación. ObjectDataSource Permite trabajar con un objeto comercial u otra clase y crear aplicaciones Web basadas en objetos de nivel medio para administrar los datos. SiteMapDataSource Se utiliza con la navegación en el sitio ASP.NET. SqlDataSource Permite trabajar con proveedores de datos administrados de ADO.NET, que proporcionan acceso a bases de datos de Microsoft SQL Server, OLE DB, ODBC u Oracle. XmlDataSource Permite trabajar con un archivo XML, que es especialmente útil para controles de servidor ASP.NET jerárquicos tales como el control TreeView o Menu. 6 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Los controles de origen de datos también se pueden ampliar para admitir proveedores de almacenamiento y acceso a datos adicionales. MAPA DEL SITIO Puede utilizar las características de exploración del sitio de ASP.NET con el fin de proporcionar una manera coherente a los usuarios para explorar el sitio. Cuando un sitio crece y cuando se mueven sus páginas, puede resultar complicado administrar todos los vínculos. La exploración del sitio de ASP.NET permite almacenar los vínculos de todas las páginas en una ubicación central y representar estos vínculos en listas o menús de desplazamiento en cada página incluyendo un control de servidor Web específico. Con la exploración del sitio de ASP.NET, puede crear una solución de exploración consistente y fácil de administrar para el sitio. La exploración del sitio de ASP.NET cuenta con las características siguientes: Mapas del sitio Se puede utilizar un mapa del sitio para describir la estructura lógica de su sitio. Se puede administrar la exploración de la página modificando el mapa del sitio cuando se agregan o se eliminan páginas en lugar de modificar los hipervínculos en todas las páginas Web. Controles ASP.NET Se puede utilizar estos controles para mostrar los menús de exploración en las páginas Web. Los menús de exploración se basan en el mapa del sitio. Control de programación Se puede utilizar la exploración del sitio de ASP.NET en el código para crear controles de exploración personalizados o modificar la ubicación de la información que se muestra en un menú de desplazamiento. Reglas de acceso Se puede configurar reglas de acceso para mostrar u ocultar un vínculo en el menú de desplazamiento. Proveedores de mapas de sitio personalizados Se puede crear proveedores de mapas de sitio personalizados permitiendo trabajar con el propio servidor del mapa del sitio (por ejemplo, una base de datos donde almacene la información de los vínculos) y conectar el proveedor al sistema de exploración del sitio de ASP.NET. En la ilustración siguiente se muestran las relaciones existentes entre los componentes de exploración del sitio de ASP.NET. 7 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 CONTROLES DE EXPLORACIÓN DEL SITIO Crear un mapa del sitio reflejando la estructura del sitio es una parte del sistema de exploración del sitio de ASP.NET. La otra parte es mostrar la estructura de exploración en las páginas Web ASP.NET para que los usuarios puedan desplazarse por el sitio con facilidad. Se puede establecer la exploración en las páginas de forma sencilla utilizando los siguientes controles de desplazamiento del sitio de ASP.NET: SiteMapPath Este control muestra una ruta de desplazamiento indicando al usuario la ubicación de la página actual y mostrando los vínculos como una ruta de retorno a la página principal. El control proporciona muchas opciones para personalizar el aspecto de los vínculos. TreeView Este control muestra una estructura de árbol, o de menú, que los usuarios pueden recorrer para llegar a diferentes páginas del sitio. Se puede expandir o contraer un nodo conteniendo nodos secundarios haciendo clic en él. Menu Este control muestra un menú expansible a los usuarios para recorrer llegando a diferentes páginas del sitio. Un nodo conteniendo nodos secundarios se expandirá cuando el cursor se sitúe sobre el menú. 8 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Puede utilizar el control SiteMapPath para crear la exploración del sitio sin código y sin enlaces de datos explícitos. El control puede leer y representar la información del mapa del sitio automáticamente. Sin embargo, si es necesario, también se puede personalizar el control SiteMapPath mediante código. El control SiteMapPath permite a los usuarios desplazarse hacia atrás desde la página actual a las páginas superiores en la jerarquía del sitio. Sin embargo, el control SiteMapPath no le permite desplazarse hacia delante desde la página actual a otra página más profunda en la jerarquía. El control SiteMapPath es útil para las aplicaciones de grupos de noticias o mensajería cuando los usuarios desean ver la ruta de acceso al artículo que están explorando. Con los controles TreeView o Menu, los usuarios pueden abrir los nodos y desplazarse directamente a una página determinada. Estos controles no leen el mapa del sitio directamente, puesto que ya lo hace el control SiteMapPath. En su lugar, se puede agregar un control SiteMapDataSource a una página que pueda leer el mapa del sitio. A continuación, se puede enlazar el control TreeView o Menu al control SiteMapDataSource, lo que hace que el mapa del sitio se represente en la página. PROTEGER EL ACCESO A DATOS La mayoría de las aplicaciones Web ASP.NET implican el acceso a datos. Muchas aplicaciones recogen datos para almacenarlos en una base de datos o en un archivo y, a menudo, se basan en información procedente de los usuarios. Puesto que los datos originales pueden proceder de orígenes no de confianza (y la información se almacena en un formato permanente) y se debe asegurar que los usuarios no autorizados no puedan obtener acceso al origen de datos directamente, es necesario prestar especial atención a los problemas de seguridad relacionados con el acceso a datos. Aunque se puede mejorar la seguridad de la aplicación siguiendo las buenas prácticas en materia de codificación y configuración, también es importante mantener actualizado el servidor Web con las últimas actualizaciones de seguridad de Microsoft Windows e Internet Information Services (IIS), así como las actualizaciones de seguridad de Microsoft SQL Server o cualquier otro software de base de datos. Proteger el acceso a un origen de datos Cadenas de conexión: Para conectar con una base de datos, se necesita una cadena de conexión. Puesto que las cadenas de conexión pueden contener datos confidenciales, se deben seguir estas instrucciones: a) No almacenar cadenas de conexión en ninguna página. Por ejemplo, evite la configuración de las cadenas de conexión como propiedades declarativas del control SqlDataSource o de otros controles de origen de datos. En su lugar, almacénelas en el archivo Web.config del sitio. b) No almacenar cadenas de conexión como texto sin formato. Para proteger la conexión al servidor de base de datos, se recomienda cifrar la información de la cadena de conexión del archivo de configuración mediante la configuración protegida. Conectar con SQL Server mediante seguridad integrada: En lo posible conectarse a una instancia de SQL Server utilizando la seguridad integrada en lugar de un nombre de usuario explícito y una contraseña. De esta forma, se evita la posibilidad de comprometer la integridad de la cadena de conexión y de exponer el identificador de usuario y la contraseña. Se recomienda asegurarse de la identidad del proceso (por ejemplo, la agrupación de aplicaciones) ejecutando ASP.NET sea la cuenta de proceso predeterminada o una cuenta de usuario restringida. En los casos donde distintos sitios Web conectan con diversas bases de datos de SQL Server, puede no resultar práctico utilizar la seguridad integrada. Por ejemplo, en los sitios de alojamiento Web, se suele asignar a cada cliente una base de datos de SQL Server diferente, pero todos utilizan el servidor Web como usuarios anónimos. En estos casos, debe utilizar credenciales explícitas para conectarse a una instancia de SQL Server. Asegúrese de almacenar las credenciales de forma segura. Permisos de base de datos de SQL Server Se recomienda asignar los privilegios mínimos al identificador de usuario utilizado para la conexión a las bases de datos de SQL Server usadas en la aplicación. Restringir las operaciones de SQL Los controles enlazados a datos pueden admitir una gran variedad de operaciones con datos como selección, inserción, eliminación y actualización de registros en las tablas de datos. Se recomienda configurar los controles de datos para realizar la funcionalidad 9 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 mínima necesaria de la página o aplicación. Por ejemplo, si un control no debe permitir a los usuarios que eliminar datos, no se debe incluir una consulta Delete con un control de origen de datos y no permitir eliminación en el control. Protegerse de los datos de entrada malintencionados Si la aplicación acepta la entrada de datos de los usuarios, debe asegurar su contenido no es malintencionado y no compromete la integridad de la aplicación. Los usuarios malintencionados pueden introducir datos para iniciar los siguientes ataques: a) Inyección de secuencia de comandos Un ataque de inyección consiste en enviar una secuencia de comandos a la aplicación para que otros usuarios la ejecuten. En los ataques de inyección típicos, las secuencias de comandos se envían a una página almacenándolas en una base de datos, de modo que otro usuario que vea los datos ejecute el código sin darse cuenta. b) Inyección SQL Los ataques de inyección SQL intentan comprometer la seguridad de la base de datos, y posiblemente la del equipo en el que se está ejecutando, creando comandos de SQL que se ejecutan sustituyendo o sumándose a los integrados en la aplicación. 2 CONFIGURAR LA AUTENTICACIÓN, AUTORIZACIÓN Y LA REPRESENTACIÓN: AUTENTICACIÓN DE FORMULARIOS, AUTENTICACIÓN DE WINDOWS ASP.NET, conjuntamente con Microsoft Internet Information Services (IIS), puede autenticar las credenciales del usuario como nombres y contraseñas mediante los métodos de autenticación siguientes: Windows: básica, implícita, y Autenticación de Windows integrada (NTLM o Kerberos). Autenticación mediante formularios, con la que crea una página de inicio de sesión y se administra la autenticación en la aplicación. Autenticación mediante certificados de cliente ASP.NET controla el acceso a la información de los sitios comparando las credenciales autenticadas, o representaciones de las mismas, con los permisos del sistema de archivos de Microsoft Windows NT o con un archivo XML conteniendo la lista de usuarios autorizados, funciones autorizadas (grupos) o verbos HTTP autorizados. Para ayudar a proteger la seguridad de una aplicación ASP.NET, se deben llevar a cabo las dos funciones principales descritas en la siguiente tabla. Función de seguridad Descripción Autenticación Ayuda a comprobar que el usuario es precisamente quien dice ser. La aplicación obtiene las credenciales (diversas formas de identificación, como nombre y contraseña) de un usuario, y las valida consultando a una autoridad determinada. Si las credenciales son válidas, se considera a la entidad enviando las credenciales como una entidad autenticada. Autorización Limita los derechos de acceso mediante la concesión o negación de permisos específicos a una identidad autenticada. Además, Internet Information Services (IIS) puede conceder o negar el acceso en función de la dirección IP o del nombre de host del usuario. Cualquier autorización de acceso posterior se realiza mediante la autorización de la dirección URL del permiso de acceso al sistema de archivos NTFS. Es importante entender cómo interactúan todos los diversos subsistemas de seguridad. Puesto que ASP.NET se basa en Microsoft .NET Framework, el desarrollador de aplicaciones ASP.NET también tiene acceso a todas las características de seguridad integradas de .NET Framework, como la seguridad de acceso a código y la seguridad de acceso basada en funciones ARQUITECTURA DE SEGURIDAD DE ASP.NET En esta sección se proporciona información general sobre la infraestructura de seguridad de ASP.NET. En la siguiente ilustración se muestran las relaciones entre los sistemas de seguridad de ASP.NET. 10 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Como se muestra en la ilustración, todos los clientes Web se comunican con las aplicaciones ASP.NET a través de Microsoft Internet Information Services (IIS). IIS autentica la solicitud si fuera necesario y, a continuación, busca el recurso solicitado (como una aplicación ASP.NET). Si el cliente está autorizado, el recurso estará disponible. Cuando se está ejecutando una aplicación ASP.NET, puede utilizar las características de seguridad de ASP.NET integradas. Además, una aplicación ASP.NET puede utilizar las características de seguridad de .NET Framework 11 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Flujo de datos en Seguridad .Net Por Windows 12 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Por formularios AUTENTICACIÓN DE ASP.NET La autenticación es un proceso que consiste en obtener las credenciales de identificación, como nombre y contraseña, de un usuario y validarlas consultando a una autoridad determinada. Si las credenciales son válidas, se considera a la entidad que ha enviado las credenciales como una entidad autenticada. Una vez autenticada la identidad, el proceso de autorización determina si esa identidad tiene acceso a un recurso específico. ASP.NET implementa este proceso a través de proveedores de autenticación, módulos conteniendo el código necesario para autenticar las credenciales del solicitante. Proveedor de autenticación de Windows Proporciona información sobre cómo utilizar la autenticación de Windows junto con la autenticación de Microsoft Internet Information Services (IIS) para proteger las aplicaciones ASP.NET. Proveedor de autenticación mediante formularios Proporciona información sobre cómo crear un formulario de inicio de sesión específico de la aplicación y realizar la autenticación mediante código propio. Una manera sencilla de trabajar con la autenticación de formularios consiste en utilizar la suscripción de 13 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 ASP.NET y los controles de inicio de sesión de ASP.NET, que conjuntamente proporcionan un método para recopilar las credenciales de usuario, autenticarlas y administrarlas, con muy poco código o nada en absoluto. PROVEEDOR DE AUTENTICACIÓN DE WINDOWS La Autenticación de Windows trata la identidad de usuario proporcionada por Servicios de Microsoft Internet Information Server (IIS) como el usuario autenticado en una aplicación ASP.NET. IIS ofrece diversos mecanismos de autenticación para comprobar la identidad del usuario, incluyendo autenticación anónima, autenticación de Windows integrada (NTLM), autenticación de Windows integrada (Kerberos), autenticación básica (codificada en base64), autenticación de texto implícita y autenticación basada en certificados de cliente. La autenticación de Windows se implementa en ASP.NET utilizando el módulo WindowsAuthenticationModule. El módulo construye una identidad WindowsIdentity basándose en las credenciales proporcionadas por IIS y establece la identidad como el valor actual de la propiedad User para la aplicación. La autenticación de Windows es el mecanismo de autenticación predeterminado para las aplicaciones ASP.NET y se identifica como el modo de autenticación para una aplicación mediante el elemento de configuración authentication, tal como se muestra en el ejemplo de código siguiente. <system.web> <authentication mode="Windows"/> </system.web> Suplantar la identidad de Windows El modo de autenticación de Windows establece el valor de la propiedad User actual en una identidad WindowsIdentity basándose en las credenciales proporcionadas por IIS, no modifica la identidad de Windows proporcionada al sistema de operación. La identidad de Windows proporcionada al sistema operativo se utiliza para comprobar los permisos, como los permisos de archivos NTFS, o para conectarse a una base de datos mediante la seguridad integrada. De forma predeterminada, esta identidad de Windows es la identidad del proceso de ASP.NET. En Microsoft Windows 2000 y Windows XP Professional, ésta es la identidad del proceso de trabajo de ASP.NET, la cuenta local de ASPNET. En Windows Server 2003, ésta es la identidad del Grupo de aplicaciones IIS de la aplicación ASP.NET. De forma predeterminada, ésta es la cuenta NETWORK SERVICE. Para configurar la identidad de Windows de la aplicación ASP.NET como la identidad de Windows proporcionada por IIS se debe habilitar la suplantación. Es decir, indicar a la aplicación ASP.NET suplantar la identidad suministrada por IIS para todas las tareas autenticadas por el sistema de operación Windows, incluyendo el acceso a archivos y a la red. Para habilitar la suplantación para la aplicación Web, en el archivo Web.config de la aplicación se establece el atributo impersonate del elemento identity en true, como se muestra en el ejemplo de código siguiente. <system.web> <authentication mode="Windows"/> <identity impersonate="true"/> </system.web> Habilitar la autorización utilizando ACL de NTFS Se puede mejorar la seguridad de una aplicación ASP.NET protegiendo los archivos de la aplicación mediante el sistema de archivos NTFS y Listas de control de acceso (ACL). Las ACL permiten especificar cuáles usuarios y grupos de usuarios tienen acceso a los archivos de la aplicación. 14 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 PROVEEDOR DE AUTENTICACIÓN MEDIANTE FORMULARIOS Se presenta una implementación simple de la autenticación mediante formularios de ASP.NET. Está diseñada para mostrar los principios de cómo utilizar la autenticación mediante formularios para registrar a los usuarios en una aplicación ASP.NET. La forma útil de trabajar con la autenticación mediante formularios es utilizar la suscripción y los controles de inicio de sesión de ASP.NET. La suscripción de ASP.NET proporciona un medio para almacenar y administrar la información de los usuarios e incluye métodos para su autenticación. Los controles de inicio de sesión de ASP.NET funcionan con la suscripción de ASP.NET y encapsulan la lógica requerida para solicitar credenciales a los usuarios, validarlos, recuperar o reemplazar contraseñas, etc. Efectivamente, la suscripción y los controles de inicio de sesión de ASP.NET proporcionan una capa de abstracción en la autenticación mediante formularios y reemplazan la mayor parte del trabajo que tendría que llevarse a cabo normalmente para utilizar dicha autenticación. En el escenario del ejemplo los usuarios solicitan un recurso protegido, concretamente una página denominada Default.aspx. Solamente un usuario tiene acceso al recurso protegido: [email protected], con la contraseña "WakaMaY@". El nombre de usuario y la contraseña están incluidos en el código del archivo Logon.aspx. El ejemplo requiere tres archivos: el archivo Web.config, una página denominada Logon.aspx, y una página denominada Default.aspx. Los archivos residen en el directorio raíz de la aplicación. Para configurar la aplicación para la autenticación mediante formularios 1. Colocar en el archivo Web.config de la carpeta raíz de la aplicación los siguientes elementos: <?xml version="1.0"?> <configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0"> <system.web> </system.web> </configuration> 2. Dentro del elemento system.web, crear un elemento authentication y establecer el atributo mode en Forms, como se muestra en el ejemplo siguiente: <system.web> <authentication mode="Forms"> </authentication> </system.web> 3. Dentro del elemento authentication, crear un elemento forms y establecer los atributos siguientes: loginUrl Establecer este atributo en "Logon.aspx". Logon.aspx es la dirección URL a utilizar para el redireccionamiento si ASP.NET no encuentra una cookie de autenticación con la solicitud. name Establezca este atributo en ".ASPXFORMSAUTH". De este modo se establece el sufijo del nombre de la cookie conteniendo el “token” de autenticación. <system.web> <authentication mode="Forms"> <forms loginUrl="Logon.aspx" name=".ASPXFORMSAUTH"> </forms> </authentication> </system.web> 4. Dentro del elemento system.web, crear un elemento authorization. <system.web> 15 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 <authentication mode="Forms"> <forms loginUrl="Logon.aspx" name=".ASPXFORMSAUTH"> </forms> </authentication> <authorization> </authorization> </system.web> 5. Dentro del elemento authorization, crear un elemento deny y establezca su atributo users en "?". Esto especifica que los usuarios no autenticados (representados por "?") no tienen acceso a los recursos de esta aplicación. <authentication mode="Forms"> <forms loginUrl="logon.aspx" name=".ASPXFORMSAUTH"></forms> </authentication> <authorization> <deny users="?" /> </authorization> </system.web> Crear la página de inicio de sesión Cuando los usuarios solicitan cualquier página del sitio Web y no se han autenticado previamente, son redirigidos a una página denominada Logon.aspx. Este nombre de archivo ya se ha especificado anteriormente en el archivo Web.config. La página Logon.aspx recoge las credenciales del usuario (dirección de correo electrónico y contraseña) y las autentica. Si el usuario es autenticado correctamente, la página de inicio de sesión le redirige a la página solicitada originalmente. En el ejemplo, las credenciales válidas están incluidas en el código de la página. 1. Crear una página ASP.NET denominada Logon.aspx en la carpeta raíz de la aplicación. 2. Copiar el marcado siguiente y codifique en él: <%@ Page Language="C#" %> <%@ Import Namespace="System.Web.Security" %> <script runat="server"> void Logon_Click(object sender, EventArgs e) { if ((UserEmail.Text == " [email protected]") && (UserPass.Text == " WakaMaY@")) { 16 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 FormsAuthentication.RedirectFromLoginPage (UserEmail.Text, Persist.Checked); } else { Msg.Text = "Invalid credentials. Please try again."; } } </script> <html> <head id="Head1" runat="server"> <title>Forms Authentication - Login</title> </head> <body> <form id="form1" runat="server"> <h3> Logon Page</h3> <table> <tr> <td> E-mail address:</td> <td> <asp:TextBox ID="UserEmail" runat="server" /></td> <td> <asp:RequiredFieldValidator ID="RequiredFieldValidator1" ControlToValidate="UserEmail" Display="Dynamic" ErrorMessage="Cannot be empty." runat="server" /> </td> </tr> 17 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 <tr> <td> Password:</td> <td> <asp:TextBox ID="UserPass" TextMode="Password" runat="server" /> </td> <td> <asp:RequiredFieldValidator ID="RequiredFieldValidator2" ControlToValidate="UserPass" ErrorMessage="Cannot be empty." runat="server" /> </td> </tr> <tr> <td> Remember me?</td> <td> <asp:CheckBox ID="Persist" runat="server" /></td> </tr> </table> <asp:Button ID="Submit1" OnClick="Logon_Click" Text="Log On" runat="server" /> <p> <asp:Label ID="Msg" ForeColor="red" runat="server" /> </p> </form> </body> </html> La página contiene controles de servidor ASP.NET recogiendo información sobre el usuario y una casilla de verificación en la que los usuarios pueden hacer clic para conservar sus credenciales de inicio de sesión. El controlador de Click del botón Iniciar sesión contiene código para comprobar la dirección de correo electrónico y la contraseña del usuario utilizando como referencia los valores 18 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 incluidos en el código. (La contraseña es una contraseña segura conteniendo al menos ocho caracteres e incluyendo varios caracteres no alfabéticos). Si las credenciales del usuario son correctas, el código llama al método RedirectFromLoginPage de la clase FormsAuthentication, y le pasa el nombre de usuario y un valor booleano (derivado de la casilla de verificación) indicando si se ha de conservar el “token” de autenticación como una cookie. El método redirige al usuario a la página solicitada originalmente. Si las credenciales del usuario no coinciden, se muestra un mensaje de error. La página importa el espacio de nombres System.Web.Security, conteniendo la clase FormsAuthentication. Crear la página predeterminada Para el ejemplo, se creará una página ASP.NET en la carpeta raíz de la aplicación. Como se especificó en el archivo de configuración la negación a todos los usuarios no autenticados el acceso a los recursos de ASP.NET de la aplicación (incluidos los archivos .aspx, pero no los archivos estáticos como los archivos HTML o los archivos multimedia con imágenes, música etc.), cuando un usuario solicite la página, la autenticación mediante formularios comprobará sus credenciales y, si es necesario, le redirigirá a la página de inicio de sesión. La página que cree también permitirá a los usuarios cerrar la sesión, borrando su vale de autenticación almacenado (cookie). 1. Crear una página ASP.NET denominada Default.aspx en la carpeta raíz de la aplicación. 2. Colocar el siguiente código <%@ Page Language="C#" %> <html> <head> <title>Forms Authentication - Default Page</title> </head> <script runat="server"> void Page_Load(object sender, EventArgs e) { Welcome.Text = "Hello, " + Context.User.Identity.Name; } void Signout_Click(object sender, EventArgs e) { FormsAuthentication.SignOut(); Response.Redirect("Logon.aspx"); } </script> <body> <h3> Using Forms Authentication</h3> 19 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 <asp:Label ID="Welcome" runat="server" /> <form id="Form1" runat="server"> <asp:Button ID="Submit1" OnClick="Signout_Click" Text="Sign Out" runat="server" /><p> </form> </body> </html> La página muestra la identidad autenticada del usuario, establecida por la clase FormsAuthentication y disponible en una página ASP.NET como propiedad Context.User.Identity.Name. El controlador de Click del botón Cerrar sesión contiene código que llama al método SignOut para borrar la identidad del usuario y quitar el “token” de autenticación (cookie). A continuación, redirige al usuario a la página de inicio de sesión. 3 CONFIGURAR PROYECTOS, SOLUCIONES Y CONJUNTOS DE REFERENCIAS: CONJUNTOS LOCALES, CONJUNTOS COMPARTIDOS (GAC), PROYECTOS DE APLICACIONES WEB, SOLUCIONES Introducción a soluciones, proyectos y elementos Visual Studio dispone de dos contenedores para administrar eficazmente los elementos necesarios para el desarrollo, como referencias, conexiones de datos, carpetas y archivos. Estos contenedores se denominan soluciones y proyectos. Asimismo, Visual Studio proporciona carpetas de soluciones para organizar proyectos relacionados en grupos y, a continuación, llevar a cabo acciones en esos grupos de proyectos. El Explorador de soluciones, una interfaz para ver y administrar estos contenedores y sus elementos asociados, forma parte del entorno de desarrollo integrado (IDE). Contenedores: soluciones y proyectos Las soluciones y los proyectos contienen elementos en forma de referencias, conexiones de datos, carpetas y archivos necesarios para crear la aplicación. Una solución puede contener varios proyectos y un proyecto normalmente contiene varios elementos. Estos contenedores permiten sacar partido del IDE mediante las siguientes tareas: Administrar la configuración de la solución en su totalidad o dividida en proyectos individuales Agregar elementos útiles a varios proyectos de la solución o a la solución sin tener que hacer referencia a dichos elementos en cada proyecto. Trabajar en diversos archivos, independientes de soluciones o proyectos Utilizar el Explorador de soluciones para controlar los detalles de la administración de archivos y centrarse al mismo tiempo en los elementos que constituyen la labor de desarrollo. Elementos: archivos, referencias y conexiones de datos Los elementos pueden ser archivos y otras partes del proyecto como referencias, conexiones de datos o carpetas. En el Explorador de soluciones los elementos pueden organizarse de varias formas: En forma de elementos del proyecto, tales como formularios, archivos de código fuente y clases de un proyecto del Explorador de soluciones. La organización y la presentación dependerán de la plantilla de proyecto que se seleccione, así como de cualquier modificación que se realice. En forma de elementos de la solución para archivos aplicando a la solución en su totalidad en la carpeta Elementos de la solución del Explorador de soluciones. 20 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 En forma de varios archivos no asociados a ningún proyecto ni a ninguna solución pudiendo mostrarse en la carpeta Archivos varios. COLOCACIÓN DE ENSAMBLADOS En la mayoría de las aplicaciones .NET Framework, los ensamblados que componen una aplicación se colocan en el directorio de la aplicación, en un subdirectorio de este último o en la caché de ensamblados global (si el ensamblado está compartido). Para reemplazar la ubicación en la que Common Language Runtime busca un ensamblado, se utiliza el elemento <codeBase> en un archivo de configuración. Si el ensamblado no tiene un nombre seguro, la ubicación especificada mediante Elemento <codeBase> se limita al directorio de la aplicación o a un subdirectorio de éste. Si el ensamblado tiene un nombre seguro, Elemento <codeBase> puede especificar cualquier ubicación en el equipo o la red. Se aplican reglas similares a la búsqueda de ensamblados cuando se trabaja con código no administrado o aplicaciones de interoperabilidad COM: si el ensamblado va a compartirse entre varias aplicaciones, debe instalarse en la caché de ensamblados global. Los ensamblados que se utilizan con código no administrado deben exportarse como biblioteca de tipos y registrarse. Los ensamblados utilizados por la interoperabilidad COM deben registrarse en el catálogo, aunque, en algunos casos, este registro es automático. CACHÉ DE ENSAMBLADOS GLOBAL Cada equipo donde se instala Common Language Runtime CLR tiene una memoria caché de código denominada caché de ensamblados global. La caché de ensamblados global almacena los ensamblados designados específicamente para ser compartidos por varias aplicaciones del equipo. Se recomienda compartir los ensamblados mediante su instalación en la caché de ensamblados global sólo cuando sea necesario. Como norma general, se deben mantener las dependencias de los ensamblados privadas y colocar los ensamblados en el directorio de la aplicación, a menos que sea explícitamente necesario compartir un ensamblado en concreto. Además, no es necesario instalar los ensamblados en la caché de ensamblados global para obtener acceso a ellos el código de interoperabilidad COM o el código no administrado. Existen escenarios donde no se desea instalar un ensamblado en la caché de ensamblados global. Si se coloca uno de los ensamblados componiendo una aplicación en la memoria caché de ensamblados global, no se podrá replicar ni instalar la aplicación utilizando el comando xcopy para copiar el directorio de la aplicación. También se debe mover el ensamblado en la caché de ensamblados global. Existen varias formas de implementar un ensamblado en la caché de ensamblados global: Usar un instalador diseñado para funcionar con la caché de ensamblados global. Es la opción preferida para instalar ensamblados en la caché de ensamblados global. Utilizar la herramienta de desarrollador Caché de ensamblados global (Gacutil.exe), suministrada con Kit de desarrollo de software de Windows (SDK). Usar el Explorador de Windows para incluir ensamblados en la caché. En escenarios de implementación, se recomienda utilizar Windows Installer 2.0 para instalar los ensamblados en la caché de ensamblados global. Utilizar el Explorador de Windows o la herramienta Caché de ensamblados global sólo en escenarios de programación, porque no proporcionan funciones de recuento de referencias de ensamblados y otras funciones que se incluyen con Windows Installer. Con frecuencia, los administradores protegen el directorio systemroot con una lista de control de acceso (ACL) para controlar el acceso de escritura y ejecución. Puesto que la caché de ensamblados global está instalada en un subdirectorio del directorio systemroot, hereda la lista (ACL) de dicho directorio. Es recomendable que sólo puedan eliminar archivos de la caché de ensamblados global los usuarios que tengan privilegios de administrador. Los ensamblados implementados en la caché de ensamblados global deben tener nombres seguros. Cuando se agrega un ensamblado a la caché de ensamblados global, se realizan comprobaciones de integridad de todos los archivos que componen el ensamblado. La caché realiza estas comprobaciones de integridad para garantizar que no se ha manipulado ningún ensamblado, por ejemplo, cuando se ha modificado un archivo pero el manifiesto no refleja el cambio. 21 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 4 CONFIGURAR EL ESTADO DE LA SESIÓN UTILIZANDO MICROSOFT SQL SERVER, STATE SERVER O INPROC: CONFIGURACIÓN DEL TIEMPO DE ESPERA; SESIONES SIN COOKIES ESTADO DE SESIÓN DE ASP.NET El estado de sesión de ASP.NET permite almacenar y recuperar los valores de un usuario cuando el usuario explora diferentes páginas ASP.NET conformando una aplicación Web. HTTP es un protocolo sin estado, es decir, el servidor Web trata cada solicitud HTTP de página como solicitud independiente; de forma predeterminada, el servidor no retiene información alguna sobre los valores de las variables que se utilizan durante las solicitudes anteriores. En consecuencia, la creación de aplicaciones Web que necesitan mantener la información de estado entre las solicitudes (aplicaciones que implementan carros de la compra, desplazamiento de datos, etc.) puede resultar complicada. El estado de sesión de ASP.NET identifica las solicitudes recibidas desde el mismo explorador durante un período limitado de tiempo como una sesión y proporciona la capacidad de conservar los valores de las variables durante la duración de esa sesión. El estado de sesión de ASP.NET se habilita de forma predeterminada en todas las aplicaciones ASP.NET. Las variables de estado de sesión de ASP.NET se definen con facilidad y se recuperan mediante la propiedad Session, que almacena los valores de las variables de la sesión como una colección indizada por nombre. Por ejemplo, mediante el ejemplo de código siguiente se crean las variables de sesión FirstName y LastName para representar el nombre y el apellido de un usuario, y las variables se establecen en los valores recuperados de los controles TextBox. Session["FirstName"] = FirstNameTextBox.Text; Session["LastName"] = LastNameTextBox.Text; De forma predeterminada, ASP.NET almacena la información de la sesión en el espacio de memoria de la aplicación ASP.NET. Si se desea, puede almacenarse la información de la sesión mediante un servicio independiente para que no se pierda si se reinicia la aplicación ASP.NET, en un servidor SQL Server, a fin de que la información de la sesión esté disponible para varios servidores Web en una batería de servidores Web (y también se mantenga si se reinicia la aplicación ASP.NET), o en un almacén de datos personalizado. ASP.NET proporciona también algunas otras opciones para conservar los datos en una aplicación además del estado de sesión. MODOS DE ESTADO DE SESIÓN El estado de sesión de ASP.NET es compatible con distintas opciones de almacenamiento de los datos de la sesión. Cada opción se identifica mediante un valor en la enumeración SessionStateMode. En la lista siguiente se describen los modos de estado de sesión disponibles: Modo InProc, almacena el estado de sesión en memoria en el servidor Web. Éste es el valor predeterminado. Modo StateServer, almacena el estado de sesión en un proceso distinto denominado "servicio de estado de ASP.NET". Este modo garantiza que el estado de sesión se mantiene si se reinicia la aplicación Web y que esté disponible también para varios servidores Web en una batería de servidores Web. Modo SQLServer, almacena el estado de sesión en una base de datos de SQL Server. Este modo garantiza que el estado de sesión se mantiene si se reinicia la aplicación Web y que esté disponible también para varios servidores Web en una batería de servidores Web. Modo Custom, permite especificar un proveedor de almacenamiento personalizado. Modo Off, deshabilita el estado de sesión. Se puede especificar el modo para el estado de sesión de ASP.NET asignando valores de enumeración SessionStateMode al atributo mode del elemento sessionState en el archivo Web.config de la aplicación. Todos los modos, excepto InProc y Off, requieren parámetros adicionales, como valores de cadena de conexión. Para ver el estado de sesión seleccionado actualmente se consulta el valor de la propiedad System.Web.SessionState.HttpSessionState.Mode. 22 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 MODO EN PROCESO “IN PROC” En proceso es el modo de estado de sesión predeterminado y se especifica mediante el valor InProc de la enumeración SessionStateMode. El modo En proceso almacena valores de estado de sesión y variables en memoria en el servidor Web local. Es el único modo que admite el evento Session_OnEnd. Si se habilita el modo Hospedaje multiproceso en un único equipo y para ello establece el atributo webGarden en true en el elemento processModel del archivo Web.config de la aplicación, no se debe utilizar el modo de estado de sesión InProc. De hacerse, se puede producir una pérdida de datos si diferentes procesos de trabajo atienden solicitudes distintas para la misma sesión. MODO SERVIDOR DE ESTADO “STATE SERVER” El modo StateServer almacena estado de sesión en un proceso, al que se denomina servicio de estado de ASP.NET, independiente del proceso de trabajo ASP.NET o grupo de aplicaciones IIS. Con este modo se garantiza que el estado de sesión se mantiene si se reinicia la aplicación Web y que esté disponible también para varios servidores Web en una batería de servidores Web. Para utilizar el modo StateServer, debe asegurarse de que el servicio de estado de ASP.NET se está ejecutando en el servidor remoto utilizado como almacén de la sesión. El servicio de estado de ASP.NET se instala como un servicio cuando se instalan ASP.NET y .NET Framework. El servicio de estado de ASP.NET se instala en la ubicación siguiente: raízDelSistema\Microsoft.NET\Framework\númeroDeVersión\aspnet_state.exe Para configurar una aplicación ASP.NET para utilizar el modo StateServer, en el archivo Web.config de la aplicación haga lo siguiente: Establecer el atributo mode del elemento sessionState en StateServer. Establecer el atributo stateConnectionString en tcpip=nombreDeServidor:42424. Para mejorar la seguridad de la aplicación al utilizar el modo StateServer, se recomienda proteger el valor stateConnectionString cifrando la sección sessionState en el archivo de configuración. En el ejemplo siguiente se muestra una opción de configuración para el modo StateServer donde el estado de sesión se almacena en un equipo remoto denominado SampleStateServer: <configuration> <system.web> <sessionState mode="StateServer" stateConnectionString="tcpip=SampleStateServer:42424" cookieless="false" timeout="20"/> </system.web> </configuration> Los objetos almacenados en el estado de sesión deben ser serializables si el modo está establecido en StateServer. Para utilizar el modo StateServer en una batería de servidores Web, debe tener las mismas claves de cifrado especificadas en el elemento machineKey de la configuración Web para todas las aplicaciones formando parte de la batería de servidores. MODO SQL SERVER El modo SQLServer almacena el estado de sesión en una base de datos de SQL Server. Con este modo se garantiza que el estado de sesión se mantiene si se reinicia la aplicación Web y que esté disponible también para varios servidores Web en una batería de servidores Web. 23 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Los objetos que están almacenados en el estado de sesión deben ser serializables si el modo utilizado es SQL Server. Para utilizar el modo SQLServer, primero debe estar seguro de que la base de datos del estado de sesión de ASP.NET esté instalada en SQL Server. Puede instalar la base de datos del estado de sesión de ASP.NET mediante la herramienta Aspnet_regsql.exe. Para configurar una aplicación ASP.NET para utilizar el modo SQLServer, en el archivo Web.config: Establecer el atributo mode del elemento sessionState en SQLServer. Establecer el atributo sqlConnectionString en una cadena de conexión para su base de datos de SQL Server. Para mejorar la seguridad de la aplicación al utilizar el modo SQLServer, se recomienda proteger el valor sqlConnectionString cifrando la sección sessionState de su archivo de configuración.. En el ejemplo siguiente se muestra una opción de configuración para el modo SQLServer donde el estado de sesión se almacena en un servidor SQL Server denominado "BDGALA": <configuration> <system.web> <sessionState mode="SQLServer" sqlConnectionString="Integrated Security=SSPI;data source=BDGALA;" /> </system.web> </configuration> Si especifica una conexión de confianza con el SQL Server en el archivo de configuración utilizando el atributo sqlConnectionString del elemento sessionState, el SessionStateModule conectará con el SQL Server mediante la seguridad integrada de SQL Server. La conexión se realizará utilizando la identidad del proceso en ASP.NET o las credenciales del usuario proporcionadas para el elemento de configuración de identidad, si existen. Se puede especificar utilizar la identidad suplantada por IIS definiendo <identity impersonate="true" /> y establecer el atributo useHostingIdentity del elemento de configuración sessionState en false. Para configurar el modo SQLServer para una batería de servidores Web, en el archivo de configuración para cada servidor Web, se establece el atributo sqlConnectionString del elemento sessionState para señalar a la misma base de datos SQL Server. La ruta de acceso de la aplicación ASP.NET en la metabase de IIS debe ser idéntica en todos los servidores Web que compartan el estado de sesión en la base de datos de SQL Server. Instalar la base de datos de estado de sesión mediante la herramienta Aspnet_regsql.exe Para instalar la base de datos de estado de sesión en SQL Server, ejecutar la herramienta Aspnet_regsql.exe que se encuentra en la carpeta raízDelSistema\Microsoft.NET\Framework\númeroDeVersión del servidor Web. Se proporciona la información siguiente con el comando: El nombre de la instancia de SQL Server, mediante la opción -S. Las credenciales de inicio de sesión para una cuenta que tiene el permiso para crear una base de datos en SQL Server. Seleccionar la opción -E para utilizar el usuario que tiene la sesión actual abierta o utilizar la opción -U para especificar un identificador de usuario junto con la opción -P para especificar una contraseña. La opción de la línea de comandos -ssadd para agregar la base de datos de estado de sesión. De forma predeterminada, no se puede utilizar la herramienta Aspnet_regsql.exe para instalar la base de datos de estado de sesión en SQL Server Express Edition. Para ejecutar la herramienta Aspnet_regsql.exe para instalar una base de datos SQL Server Express Edition, primero se debe habilitar la opción Agent XPs SQL Server mediante comandos de T-SQL como los siguientes: EXECUTE sp_configure 'show advanced options', 1 24 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 RECONFIGURE WITH OVERRIDE GO EXECUTE sp_configure 'Agent XPs', 1 RECONFIGURE WITH OVERRIDE GO EXECUTE sp_configure 'show advanced options', 0 RECONFIGURE WITH OVERRIDE GO Se debe ejecutar estos comandos T-SQL para cualquier instancia de SQL Server Express Edition dónde se deshabilita la opción Agent XPs. De forma predeterminada, la herramienta Aspnet_regsql.exe creará una base de datos denominada ASPState que contiene procedimientos almacenados que admiten el modo SQLServer. Los datos de la sesión se almacenan de forma predeterminada en la base de datos tempdb. Si se desea, puede utilizar la opción -sstype para cambiar la ubicación de almacenamiento de los datos de la sesión. A continuación se especifica los valores posibles para la opción -sstype: t : Almacena los datos de la sesión en la base de datos tempdb de SQL Server. Éste es el valor predeterminado. Si almacena los datos de la sesión en esta base de datos, los datos de la sesión se perderán si se reinicia SQL Server. p : Almacena los datos de la sesión en la base de datos ASPState en lugar de en la base de datos tempdb. c : Almacena los datos de la sesión en una base de datos personalizada. Si especifica la opción c, también debe incluir el nombre de la base de datos personalizada utilizando la opción -d. Por ejemplo, el siguiente comando crea una base de datos llamada ASPState en una instancia de SQL Server denominada "BDGALA" y especifica que los datos de la sesión también se almacenan en la base de datos ASPState: aspnet_regsql.exe -S BDGALA -E -ssadd -sstype p Si se va a ejecutar ASP.NET 1.0 o ASP.NET 1.1, no se puede utilizar la herramienta Aspnet_regsql.exe para configurar ASP.NET para almacenar el estado de sesión en una base de datos persistente de SQL Server. Sin embargo, se puede obtener secuencias de comandos para almacenar estados de sesión en una base de datos persistente. En el modo SQLServer, se puede configurar varios equipos ejecutando SQL Server para funcionar como un clúster de conmutación por error, es decir, dos o más equipos idénticos ejecutándo SQL Server y almacenando datos para una sola base de datos. Si se produce un error en un equipo que ejecuta SQL Server, otro servidor del clúster asume el control y atiende las solicitudes sin que se pierdan los datos de la sesión. Para configurar el modo SQL Server para un clúster de conmutación por error, debe especificar sstype p cuando ejecute la herramienta Aspnet_regsql.exe de modo que los datos del estado de sesión se almacenan en la base de datos ASPState en vez de en la base de datos tempdb. Los clústeres de servidores SQL Server no permiten almacenar el estado de sesión en la base de datos tempdb. MODO PERSONALIZADO El modo Custom especifica que desea almacenar datos del estado de sesión mediante un proveedor del almacén de estados de sesión personalizado. Cuando se configura la aplicación de ASP.NET con una propiedad Mode de Custom, se debe especificar el tipo de proveedor de almacenes de estados de sesión mediante el subelemento providers del elemento de configuración sessionState. El tipo de proveedor se especifica utilizando un subelemento add e incluyendo tanto un atributo type que especifique el nombre del tipo de proveedor como un atributo name que especifique el nombre de la instancia del proveedor. El nombre de la instancia del proveedor se proporciona al atributo customProvider del elemento de sessionState para configurar el estado de sesión de ASP.NET de modo que utilice esa instancia de proveedor para almacenar y recuperar los datos de la sesión. 25 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 En el ejemplo siguiente se muestran elementos de un archivo Web.config donde se especifica que el estado de sesión de ASP.NET utiliza un proveedor de almacenes de estados de sesión personalizado. <configuration> <connectionStrings> <add name="OdbcSessionServices" connectionString="DSN=SessionState;" /> </connectionStrings> <system.web> <sessionState mode="Custom" customProvider="OdbcSessionProvider"> <providers> <add name="OdbcSessionProvider" type="Samples.AspNet.Session.OdbcSessionStateStore" connectionStringName="OdbcSessionServices" writeExceptionsToEventLog="false" /> </providers> </sessionState> </system.web> </configuration> Un proveedor de almacenes de estados de sesión personalizados obtendrá acceso a cualquier recurso protegido, como por ejemplo SQL Server, mediante la identificación del proceso ASP.NET o las credenciales de usuario proporcionadas al elemento de configuración identity, si existieran. Se puede especificar utilizar la identidad suplantada por IIS definiendo <identity impersonate="true" /> y estableciendo el atributo useHostingIdentity del elemento de configuración sessionState en false. 5 PUBLICAR APLICACIONES WEB: SISTEMA DE ARCHIVOS O HTTP DE VISUAL STUDIO Lo nuevo en la publicación de sitios Web en Visual Studio En este tema se describen las nuevas características de Visual Studio para implementar, o publicar, sitios Web en un servidor de ensayo o de producción. 26 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 A partir de Visual Studio 2005, el proceso de trasladar un sitio Web en desarrollo a un servidor de ensayo o de producción es mucho más fácil que con las versiones anteriores. En versiones anteriores, todas las partes del código del sitio Web se generaban en un ensamblado único. A continuación, el ensamblado generado, junto con los archivos .aspx, el archivo Web.config y otros archivos que no son de código se implementaban en el servidor de destino. Las formas más habituales de implementar los archivos eran las siguientes: usar la utilidad Copiar proyecto, para lo que el servidor de destino tenía que estar en una red de área local; usar las Extensiones de servidor de FrontPage de Microsoft, o crear un proyecto de instalación para generar un archivo de instalación (.msi). En la versión actual de Visual Studio, se puede implementar un proyecto utilizando las herramientas siguientes: La herramienta Copiar sitio Web, que copia directamente el sitio Web actual en el servidor de destino. La utilidad Publicar sitio Web, que compila el sitio Web en un conjunto de archivos ejecutables. A continuación, se puede copiar los archivos en el servidor de destino, utilizando el método que desee. La utilidad de publicación de sitios Web no está disponible en Visual Web Developer Express. Estas herramientas no requieren configuración especial en el servidor de destino, como sucede con las Extensiones de servidor de FrontPage. Además de crear el sitio Web e implementarlo en un servidor de destino, también puede crear un sitio Web del Protocolo de transferencia de archivos (FTP). En ese caso, los archivos se crean y editan directamente en el servidor de destino, lo que representa una forma muy cómoda de trabajar con un sitio Web en un servidor alojado. Copiar sitios Web La herramienta Copiar sitio Web es parecida a una utilidad de FTP: se puede abrir una carpeta en un servidor de destino y, a continuación, cargar y descargar archivos del sitio Web actual en el sitio Web de destino, y viceversa. La herramienta Copiar sitio Web ofrece las mejoras siguientes respecto a la utilidad Copiar proyecto de las versiones anteriores de Visual Studio: No es necesario compilar los archivos en el sitio Web antes de copiarlos en el servidor de destino. En lugar de ello, sólo se debe copiar los archivos de código fuente, incluidos los archivos .aspx y archivos de clase, en el servidor de destino. Igual que sucede con cualquier sitio Web ASP.NET, las páginas Web se compilan dinámicamente cuando se solicita. La herramienta Copiar sitio Web permite abrir y copiar archivos desde cualquier sitio Web compatible con Visual Studio, incluidos los de Servicios de Internet Information Server (IIS), IIS remoto y FTP. No es necesario que el servidor de destino tenga las Extensiones de servidor de FrontPage. Además de copiar un proyecto en un servidor de destino, la herramienta Copiar sitio Web se puede utilizar para realizar otras tareas. Es compatible con una característica de sincronización que examina los archivos de los dos sitios Web y, automáticamente, garantiza que las versiones de los archivos están actualizadas en ambos sitios. Antes de copiar los archivos de aplicación, la herramienta Copiar sitio Web coloca un archivo denominado App_offline.htm en el directorio raíz del sitio Web de destino. Mientras exista el archivo App_offline.htm, todas las solicitudes que se hagan al sitio Web se redirigirán a este archivo, que muestra un mensaje descriptivo para indicar a los clientes que se está actualizando el sitio Web. Una vez que se han copiado todos los archivos del sitio Web, la herramienta Copiar sitio Web elimina el archivo App_offline.htm del sitio Web de destino. Debe tener la versión 2.0 de .NET Framework instalada en el servidor de destino para que las páginas Web se ejecuten como se espera. Si el servidor de destino es un servidor FTP, se pueden abrir y editar los archivos en el servidor creando un sitio Web FTP. También se pueden administrar el sitio de destino la herramienta Administración de sitios Web. Compilar sitios Web La utilidad de publicación de sitios Web realiza la compilación previa del contenido del sitio Web, tanto las páginas Web (archivos .aspx) como el código, y copia el resultado en el directorio o ubicación de servidor especificada. Se puede publicar el contenido directamente como parte del proceso de compilación previa, o realizar la compilación previa localmente y, después, copiar los archivos. La utilidad de publicación de sitios Web compila el sitio Web y elimina el código fuente de los archivos, y sólo deja los 27 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 archivos de código auxiliar de las páginas y los ensamblados compilados. Cuando los usuarios solicitan las páginas, ASP.NET da servicio a la solicitud desde los ensamblados precompilados. El proceso de compilación previa de la utilidad de publicación de sitios Web no es igual que el de las versiones anteriores de Visual Studio, como se describe a continuación: En Visual Studio .NET 2003, sólo se compilaban los archivos de código. En la utilidad de publicación de sitios Web, se puede compilar opcionalmente el marcado de los archivos .aspx junto con el código de página y cualquier otro archivo ejecutable. En Visual Studio .NET 2003, todo el código se compilaba en un ensamblado único. En el nuevo modelo, todos los archivos de clase independientes se compilan en un ensamblado. Sin embargo, las pagina y el código correspondiente (de un solo archivo o subyacente) se compilan en ensamblados individuales. En la utilidad de publicación de sitios Web, el código fuente se quita del sitio Web, incluido, si se desea, el marcado de los archivos .aspx. Los archivos .aspx siguen estando presentes, pero sólo contienen punteros que indican las versiones compiladas de las páginas. De esta forma, el contenido queda más protegido y resulta más difícil que otros usuarios tengan acceso al código fuente del sitio. En consecuencia, el sitio Web tiene las mismas ventajas que los resultados creados con versiones anteriores de Visual Studio, con mayor rapidez de respuesta inicial de las páginas y compilación previa que contribuye a descubrir errores del código en tiempo de compilación. La utilidad de publicación de sitios Web también compila archivos que no son de código, por ejemplo el archivo Web.config. Así, sirve de ayuda para encontrar errores de compilación y problemas en el archivo de configuración. Copiar sitios Web con la herramienta Copiar sitio Web La herramienta Copiar sitio Web permite copiar los archivos entre el sitio Web actual y otro sitio. La herramienta Copiar sitio Web es similar a una utilidad FTP, pero se diferencia en lo siguiente: Permite conectar y copiar archivos entre todos los tipos de sitios Web creados en Visual Studio, incluidos los sitos Web locales, los sitios Web de ISS, los sitios Web remotos (FrontPage) y los sitios FTP. Admite una característica de sincronización, que examina los archivos en ambos sitios y se asegura de que todos los archivos están actualizados. Se puede utilizar la herramienta Copiar sitio Web para mover archivos de su equipo local a un servidor de ensayo o a un servidor de producción. La herramienta Copiar sitio Web es especialmente útil en situaciones donde no puede abrir los archivos desde el sitio remoto para editarlos. Se puede utilizar la herramienta Copiar sitio Web para copiar archivos en el equipo local, editarlos y copiarlos otra vez en el sitio remoto. También se puede utilizar la herramienta para copiar archivos de un servidor de ensayo a un servidor de producción cuando haya terminado su proceso de desarrollo. Si copia una aplicación que contiene una referencia a un componente personalizado registrado en la GAC, el componente no se copiará con la aplicación. Sitios de origen y sitios remotos La herramienta Copiar sitio Web copia archivos entre un sitio de origen y un sitio remoto. Estos términos se utilizan para distinguir los dos sitios con los que trabaja la herramienta. Los términos se utilizan con significados específicos: Sitio de origen El sitio de origen es el sitio que tiene actualmente abierto en Visual Studio. Sitio remoto El sitio remoto es el sitio en el que desea copiar archivos. Un sitio remoto puede ser una ubicación en otro equipo al que puede tener acceso utilizando las Extensiones de servidor de FrontPage o FTP. En estos casos, el sitio es literalmente remoto. Sin embargo, el sitio remoto también puede ser otro sitio en su propio equipo. Por ejemplo, se puede publicar desde un sitio Web del sistema de archivos de su equipo en un sitio Web de ISS local que está también en su equipo. En este caso, aunque el sitio es local en su equipo, es el sitio remoto a efectos de la herramienta Copiar sitio Web. Observe que el sitio de origen no es necesariamente el origen del que se copia. Se puede copiar del sitio remoto al sitio de origen. Sincronizar los sitios Además de copiar archivos, la herramienta Copiar sitio Web permite sincronizar los sitios. Al sincronizar, se examinan los archivos de los sitios local y remoto y se asegura que todos los archivos de ambos sitios están actualizados. Por ejemplo, si un archivo en un 28 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 sitio remoto es más actual que la versión que hay del mismo archivo en el sitio local, al sincronizar los archivos se copia el archivo del sitio remoto en el sitio local. La herramienta Copiar sitio Web no combina archivos que tienen el mismo nombre pero diferente contenido. En ese caso, la sincronización le da la oportunidad de especificar qué versión del archivo desea mantener. La sincronización hace que la herramienta resulte adecuada para un entorno de varios desarrolladores en el que éstos mantienen copias del sitio Web en sus equipos locales. Cada desarrollador puede copiar los últimos cambios en un servidor remoto compartido y a la vez actualizar su equipo local con los archivos que han modificado otros desarrolladores. Un desarrollador que sea nuevo en un proyecto puede también obtener rápidamente copias de todos los archivos de un sitio Web mediante la creación de un sitio Web local en su propio equipo y la sincronización con el sitio del servidor compartido. Estado de los archivos Para sincronizar archivos, la herramienta Copiar sitio Web necesita información sobre el estado de los archivos en ambos sitios. Por consiguiente, la herramienta mantiene información que consta de las marcas de hora de los archivos más la información adicional que se necesita para realizar la sincronización. Por ejemplo, la herramienta mantiene una lista de cuándo fue la última vez que se modificaron los archivos, lo que le permite a la herramienta determinar, por ejemplo, si se ha eliminado un archivo. Cuando se conecta a un sitio (o se actualiza), la herramienta compara las marcas de hora de los archivos en ambos sitios así como la información almacenada sobre ambos sitios y se crea un informe del estado de cada archivo. A continuación se muestra el estado de los archivos. Sin cambios El archivo no ha cambiado desde la última vez que se copió. Modificado El archivo tiene una marca de hora más reciente que la marca de hora que se tomó cuando se copió el archivo por última vez. Nuevo Se ha agregado el archivo desde la última vez que se copió el sitio. Eliminado Se ha eliminado el archivo desde la última vez que se copió el sitio. Si selecciona Mostrar archivos eliminados en la herramienta Copiar sitio Web, en la ventana se muestra una entrada para el archivo. 6 CONFIGURAR CONJUNTOS DE APLICACIONES Una de las características de IIS a partir de la versión 6.0 es el “Application Pool”, conjunto de aplicaciones. Esta facilidad pude ser utilizada para aislar las aplicaciones WEB ASP.Net y de esta manera se incrementa la confiablidad de las aplicaciones. El conjunto de aplicaciones también afecta en el tipo de identidad que es utilizada para ejecutar las aplicaciones ASP.Net. Los conjuntos de aplicaciones se crean en IIS y estos son configurados para ser ejecutados utilizando las credenciales de una cuenta de usuario. ¿Qué es un conjunto de aplicaciones? Un conjunto de aplicaciones puede contener una o más aplicaciones y permite configurar un nivel de aislamiento entre diferentes aplicaciones WEB. Por ejemplo, se podrían aislar todas las aplicaciones web para ser ejecutadas en el mismo equipo; para lograr esto se puede crear un grupo de aplicaciones para cada aplicación web y colocarlas todas en el correspondiente grupo de aplicaciones. Como cada grupo de aplicaciones corre sus propios procesos de trabajos, errores en un grupo de aplicaciones no afectará a las aplicaciones ejecutándose en otro grupo de aplicaciones. La implantación de aplicaciones en grupos de aplicaciones es la principal ventaja de ejecutar II 6.0 en el modo de aislamiento de procesos de trabajo porque se pueden parametrizar los grupos de aplicaciones para lograr el nivel de aislamiento requerido. Cuando se configuran los grupos de aplicaciones buscando lograr la disponibilidad óptima, también deben ser considerados los criterios de seguridad. Por ejemplo, se pueden crear grupos de aplicaciones separados para aplicaciones que requieran un alto nivel de seguridad mientras que todas aquellas aplicaciones no necesitando este nivel de seguridad pueden ser colocadas en otro grupo de aplicaciones. Crear un grupo de aplicaciones Este proceso se realiza en el administrador de IIS. Existen dos opciones para crear un grupo de aplicaciones: 29 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Crear desde cero un nuevo grupo de aplicaciones Crear un grupo de aplicaciones importando los parámetros de configuración desde un archivo XML externo Para crear un grupo de aplicaciones desde cero, se pulsa botón derecho en el nodo “Application Pools” del árbol y se coloca el nombre deseado para el grupo. Cuando se crea una nueva aplicación, existe la opción de heredar los parámetros de un grupo de aplicaciones existentes. Por ejemplo si se requiere heredar del grupo DefaultAppPool, se escoge la opción utilizar un grupo de aplicaciones existentes como plantilla. Una vez creado el grupo de aplicaciones, los parámetros pueden ser almacenados en un archivo XML externo. Se selecciona el grupo de aplicaciones, Todasl Las tareas, Guardar archivo de Configuración. Configurando la identidad para las Aplicaciones Web ASP.NET En versiones previas de IIS, los procesos de trabajo corrían como LocalSystem, una cuenta con bastante poder y con privilegios de administrador de sistemas en el servidor. LocalSystem tiene acceso casi total a todos los recursos del sistema de operación y esto ocasionaba inconvenientes de seguridad. A partir de IIS 6.0 se puede parametrizar la identidad del proceso de trabajo al nivel del grupo de aplicaciones. La identidad de un grupo de aplicaciones es la cuenta donde el proceso de trabajo del grupo de aplicaciones se está ejecutando. Por defecto, el grupo de aplicaciones opera sobre la cuenta NetworkService, la cual tiene derechos de un usuario de bajo nivel de acceso. La cuenta NetworkService tiene los siguientes siete privilegios: Ajuste de cuotas de memoria para un proceso Generar auditorias de seguridad Log on como servicio Reemplazo de ficha (token) a nivel de proceso Impersonar a un cliente después de la autorización Permitir acceso local Acceso al computador desde la red Al ejecutar el proceso de trabajo con una cuenta de bajos privilegios como NetworkService, se puede reducer la vulnerabilidad del sistema. Sin embargo, empleando el IIS manager, se puede configurar el grupo de aplicaciones para ser ejecutado en cualquiera de las siguientes cuentas definidas: NetworkService LocalSystem LocalService 7 COMPILAR UNA APLICACIÓN UTILIZANDO VISUAL STUDIO O HERRAMIENTAS DE LÍNEA DE COMANDO: ASPNET_COMPILER.EXE, COMPILACIÓN JUST-IN-TIME (JIT), ASPNET_MERGE.EXE HERRAMIENTA DE COMPILACIÓN DE ASP.NET (Aspnet_compiler.exe) La herramienta de compilación de ASP.NET (Aspnet_compiler.exe) hace posible la compilación de una aplicación Web ASP.NET, en el propio lugar donde se encuentra o para implementarse en una ubicación de destino como un servidor de producción. La compilación en el mismo lugar donde se encuentra ayuda al rendimiento de la aplicación ya que los usuarios finales no sufren ningún retraso en la primera solicitud que se hace a la aplicación mientras se compila la aplicación en cuestión. La compilación para implementación se puede llevar a cabo de una de las dos formas siguientes: una que consiste en quitar todos los archivos de código fuente (como archivos de marcado y archivos de código subyacente), o bien otra que retiene los archivos de marcado. La herramienta de compilación de ASP.NET no está disponible en versiones de ASP.NET anteriores a la 2.0. 30 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 La sintáxis de la herramienta es la siguiente: aspnet_compiler [-?] [-m metabasePath | -v virtualPath [-p physicalPath]] [[-u] [-f] [-d] [-fixednames] targetDir] [-c] [-errorstack] [-nologo] [-keyfile file | -keycontainer container ] [-aptca] [-delaysign]] Opción Descripción -m metabasePath Especifica la ruta completa de la metabase de IIS de la aplicación que se va a compilar. La metabase de IIS es un almacén de información de carácter jerárquico que se utiliza para configurar IIS. Por ejemplo, la ruta de acceso de la metabase al sitio Web de IIS predeterminado es LM/W3SVC/1/ROOT. Esta opción no se puede combinar con las opciones -v o -p. -v virtualPath Especifica la ruta de acceso virtual de la aplicación que se va a compilar. Si también se especifica -p, el valor del parámetro physicalPath acompañante se utiliza para ubicar la aplicación que se va a compilar. En caso contrario, se utiliza la metabase de IIS y la herramienta da por hecho que los archivos de código fuente se encuentran en el sitio Web predeterminado (especificado en el nodo de la metabase LM/W3SVC/1/ROOT). Esta opción no se puede combinar con la opción -m. -p physicalPath Especifica la ruta completa de acceso a la red o la ruta de acceso local al disco del directorio raíz que contiene la aplicación que se va a compilar. Si no se especifica -p, la metabase de IIS se utiliza para buscar el directorio. Esta opción se debe combinar con la opción -v y no se puede combinar con la opción -m. -u Especifica que Aspnet_compiler.exe debería crear una aplicación precompilada que permita llevar a cabo actualizaciones subsiguientes de contenido como páginas .aspx. Si se omite esta opción, la aplicación resultante sólo contendrá archivos compilados y no se podrá actualizar en el servidor de implementación. Sólo se podrá actualizar la aplicación cambiando los archivos de marcado de código fuente y volviendo a realizar una nueva compilación. Debe incluirse el parámetro targetDir. -f Especifica que la herramienta debería sobrescribir los archivos existentes en el directorio targetDir y sus subdirectorios. -d Reemplaza los valores de configuración definidos en los archivos de configuración de código fuente de la aplicación para obligar a a que se incluya información de depuración en la aplicación compilada. En caso 31 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 contrario, no se emite ningún resultado de depuración. No se puede utilizar la opción -d para la compilación en contexto; la compilación en contexto admite los valores de configuración de las opciones de depuración. targetDir Ruta de acceso a la red o la ruta de acceso del disco local al directorio raíz que contendrá la aplicación compilada. Si no se incluye el parámetro targetDir, la aplicación se compila en el lugar donde se encuentra. -c Especifica que se debería volver a generar por completo la aplicación que se va a compilar. Se vuelven a compilar componentes ya compilados. Si se omite esta opción, la herramienta genera sólo aquellas partes de la aplicación que se hayan modificado desde la última vez que se realizó la compilación. -errorstack Especifica que la herramienta debería incluir información del seguimiento de la pila si se produce un error a la hora de compilar la aplicación. -keyfile file Especifica que AssemblyKeyFileAttribute, que indica el nombre del archivo que contiene el par de claves pública y privada utilizado para generar un nombre seguro, debería aplicarse al ensamblado compilado. Esta opción debe combinarse con la opción -aptca. Si el atributo ya se aplica al ensamblado en archivos de código, Aspnet_compiler.exe produce una excepción. - Especifica que AssemblyKeyNameAttribute , que indica el nombre del archivo que contiene el par de keycontainer container claves pública y privada utilizado para generar un nombre seguro, debería aplicarse al ensamblado compilado. Esta opción debe combinarse con la opción -aptca. Si el atributo ya se aplica al ensamblado en archivos de código, Aspnet_compiler.exe produce una excepción. -aptca Especifica que AllowPartiallyTrustedCallersAttribute , que permite el acceso parcial de los llamadores de plena confianza a un ensamblado, se debería aplicar al ensamblado de nombre seguro que Aspnet_compiler.exe genera. Esta opción no se puede combinar con la opción -keyfile o -keycontainer. Si el atributo ya se aplica al ensamblado en archivos de código, Aspnet_compiler.exe produce una excepción. -delaysign Especifica que AssemblyDelaySignAttribute , que indica que un ensamblado sólo se debería firmar con el símbolo (token) de clave pública y no con el par de claves pública/privada, se debería aplicar al ensamblado generado. Esta opción no se puede combinar con la opción -keyfile o -keycontainer. Si el atributo ya se aplica al ensamblado en archivos de código, Aspnet_compiler.exe produce una excepción. -fixednames Especifica que se debería generar un ensamblado para cada página de la aplicación. En el nombre de cada ensamblado figura la ruta de acceso virtual de la página original a menos que el nombre exceda el límite del sistema operativo para los nombres de archivo, en cuyo caso se genera código hash y se utiliza para el nombre del ensamblado. No se puede utilizar la opción -fixednames para la compilación en contexto; la compilación en contexto admite los valores de configuración del modo de procesamiento por lotes de la compilación. -nologo Suprime el mensaje de copyright. 32 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 -? Muestra la sintaxis de comandos y opciones para la herramienta. La herramienta de compilación de ASP.NET se puede utilizar de dos formas generales: para una compilación en contexto y para una complicación para implementación, donde se especifica un directorio de destino de resultados. En las secciones siguientes se describen los siguientes escenarios. Compilar una aplicación en contexto La herramienta de compilación de ASP.NET puede compilar una aplicación en contexto, es decir, reproduce el comportamiento de realización de varias solicitudes en la aplicación, así como el hecho de que se produzca una compilación de forma regular. Los usuarios de un sitio precompilado no experimentarán ningún retraso que se haya producido durante la compilación de la página en primera solicitud. Al precompilar un sitio en contexto, se aplican los siguientes elementos: El sitio retiene sus archivos y la estructura de directorios. Es necesario contar con compiladores para todos los lenguajes de programación utilizados por el sitio en el servidor. Si se produce algún error en algún archivo durante el proceso de compilación, también aparecerá un error que afectará a todo el sitio relacionado con la compilación. También será posible recompilar una aplicación en contexto después de agregar nuevos archivos de código fuente a él. La herramienta sólo compila los archivos nuevos o que se hayan modificado a menos que se incluya la opción -c. Nota: La compilación de una aplicación que contiene una aplicación anidada no compila la aplicación anidada. La aplicación anidada se debe compilar por separado. Compilar una aplicación para implementación Es posible compilar una aplicación para su implementación (compilación en una ubicación de destino) especificando el parámetro targetDir. targetDir puede constituir la ubicación final de la aplicación Web o la aplicación compilada se puede implementar de forma más completa. La utilización de la opción -u compila la aplicación de tal forma que se pueden realizar cambios en determinados archivos de la aplicación compilada sin necesidad de recompilarla. Aspnet_compiler.exe realiza una distinción entre tipos de archivos estáticos y dinámicos y los controla de manera diferente al crear la aplicación resultante. Los tipos de archivos estáticos son aquellos que no tienen un compilador asociado o que generan un proveedor, tales como archivos cuya denominación contiene extensiones .css, .gif, .htm, .html, .jpg o .js, entre otros. Estos archivos simplemente se copian en la ubicación de destino, con sus lugares relativos en la estructura de directorios que se ha conservado. Los tipos de archivos dinámicos son aquellos que tienen un compilador asociado o que generan un proveedor, incluyendo archivos con extensiones de nombre de archivo específicas de ASP.NET tales como .asax, .ascx, .ashx, .aspx, .browser y .master, entre otros. La herramienta de compilación de ASP.NET genera ensamblados a partir de estos archivos. Si se omite la opción -u, la herramienta también crea archivos con la extensión de nombre de archivo .COMPILED que asigna los archivos de código fuente a sus ensamblados. Para asegurar que se vaya a conservar la estructura de directorios del origen de la aplicación, la herramienta genera archivos de marcador en las correspondientes ubicaciones de la aplicación de destino. Se debe utilizar la opción -u para indicar que se puede modificar el contenido de la aplicación compilada. De lo contrario, se omiten las modificaciones subsiguientes o producen errores en tiempo de ejecución. Nombres de ensamblado fijos Algunos escenarios, como la implementación de una aplicación Web utilizando MSI Windows Installer, requieren la utilización de nombres de archivos coherentes y de contenido, así como estructuras de directorios igualmente coherentes para identificar ensamblados y valores de configuración para actualizaciones. En algunos casos, se puede utilizar la opción -fixednames para especificar que la herramienta de compilación de ASP.NET deberían compilar un ensamblado para cada archivo de código fuente en 33 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 lugar de utilizar los lugares donde varias páginas se compilan en ensamblados. Esto puede conducir a un gran número de ensamblados, por lo que si existe algún tipo de relación con escalabilidad debería utilizarse esta opción con precaución. Compilación de nombre seguro Las opciones -aptca, -delaysign, -keycontainer y -keyfile se proporcionan para que el usuario pueda utilizar Aspnet_compiler.exe para crear ensamblados de nombre seguro sin utilizar Herramienta de nombre seguro (Sn.exe) por separado. Estas opciones corresponden, respectivamente, a AllowPartiallyTrustedCallersAttribute, AssemblyDelaySignAttribute, AssemblyKeyNameAttribute y AssemblyKeyFileAttribute. Debido a que cada opción aplica el correspondiente atributo al ensamblado compilado y debido a que los atributos aparecen marcados con un AttributeUsageAttribute cuya propiedad AllowMultiple está establecida en false, la utilización de estas claves en el código fuente que ya ha sido marcado hace que se produzca un error de compilación. Clases de ASP.NET asociadas Varias clases en el espacio de nombres System.Web.Compilation hacen posible que su código pueda obtener acceso o invocar a Aspnet_compiler.exe fuera del entorno de IIS. La clase ClientBuildManager proporciona el método PrecompileApplication para compilar una aplicación. La clase ClientBuildManager también funciona con la clase ClientBuildManagerParameter, que permite especificar PrecompilationFlags el cual corresponde a las opciones utilizadas por esta herramienta y, de igual forma, para especificar claves de nombre seguro. Ejemplos El siguiente comando compila la aplicación WebApplication1 en contexto: Aspnet_compiler -v /WebApplication1 El siguiente comando compila la aplicación WebApplication1 en contexto. La aplicación compilada también incluye información de depuración y, a su vez, la herramienta agrega información de seguimiento de la pila si se debe crear un informe los errores. Aspnet_compiler -v /WebApplication1 -d -errorstack El siguiente comando compila la aplicación WebApplication1 para su implementación, utilizando la ruta de acceso física del directorio. También agrega dos atributos a los ensamblados de salida. Utiliza la opción -keyfile para agregarla a un atributo AssemblyKeyFileAttribute que especifica que el archivo Key.sn contiene información sobre el par de claves pública y privada que la herramienta debería utilizar para aplicar un nombre seguro al ensamblado generado. El comando también utiliza la opción -aptca para agregar un atributo AllowPartiallyTrustedCallersAttribute a los ensamblados generados. La aplicación Web compilada se crea en el directorio c:\applicationTarget. Aspnet_compiler -v /WebApplication1 -p c:\Documents and Settings\Default\My Documents\MyWebApplications\WebApplication1 keyfile c:\Documents and Settings\Default\My Documents\Key.sn -aptca c:\applicationTarget El comando siguiente compila el servicio WebService2 en la ruta de acceso de la metabase predeterminada, sobrescribiendo el directorio de destino SampleWebService con la aplicación compilada. Aspnet_compiler -m LM/W3SVC/1/ROOT/WebService2 -f c:\InetPub\wwwroot\SampleWebService HERRAMIENTA COMBINACIÓN DE ASP.NET (Aspnet_merge.exe) La herramienta Combinación de ASP.NET (Aspnet_merge.exe) permite combinar y administrar ensamblados creados por la herramienta Compilación de ASP.NET (Aspnet_compiler.exe). La herramienta Combinación de ASP.NET funciona en los ensamblados creados con ASP.NET versión 2.0 o posteriores. Existen dos versiones de la herramienta de combinación de ASP.NET: El que se proporciona con .NET Framework 2.0. Se puede utilizar esta versión para sitios web diseñados para .NET Framework 2.0, .NET Framework 3.0 o .NET Framework 3.5. El que se proporciona con .NET Framework 4. Puede utilizar esta versión de los sitios web diseñados para .NET Framework 2.0 y versiones posteriores, incluido .NET Framework 4. Cuando esta versión se utiliza para los sitios web diseñados para 34 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 .NET Framework 2.0, .NET Framework 3.0 o .NET Framework 3.5, proporciona un informe de errores mejorado comparado con la versión de .NET Framework 2.0 . La herramienta Compilación de ASP.NET se utiliza para precompilar una aplicación para su implementación. La herramienta crea un ensamblado para cada carpeta de contenido del sitio web de destino o crea un ensamblado para cada archivo de contenido. La herramienta Combinación de ASP.NET aporta flexibilidad para la implementación y administración de lanzamientos. Permite hacer lo siguiente: Crear un ensamblado para todo el sitio web. Crear un ensamblado para cada carpeta del sitio web y agregar un prefijo al nombre de ensamblado. Crear un único ensamblado sólo para los elementos de la interfaz de usuario del sitio web, como páginas y controles. La sintaxis del commando es la siguiente: aspnet_merge [-?] applicationPath [-keyfile filename [-delaysign]] [-o assemblyname | -w assemblyname | -prefix prefix] [-copyattrs [assemblyfile]] [-debug] [-nologo] [-errorstack] [-r] [-xmldocs] [-a] [-logfile logfile] [-allowattrs textfile] ARGUMENTOS Argumento Descripción applicationPath (Necesario) Especifica el nombre de la carpeta que contiene la aplicación para crear los ensamblados. Ésta es la operación de combinación predeterminada. Crea un número menor de ensamblados que la opción fixednames del compilador. OPCIONES Option Description -keyfile filename Especifica que se debe aplicar el atributo AssemblyKeyFileAttribute al ensamblado compilado. El atributo especifica el nombre del archivo que contiene el par de claves pública y privada utilizadas para generar un nombre seguro. Si se firman los ensamblados de entrada y la herramienta Combinación no 35 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 firma los ensamblados, recibirá un mensaje que advierte que se han quitado las claves. Si no se especifica un nombre de archivo de claves y un ensamblado tiene una clave pública y otro ensamblado no, se producirá un error en la herramienta Combinación . -delaysign Especifica que se debe aplicar el atributo AssemblyDelaySignAttribute al ensamblado generado. Este atributo especifica que un ensamblado sólo se debería firmar con el token de clave pública en lugar del par de claves pública/privada. Esta opción debe combinarse con la opción -keyfile. Si el atributo ya se aplica al ensamblado en los archivos de código, la herramienta Combinación produce una excepción. Cuando se utiliza la opción delaysign, si la comprobación del nombre seguro no está habilitada, el código generado por la herramienta Combinación se puede ejecutar antes de que se firme el código. Si no está habilitada la comprobación del nombre seguro, asegúrese de que el código no sea vulnerable a los ataques de usuarios malintencionados antes de que se complete la firma. -o assemblyname Especifica el nombre de un único ensamblado combinado para todo el contenido de la interfaz de usuario web y los ensamblados de nivel superior. Todos los archivos que tienen la extensión .compiled se modifican para que hagan referencia al ensamblado único. (Los archivos con la extensión .compiled se compilan a partir de contenido como .aspx, .master y .ascx.) Esta opción no se puede combinar con las opciones w o prefix. El parámetro assemblyname es necesario. -w assemblyname Especifica el nombre de un único ensamblado combinado para todo el contenido de la interfaz de usuario web (páginas y controles de usuario). Todos los archivos .aspx, .master y .ascx compilados se modifican para que hagan referencia al ensamblado único. Esto permite actualizar los elementos de la interfaz de usuario independientemente de la actualización del código. Los ensamblados de nivel superior para los recursos locales y globales no se combinan. Esta opción no se puede combinar con las opciones o o prefix. El parámetro assemblyname es necesario. -prefix prefix Especifica un prefijo para los nombres de ensamblados. El ensamblado de carpeta raíz sólo tiene el parámetro prefix como nombre del ensamblado. Los ensamblados de subcarpeta tienen el parámetro prefix combinado con el nombre de la subcarpeta. Por ejemplo, si una subcarpeta se denomina Admin, el ensamblado resultante se denominaría prefix.Admin .dll. Para los sitios web que no pueden ser actualizados, la herramienta Compilación compila los temas y recursos locales en ensamblados independientes en la carpeta Bin. Para los sitios web que se pueden actualizar, los temas y los recursos locales no se compilan en ensamblados en la carpeta Bin. En su lugar, se dejan en sus carpetas originales en la aplicación. Además, para los sitios actualizables, la herramienta Combinación modifica los archivos .aspx, .master y .ascx para que señalen al nuevo ensamblado combinado para la carpeta en la que residen los archivos. Esta opción no se puede combinar con las opciones o o w. El parámetro prefix es necesario. - Especifica que los ensamblados combinados debe tener asignados los mismos atributos de ensamblado copyattrs assemblyfile que el ensamblado especificado. Si no se especifica assemblyFile, se utiliza el ensamblado App_Code, aunque el ensamblado de nivel superior App_Code.dll no esté incluido en el resultado combinado. Si hay una incoherencia de atributos entre un ensamblado que se va a combinar y el ensamblado assemblyFile, se produce un error. Utilice la opción a para omitir la comprobación de atributos incoherentes o utilice la 36 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 opción allowattrs para especificar el atributo que se excluirá de la comprobación. Para los atributos que no están incluidos en la comprobación de coherencia, vea la descripción de la opción allowattrs en la tabla. -debug Especifica que el resultado de la depuración debe conservarse en el ensamblado combinado. -nologo Suprime el mensaje de copyright. -errorstack Especifica que la herramienta debería incluir información del seguimiento de la pila si se produce un error a la hora de compilar la aplicación. -r Quita los archivos .compiled del ensamblado de código principal (código de la carpeta App_Code). No utilice esta opción si su aplicación contiene una referencia de tipo explícito al ensamblado de código principal. -xmldocs Combina los archivos de documentación XML asociados a los ensamblados de entrada. La carpeta Bin del sitio combinado incluye un archivo XML. -a Obliga a la herramienta Combinación a combinar los ensamblados que no tienen aplicados todos los atributos AllowPartiallyTrustedCallersAttribute o que presentan incoherencias de atributos. AllowPartiallyTrustedCallersAttribute permite que los llamadores de confianza parcial tengan acceso a un ensamblado y se especifica durante la compilación realizada por la herramienta Compilación. Importante Cuando se utiliza la opción a, los ensamblados combinados que no se marcaron previamente para permitir llamadores de confianza parcial, se marcan con AllowPartiallyTrustedCallersAttribute. El resultado es que un código de confianza parcial puede llamar al ensamblado. -log logfile Escribe mensajes en el archivo especificado. -allowattrs textfile Especifica un archivo que contiene los atributos que se excluirán cuando la herramienta compruebe la coherencia de los atributos en ensamblados combinados. Cada línea del archivo puede ser el nombre completo de un atributo o un espacio de nombres completo. Si se especifica un espacio de nombres, se excluirán todos los atributos encontrados en ese espacio de nombres. Cada atributo o espacio de nombres debe estar en una línea diferente. Algunos atributos no tienen que especificarse explícitamente. La herramienta Combinación genera una advertencia si encuentra los siguientes atributos y, a continuación, sigue procesando. -? System.CodeDom.Compiler..::..GeneratedCodeAttribute System.Runtime.CompilerServices..::..CompilationRelaxationsAttribute System.Runtime.CompilerServices..::..RuntimeCompatibilityAttribute System.Diagnostics..::..DebuggableAttribute Microsoft.JScript..::..ReferenceAttribute Muestra la sintaxis de comandos y opciones para la herramienta. 37 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 La herramienta Combinación de ASP.NET proporciona una flexibilidad mayor al precompilar el sitio web que la que se logra sólo con la herramienta Compilación de ASP.NET. La herramienta Combinación de ASP.NET combina el resultado de la herramienta Compilación de ASP.NET para generar los ensamblados. Estos ensamblados combinados pueden mejorar administración de lanzamientos y la implementación de sitios web grandes. La herramienta Combinación de ASP.NET se puede utilizar de tres maneras: Combinar todos los resultados en un único ensamblado. Combinar el contenido de la interfaz de usuario web (páginas Web, máscaras, etc.) de cada carpeta en su propio ensamblado. Combinar todo el contenido de la interfaz de usuario web del sitio en un único ensamblado. Grupos de ensamblados La herramienta Compilación crea ensamblados de manera diferente en función del tipo del archivo de código fuente y de carpeta. El resultado de la herramienta Compilación puede clasificarse en dos grupos de ensamblados. La herramienta Combinación combina los dos grupos de ensamblados de manera diferente. Los dos grupos de ensamblados son los siguientes: Ensamblados de contenido de interfaz de usuario web, que se generan a partir de archivos de contenido de interfaz de usuario web como .aspx, .ascx, .master, .ashx, .skin y archivos .resx locales (en la carpeta App_LocalResources). La manera en que se combinan estos ensamblados depende de si el sitio precompilado es actualizable, lo que se determina mediante la opción u de la herramienta Compilación. Si un sitio compilado es actualizable, el contenido de la interfaz de usuario puede actualizarse sin volver a compilar el sitio. Cuando un sitio web es actualizable, los archivos de contenido permanecen en sus carpetas originales y sólo se combinan los archivos de código asociados. Si el sitio no es actualizable, los archivos de contenido .ascx, .master y .skin se quitan de su carpeta original. Los archivos .aspx de ASP.NET se reemplazan con un archivo de marcador que no tiene ningún contenido. En este caso, se combinan el contenido de la interfaz de usuario y el código. Ensamblados de nivel superior, que son ensamblados generados a partir de carpetas de aplicación como App_Code, App_GlobalResources, App_WebReferences. Los ensamblados de nivel superior también se generan para archivos especiales como Global.asax. Los ensamblados de nivel superior siempre se compilan en la carpeta Bin del sitio de implementación. El sitio de implementación final no tendrá una carpeta App_Code, App_GlobalResources o App_WebReferences ni un archivo Global.asax. En su lugar, el sitio de implementación final tendrá uno o varios ensamblados en el directorio Bin, en función de las opciones utilizadas con la herramienta Combinación. También se compilan siempre las carpetas definidas por el usuario, sólo que el sitio de implementación final mantiene la carpeta definida por el usuario cuando en ella hay archivos de contenido de interfaz de usuario. El contenido estático, como los archivos que tienen las extensiones .css, .gif, .htm, .html, .jpg, .js, quedan en sus ubicaciones en la estructura de directorios precompilada. La herramienta Combinación no los mueve ni los modifica. Escenarios de compilación y combinación Con ASP.NET 2.0, puede utilizar una combinación de compilación dinámica, precompilación con la herramienta Compilación, y combinación con la herramienta Combinación para adecuarse a sus objetivos de implementación y administración de lanzamientos. En la tabla siguiente se enumeran los diferentes escenarios de compilación y combinación, e indica cuándo se debería utilizar la herramienta Combinación. Escenario Notas Compilación dinámica (sin precompilación) La compilación dinámica es útil en escenarios de desarrollo rápidos. Visual Studio utiliza la compilación dinámica (cuando presiona F5 o CTRL+F5, solo se compilan dinámicamente la página en la que está trabajando y sus dependencias). Esto evita una compilación del sitio web completo. Precompile para crear un único ensamblado Cuando se precompila con la opción fixednames, puede realizar actualizaciones para cada archivo de contenido de interfaz incrementales de unidades tan pequeñas como páginas individuales, e implementar de usuario web utilizando de nuevo sólo las páginas cambiadas. Puede crear sitios precompilados actualizables y Aspnet_compiler.exe con la opción no actualizables mediante la opción u con la opción fixednames. La opción 38 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 fixednames. fixednames no afecta a la manera en que se combinan los ensamblados posteriormente mediante la herramienta Combinación. Para un sitio grande, el gran número de ensamblados creado por la opción fixednames puede producir problemas de administración de lanzamientos o implementación. Combine para crear un ensamblado para En este escenario, puede controlar los ensamblados en el nivel de carpeta de cada carpeta de contenido de interfaz de contenido de interfaz de usuario. Este escenario es como omitir la opción fixenames usuario web utilizando Aspnet_merge.exe cuando se utiliza la herramienta Compilación. La diferencia es que la herramienta con la opción prefix. Combinación permite más control sobre los nombres de los ensamblados finales derivados de la carpeta raíz y de las carpetas de contenido definidas por el usuario. Los ensamblados de nivel superior y el contenido estático no resultan afectados. Una posible desventaja de este escenario es que si cambia un archivo de una carpeta, debe implementar de nuevo el ensamblado de la carpeta y la página modificada. Puede combinar sitios precompilados actualizables y no actualizables mediante la opción prefix. Este escenario es el predeterminado si ejecuta la herramienta Combinación sin opciones. Combine para crear un único ensamblado En este escenario, todo el contenido de la interfaz de usuario se combina en un para todos los archivos de contenido de ensamblado que tiene el nombre especificado en el parámetro assemblyname. Esto interfaz de usuario web utilizando reduce el número total de ensamblados en el sitio final implementado. Sin embargo, Aspnet_merge.exe con la opción w. también requiere que implementa de nuevo el ensamblado de contenido de interfaz de usuario en caso de que cambie un archivo de contenido. Los ensamblados de nivel superior y el contenido estático no resultan afectados. Combine para crear un único ensamblado En este escenario, el sitio final implementado contiene sólo un ensamblado que tiene para todo el sitio web utilizando el nombre especificado en el parámetro assemblyname. Un ensamblado único Aspnet_merge.exe con la opción o. simplifica la implementación del sitio. Sin embargo, significa que si cambia cualquier contenido del sitio, debe volver a crear e implementar el ensamblado del sitio. Los ensamblados de nivel superior (App_Code, App_GlobalResources y App_WebReferences) resultan afectados porque están incluidos en el ensamblado único. El contenido estático no resulta afectado. Combinar una aplicación para su implementación Para combinar los ensamblados de un sitio web, se ejecuta la herramienta Combinación y se especifica la ubicación del sitio precompilado con el parámetro applicationPath. La herramienta Combinación de ASP.NET combina un sitio precompilado en contexto. En otras palabras, no crea una nueva copia combinada del sitio precompilado. El parámetro applicationPath puede ser la ubicación final de la aplicación web. Asimismo, se puede volver a implementar la aplicación de compilación, por ejemplo, copiando el directorio. Cuando la herramienta Combinación combina un sitio precompilado, conserva la ubicación de los archivos dinámicos cuando aparecen en el paso precompilado. El único cambio que la herramienta Combinación realiza al contenido de los archivos dinámicos es cambiar las directivas @ Page, @ Control y @ Master. Garantiza que los archivos que tienen estas directivas heredan del ensamblado combinado correcto en la carpeta Bin. Para los ensamblados que derivan de las carpetas definidas por el usuario (incluida la carpeta del sitio raíz), algunas opciones de combinación pueden crear nombres que difieren de los que aparecen en el sitio precompilado. Por ejemplo, la tabla siguiente muestra los nombres del ensamblado combinado cuando no se utiliza ninguna opción con la herramienta Combinación. El nombre de ensamblado para cada carpeta definida por el usuario es App_Web_nnnn.dll, 39 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 donde nnnn es un valor hash generado de forma interna. Carpeta del sitio precompilado Nombre del ensamblado combinado sin utilizar ninguna opción de Aspnet_merge.exe \ Root.dll Admin Admin.dll La tabla siguiente muestra los nombres del ensamblado combinado cuando se utiliza la opción prefix y el parámetro NewName. Carpeta del sitio precompilado Nombre del ensamblado combinado utilizando la opción prefix de Aspnet_merge.exe \ Nuevo nombre.dll Admin Nuevo nombre.Admin.dll Los temas se tratan de manera diferente en un sitio combinado que no es actualizable. En el sitio precompilado no combinado, hay un ensamblado independiente para cada tema. Cada ensamblado recibe el nombre App_Theme_Nombre del tema.dll. En el sitio combinado, hay un ensamblado denominado Theme.dll. Si el sitio precompilado es actualizable, no hay ningún ensamblado basado en temas en la carpeta Bin combinada. Solucionar problemas del proceso de combinación Mientras se está compilando o combinando un sitio web, la ruta de acceso de un ensamblado podría resultar mayor que la longitud máxima permitida para una ruta de acceso de archivo de Microsoft Windows. En ese caso, cuando se solicita un recurso del ensamblado combinado, se produce un error HttpException que indica que el recurso no se precompiló y no se puede solicitar. La longitud de la ruta de acceso de archivo máxima en Microsoft Windows es 260 caracteres. Si la ruta de acceso de un ensamblado supera este límite, debe acortar la ruta de acceso del sitio web o de sus subcarpetas. También podría tener que deshabilitar las copias sombra del archivo Web.config mediante la propiedad ShadowCopyBinAssemblies del elemento hostingEnvironment. Cuando se utiliza la herramienta Combinación con la opción o para crear un único ensamblado para el sitio, se producirá un error si el proceso de combinación crea referencias circulares. Hay dos soluciones posibles para esta situación: Utilizar en su lugar la opción w para que el archivo de código fuente que contiene la referencia circular se mantenga como referencia externa y no se combine. Separar los controles implicados en una referencia circular en directorios diferentes. Cuando se combinan ensamblados que tienen atributos incoherentes, utilice las instrucciones siguientes para asegurarse de que la operación de combinación sea correcta: Hacer una lista de los atributos incoherentes mediante la opción allowattrs. Utilizar las opciones copyattrs y asegurarse de que coinciden los atributos de todos los ensamblados que se van a combinar. Utilizar la opción a. Firmar ensamblados Las opciones keyfile y delaysign permiten utilizar la herramienta Combinación para crear ensamblados con nombre seguro sin utilizar la herramienta Nombre seguro (Sn.exe). Las opciones delaysign corresponden al atributo AssemblyDelaySignAttribute y la opción keyfile corresponde al atributo AssemblyKeyFileAttribute. Cada opción aplica el atributo correspondiente al ensamblado combinado. El atributo que se va a aplicar se marca con un atributo AttributeUsageAttribute cuya propiedad AllowMultiple es false. Por consiguiente, si utiliza estas opciones al combinar ensamblados que ya están marcados con uno de los atributos, no se realizará la combinación. 40 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Ejemplos El comando siguiente combina los ensamblados del sitio precompilado en el directorio C:\PrecompiledSite. Aspnet_merge C:\PrecompiledSite El comando siguiente combina los ensamblados de un sitio precompilado en el directorio C:\PrecompiledSite y firma los ensamblados combinados mediante el archivo KeyFile.snk. El sitio combinado tendrá un ensamblado para cada carpeta del sitio precompilado. Aspnet_merge C:\PrecompiledSite -keyfile KeyFile.snk El comando siguiente combina todos los ensamblados del sitio precompilado en el directorio C:\PrecompiledSite en un único ensamblado y asigna el nombre MyApp.dll al ensamblado resultante. El sitio combinado tendrá un ensamblado para todo el contenido de interfaz de usuario del sitio web. Aspnet_merge C:\PrecompiledSite -w MyApp.dll El comando siguiente combina todos los ensamblados del sitio precompilado en el directorio C:\PrecompiledSite en un único ensamblado y asigna el nombre MyApp.dll al ensamblado resultante. Aspnet_merge C:\PrecompiledSite -o MyApp.dll REALIZAR LA COMPILACIÓN CON EL COMPILADOR Just-In-Time (JIT) La compilación JIT convierte MSIL en código nativo a petición en el tiempo de ejecución de la aplicación, cuando el contenido de un ensamblado se carga y ejecuta. Common Language Runtime proporciona un compilador JIT para cada arquitectura de CPU compatible, por lo que los programadores pueden crear un conjunto de ensamblados MSIL que se puede compilar con un compilador JIT y se puede ejecutar en equipos distintos con diferentes arquitecturas. No obstante, el código administrado sólo se ejecutará en un determinado sistema operativo si llama a las API nativas específicas de la plataforma o a una biblioteca de clases específica de la plataforma. La compilación JIT tiene en cuenta el hecho de que durante la ejecución nunca se llamará a parte del código. En vez de utilizar tiempo y memoria para convertir todo el MSIL de un archivo ejecutable portable (PE) a código nativo, convierte el MSIL necesario durante la ejecución y almacena el código nativo resultante en memoria para que sea accesible en las llamadas posteriores que se produzcan en el contexto de ese proceso. El cargador crea y asocia un código auxiliar a cada método de un tipo cuando este tipo se carga y se inicializa. Cuando se llama a un método por primera vez, el código auxiliar pasa el control al compilador JIT, el cual convierte el MSIL del método en código nativo y modifica el código auxiliar para señalar directamente al código nativo generado. Por tanto, las siguientes llamadas al método compilado mediante un compilador JIT pasan directamente al código nativo. 8 IMPLEMENTAR CONTROLES ASOCIADOS CON DATOS: DATAGRID, DATALIST, REPEATER, LISTVIEW, GRIDVIEW, FORMVIEW, DETAILSVIEW, TREEVIEW, DATAPAGER Los controles de servidor Web enlazados a datos son controles que pueden ser enlazados a un control de origen de datos para facilitar la operación de mostrar y modificar datos en la aplicación Web. Los controles de servidor Web enlazados a datos son controles compuestos que combinan otros controles Web de ASP.NET, como los controles Label y TextBox, en un diseño único. Por ejemplo, un control enlazado a datos, como el control DetailsView se puede enlazar a un conjunto de resultados como una tabla de empleados que contenga el nombre de cada empleado, la dirección, el puesto de trabajo, etc. Dentro del control DetailsView, se pueden enlazar controles Label a valores de datos únicos, como el campo de nombre o de dirección para crear el diseño de datos de la página. 41 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Además de permitir enlazar el control a un conjunto de resultados de datos, los controles enlazados a datos permiten personalizar el diseño del control mediante la utilización de plantillas. También proporcionan un modelo cómodo para controlar y cancelar los eventos. Enlazar a datos un control de servidor Web enlazado a datos Se puede trabajar con un control enlazado a datos enlazándolo a un control de origen de datos como el control ObjectDataSource o el control SqlDataSource. El control de origen de datos conecta a un origen de datos como una base de datos o el objeto de nivel medio y, a continuación, recupera o actualiza los datos. El control enlazado a datos puede utilizar entonces este dato. Para realizar el enlace, se establece la propiedad DataSourceID del control enlazado a datos para señalar a un control de origen de datos. Cuando un control enlazado a datos se enlaza a un control de origen de datos, apenas se necesita escribir código adicional, o no se necesita en absoluto, para realizar operaciones con datos, porque el control enlazado a datos puede aprovecharse automáticamente de los servicios de datos proporcionados por el control de origen de datos. Nota: En las versiones 1.0 y 1.1 de ASP.NET, los controles enlazados a datos lo hacían utilizando la propiedad DataSource y era necesario escribir código para administrar operaciones como mostrar, paginar, ordenar, editar y eliminar datos. Aunque todavía se pueden enlazar controles a datos utilizando la propiedad DataSource (y el código existente), en ASP.NET versión 2.0 y posteriores se pueden realizar enlaces mediante la propiedad DataSourceID en su lugar. GridView Control El control GridView muestra los datos en forma de tabla y ofrece la función de ordenar columnas, paginar los datos y editar o eliminar un único registro. El control GridView es el sucesor del control DataGrid disponible en versiones anteriores de ASP.NET. Junto con la capacidad adicional para aprovechar las funciones de los controles de origen de datos, el control GridView ofrece mejoras como la capacidad de definir varios campos de clave principal, mejor personalización de la interfaz de usuario utilizando campos y plantillas enlazados y un nuevo modelo para controlar o cancelar eventos. DetailsView Control El control DetailsView representa un único registro cada vez en forma de tabla y proporciona la capacidad de paginar varios registros, así como de insertar, actualizar y eliminar registros. El control DetailsView se utiliza a menudo en escenarios maestrodetalle donde el registro seleccionado en un control maestro como el control GridView determina el registro que muestra el control DetailsView. FormView Control El control FormView representa un único registro cada vez desde un origen de datos y proporciona la capacidad de paginar varios registros, así como de insertar, actualizar y eliminar registros, de forma similar al control DetailsView. Sin embargo, la diferencia entre los controles FormView y DetailsView radica en que el control DetailsView utiliza un diseño tabular donde cada campo del registro se muestra como una fila del control. En cambio, el control FormView no especifica un diseño predefinido para mostrar un registro. Por tanto, debe crear plantillas que contengan controles para mostrar los campos individuales del registro. La plantilla contiene el formato, los controles y las expresiones de enlace que se utilizan para diseñar el formulario. Repeater Control El control Repeater representa una lista de sólo lectura de un conjunto de registros devueltos desde un origen de datos. Al igual que el control FormView, el control Repeater no especifica un diseño integrado. En su lugar, se crea el diseño para el control Repeater utilizando plantillas. DataList Control El control DataList representa datos en forma de tabla y permite mostrar registros de datos en diferentes diseños, por ejemplo ordenados en columnas o en filas. Puede configurar el control DataList para permitir a los usuarios editar o eliminar un registro de la tabla. (El control DataList no puede aprovechar las funciones de los controles de origen de datos para modificar datos; el usuario debe proporcionar este código). El control DataList se diferencia del control Repeater en que el control DataList coloca explícitamente los elementos en una tabla HTML, mientras que el Repeater no lo hace. 42 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 ListView Control El control ListView muestra los datos de un origen de datos en un formato que se define mediante plantillas. La plantilla contiene el formato, los controles y las expresiones de enlace que se utilizan para diseñar los datos. El control ListView resulta útil para los datos de cualquier estructura de repetición, de forma similar a los controles DataList y Repeater. Sin embargo, a diferencia de los controles DataList y Repeater, el control ListView admite implícitamente las operaciones de edición, inserción y eliminación, así como la funcionalidad de ordenación y paginación. 9 CARGAR LOS CONTROLES DEL USUARIO DINÁMICAMENTE La creación mediante programación de una instancia de un control de servidor en una página Web ASP.NET es muy similar a la creación de un control de usuario. Para crear una instancia de un control de usuario mediante programación, se siguen los siguientes pasos: 1. 2. 3. 4. 5. En el control de usuario, la directiva @ Control contiene un atributo ClassName que asigna una clase al control de usuario. En el ejemplo siguiente se establece el atributo ClassName para realizar el establecimiento inflexible de tipos en un control de usuario. <%@ Control className="MyUserControl" %> En la página donde se va a trabajar con el control de usuario, crear una referencia a dicho control con la directiva @ Reference. Cuando se cree el control de usuario mediante programación, el tipo inflexible para dicho control estará disponible para la página Web ASP.NET sólo después de haber creado una referencia al mismo. Por ejemplo, el código siguiente crea una referencia a un control de usuario creado en el archivo MyUserControl.ascx. <%@ Reference Control="MyUserControl.ascx" %> Nota: Utilizar la directiva @ Reference cuando se vaya a cargar el control mediante programación. Utilizar la directiva @ Register cuando se agregue un control de usuario a la página mediante declaración. Crear una variable de instancia para el control de usuario, utilizando el nombre de clase del control. La clase será parte del espacio de nombres ASP. Por ejemplo, si se desea crear una instancia del control de usuario declarada como clase Spinner, se debe utilizar sintaxis como la siguiente: Protected ASP.Spinner Spinner1; Crear una instancia del control de usuario en el código llamando al método LoadControl. Asignar los valores de las propiedades según sea necesario y, a continuación, agregar el control a la colección ControlCollection de un contenedor de la página, como un control PlaceHolder. Nota: Cuando se agregan controles al objeto ControlCollection mediante el método Add, dichos controles se colocan en la colección en el orden en el que se procesan. Si desea agregar un control en una posición específica de la colección, utilice el método AddAt y especifique la ubicación de índice en la que desea almacenar el control. Ejemplo En el ejemplo siguiente se muestra una página Web ASP.NET que carga un control de usuario mediante programación. La página incluye una directiva @ Reference para especificar el archivo del control. El método LoadControl lee el archivo y crea una instancia de éste en forma de control que se puede agregar a la página. <%@ Page Language="C#" %> <%@ Reference Control="~/Controls/Spinner.ascx" %> <script runat="server"> private ASP.Spinner Spinner1; protected void Page_Load(object sender, EventArgs e) { 43 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Spinner1 = (ASP.Spinner)LoadControl("~/Controls/Spinner.ascx"); // Set MaxValue first. Spinner1.MaxValue = 20; Spinner1.MinValue = 10; PlaceHolder1.Controls.Add(Spinner1); } protected void Button1_Click(object sender, EventArgs e) { Label1.Text = Spinner1.CurrentNumber.ToString(); } </script> <html> <head id="Head1" runat="server"> <title>Load User Control Programmatically</title> </head> <body> <form id="form1" runat="server"> <div> <asp:PlaceHolder runat=server ID="PlaceHolder1" /> <br /> <asp:Button ID="Button1" runat="server" Text="Button" OnClick="Button1_Click" /> <br /> <br /> <asp:Label ID="Label1" runat="server" Text=""></asp:Label> </div> </form> </body> 44 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 </html> 10 CREAR Y UTILIZAR CONTROLES PERSONALIZADOS: REGISTRO DE CONTROLES EN UNA PÁGINA, CREACIÓN DE CONTROLES EN PLANTILLA En ocasiones, es posible la necesidad de cierta funcionalidad en un control que no está incluida en los controles de servidor Web ASP.NET integrados. En estos casos, se pueden crear controles propios. Se dispone de dos opciones. Se pueden crear: Controles de usuario. Los controles de usuario son contenedores en los que puede colocar controles de formato y de servidor Web. A continuación puede tratar el control de usuario como una unidad y definir propiedades y métodos para el mismo. Controles personalizados. Un control personalizado es una clase escrita por un desarrollador que se deriva de Control o WebControl. Los controles de usuario son mucho más fáciles de crear que los controles personalizados, ya que es posible reutilizar los ya existentes. Esto permite crear con facilidad controles con elementos de interfaz de usuario complejos. Aunque las herramientas de diseño visual como Microsoft Visual Studio 2005 simplifican el desarrollo de controles, no son imprescindibles para la creación o generación de controles personalizados. Los controles pueden crearse con cualquier editor de texto y generarse desde la línea de comandos mediante los compiladores que forman parte de Kit de desarrollo de software de Windows (SDK). Independientemente del método empleado para crear el control, su aspecto y su comportamiento en tiempo de diseño en un diseñador visual serán los mismos. Los desarrolladores de páginas podrán agregar el control al cuadro de herramientas del diseñador visual, arrastrarlo a la superficie de diseño y tener acceso a sus propiedades y eventos en el explorador de propiedades. En algunos diseñadores visuales como Visual Studio 2005, los controles personalizados también admiten IntelliSense sin que sea necesario realizar ninguna operación adicional. Crear el control de servidor El control a crear, WelcomeLabel, es un control simple similar al control Label estándar. La clase WelcomeLabel se deriva de WebControl y define una propiedad Text que permite al desarrollador de páginas proporcionar una cadena de texto para dar la bienvenida a los usuarios de un sitio. WelcomeLabel agrega el nombre del usuario a la cadena de texto si dicho nombre está presente en el encabezado enviado por el explorador del usuario. Por ejemplo, si el desarrollador de páginas establece "Hola" como valor de la propiedad Text, WelcomeLabel representará "¡Hola, nombreDeUsuario!" u "¡Hola!" en función de si el nombre de usuario está presente en el encabezado. Para crear el código del control de servidor personalizado 1. Crear un archivo denominado WelcomeLabel.cs o WelcomeLabel.vb. 2. Agregar el código siguiente al archivo de código fuente del control: // WelcomeLabel.cs using System; using System.ComponentModel; using System.Security.Permissions; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; namespace Samples.AspNet.CS.Controls { [ 45 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 AspNetHostingPermission(SecurityAction.Demand, Level = AspNetHostingPermissionLevel.Minimal), AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal), DefaultProperty("Text"), ToolboxData("<{0}:WelcomeLabel runat=\"server\"> </{0}:WelcomeLabel>") ] public class WelcomeLabel : WebControl { [ Bindable(true), Category("Appearance"), DefaultValue(""), Description("The welcome message text."), Localizable(true) ] public virtual string Text { get { string s = (string)ViewState["Text"]; return (s == null) ? String.Empty : s; } set { ViewState["Text"] = value; } } protected override void RenderContents(HtmlTextWriter writer) { 46 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 writer.WriteEncodedText(Text); if (Context != null) { string s = Context.User.Identity.Name; if (s != null && s != String.Empty) { string[] split = s.Split('\\'); int n = split.Length - 1; if (split[n] != String.Empty) { writer.Write(", "); writer.Write(split[n]); } } } writer.Write("!"); } } } Descripción del código Si el control representa un elemento de interfaz de usuario o cualquier otro elemento visible en el cliente, debe derivar el control de System.Web.UI.WebControls.WebControl (o una clase derivada). Si el control representa un elemento que no está visible en el explorador del cliente, como un elemento oculto o un elemento meta, se deriva el control de System.Web.UI.Control. La clase WebControl se deriva de Control y agrega propiedades relacionadas con el estilo como Font, ForeColor y BackColor. Por otra parte, los controles que se derivan de WebControl participan de las mismas características de temas de ASP.NET sin que sea necesario realizar ninguna operación adicional. Si un control extiende la funcionalidad de otro control existente, como Button, Label o Image, se puede derivar de ese control. Dado que WelcomeLabel extiende la funcionalidad del control Label, podría derivarse de Label. Sin embargo, se deriva WelcomeLabel de WebControl para mostrar cómo se debe definir una propiedad y los metadatos de las propiedades. WelcomeLabel define una propiedad, Text, y utiliza el estado de vista para almacenar el valor de dicha propiedad. Al utilizar el estado de vista se conserva el valor de Text en las distintas devoluciones de datos. En cada devolución de datos, se vuelve a crear la página y los valores se restauran desde el estado de vista. Si el valor de Text no se almacenara en el estado de vista, el valor se establecería en su valor predeterminado, Empty, en cada devolución de datos. La propiedad ViewState heredada de WebControl es un diccionario en el que se guardan los valores de datos. Los valores se escriben y se recuperan utilizando una clave String. En este caso, se utiliza "Text" como clave. Los elementos del diccionario son de tipo Object y deberá convertirlos al tipo de la propiedad. 47 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 El control WelcomeLabel representa su propiedad Text reemplazando el método RenderContents heredado. El parámetro pasado al método RenderContents es un objeto del tipo HtmlTextWriter, que es una clase de utilidad que tiene métodos para representar etiquetas y otros formatos HTML (así como de las variantes de HTML). WelcomeLabel realiza llamadas sucesivas al método Write del objeto HtmlTextWriter en lugar de realizar una concatenación de cadenas y, a continuación, invocar al método Write. Esto mejora el rendimiento debido a que el objeto HtmlTextWriter escribe directamente en la secuencia de salida. La concatenación de cadenas requiere tiempo y memoria para crear la cadena y, a continuación, escribe en la secuencia. Cuando se implementen la representación en los controles, se deberá seguir el modelo planteado. Nota: En general, cuando el control se deriva de WebControl y representa un solo elemento, se debe reemplazar el método RenderContents (no el método Render) para representar el contenido de las etiquetas del control. El método Render de WebControl invoca al método RenderContents después de representar la etiqueta de apertura del control y sus atributos de estilo. Si se reemplaza el método Render para escribir el contenido, el control perderá la lógica de representación de estilos integrada en el método Render de WebControl. Los atributos aplicados a WelcomeLabel contienen metadatos utilizados por Common Language Runtime y por las herramientas en tiempo de diseño. En el nivel de clase, WelcomeLabel se marca con los atributos siguientes: AspNetHostingPermissionAttribute es un atributo de seguridad de acceso a código. Hace que el compilador JIT compruebe que al código vinculado a WelcomeLabel se le ha concedido el permiso AspNetHostingPermission. Todas las clases de ASP.NET públicas se marcan con este atributo. Debe aplicar AspNetHostingPermissionAttribute a los controles como medida de seguridad frente a los llamadores de confianza parcial. DefaultPropertyAttribute es un atributo en tiempo de diseño que especifica la propiedad predeterminada de un control. En los diseñadores visuales, el explorador de propiedades generalmente resalta la propiedad predeterminada cuando el desarrollador de páginas hace clic en el control en la superficie de diseño. ToolboxDataAttribute especifica la cadena de formato del elemento. La cadena se convierte en el formato del control cuando se hace doble clic en el control en el cuadro de herramientas o cuando el control se arrastra del cuadro de herramientas a la superficie de diseño. En el caso de WelcomeLabel, la cadena crea este elemento: <aspSample:WelcomeLabel runat="server"> </aspSample:WelcomeLabel> El control WelcomeLabel también hereda dos atributos de la clase base WebControl: ParseChildrenAttribute y PersistChildrenAttribute. Se aplican como ParseChildren(true) y PersistChildren(false). Estos dos atributos funcionan juntos y con el atributo ToolboxDataAttribute a fin de que los elementos secundarios se interpreten como propiedades y las propiedades se conserven como atributos. Los atributos siguientes aplicados a la propiedad Text de WelcomeLabel son atributos estándar en tiempo de diseño que se aplican generalmente a todas las propiedades públicas de los controles: BindableAttribute, especificado como true o false, indica a los diseñadores visuales si tiene sentido enlazar la propiedad a datos. Por ejemplo, en Visual Studio 2005, si una propiedad se marca con Bindable(true), esta se mostrará en el cuadro de diálogo DataBindings. Si la propiedad no se marca con este atributo, el explorador de propiedades deduce que el valor es Bindable(false). CategoryAttribute, especifica en qué categoría se debe situar la propiedad en el explorador de propiedades del diseñador visual. Por ejemplo, Category("Appearance") indica al explorador de propiedades que muestre la propiedad en la categoría Apariencia cuando el desarrollador de páginas utilice la vista por categorías del explorador de propiedades. Se puede especificar un argumento de cadena correspondiente a una categoría existente en el explorador de propiedades o crear una categoría propia. DescriptionAttribute especifica una breve descripción de la propiedad. En Visual Studio 2005, el explorador de propiedades muestra la descripción de la propiedad seleccionada en la parte inferior de la ventana Propiedades. DefaultValueAttribute especifica un valor predeterminado para la propiedad. Este valor debe ser idéntico al valor predeterminado que se devuelve desde el descriptor de acceso de la propiedad (captador). En Visual Studio 2005, DefaultValueAttribute permite al desarrollador de páginas restablecer el valor de una propiedad a su valor predeterminado si se abre el menú de acceso directo en la ventana Propiedades y se hace clic en el botón Restablecer. LocalizableAttribute , especificado como true o false, indica a los diseñadores visuales si tiene sentido traducir la propiedad. Cuando una propiedad se marca con Localizable(true), el diseñador visual la incluye cuando se serializan los 48 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 recursos traducibles. El diseñador conservará el valor de la propiedad en el archivo de recursos de referencia cultural neutra u otro origen de localización cuando el control se sondee para buscar propiedades localizables. Nota: En las versiones 1.0 y 1.1 de ASP.NET, LocalizableAttribute no se podía aplicar a los controles de servidor personalizados ya que el modelo de localización de ASP.NET era distinto en dichas versiones. Los atributos en tiempo de diseño aplicados a un control y sus miembros no afectan al funcionamiento del control en tiempo de ejecución, pero mejoran la experiencia del desarrollador cuando el control se utiliza en un diseñador visual. Puede ver una lista completa de los atributos en tiempo de diseño, tiempo de análisis y tiempo de ejecución para los controles de servidor en Atributos de metadatos para controles de servidor personalizados. Utilizar el directorio App_Code para probar los controles sin compilación Se puede utilizar la característica de compilación dinámica de ASP.NET para probar el control en una página sin compilarlo en un ensamblado. ASP.NET compila dinámicamente el código colocado en el directorio App_Code bajo la raíz de un sitio Web ASP.NET. De este modo, es posible obtener acceso a las clases de los archivos de código fuente de este directorio desde las páginas sin necesidad de compilarlas manualmente en ensamblados. Si coloca los archivos de código fuente para los controles en el directorio App_Code, los cambios que realice en el código de los controles se reflejarán de forma inmediata en las páginas que utilizan dichos controles. Nota: El directorio App_Code es una nueva característica que no estaba disponible en ASP.NET 1.0 y 1.1. El uso del directorio App_Code para las pruebas iniciales del control es opcional. Los pasos principales para generar un control de servidor son los mismos que en las versiones anteriores. Para crear el sitio Web ASP.NET y el directorio App_Code 1. 2. 3. Crear un sitio Web denominado ServerControlsTest. Se puede crear el sitio en IIS como un directorio virtual denominado ServerControlsTest. Crear un directorio App_Code directamente bajo el directorio raíz del sitio Web (también denominado raíz de la aplicación Web). Copiar el archivo de código fuente del control (WelcomeLabel.cs o WelcomeLabel.vb) en el directorio App_Code. Crear un prefijo de etiqueta Un prefijo de etiqueta es el prefijo, como "asp" en <asp:Table />, que aparece antes del nombre de tipo del control cuando éste se crea mediante declaración en una página. Para habilitar el control a fin de que pueda utilizarse mediante declaración en una página, ASP.NET necesita que se asigne un prefijo de etiqueta al espacio de nombres del control. El desarrollador de páginas puede proporcionar una asignación de prefijo de etiqueta y espacio de nombres agregando una directiva @ Register en cada página que utiliza el control personalizado, como en el ejemplo siguiente: Copiar <%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.CS.Controls"%> La directiva @ Register de ASP.NET 2.0 es la misma que en ASP.NET 1.0 y ASP.NET 1.1. Se podrá observar que el atributo assembly que especifica el nombre de ensamblado del control no aparece en la directiva Register anterior. Cuando falta el atributo assembly, ASP.NET deduce que el ensamblado se ha compilado dinámicamente a partir de los archivos de código fuente del directorio App_Code. Como alternativa al uso de la directiva @ Register en cada página .aspx, el desarrollador de páginas puede especificar la asignación de prefijo de etiqueta y espacio de nombres en el archivo Web.config. Esto resulta útil si el control personalizado se utiliza en varias páginas de la aplicación Web. En el procedimiento siguiente se describe cómo especificar la asignación del prefijo de etiqueta en el archivo Web.config. Para agregar una asignación de prefijo de etiqueta al archivo Web.config 1. Crear un archivo de texto denominado Web.config bajo el directorio raíz del sitio Web si dicho archivo no existe todavía. 2. Colocar el siguiente código. <?xml version="1.0"?> <configuration> 49 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 <system.web> <pages> <controls> <add tagPrefix="aspSample" namespace="Samples.AspNet.CS.Controls"> </add> </controls> </pages> </system.web> </configuration> La sección resaltada muestra una entrada de prefijo de etiqueta que asigna el prefijo "aspSample" al espacio de nombres Samples.AspNet.CS.Controls. Nota: El prefijo de etiqueta debe ser un elemento secundario de la sección controls, que debe estar bajo la sección pages, que a su vez debe ser un elemento secundario de system.web. Tras haber especificado la asignación del prefijo de etiqueta en el archivo de configuración, puede utilizar el control WelcomeLabel mediante declaración (como <aspSample:WelcomeLabel />) en cualquier página del sitio Web. Crear una página para utilizar el control Para crear una página que utilice el control personalizado 1. Crear un archivo de texto denominado WelcomeLabelTest.aspx en el sitio Web. 2. Copiar el formato siguiente en el archivo WelcomeLabelTest.aspx. <%@ Page Language="C#"%> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" > <head id="Head1" runat="server"> <title>WelcomeLabel Test</title> </head> <body> <form id="form1" runat="server"> <div> 50 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 <aspSample:WelcomeLabel Text="Hello" ID="WelcomeLabel1" runat="server" BackColor="Wheat" ForeColor="SaddleBrown" /> </div> </form> </body> </html> 3. Visualizar el archivo WelcomeLabelTest.aspx en el explorador escribiendo la dirección URL siguiente en la barra de direcciones: http://localhost/ServerControlsTest/WelcomeLabelTest.aspx 4. Realizar algún cambio en el código fuente del control. Por ejemplo, escribir una cadena adicional agregando esta línea de código al final del método RenderContents: writer.Write("Testing how the App_Code directory works."); 5. Actualizar la página WelcomeLabelTest.aspx en el explorador. Se verá que los cambios realizados en el control se reflejan en la página aunque no se haya compilado el control. Además de la propiedad Text del control WelcomeLabel definido de forma explícita, la instancia del control de la página tiene las propiedades BackColor y ForeColor no definidas. El control WelcomeLabel obtiene estas y otras propiedades relacionadas con el estilo heredándolas de la clase base WebControl. Por otra parte, al control WelcomeLabel se le puede asignar una máscara y puede formar parte de un tema sin que sea necesario realizar ninguna operación adicional. Compilar el control en un ensamblado Aunque el directorio App_Code permite probar el control sin compilarlo, si se desea distribuir a otros desarrolladores como código de objeto, se debe compilar. Por otra parte, el control no se puede agregar al cuadro de herramientas del diseñador visual a menos que se compile en un ensamblado. Para compilar el control en un ensamblado 1. 2. Establecer la variable PATH del entorno de Windows del equipo para que incluya la ruta de acceso a la instalación de .NET Framework. Generalmente, .NET Framework está instalado en el directorio de instalación de Windows, en \Microsoft.NET\Framework\númeroDeVersión. Ejecutar el comando siguiente desde el directorio que ha creado para los archivos de código fuente. csc /t:library /out:Samples.AspNet.CS.Controls.dll /r:System.dll /r:System.Web.dll *.cs La opción del compilador /t:library indica al compilador que debe crear una biblioteca en lugar de un ensamblado ejecutable. La opción /out proporciona un nombre para el ensamblado y la opción /r muestra los ensamblados que están vinculados al ensamblado. Incrustar un icono en el ensamblado del control Generalmente, los diseñadores visuales como Visual Studio 2005 usan un icono predeterminado (como la imagen de un engranaje) para mostrar un control en el cuadro de herramientas. Como opción para el control, se puede personalizar su aspecto en el cuadro de herramientas incrustando un mapa de bits de 16 por 16 píxeles en el ensamblado del control. Por convención, los diseñadores visuales utilizan el píxel situado más abajo en la parte izquierda del mapa de bits como color transparente. Utilizar TagPrefixAttribute para proporcionar una asignación de prefijo de etiqueta y espacio de nombres 51 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Se puede especificar un prefijo de etiqueta en la página o en el archivo Web.config. Opcionalmente también se puede sugerir el prefijo de etiqueta predeterminado que el diseñador visual deba utilizar para el control, incluyendo el atributo System.Web.UI.TagPrefixAttribute del nivel de ensamblado. El atributo TagPrefixAttribute es útil porque proporciona un prefijo de etiqueta para que el diseñador visual pueda utilizarlo si no encuentra una asignación de prefijo de etiqueta en el archivo Web.config o en una directiva Register de la página. El prefijo de etiqueta se registra con la página la primera vez que se hace doble clic en el control en el cuadro de herramientas o cuando el control se arrastra del cuadro de herramientas a la página. Si se decide usar el atributo TagPrefixAttribute, se puede especificar en un archivo independiente que se compila con los controles. Por convención, el archivo se denomina AssemblyInfo.extensiónDeIdioma, como AssemblyInfo.cs o AssemblyInfo.vb. En el procedimiento siguiente se describe cómo especificar los metadatos de TagPrefixAttribute. Nota: Si no se especifica el atributo TagPrefixAttribute en el ensamblado del control y el desarrollador de páginas no especifica la asignación de prefijo de etiqueta y espacio de nombres en la página o en el archivo Web.config, el diseñador visual podría crear un prefijo de etiqueta predeterminado. Por ejemplo, Visual Studio 2005 creará su propia etiqueta (como cc1) para el control cuando éste se arrastre desde el cuadro de herramientas. Para agregar una asignación de espacio de nombres y prefijo de etiqueta mediante TagPrefixAttribute 1. Crear un archivo denominado AssemblyInfo.cs o AssemblyInfo.vb en el directorio del código fuente y agregar el código siguiente al archivo. using System; using System.Web.UI; [assembly: TagPrefix("Samples.AspNet.CS.Controls", "aspSample")] tributo de prefijo de etiqueta crea una asignación Samples.AspNet.VB.Controls y el prefijo aspSample. 2. entre el espacio de nombres Samples.AspNet.CS.Controls o Compilar todos los archivos de código fuente utilizando el comando de compilación. Utilizar el control personalizado compilado en una página ASP.NET Para probar la versión compilada del control personalizado es necesario que las páginas del sitio Web puedan tener acceso al ensamblado del control. Para hacer que el sitio Web tenga acceso al ensamblado del control 1. Crear un directorio Bin bajo la raíz del sitio Web. 2. Copiar el ensamblado del control (Samples.AspNet.CS.Controls.dll o Samples.AspNet.VB.Controls.dll) en el directorio Bin. 3. Eliminar el archivo de código fuente del control del directorio App_Code. Si no se elimina los archivos de código fuente, el tipo del control existirá tanto en el ensamblado compilado como en el ensamblado generado dinámicamente creado por ASP.NET. Esto creará una referencia ambigua al cargar el control y las páginas en las que se utilice dicho control producirán un error de compilador. El ensamblado creado en este ejemplo se denomina ensamblado privado porque debe estar colocado en un directorio Bin del sitio Web ASP.NET para permitir que las páginas del sitio utilicen el control. No es posible tener acceso al ensamblado desde otras aplicaciones a menos que también se instale una copia con dichas aplicaciones. Si se crea controles para aplicaciones de hospedaje Web compartidas, normalmente los empaquetará en un ensamblado privado. No obstante, si se crea controles para su uso en un entorno de hospedaje dedicado o crea un conjunto de controles que un ISP pone a disposición de todos sus clientes, se podría necesitar empaquetar los controles en un ensamblado compartido (con nombre seguro) que esté instalado en la Caché de ensamblados global. A continuación, se debe modificar la asignación del prefijo de etiqueta creada en Web.config para especificar el nombre de ensamblado del control. Para modificar la asignación del prefijo de etiqueta de Web.config 52 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Editar el archivo Web.config para agregar un atributo assembly al elemento addtagPrefix: <controls> <add tagPrefix="aspSample" namespace="Samples.AspNet.CS.Controls" assembly="Samples.AspNet.CS.Controls"> </add> </controls> El atributo assembly especifica el nombre del ensamblado en el que está el control. El elemento addtagPrefix asigna un prefijo de etiqueta a una combinación de espacio de nombres y ensamblado. Cuando ASP.NET genera dinámicamente el ensamblado a partir de los archivos de código fuente del directorio App_Code, el atributo assembly no es necesario. Cuando no se utiliza el atributo assembly, ASP.NET carga el tipo del control de los ensamblados generados dinámicamente desde el directorio App_Code. Para ver la página que utiliza el control personalizado Visualizar la página WelcomeLabelTest.aspx en el explorador escribiendo la dirección URL siguiente en la barra de direcciones: http://localhost/ServerControlsTest/WelcomeLabelTest.aspx Si se utiliza el control en un diseñador visual como Visual Studio 2005, podrá agregar el control al cuadro de herramientas, arrastrarlo del cuadro de herramientas a la superficie de diseño y tener acceso a sus propiedades y eventos en el explorador de propiedades. Además, en Visual Studio 2005, el control es totalmente compatible con IntelliSense en la vista de código fuente del diseñador de páginas y en el editor de código. Esto incluye la finalización de instrucciones en un bloque script así como la compatibilidad con el explorador de propiedades cuando el desarrollador de páginas hace clic en la etiqueta del control. CONTROL DE SERVIDOR CON PLANTILLA En este ejemplo se muestra un control denominado VacationHome que describe cómo implementar un control de servidor con plantilla. El control VacationHome define dos propiedades, Title y Caption. Mediante la edición del elemento Template en el control, el desarrollador de páginas especifica los controles y el formato que definen la interfaz de usuario del control. El control también permite al desarrollador de páginas utilizar la sintaxis <#% Container%>, a fin de que Title y Caption puedan mostrarse en la interfaz de usuario. El diseñador de páginas podría crear una página Web ASP.NET que presentara el aspecto siguiente: <aspSample:VacationHome ID="VacationHome1" Title="Condo for Rent in Hawaii" Caption="Ocean view starting from $200" Runat="server" Width="230px" Height="129px"> <Template> <table bgcolor="aqua" align="center" id="Table1" runat="server" style="width: 286px; height: 260px"> <tr> <td style="width: 404px" align="center"> 53 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 <asp:Label ID="Label1" Runat="server" Text="<%#Container.Title%>" Font-Names="Arial, Helvetica"></asp:Label> </td> </tr> <tr> <td style="width: 404px"> <asp:Image ID="Image1" Runat="server" ImageUrl="~/images/hawaii.jpg" /> </td> </tr> <tr> <td style="width: 404px; height: 26px;" align="center"> <asp:Label ID="Label2" Runat="server" Text="<%#Container.Caption%>" Font-Names="Arial, Helvetica"> </asp:Label> </td> </tr> </table> </Template> </aspSample:VacationHome> Lista de código del control VacationHome // VacationHome.cs using System; using System.ComponentModel; using System.Drawing; using System.Security.Permissions; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; 54 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 using System.Web.UI.Design; namespace Samples.AspNet.CS.Controls { [ AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal), AspNetHostingPermission(SecurityAction.Demand, Level = AspNetHostingPermissionLevel.Minimal), Designer(typeof(VacationHomeDesigner)), DefaultProperty("Title"), ToolboxData( "<{0}:VacationHome runat=\"server\"> </{0}:VacationHome>"), ] public class VacationHome : CompositeControl { private ITemplate templateValue; private TemplateOwner ownerValue; [ Bindable(true), Category("Data"), DefaultValue(""), Description("Caption") ] public virtual string Caption { get { string s = (string)ViewState["Caption"]; return (s == null) ? String.Empty : s; 55 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 } set { ViewState["Caption"] = value; } } [ Browsable(false), DesignerSerializationVisibility( DesignerSerializationVisibility.Hidden) ] public TemplateOwner Owner { get { return ownerValue; } } [ Browsable(false), PersistenceMode(PersistenceMode.InnerProperty), DefaultValue(typeof(ITemplate), ""), Description("Control template"), TemplateContainer(typeof(VacationHome)) ] public virtual ITemplate Template { get { 56 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 return templateValue; } set { templateValue = value; } } [ Bindable(true), Category("Data"), DefaultValue(""), Description("Title"), Localizable(true) ] public virtual string Title { get { string s = (string)ViewState["Title"]; return (s == null) ? String.Empty : s; } set { ViewState["Title"] = value; } } protected override void CreateChildControls() { Controls.Clear(); 57 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 ownerValue = new TemplateOwner(); ITemplate temp = templateValue; if (temp == null) { temp = new DefaultTemplate(); } temp.InstantiateIn(ownerValue); this.Controls.Add(ownerValue); } public override void DataBind() { CreateChildControls(); ChildControlsCreated = true; base.DataBind(); } } [ ToolboxItem(false) ] public class TemplateOwner : WebControl { } #region DefaultTemplate sealed class DefaultTemplate : ITemplate { 58 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 void ITemplate.InstantiateIn(Control owner) { Label title = new Label(); title.DataBinding += new EventHandler(title_DataBinding); LiteralControl linebreak = new LiteralControl("<br/>"); Label caption = new Label(); caption.DataBinding += new EventHandler(caption_DataBinding); owner.Controls.Add(title); owner.Controls.Add(linebreak); owner.Controls.Add(caption); } void caption_DataBinding(object sender, EventArgs e) { Label source = (Label)sender; VacationHome container = (VacationHome)(source.NamingContainer); source.Text = container.Caption; } void title_DataBinding(object sender, EventArgs e) { Label source = (Label)sender; VacationHome container = (VacationHome)(source.NamingContainer); source.Text = container.Title; 59 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 } } #endregion public class VacationHomeDesigner : ControlDesigner { public override void Initialize(IComponent Component) { base.Initialize(Component); SetViewFlags(ViewFlags.TemplateEditing, true); } public override string GetDesignTimeHtml() { return "<span>This is design-time HTML</span>"; } public override TemplateGroupCollection TemplateGroups { get { TemplateGroupCollection collection = new TemplateGroupCollection(); TemplateGroup group; TemplateDefinition template; VacationHome control; control = (VacationHome)Component; group = new TemplateGroup("Item"); template = new TemplateDefinition(this, "Template", control, "Template", true); group.AddTemplateDefinition(template); 60 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 collection.Add(group); return collection; } } } } Descripción del código Un control con plantilla extiende CompositeControl si se agrega una propiedad del tipo ITemplate y se define el contenedor de nombres para el control. La definición del contenedor de nombres permitirá al desarrollador de páginas utilizar la sintaxis <#%Container%> en la definición de la plantilla. El control con plantilla también define una propiedad de un tipo que se deriva de Control para alojar los controles definidos en la plantilla. También se implementan reemplazos de atributos y miembros concretos para coordinar la propiedad de la plantilla, el control de host y el comportamiento del contenedor de nombres. En la lista siguiente se resumen los requisitos de implementación principales para un control con plantilla como muestra VacationHome. En la explicación que acompaña a la lista se proporciona información detallada sobre cada uno de los requisitos. El control VacationHome muestra: La derivación de la clase base CompositeControl. Un control con plantilla es una clase especial de control compuesto. También se puede derivar de WebControl, pero CompositeControl agrega la implementación para INamingContainer, lo que permite el uso de la sintaxis <#%Container%>. La implementación de una propiedad del tipo ITemplate y la aplicación a la misma de atributos de metadatos relevantes para definir su persistencia y su contenedor de nombres. La exposición de una propiedad del tipo Control o una clase derivada de Control que sirve para alojar los controles definidos en el elemento de plantilla. Este control se denomina contenedor de plantilla. El reemplazo del método CreateChildControls para crear instancias de los controles con plantilla en la colección Controls del contenedor de plantilla. Opcionalmente, la definición de la plantilla predeterminada que el control utilizará cuando el desarrollador de páginas no especifique ninguna plantilla. Opcionalmente, la definición de una clase de diseñador para el control. La clase de diseñador permite al desarrollador de páginas editar las plantillas en un diseñador visual. Los atributos aplicados a la propiedad ITemplate son BrowsableAttribute, PersistenceModeAttribute y TemplateContainerAttribute. TemplateContainerAttribute especifica el tipo del control que el analizador de páginas debe utilizar durante la resolución de la variable Container en una expresión como <#%Container.Title%> de una plantilla. El tipo especificado debe implementar INamingContainer y definir las propiedades de datos (en este caso, Caption y Title) para el control. Este tipo puede ser el tipo del propietario de la plantilla o de un control situado más arriba en el árbol de control. En el control VacationHome, el control cuyo tipo se pasa al constructor TemplateContainerAttribute no es el propietario de la plantilla, sino el propio control VacationHome. BrowsableAttribute se establece en false, dado que generalmente las plantillas no se editan en la ventana de edición de propiedades del diseñador visual. PersistenceModeAttribute se establece en InnerProperty, dado que la especificación de la plantilla está escrita como un elemento interno del control. El control con plantilla debe definir una propiedad del tipo Control que se convierte en el contenedor para los controles creados por la plantilla. En el ejemplo, el control VacationHome define la propiedad Owner, que es del tipo TemplateOwner, que a su vez se deriva de WebControl. La clase TemplateOwner está marcada con ToolboxItem(false) para indicar que la clase TemplateOwner no necesita la compatibilidad del cuadro de herramientas en el diseñador visual. Se crean instancias de los controles de la plantilla y se agregan a la propiedad Controls del control Owner. Si el control expone varias propiedades ITemplate, podría definir una propiedad de contenedor de plantilla independiente para cada plantilla. La propiedad Owner se expone como propiedad pública. Esto permite al diseñador de páginas utilizar el método FindControl para hacer referencia a controles concretos en la plantilla en tiempo de ejecución. 61 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 El control VacationHome reemplaza al método base CreateChildControls. El método CreateChildControls crea instancias de los controles especificados en la propiedad Template y los agrega a la colección Controls del objeto Owner. A continuación, el objeto Owner se agrega a la colección Controls de la instancia de VacationHome, con lo que se podrá representar el control. Si el desarrollador de páginas no ha definido una plantilla, VacationHome creará una instancia de DefaultTemplate, que se deriva de ITemplate. El método InstantiateIn crea dos controles Label para mostrar las propiedades Title y Caption. Se crea un método controlador de eventos para el evento DataBinding de cada control. El controlador de eventos DataBinding establece la propiedad Text en la propiedad correspondiente (Title o Caption) de VacationHome. La clase VacationHomeDesigner que implementa un diseñador para la clase VacationHome se deriva de ControlDesigner. Durante la inicialización, el método SetViewFlags, al que se llama con TemplateEditing, permite la edición de la plantilla en tiempo de diseño. El método GetDesignTimeHtml se reemplaza para representar el control cuando no está en modo de edición de plantillas. El código de la propiedad TemplateGroups reemplazada define un grupo de plantillas que contiene una plantilla. Cada objeto TemplateGroup agrega una opción de edición de plantillas a la interfaz de usuario de edición de plantillas del diseñador visual. (En Visual Studio 2005, las opciones de edición de plantillas se muestran en una etiqueta inteligente asociada al control.) En el control VacationHome, la única opción de edición es "Item". Cada objeto TemplateDefinition crea una plantilla para la edición en el diseñador. El parámetro templatePropertyName del constructor TemplateDefinition especifica el nombre de la propiedad de plantilla en el control. DesignerAttribute se aplica a la clase VacationHome para especificar la clase de diseñador. Página de prueba del control VacationHome El ejemplo siguiente muestra una página .aspx que utiliza el control VacationHome. La primera instancia del control de la página especifica una plantilla para la propiedad ITemplate del control. La segunda instancia no especifica la propiedad ITemplate, lo que hace que el control VacationHome utilice su plantilla predeterminada en tiempo de ejecución. <%@ Page Language="C#"%> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <script runat="server"> void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { VacationHome1.DataBind(); VacationHome2.DataBind(); } } </script> <html xmlns="http://www.w3.org/1999/xhtml" > <head id="Head1" runat="server"> <title> VacationHome Control Test Page 62 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 </title> </head> <body> <form id="form1" runat="server"> <aspSample:VacationHome ID="VacationHome1" Title="Condo for Rent in Hawaii" Caption="Ocean view starting $200" Runat="server" Width="230px" Height="129px"> <Template> <table id="TABLE1" runat="server" style="width: 286px; height: 260px; background-color:Aqua; text-align:center"> <tr> <td style="width: 404px" align="center"> <asp:Label ID="Label1" Runat="server" Text="<%#Container.Title%>" Font-Names="Arial, Helvetica"></asp:Label> </td> </tr> <tr> <td style="width: 404px"> <asp:Image ID="Image1" Runat="server" ImageUrl="~/images/hawaii.jpg" AlternateText="Hawaii home" /> </td> </tr> <tr> <td style="width: 404px; height: 26px;" align="center"> <asp:Label ID="Label2" Runat="server" Text="<%#Container.Caption%>" Font-Names="Arial, Helvetica"> 63 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 </asp:Label> </td> </tr> </table> </Template> </aspSample:VacationHome> <br /> <br /> <br /> The VacationHome control rendered with its default template: <br /> <br /> <aspSample:VacationHome ID="VacationHome2" Title="Condo for Rent in Hawaii" Caption="Ocean view starting $200" Runat="server" BorderStyle="Solid" BackColor="#66ffff" Height="30px" Width="238px" Font-Names="Arial, Helvetica" /> </form> </body> </html> 11 IMPLEMENTAR LA VALIDACIÓN EN EL CLIENTE Y EN EL SERVIDOR: REQUIREDFIELDVALIDATOR, COMPAREVALIDATOR, REGULAREXPRESSIONVALIDATOR, CUSTOMVALIDATOR, RANGEVALIDATOR Un aspecto importante de la creación de páginas Web ASP.NET para la entrada de datos por el usuario consisten en poder comprobar que la información que introducen los usuarios es válida. ASP.NET ofrece un conjunto de controles de validación que proporciona una forma eficaz y fácil de usar para comprobar errores y, si es necesario, mostrar mensajes al usuario VALIDAR LA INFORMACIÓN ESPECIFICADA POR EL USUARIO EN PÁGINAS WEB ASP.NET Mediante los controles de validación se puede agregar validación de entrada a las páginas Web ASP.NET. Los controles de validación proporcionan un mecanismo fácil de utilizar para todos los tipos comunes de validación estándar (por ejemplo, probar fechas válidas o valores comprendidos en un intervalo), además de otras formas para proporcionar validación escrita personalizada. Además, los controles de validación permiten personalizar completamente cómo se muestra la información de errores al usuario. Los controles de validación se pueden utilizar con cualquier control que se coloque en una página Web ASP.NET, incluidos los controles HTML y de servidor Web. Nota de seguridad: De forma predeterminada, las páginas Web ASP.NET comprueban automáticamente la entrada de datos potencialmente malintencionados. 64 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Utilizar controles de validación Habilitar la validación de los datos introducidos por el usuario agregando controles de validación a la página como se haría con otros controles de servidor. Existen controles para distintos tipos de validación, como la comprobación de un intervalo o la comparación de modelos. Cada control de validación hace referencia a un control de entrada (un control de servidor) situado en otra parte de la página. Cuando se procesan los datos introducidos por el usuario (por ejemplo, cuando se envía una página), el control de validación comprueba dichos datos y establece una propiedad para indicar si han pasado la comprobación. Una vez que se ha llamado a todos los controles de validación, se establece una propiedad en la página que indica si alguna de las comprobaciones de validación ha producido un error. Los controles de validación se pueden asociar en grupos de validación a fin de que los controles que pertenezcan a un grupo común se validen juntos. Se puede utilizar estos grupos para habilitar o deshabilitar de forma selectiva la validación para controles relacionados en una página. Otras operaciones de validación, como mostrar un control ValidationSummary o llamar al método GetValidators, pueden hacer referencia al grupo de validación. En el código se puede probar el estado de la página y de los controles individuales. Por ejemplo, se podría probar el estado de los controles de validación antes de actualizar un registro de datos con información introducida por el usuario. Si se detecta un estado no válido, se omite la actualización. Normalmente, si una comprobación de validación produce errores, se omite todo el procesamiento y se devuelve la página al usuario. Los controles de validación que detectan errores generan un mensaje de error que aparece en la página. Puede mostrar todos los errores de validación en un solo lugar mediante un control ValidationSummary. Nota: Los controles enlazados a datos que actualizan, insertan y eliminan datos, como los controles GridView, FormView y DetailsView, comprueban automáticamente si se han realizado las comprobaciones de validación antes de realizar una operación de actualización de datos. Cuándo se produce la validación Los controles de validación ejecutan la comprobación de los datos introducidos en el código del servidor. Cuando el usuario envía una página al servidor, los controles de validación se invocan para comprobar los datos introducidos por el usuario, control a control. Si se detecta un error de validación en uno de los controles de entrada de datos, la propia página se establece en un estado no válido para que se pueda probar la validez antes de ejecutar el código. La validación se produce después de la inicialización de la página (es decir, después de que el estado de vista y los datos devueltos se hayan procesado) pero antes de llamar a los controladores de eventos Change o Click. Si el usuario está trabajando con un explorador compatible con ECMAScript (Javascript), los controles de validación también pueden realizar la validación mediante secuencias de comandos del cliente. Esto puede mejorar el tiempo de respuesta de la página, ya que los errores se detectan inmediatamente y los mensajes de error se muestran en cuanto el usuario abandona el control que contiene el error. Si la validación está disponible en el cliente, se obtiene más control sobre la presentación de los mensajes de error y se puede mostrar un resumen de errores en un cuadro de mensaje. ASP.NET ejecuta una validación en el servidor aunque los controles de validación la hayan ejecutado en el cliente, por lo que se puede probar la validez en los controladores de eventos basados en el servidor. Además, la nueva comprobación en el servidor ayuda a evitar que los usuarios puedan omitir la validación deshabilitando o cambiando la secuencia de comandos del cliente. Si se desea, se puede invocar la validación en su propio código llamando al método Validate de un control de validación. Validar múltiples condiciones Cada control de validación normalmente realiza una comprobación. No obstante, es posible que se deseen comprobar múltiples condiciones. Por ejemplo, se desea especificar que una entrada de usuario es necesaria y que sólo puede contener fechas dentro de un intervalo especificado. En las páginas se puede asociar más de un control de validación a cada control de entrada. En ese caso, las comprobaciones realizadas por los controles se resuelven utilizando un operador lógico AND, lo que significa que los datos introducidos por el usuario deben pasar todas las comprobaciones para que se consideren válidos. En algunos casos podrían ser entradas válidas en varios formatos distintos. Por ejemplo, si se solicita un número de teléfono, se puede permitir que los usuarios introduzcan un número local, un número de larga distancia o un número internacional. El uso de múltiples controles de validación no funcionaría en esta instancia, ya que los datos introducidos por el usuario deben pasar todas las comprobaciones para ser válidos. Para realizar este tipo de comprobación, que es una operación lógica OR en la que sólo se debe 65 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 pasar una comprobación, se utiliza el control de validación RegularExpressionValidator y se deben especificar múltiples modelos válidos en el control. Opcionalmente, se puede utilizar el control de validación CustomValidator y escribir el propio código de validación. Mostrar la información de errores Normalmente, los controles de validación no son visibles en la página presentada. No obstante, si el control detecta un error, muestra el texto del mensaje de error que se especifique. El mensaje de error se puede mostrar de formas diferentes: En contexto: Cada control de validación puede mostrar su propio mensaje de error en contexto (normalmente junto al control donde se ha producido el error). Resumen: Los errores de validación pueden recopilarse y mostrarse en un lugar, por ejemplo, en la parte superior de la página. Esta estrategia se utiliza a menudo junto con la presentación de un mensaje al lado de los campos de entrada con errores. Si el usuario trabaja con Internet Explorer 4.0 o posterior, el resumen puede mostrarse en un cuadro de mensaje. Si se utiliza grupos de validación, se necesita un control ValidationSummary para cada uno de ellos. En contexto y en un resumen: El mensaje de error puede ser diferente en el resumen y en contexto. Puede utilizar esta opción para mostrar un mensaje de error más corto en el contexto y con más detalles en el resumen. Personalizado: Puede personalizar la presentación del mensaje de error capturando la información de error y diseñando su propio resultado. Si se utiliza las opciones de presentación en contexto o en un resumen, se puede dar formato al texto del mensaje de error mediante HTML. Nota de seguridad: Si se crean mensajes de error personalizados, asegúrarse de no mostrar información que pudiera ayudar a un usuario malintencionado a poner en peligro la aplicación. Modelo de objetos de validación El modelo de objetos expuesto por cada uno de los controles de validación y por la página permite interactuar con los controles de validación. Cada control de validación expone su propiedad IsValid, que se puede probar para determinar si se ha pasado la comprobación de validación o ha producido errores en ese control. La página también expone una propiedad IsValid que resume el estado IsValid de todos los controles de validación de la página. Esta propiedad le permite realizar una única comprobación para determinar si puede continuar con su propio procesamiento. La página también expone una colección Validators que contiene una lista de todos los controles de validación de la página. Puede recorrer esta colección para examinar el estado de controles de validación individuales. Personalizar la validación El proceso de validación se puede personalizar de las maneras siguientes: Especificar el formato, el texto y la ubicación de los mensajes de error. Además, se puede especificar si los mensajes de error aparecen de forma individual o como un resumen. Crear validación personalizada utilizando el control CustomValidator. El control llama a la lógica personalizada, pero, por lo demás, funciona de la misma manera que otros controles de validación al establecer el estado de error, mostrar los mensajes de error, etc. Esto proporciona una forma fácil de crear una lógica de validación personalizada, pero sin dejar de utilizar el marco de trabajo de validación de la página. En la validación en el cliente, interceptar la llamada a la validación y sustituir o agregar su propia lógica de validación. TIPOS DE VALIDACIÓN Y CONTROLES Tipo de validación Utilizar control Entrada RequiredFieldValidator Descripción Garantiza que el usuario no omite una entrada. requerida. Comparación con CompareValidator Compara los datos proporcionados por el usuario con un valor constante, con el valor un valor de otro control (mediante un operador de comparación como menor que, igual que o 66 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 mayor que) o para un tipo de datos específico. Comprobación RangeValidator del intervalo Comprueba que una entrada de usuario está entre los límites superior e inferior especificados. Se pueden comprobar los intervalos entre pares de números, caracteres alfabéticos y fechas. Coincidencia de RegularExpressionValidator Comprueba que la entrada del usuario coincide con un modelo definido por una modelos expresión regular. Este tipo de validación permite comprobar secuencias de caracteres predecibles, como los que aparecen en las direcciones de correo electrónico, números de teléfono, códigos postales, etc. Definida por el CustomValidator usuario Comprueba la entrada de usuario utilizando la validación lógica que ha escrito. Este tipo de validación permite comprobar valores derivados en tiempo de ejecución. 12 UTILIZAR CONTROLES ESTÁNDAR: BUTTON, TEXTBOX, DROPDOWNLIST, RADIOBUTTON, CHECKBOX, HYPERLINK, WIZARD, MULTIVIEW Los controles estándar son los controles de servidor Web ASP.NET que aparecen en la ficha Estándar del cuadro de herramientas de Visual Web Developer. Entre ellos se incluyen controles que permiten mostrar botones, listas, imágenes, cuadros, hipervínculos, etiquetas o tablas, así como controles más complejos que trabajan con datos estáticos y dinámicos, o controles que actúan como contenedores de otros controles. BUTTON Mediante los controles Button de servidor Web de ASP.NET, las páginas Web ASP.NET permiten a los usuarios indicar que han finalizado el formulario o que desean ejecutar un comando concreto. Los controles de servidor Web incluyen tres tipos de botones, cada uno de los cuales aparece de manera diferente en las páginas Web. Tipos de botones En la tabla siguiente se muestran los tipos de botones que se pueden crear mediante los controles de servidor Web. Control Control Descripción Button de Presenta un botón de comando estándar, que se representa como un elemento input HTML. servidor Web Control LinkButton de Se representa como un hipervínculo en la página. No obstante, contiene una secuencia de comandos del servidor Web lado cliente que hace que el formulario se devuelva al servidor. (Se Puede crear un hipervínculo real mediante el control HyperLink de servidor Web.) Control ImageButton Permite especificar un gráfico como botón. Esto es útil para representar los botones con una apariencia más de servidor Web rica. Los controles ImageButton determinan con precisión el punto en el que hizo clic el usuario, lo que permite utilizar el botón como si fuera un mapa de imagen. TextBox El control de servidor Web TextBox proporciona a los usuarios un medio para escribir datos en una página Web ASP.NET, incluidos texto, números y fechas. DropDownList 67 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 El control DropDownList de servidor Web permite a los usuarios seleccionar uno o varios elementos de una lista predefinida. Se diferencia del control ListBox de servidor Web en que la lista de elementos permanece oculta hasta que los usuarios hacen clic en el botón desplegable. Además, el control DropDownList difiere del control ListBox en que no admite el modo de selección múltiple. RadioButton Los controles RadioButton y RadioButtonList permiten a los usuarios seleccionar opciones de entre un pequeño conjunto de opciones predefinidas mutuamente excluyentes. Se puede utilizar los controles CheckBox y CheckBoxList para hacer lo siguiente: Generar una devolución de datos de página cuando se selecciona un botón de opción. Capturar la interacción del usuario cuando un usuario selecciona un botón de opción. Enlazar cada botón de opción a los datos de una base de datos. CheckBox Se Puede utilizar dos tipos de controles de servidor Web para agregar casillas de verificación a una página de formularios Web Forms: controles CheckBox individuales o un control CheckBoxList. Ambos controles proporcionan a los usuarios la posibilidad de introducir datos de tipo Boolean: verdadero o falso (true o false), sí o no (yes o no). Nota: También se puede utilizar el control HtmlInputCheckBox para agregar casillas de verificación a una página de formularios Web Forms. Se puede agregar controles CheckBox individuales a una página y utilizarlos por separado. En cambio, el control CheckBoxList es un control único que actúa como control primario para una colección de elementos de lista de casillas de verificación. Este control proviene de una clase base ListControl y, por consiguiente, funciona como los controles de servidor Web ListBox, DropDownList, RadioButtonList y BulletedList. Por esta razón, muchos de los procedimientos para trabajar con el control CheckBoxList son los mismos que se utilizan para otros controles de lista de servidor Web. Cada tipo de control tiene sus ventajas. Al utilizar controles CheckBox individuales, tendrá mayor control sobre la distribución de las casillas de verificación en la página que si utiliza el control CheckBoxList. Por ejemplo, puede incluir texto (es decir, texto no perteneciente a casillas de verificación) entre las casillas de verificación. También puede controlar la fuente y el color de cada casilla de verificación. El control CheckBoxList es preferible si se desea crear una serie de casillas de verificación a partir de los datos de una base de datos. (También se puede enlazar un control CheckBox individual a datos.) HyperLink El control HyperLink de servidor Web crea vínculos en una página Web que permiten a los usuarios moverse por las páginas de una aplicación. La principal ventaja de utilizar un control HyperLink es que es posible establecer las propiedades de los vínculos en el código del servidor. Por ejemplo, se puede cambiar dinámicamente el texto del vínculo o la página de destino basándose en las condiciones de la página. Las direcciones URL asociadas con un hipervínculo pueden ser manipuladas por algún usuario malintencionado. Otra ventaja de utilizar el control HyperLink es que se puede utilizar el enlace de datos para especificar la dirección URL de destino del vínculo (y los parámetros que se transferirán con el vínculo, si es necesario). Un ejemplo típico es la creación de controles HyperLink basados en una lista de productos: la dirección URL apunta a una página en la que el usuario puede ver más detalles acerca del producto. Si se necesita crear controles HyperLink enlazados a datos, una manera conveniente de hacerlo es agregarlos como elementos secundarios de estos controles: Repeater, DataList, GridView, FormView o DetailsView. 68 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 El control HyperLink puede mostrar texto o una imagen en los que es posible hacer clic. A diferencia de la mayoría de controles de servidor Web, el control HyperLink no desencadena un evento en el código de servidor cuando el usuario hace clic en él. Este control simplemente desempeña tareas de desplazamiento. Wizard La recopilación de los datos proporcionados por el usuario a través de formularios es una tarea recurrente en el desarrollo de páginas Web. Un grupo de formularios que se utiliza para llevar a cabo una tarea se suele denominar asistente. ASP.NET proporciona un control Wizard que simplifica muchas de las tareas asociadas con la creación de un conjunto de formularios para recopilar los datos proporcionados por el usuario. Una práctica frecuente consiste en crear un grupo de formularios interconectados con el fin de dividir la recopilación de los datos. Para llevar a cabo esta tarea, puede administrar la exploración entre los formularios, la persistencia de los datos y la administración de estados en cada paso. El control Wizard de ASP.NET simplifica muchas de las tareas asociadas a la creación de varios formularios y la recopilación de los datos proporcionados por el usuario. El control Wizard proporciona un sencillo mecanismo que permite crear y agregar pasos o reordenar los pasos existentes con facilidad. Se puede crear exploraciones lineales y no lineales, así como personalizar la exploración del usuario del control sin necesidad de escribir código. MultiView Los controles MultiView y View de servidor Web actúan como contenedores para otros controles y el marcado, y proporcionan un medio para presentar de forma sencilla vistas alternativas de la información. Se puede utilizar los controles MultiView y View para realizar tareas como las siguientes: Proporcionar conjuntos de controles alternativos basados en la elección del usuario o en otras condiciones. Por ejemplo, se podría permitir a los usuarios hacer su selección en una lista de suministros, cada uno de los cuales estaría configurado en un control View diferente. A continuación, podría mostrar el control View que contiene la elección de suministros del usuario. Se puede utilizar los controles MultiView y View como alternativa para no crear varios controles Panel. Crear un formulario de varias páginas. Los controles MultiView y View pueden tener un comportamiento similar al del control Wizard. El control Wizard resulta especialmente apropiado para crear formularios que los usuarios rellenan paso a paso. El control Wizard también es compatible con otros elementos integrados de la interfaz de usuario, como un encabezado y pie de página, con los botones Anterior y Siguiente, y con las plantillas. Podría utilizar un control MultiView en lugar de un control Wizard si deseara crear una presentación que cambiara en función de una condición (y no de forma secuencial) o si no necesitara utilizar las características adicionales admitidas por el control Wizard. El control MultiView actúa como un contenedor externo para uno o varios controles View. Los controles View, a su vez, pueden contener cualquier combinación de marcado y controles. El control MultiView muestra un control View por vez, y expone también el marcado y los controles incluidos en ese control View. Al definir la propiedad ActiveViewIndex del control MultiView, puede especificar qué control View está visible actualmente. 13 LEER Y ESCRIBIR DATOS XML: XMLDOCUMENT, XPATHNAVIGATOR, XPATHNODEITERATOR, XPATHDOCUMENT, XMLREADER, XMLWRITER, XMLDATADOCUMENT, XMLNAMESPACEMANAGER XmlDocument (System.Xml) La clase XmlDocument implementa las interfaces de nivel 1 principal y de nivel 2 principal del DOM de W3C para leer y crear documentos XML. Esta clase implementa el Core Document Object Model (DOM) Level 1 y el Core DOM Level 2 del consorcio W3C. DOM es la representación en forma de árbol en memoria (caché) de un documento XML y permite la navegación y edición del documento. 69 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Dado que XmlDocument implementa la interfaz IXPathNavigable, también se puede utilizar como documento de origen de la clase XslTransform. XPathNavigator (System.Xml.XPath) La clase XPathNavigator ofrece numerosas opciones de edición y funciones de navegación por XML para un XmlDocument o un XPathDocument XPathNodeIterator (System.Xml.XPath) Proporciona un iterador para un conjunto seleccionado de nodos. XPathDocument (System.Xml.XPath) Proporciona una representación en memoria rápida y de solo lectura de un documento XML, utilizando el modelo de datos de XPath. XmlReader (System.Xml) La clase XmlReader proporciona un método rápido, sin almacenamiento en caché y sólo de avance (hacia adelante) para obtener acceso a los datos XML. XmlWriter (System.Xml) La clase XmlWriter proporciona un método rápido, sin almacenamiento en caché y de sólo avance (hacia adelante) para generar datos XML. XmlDataDocument (System.Xml) La clase XmlDataDocument extiende XmlDocument y permite que los datos estructurados se almacenen, recuperen y manipulen mediante un DataSet relacional. Esta clase permite que los componentes combinen vistas XML y relacionales de los datos subyacentes. XmlDataDocument tiene una relación estrecha con la clase DataSet que proporciona una vista relacional de los datos XML cargados. Los cambios efectuados en XmlDataDocument se reflejan en DataSet y viceversa. Para cargar DataSet con datos XML, se utiliza ReadXmlSchema para generar una asignación relacional. A continuación, los datos XML se pueden cargar mediante Load o LoadXml. XmlNamespaceManager (System.Xml) Resuelve, agrega y quita espacios de nombres en una colección y proporciona la administración del ámbito de estos espacios de nombres. 70 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 14 MANIPULAR LOS DATOS UTILIZANDO LOS OBJETOS DATASET Y DATAREADER ARQUITECTURA DE ADO.NET DataSet El DataSet de ADO.NET es una representación de datos residente en memoria que proporciona un modelo de programación relacional coherente independientemente del origen de datos que contiene. Un DataSet representa un conjunto completo de datos, incluyendo las tablas que contienen, ordenan y restringen los datos, así como las relaciones entre las tablas. Hay varias maneras de trabajar con un DataSet, que se pueden aplicar de forma independiente o conjuntamente. Se puede: Crear mediante programación una DataTable, DataRelation y una Constraint en un DataSet y rellenar las tablas con datos. Llenar el DataSet con tablas de datos de un origen de datos relacional existente mediante DataAdapter. Cargar y hacer persistente el contenido de DataSet mediante XML. También se puede transportar un DataSet con establecimiento inflexible de tipos mediante un servicio web XML. El diseño del DataSet lo convierte en idóneo para el transporte de datos mediante servicios web XML. Data Reader Recuperar datos mediante DataReader (ADO.NET) La recuperación de datos mediante DataReader implica crear una instancia del objeto Command y de un DataReader a continuación, para lo cual se llama a Command.ExecuteReader a fin de recuperar filas de un origen de datos. En el ejemplo siguiente se muestra cómo se utiliza un DataReader, donde reader representa un DataReader válido y command representa un objeto Command válido. 71 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 rreader = command.ExecuteReader(); Se Puede utilizar el método Read del objeto DataReader para obtener una fila a partir de los resultados de una consulta. Para tener acceso a cada columna de la fila devuelta, puede pasar a DataReader el nombre o referencia numérica de la columna en cuestión. Sin embargo, el mejor rendimiento se logra con los métodos que ofrece DataReader y que permiten tener acceso a los valores de las columnas en sus tipos de datos nativos (GetDateTime, GetDouble, GetGuid, GetInt32, etc). Los datareaders dependen de proveedores de datos específicos como por ejemploOleDbDataReader y SqlDataReader. Si se utilizan los métodos de descriptor de acceso con tipo, dando por supuesto que se conoce el tipo de datos subyacentes, se reduce el número de conversiones de tipo necesarias para recuperar el valor de una columna. DataReader (ADO.Net) Se puede utilizar el DataReader de ADO.NET para recuperar secuencias de datos de sólo lectura y sólo avance de una base de datos. Los resultados se devuelven a medida que se ejecuta la consulta y se almacenan en el búfer de red del cliente hasta que se solicitan con el método Read del DataReader. Con el DataReader puede aumentar el rendimiento de la aplicación tanto al recuperar datos en cuanto están disponibles como al almacenar (de forma predeterminada) una fila cada vez en memoria, lo que reduce la sobrecarga del sistema. Cada proveedor de datos de .NET Framework incluido en .NET Framework cuenta con un objeto DataReader: el proveedor de datos de .NET Framework para OLE DB incluye un objeto OleDbDataReader, el proveedor de datos de .NET Framework para SQL Server incluye un objeto SqlDataReader, el proveedor de datos de .NET Framework para ODBC incluye un objeto OdbcDataReader y el proveedor de datos de .NET Framework para Oracle incluye un objeto OracleDataReader. 15 LLAMAR A UN SERVICIO WINDOWS COMMUNICATION FOUNDATION (WCF) O A UN SERVICIO WEB DESDE UNA PÁGINA WEB ASP.NET: APP_WEBREFERENCES; <SYSTEM.SERVICEMODEL> CONFIGURATION CONSUMO DE SERVICIOS WCF El escenario de alojamiento elegido para el servicio WCF puede influir en el lado del consumidor. Se puede consumir los servicios WCF de varias maneras. Si se usa WCF en el lado del cliente será muy productivo, ya que WCF incluye herramientas que pueden generar clases de proxy para llamar a los servicios WCF. WCF proporciona compatibilidad con los estándares y las herramientas principalmente a través de SvcUtil.exe. Lo usará como herramienta principal de interpretación de metadatos. Eso, en combinación con la capacidad de Framework de WCF para aprovechar la reflexión para interrogar tipos adornados con los atributos apropiados, hace la generación y el uso de Framework de WCF menos complicado que con los marcos existentes. Además, Visual Studio 2005 incluye sencillas características para agregar referencias al servicio a sus proyectos y generar continuamente clases de proxy. Esencialmente, dispone de las siguientes opciones: Recuperar el WSDL del servicio y crear un proxy para llamar al servicio. Éste es un escenario típico si no se cuenta con WCF en el lado del cliente. Usar las características Add Service Reference de Visual Studio 2005 y dejar que genere un proxy que usar en el cliente. Use la herramienta SvcUtil.exe para generar clases de proxy. En las secciones siguientes, estudiaremos las dos últimas opciones: Visual Studio 2005 y SvcUtil.exe. Proxy de servicio Un proxy de servicio permite trabajar con servicios de una manera orientada a objetos. Las clases de proxy abstraen el modelo de comunicación usado por el servicio, como desarrollador de cliente se abstrae el hecho de que habla con un servicio (remoto). Es como si se llamase al código local. La clase de proxy implementa la interfaz del servicio y, por tanto, permite llamar a los métodos en la interfaz del servicio, como si éstos fueran métodos locales. Los proxy se generan para algún tipo personalizado utilizado en la interfaz de servicio. El siguiente código contiene partes de un proxy generado para el servicio TradeService ilustrando que, en el lado del cliente, hay disponible una Quote que se asigna al objeto Quote en el lado del servidor, aunque se trate de clases distintas. El objeto Quote serializa según el contrato, de modo que, en el lado del servicio, se serializa en la versión del lado del servicio del contrato de datos Quote. Además, se puede consultar los métodos GetQuote y PlaceQuote llamando a una clase base que hará finalmente la llamada a través del límite del servicio por medio del transporte configurado. 72 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 namespace SimpleClientWithProxy.ExchangeService { [DataContract()] public partial class Quote : object, IExtensibleDataObject { // Left out the Quote Datamembers in printed code, see sample code } } [GeneratedCode("System.ServiceModel", "3.0.0.0")] [ServiceContract()] public interface ITradeService { [ OperationContract(Action = "http://tempuri.org/ITradeService/GetQuote", ReplyAction = "http://tempuri.org/ITradeService/GetQuoteResponse")] Quote GetQuote(string ticker); [ OperationContract(Action = "http://tempuri.org/ITradeService/PublishQuote", ReplyAction = "http://tempuri.org/ITradeService/PublishQuoteResponse")] void PublishQuote(Quote quote); } [GeneratedCode("System.ServiceModel", "3.0.0.0")] public interface ITradeServiceChannel : ITradeService, IClientChannel { } [GeneratedCode("System.ServiceModel", "3.0.0.0")] public partial class TradeServiceClient : ClientBase<ITradeService>, ITradeService { // Left out some constructors in printed code, see sample code public SimpleClientWithProxy.ExchangeService.Quote GetQuote(string ticker) { return base.Channel.GetQuote(ticker); } } public void PublishQuote( SimpleClientWithProxy.ExchangeService.Quote quote) { base.Channel.PublishQuote(quote); } Uso de Visual Studio 2005 De forma similar al caso de la creación de proxy ASP.NET, si hace clic con el botón secundario en el proyecto del IDE, aparecerán tres opciones para agregar referencias. 73 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 La opción es Add Service Reference. Esta opción del menú es un contenedor de la utilidad SvcUtil.exe, que genera un proceso con los parámetros necesarios. Una vez que haya seleccionado Add Service Reference, aparecerá el siguiente cuadro de diálogo. Una vez que hecho clic en Aceptar en el cuadro de diálogo, el complemento genera SvcUtil.exe, que crea la clase de proxy necesaria y el archivo de configuración requerido (o lo modifica) y agrega las referencias necesarias al proyecto. Las referencias del proyecto ahora enumerarán los ensamblados de WCF. Nota Para que esto funcione, ServiceHost de Windows debe estar en ejecución o debe cambiar la URL para señalar a cualquiera de los servicios alojados en IIS (una dirección URL que señala a cualquiera de los archivos .svc). Ahora es posible programar la primera llamada a servicio en su nivel de servicio. Implementación de línea de comandos Un método alternativo es aprovechar la utilidad SvcUtil.exe directamente en lugar del complemento de Visual Studio. De nuevo, el complemento de Visual Studio llama a SvcUtil.exe, con parámetros, para generar el proxy cuando se ejecuta directamente desde Visual Studio. Se puede ver la línea de comandos y los resultados de ese comando consultando la ventana Resultado y estableciendo Show output en la lista desplegable en Service Reference. Para una generación manual, se elija la ventana CMD seleccionando Inicio | Todos los programas | Microsoft Windows SDK | CMD. Este símbolo del sistema es útil porque su ruta de acceso está establecida en el directorio binario donde se encuentran las herramientas y utilidades del SDK. Se usará la herramienta de línea de comandos SvcUtil.exe para generar dos resultados que podrían usarse en el proyecto SimpleClientWithProxy. No obstante, en el código de ejemplo incluido en este capítulo se usó el método Add Service Reference descrito en la sección anterior. Los pasos aquí descritos explican cómo generar los mismos resultados que Add Service Reference. Los archivos de resultados son el archivo de código fuente del proxy de cliente y el archivo de configuración de la aplicación. Estos 74 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 archivos se integran en el proyecto cliente. SvcUtil.exe puede generar ambos. Para este ejemplo, el comando siguiente (es una sola línea, a pesar de cómo queda dispuesto en la imagen) produce tanto una clase de proxy como un archivo de configuración: svcutil /config:app.config /out:"ExchangeService.cs" /language:csharp /n:*, SimpleClientWithProxy.ExchangeService "http://localhost/ExchangeService/? ExchangeService.svc" Nota Para que esto funcione, se necesita una versión en ejecución de ServiceHost de Windows, o se debe cambiar la dirección URL para señalar a cualquiera de los servicios alojados en IIS (una dirección URL que señala a cualquiera de los archivos .svc tratados en este capítulo). El comando se explica por sí mismo. El modificador /n indica bajo qué espacio de nombres debería ubicarse la clase de proxy generada. El último parámetro es la dirección URL del extremo del servicio donde se encuentra la información de esquema. Tener en cuenta que ?wsdl se puede reemplazar con ?mex, ya que SvcUtil.exe admite ambos métodos de descubrimiento. Se puede obtener más ayuda ejecutando svcutil.exe/? desde el símbolo del sistema. El paso siguiente es tomar los archivos de resultados Exchangeservice.cs y App.config, e integrarlos en el proyecto. Se puede agregar sólo el primer archivo, Exchangeservice.cs, directamente al proyecto eligiendo Agregar elemento existente en el menú Proyecto de Visual Studio 2005. Se debe agregar al proyecto el segundo archivo como archivo de configuración de aplicación (App.config). Si el proyecto no cuenta ya con un archivo App.config, lo podrá agregar seleccionando de nuevo Agregar elemento existente en el menú Proyecto. Si ya existe un archivo App.config, se debe unir la sección system.serviceModel, asegurándose de tomar todos los elementos secundarios adecuados. SERVICIOS WEB Agregar y quitar referencias Web Una referencia Web habilita un proyecto para que utilice uno o más servicios Web XML. Utilizar el Agregar referencia Web (Cuadro de diálogo) para buscar servicios Web localmente, en una red de área local o en Internet. Después de agregar una referencia Web al proyecto actual, puede llamar a cualquier método expuesto por el servicio Web. Para agregar una referencia Web a un proyecto 1. En el Explorador de soluciones, clic con el botón secundario del mouse en el nombre del proyecto al que va a agregar el servicio Web y, a continuación, clic en Agregar referencia Web. Aparece el cuadro de diálogo Agregar referencia Web. 2. En el cuadro Dirección URL, escribir la dirección URL del servicio Web que va a utilizar. Se pueden utilizar los vínculos del panel de exploración para buscar el servicio Web. Nota: Si se está desarrollando una aplicación Web en un equipo protegido por un firewall y la aplicación va a utilizar servicios Web situados fuera de ese firewall, es preciso incluir en la dirección URL la dirección y el puerto del servidor proxy de la red. Solicitar al administrador de red facilitar esta parte de la ruta de acceso de la dirección URL. 3. En el cuadro Servicios Web disponibles en esta dirección URL, seleccionar el servicio Web que va a utilizar. 4. Comprobar que el proyecto puede utilizar el servicio Web y que cualquier código externo proporcionado es de confianza. Nota de seguridad: Cuando se abre un proyecto para editarlo y éste incluye una referencia Web, un archivo local del proxy correspondiente al servicio Web utilizado se ejecutará en un proceso de Devenv.exe iniciado por un usuario de confianza: el propio usuario. Al abrir proyectos o componentes en el entorno de desarrollo integrado (IDE), puede que se ejecute código en el equipo local. 5. En el campo Nombre de referencia Web escribir el nombre que luego vaya a utilizar en el código para obtener acceso mediante programación al servicio Web seleccionado. Nota: De forma predeterminada, a las referencias Web se les asigna un espacio de nombres que corresponde al nombre del servidor. Se puede cambiar este valor y escribir un nombre de espacio de nombres personalizado. Hay algunas limitaciones en 75 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 cuanto a los nombres de espacio de nombres aceptados. Visual Web Developer crea un espacio de nombres basado en el nombre de la referencia Web, generando una jerarquía de carpetas anidada. Dentro de la carpeta más interna se crea un archivo .wsdl que hace referencia al servicio Web, además de otros archivos auxiliares, como archivos de descubrimiento (.disco y .discomap), que incluyen información sobre dónde se encuentra el servicio Web. 6. Clic en Agregar referencia. Si el sitio Web no tiene todavía una, Visual Studio creará una carpeta App_WebReferences. Quitar una referencia Web Si el proyecto ya no necesita una referencia a un servicio Web XML, se puede quitar del mismo. En el Explorador de soluciones, Clic con el botón secundario del mouse en la referencia Web y, a continuación, Clic en Eliminar. Toda la información de referencia se quita del proyecto y del almacenamiento local. Invocar a un servicio Web Después de agregar al proyecto una referencia Web al servicio Web XML, se puede utilizar el nombre del servidor para crear un objeto proxy que permita llamar a los métodos en un servicio Web XML. Para llamar a un servicio Web mediante programación se utiliza el nombre de la referencia Web (o nombre del servidor) como espacio de nombres y el nombre del archivo .WSDL (o nombre del servicio) como la clase de proxy. El ejemplo de código siguiente llama a un método de servicio Web para obtener un valor de cadena. void Call_Web_Service_Method() { ServerName.WebServiceNameCallWebService = new ServerName.WebServiceName(); String sGetValue = CallWebService.MethodName(); Label1.Text = sGetValue; } 16 IMPLEMENTAR UN CONTROL DATASOURCE: LINQDATASOURCE, OBJECTDATASOURCE, XMLDATASOURCE, SQLDATASOURCE ASP.NET incluye controles de origen de datos que permiten trabajar con distintos tipos de orígenes de datos, como bases de datos, archivos XML u objetos comerciales de nivel medio. Los controles de origen de datos se conectan a un origen de datos para recuperar datos y permiten a otros controles enlazarse a ellos, sin necesidad de código. También admiten la modificación de datos. Esta tema ofrece información sobre los distintos tipos de controles de origen de datos en ASP.NET. El modelo de control de origen de datos es ampliable, por lo que también puede crear sus propios controles de origen de datos que interactúen con orígenes de datos diferentes o que proporcionen funcionalidad adicional para un origen de datos existente. Comparación de controles de origen de datos .NET Framework incluye controles de origen de datos que admiten el uso de distintos escenarios de enlace de datos. En la tabla siguiente se describen los controles de origen de datos integrados. LinqDataSource 76 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Permite usar Language-Integrated Query (LINQ) en una página web ASP.NET a través de marcado declarativo para recuperar y modificar datos de un objeto de datos. Admite la generación automática de comandos de selección, actualización, inserción y eliminación. El control también admite ordenación, filtrado y paginación. El control LinqDataSource permite usar LINQ en una página ASP.NET para recuperar datos de una tabla de base de datos o de una recolección de datos en memoria. Se puede usar marcado declarativo para escribir todas las condiciones que se requieren para recuperar, filtrar, ordenar y agrupar los datos. Si se recupera datos de una tabla de base de datos SQL, también se puede configurar un control LinqDataSource para administrar las operaciones de actualización, inserción y eliminación. Se puede escribir comandos SQL para realizar estas tareas. Si se usa el control LinqDataSource, se puede reducir la cantidad de código necesario para las operaciones de datos, en comparación con las mismas operaciones en otros controles de origen de datos. EntityDataSource Permite enlazar a datos basados en Entity Data Model (EDM). Admite la generación automática de comandos de actualización, inserción, eliminación y selección. El control también admite la ordenación, el filtrado y la paginación. El control EntityDataSource admite escenarios de enlace de datos basados en Entity Data Model (EDM). Esta especificación de datos representa los datos como conjuntos de entidades y relaciones. Entity Framework usa el EDM en asignaciones relacionales de objetos y otros escenarios como Servicios de datos de ADO.NET. El control EntityDataSource admite Entity-SQL (eSQL) como el lenguaje de la consulta y también la especificación de la consulta que muestra la clase ObjectQuery<T>. ObjectDataSource Permite trabajar con un objeto comercial u otra clase y crear aplicaciones Web basadas en objetos de nivel medio para administrar los datos. Admite ordenación avanzada y escenarios de paginación no disponibles con los otros controles de origen de datos. El control ObjectDataSource trabaja con un objeto comercial u otra clase en las aplicaciones Web basadas en objetos comerciales de nivel medio para administrar datos. El control está diseñado para interactuar con un objeto que implementa uno o varios métodos a fin de recuperar o modificar datos. Cuando los controles enlazados a datos interactúan con el control ObjectDataSource para recuperar o modificar datos, dicho control pasa los valores del control enlazado al objeto de origen como parámetros de llamadas a métodos. Los métodos de recuperación de datos del objeto de origen deben devolver un objeto DataSet, DataTable o DataView, o un objeto que implemente la interfaz IEnumerable. Si los datos se devuelven como un objeto DataSet, DataTable o DataView, el control ObjectDataSource puede almacenar datos en caché y filtrarlos. También es posible implementar escenarios de paginación avanzados si el objeto de origen acepta la información de tamaño de página y de índice de registro del control ObjectDataSource. SqlDataSource Permite trabajar con bases de datos de Microsoft SQL Server, OLE DB, ODBC u Oracle. Cuando se utiliza con SQL Server, admite funciones de almacenamiento en caché avanzadas. Este control también admite ordenación, filtrado y paginación cuando los datos se devuelven como un objeto DataSet. El control SqlDataSource recupera y modifica datos utilizando comandos SQL. El control SqlDataSource funciona con bases de datos de Microsoft SQL Server, OLE DB, ODBC y Oracle. El control SqlDataSource puede devolver los resultados en forma de objeto DataReader o DataSet. Admite ordenación, filtrado y almacenamiento en caché cuando los resultados se devuelven como un objeto DataSet. Cuando se trabaja con Microsoft SQL Server, el control tiene la ventaja adicional de que los resultados de la caché se pueden invalidar cuando se modifica la base de datos, utilizando un objeto SqlCacheDependency. AccessDataSource Permite trabajar con una base de datos de Microsoft Access. Admite ordenación, filtrado y paginación cuando los datos se devuelven como un objeto DataSet. 77 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 XmlDataSource Permite trabajar con un archivo XML, especialmente para los controles de servidor ASP.NET como TreeView o Menu. Admite funciones de filtrado mediante expresiones XPath y permite aplicar una transformación XSLT a los datos. El control XmlDataSource permite actualizar los datos al guardar el documento XML completo con cambios. El control XmlDataSource lee y escribe datos XML, lo que permite trabajar con ellos mediante controles como TreeView y Menu. El control XmlDataSource puede leer un archivo XML o una cadena de XML. Si el control está trabajando con un archivo XML, puede escribir el código XML modificado en el archivo de código fuente. Si hay un esquema disponible que describe los datos, el control XmlDataSource puede utilizarlo para exponer los datos mediante miembros con tipo. Se Puede aplicar una transformación XSLT a los datos XML, lo que permitirá reestructurar los datos sin formato del archivo XML en un formato más apropiado para el control que desea enlazar con los datos XML. También se puede aplicar expresiones XPath a los datos XML, lo que le permitirá filtrar éstos para devolver únicamente ciertos nodos del árbol XML, buscar nodos con valores determinados, etc. El uso de una expresión XPath deshabilita la funcionalidad de insertar nuevos datos. SiteMapDataSource Se utiliza con la navegación en el sitio de ASP.NET. El control SiteMapDataSource funciona con los mapas de sitios ASP.NET y proporciona datos para la navegación en el sitio. Se suele utilizar con el control Menu. El control SiteMapDataSource también resulta útil cuando se desea personalizar la navegación en el sitio utilizando datos del mapa del sitio con controles de servidor Web que no están diseñados específicamente para la navegación, como los controles TreeView o DropDownList. 17 VINCULAR LOS CONTROLES A LOS DATOS UTILIZANDO LA SINTAXIS DE UNIÓN DE DATOS (DATA BINDING) EL MECANISMO DEL ENLACE A DATOS Para generar un nuevo control enlazado a datos en ASP.NET 2.0, se debe decidir previamente qué clase se adapta mejor a LAS necesidades. Esta decisión, sin embargo, no se limita a clases relativamente vacías como Control y WebControl o, quizá, ListControl. Examinando las clases en profundidad. BaseDataBoundControl es la raíz de todas las clases de controles enlazados a datos. Define las propiedades DataSource y DataSourceID y valida el contenido asignado de las mismas. DataSource acepta objetos enumerables que se obtienen y asignan del mismo modo que en ASP.NET 1.x. Mycontrol1.DataSource = dataSet; Mycontrol1.DataBind(); DataSourceID es una cadena y hace referencia al identificador de un componente de origen de datos. Una vez que un control se enlaza a un origen de datos, cualquier interacción posterior entre los dos (tanto en la lectura como en la escritura) queda fuera del control del programador y oculta a la vista. Este hecho muestra al mismo tiempo aspectos positivos y negativos. Una de las grandes ventajas consiste en que permite eliminar una gran cantidad de código. El marco de ASP.NET garantiza que se ejecuta el código correcto y que éste se escribe de acuerdo con las prácticas más adecuadas reconocidas. Permite una mayor productividad puesto que las páginas se crean con mayor rapidez al tener la absoluta seguridad de que no contienen ningún error. Si no es conveniente esta situación (observe que es la misma situación de la que se quejaban numerosos desarrolladores de ASP.NET 1.x) se puede seguir utilizando la programación convencional que pasa a través de la propiedad DataSource y el método DataBind. Asimismo, en este caso, la clase base evita el uso de prácticas habituales aunque el ahorro en el código no es tan notable. DataBoundControl es la clase que se utiliza para controles enlazados a datos estándares y personalizados que no comparten mucho con los controles existentes. Si se debe controlar la propia colección de elementos de datos, administrar viewstate y los estilos, crear una interfaz de usuario sencilla pero hecha a medida, esta clase ofrece un óptimo punto de partida. Más interesante resulta el hecho de que la clase DataBoundControl conecta el control con los componentes de origen de datos y oculta cualquier 78 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 diferencia entre los orígenes de datos enumerables y los componentes ad hoc en el nivel de la API. En resumen, cuando se hereda de esta clase sólo se necesita omitir un método que recibe una colección de datos independientemente del origen, ya sea un objeto DataSet o un componente de origen de datos más nuevo. BaseDataBoundControl omite el método DataBind (originalmente definido en Control) y lo hace llamar el método PerformSelect, que está marcado como protegido y abstracto. Como sugiere el nombre, PerformSelect debe recuperar una colección de datos operativa para que se realice el enlace. El método está protegido puesto que contiene detalles de la implementación y es abstracto (MustInherit en la jerga de Visual Basic) ya que su comportamiento sólo lo pueden precisar las clases derivadas como DataBoundControl. Así pues, ¿cómo actúa DataBoundControl para omitir PerformSelect? Se conecta al objeto de origen de datos y obtiene la vista predeterminada. Un objeto de origen de datos (por ejemplo, un control como SqlDataSource u ObjectDataSource) ejecuta el comando de selección y devuelve la colección resultante. El método protegido que lleva a cabo la recuperación de los datos, denominado GetData, es capaz de comprobar también la propiedad DataSource. Si DataSource no está vacío, el objeto enlazado se empaqueta en un objeto de vista de origen de datos creado dinámicamente y se devuelve. Con el siguiente paso comienza la intervención del desarrollador de controles. Hasta el momento, de una forma completamente automatizada, las clases base han recuperado los datos bien desde los objetos de ADO.NET o desde los componentes de origen de datos. El siguiente paso depende de la función que deba realizar el control. Aquí es donde interviene el método reemplazable PerformDataBinding. El siguiente fragmento de código muestra el método tal como se implementa en DataBoundControl. Observe que el parámetro IEnumerable que el marco pasa al método simplemente contiene los datos que se van a enlazar, independientemente del origen de los mismos. protected virtual void PerformDataBinding(IEnumerable data) { } En un control enlazado a datos personalizado, sólo se requiere omitir este método y rellenar todas las colecciones específicas del control como la colección Items de numerosos controles de lista (CheckBoxList, por ejemplo). El procesamiento de la interfaz de usuario del control se lleva a cabo en el método Render o en CreateChildControls, en función de la naturaleza del control. Render es adecuado para los controles de lista; CreateChildControls resulta la opción perfecta para los controles compuestos. Aún queda una cuestión por explicar: ¿quién inicia el proceso de enlace a datos? En ASP.NET 1.x, el enlace a datos requiere una llamada explícita al método DataBind para comenzar a funcionar. En ASP.NET 2.0, también se requiere esta llamada si se enlazan los datos a los controles mediante la propiedad DataSource. Sin embargo, se debería evitar si se utilizan componentes de origen de datos mediante la propiedad DataSourceID. El proceso de enlace a datos se activa automáticamente por el controlador de eventos interno OnLoad que se define en DataBoundControl, como se demuestra en el siguiente pseudocódigo. protected override void OnLoad(EventArgs e) { this.ConnectToDataSourceView(); if (!Page.IsPostBack) base.RequiresDataBinding = true; base.OnLoad(e); } 79 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Cuando el control se carga en la página (ya sea una devolución de datos o por primera vez), los datos se recuperan y se enlazan. El origen de datos es el que decide si continuar de nuevo con una consulta o utilizar datos almacenados en caché. Si la página se muestra por primera vez, se activa también la propiedad RequiresDataBinding para solicitar el enlace de los datos. Cuando el valor asignado es true, el establecedor de la propiedad llama a DataBind internamente. El pseudocódigo que aparece a continuación muestra la implementación interna del establecedor RequiresDataBinding. protected void set_RequiresDataBinding(bool value) { if (value & (DataSourceID.Length > 0)) DataBind(); else _requiresDataBinding = value; } Como se puede comprobar, para conseguir compatibilidad con versiones anteriores la llamada automática a DataBind se lleva a cabo únicamente si DataSourceID no es nulo, es decir, si se enlaza a un control de origen de datos de ASP.NET 2.0. Por lo tanto, si también se realiza una llamada a DataBind explícitamente, el resultado será un enlace doble de los datos. Observe que no se puede establecer al mismo tiempo DataSource y DataSourceID. Cuando esto ocurre, se obtiene una excepción de operación no válida. Por último, debemos mencionar brevemente el método protegido EnsureDataBound. Este método, que se define en la clase BaseDataBoundControl, garantiza que el control se ha enlazado correctamente a los datos necesarios. Si RequiresDataBinding se establece en true, el método invoca a DataBind, como en el siguiente fragmento de código. protected void EnsureDataBound() { if (RequiresDataBinding & (DataSourceID.Length > 0)) DataBind(); } En ASP.NET 1.x, un control enlazado a datos generalmente posee una arquitectura para generar su propia interfaz de usuario en uno de los dos escenarios siguientes: con acceso completo al origen de datos o basado en viewstate. Cuando el control debe administrar sus propios eventos de devolución de datos (por ejemplo, imaginemos un DataGrid con paginación activada), las dos opciones mencionadas anteriormente parecen ser dos simples extremos distantes. En ASP.NET 1.x, estos controles (pensemos de nuevo en DataGrid) sólo tenían una salida: activar los eventos en la página host para que se actualizaran. Este enfoque tiene como consecuencia el conocido exceso de código de las páginas de ASP.NET 1.x: precisamente el problema que los componentes de origen de datos se proponen solucionar. En ASP.NET 2.0, se establece RequiresDataBinding en true siempre que ocurre algo en la vida de un control que requiere el enlace de los datos. Al establecer la propiedad se activa el mecanismo del enlace a datos que vuelve a crear una versión actualizada de la infraestructura interna del control. El controlador de eventos integrado OnLoad conecta asimismo el control al origen de datos. Para que sea realmente eficaz, esta técnica se debe basar en unos controles de origen de datos inteligentes con capacidad para almacenar los datos en alguna parte de la memoria caché. El control SqlDataSource, por ejemplo, admite numerosas propiedades para almacenar cualquier conjunto de resultados enlazados en la caché de ASP.NET durante un período especificado. 80 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 18 CONFIGURAR LA DEPURACIÓN Y LOS ERRORES PERSONALIZADOS. PUEDE INCLUIR, PERO SIN LIMITARSE A ELLO: <customErrors mode="Off|On|RemoteOnly" />, <compilation debug="true"/> Para habilitar la depuración para una aplicación Web ASP.NET, se debe configurar la aplicación para que se compile en una versión de depuración. Una versión de depuración incluye información que el depurador necesita para poder recorrer el código y mostrar el contenido de las variables. La configuración de una aplicación Web para las versiones de depuración se realiza en la sección Compilation del archivo Web.config de la aplicación. Como alternativa, si sólo se desea depurar páginas individuales, puede agregar debug=true a la directiva @ Page en las páginas que desea depurar. Nota: Una aplicación compilada en una versión de depuración funcionará bastante más despacio que si se compila en una versión comercial. Asegurarse de desactivar el modo de depuración antes de implementar la aplicación. Además, en modo de depuración se expone más información en la pila cuando se produce un error y esto puede suponer un problema de seguridad. Depuración local y remota Si se está ejecutando un servidor Web localmente, como IIS, se puede depurar aplicaciones ejecutándose localmente en el equipo, de forma que se pueda ver las páginas en un explorador. Si no se puede ejecutar una página localmente, porque no se puede ejecutar un servidor Web o porque la aplicación no está disponible localmente, se puede depurar una aplicación que se ejecute en otro servidor. Para poder realizar la depuración de manera remota, debe instalar los componentes de depuración remota de Visual Studio en el servidor remoto. Permisos para la depuración La depuración de un proceso requiere más privilegios que su ejecución. Por tanto, además de configurar la aplicación para la depuración, se debe asegurar también de que se dispone de los permisos adecuados para asociarla a un proceso con el fin de depurarla. Los usuarios tienen permiso para depurar procesos que se ejecutan bajo su propia identidad de usuario local, pero no pueden depurar los procesos de otro usuario. Los administradores pueden depurar cualquier proceso. Para realizar la depuración en un servidor remoto, se necesita privilegios de administrador en el equipo donde se ejecuta el proceso que se va a depurar. Depuración de secuencias de comandos en el cliente Además de la depuración de aplicaciones en el servidor, Visual Debugger permite depurar secuencias de comandos de cliente escritas en ECMAScript (JavaScript) o en VBScript. La depuración de secuencias de comandos en el cliente puede ser especialmente útil cuando tiene controles de servidor Web que utilizan secuencias de comandos cliente. HABILITAR LA DEPURACIÓN EN ASP.NET Habilitar la depuración ASP.NET en las propiedades del proyecto (Visual Basic/C #) 1. 2. 3. En el Explorador de soluciones, Clic con el botón secundario del mouse en el nombre de un proyecto web y seleccionar Páginas de propiedades. Aparecerán las Páginas de propiedades de <proyecto>. Clic en la ficha Web. En Depuradores, activar la casilla ASP.NET. Habilitar la depuración en el archivo web.config 1. Abrir el archivo web.config utilizando cualquier editor de texto estándar o un analizador XML. a. Sin embargo, no se puede tener acceso al archivo en modo remoto utilizando un explorador web. Por motivos de seguridad, ASP.NET configura Microsoft IIS para impedir el acceso directo del explorador a los archivos Web.config. Si se intenta obtener acceso a un archivo de configuración utilizando un explorador, se obtendrá el error de acceso 403 de HTTP (prohibido). 2. Web.config es un archivo XML, por lo que contiene secciones anidadas marcadas por etiquetas. El siguiente ejemplo muestra un archivo Web.config típico. Modificar el archivo siguiendo estos pasos: a. Buscar la etiqueta <compilation>. Esta etiqueta marca el comienzo de la sección <compilation>. 81 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 b. 3. En la etiqueta <compilation>, crear el atributo de depuración. En el ejemplo siguiente, debug es el segundo atributo especificado en la etiqueta <compilation>, pero el orden no tiene importancia. c. Los atributos distinguen entre mayúsculas y minúsculas, por consiguiente, asegurarse de que especifica "debug", y no "Debug" ni "DEBUG". d. Establezca debug en true, como se muestra en el ejemplo de código siguiente. Si no se establece el atributo de depuración en true y se intenta iniciar una sesión de depuración, aparecerá un cuadro de diálogo para crear un archivo web.config conteniendo el atributo de depuración establecido. Aceptar y continuar para depurar. <configuration> <system.web> <compilation defaultLanguage="VB" debug="true" numRecompilesBeforeAppRestart="15"> <compilers> <compiler language="VB;VBScript" extension=".cls" type="Microsoft.VisualBasic.VBCodeProvider,system, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" /> < compiler language="C#;Csharp" extension=".cs" type="Microsoft.CSharp.CSharpCodeProvider,system, PublicKeyToken=b77a5c561934e089" /> Version=1.0.5000.0, Culture=neutral, </compilers> <assemblies> "" <add assembly="ADODB" /> <add assembly="*" /> </assemblies> <namespaces> <add namespace="System.Web" /> <add namespace="System.Web.UI" /> <add namespace="System.Web.UI.WebControls" /> <add namespace="System.Web.UI.HtmlControls" /> 82 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 </namespaces> </compilation> </system.web> </configuration> 19 CONFIGURAR UN ENTORNO PARA REALIZAR LA DEPURACIÓN REMOTA Para habilitar la depuración remota, se puede: Instalar el Monitor de depuración remota (msvsmon.exe) en el equipo remoto e iniciarlo cuando se inicie la depuración, o Ejecutar el Monitor de depuración remota desde un recurso compartido de forma remota. Ejecutar el Monitor de depuración remota desde un recurso compartido de archivos es la forma más sencilla de habilitar la depuración remota. Visual Studio instala msvsmon.exe en estos directorios: Ruta de Ruta de Ruta de Los componentes acceso de instalación\Microsoft Visual Studio 8\Common7\IDE\Remote Debugger\x86 acceso de instalación\Microsoft Visual Studio 8\Common7\IDE\Remote Debugger\x64 acceso de instalación\Microsoft Visual Studio 8\Common7\IDE\Remote Debugger\ia64 IA 64 únicamente están disponibles en Visual Studio Team System. Al instalar Visual Studio en una plataforma de 64 bits, se instalan los componentes de depuración remota en plataformas de 64 bits y x86. Al instalar Visual Studio en una plataforma x86, se instalan de forma predeterminada componentes de depuración remota para x86; los componentes de depuración de 64 bits se instalan si se elige la opción adecuada durante la instalación. Al instalar el Monitor de depuración remota en una plataforma x86, únicamente se instalan los componentes de depuración remota de x86. No hay ninguna opción para instalar los componentes de 64 bits. Si se comparte el directorio del depurador remoto en el equipo que ejecuta Visual Studio, es posible ejecutar msvsmon.exe en el equipo remoto. Las características de depurador siguientes no funcionan cuando el Monitor de depuración remota se ejecuta desde un recurso compartido: Ejecutar paso a paso un servicio Web XML. (Aún es posible adjuntar de forma manual). Depurar automáticamente una aplicación web de ASP.NET. (Aún es posible adjuntar de forma manual). Como alternativa a la ejecución desde un recurso compartido, se puede usar el CD del depurador remoto de Visual Studio 2005 para instalar los componentes de depuración remota necesarios en el equipo remoto. Esta instalación proporciona acceso a todas las características de depuración remota. Al ejecutar el depurador remoto en una plataforma x86, únicamente se instalan los componentes de depuración remota de x86. No hay ninguna opción para instalar los componentes de 64 bits. Si se ejecuta en una plataforma de 64 bits, se instalan los componentes de 64 bits y x86. En algunos escenarios de depuración, es preciso instalar componentes adicionales. Para instalar los componentes de depuración remota 1. 2. 3. 4. El depurador remoto se encuentra en el último disco del juego de instalación de Visual Studio. Insertar este disco en el equipo remoto. Por ejemplo, si hay cuatro discos en el juego de instalación, insertar el cuarto disco en el equipo remoto. Si tiene un DVD en lugar de un CD, insertar el DVD. En el Explorador de Windows, abrir el CD o DVD. Buscar la carpeta Remote Debugger (en el CD) o vs/Remote Debugger (en el DVD). En la carpeta Depurador remoto, abrir la subcarpeta que coincide con su plataforma (x86, x64 o IA-64). Iniciar la copia de rdbgsetup.exe situada en esa subcarpeta y siga las instrucciones para finalizar la instalación. Se puede instalar los componentes de depuración remota copiando manualmente los archivos. Ver Componentes de depuración remota para obtener una lista de componentes necesarios y sus ubicaciones de instalación. Visual Studio incluye versiones independientes del Monitor de depuración remota para las plataformas de 32 bits y de 64 bits. Si utiliza rdbgsetup.exe, la 83 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 5. instalación de componentes remotos instalará automáticamente la versión correcta del Monitor de depuración remota. Si se copian manualmente los archivos, asegurarse de copiar la versión correcta. Una vez instalados los componentes de depuración remota, asegurarse que tiene los permisos necesarios para depurar un programa en el equipo remoto. Configurar el Firewall de Windows El Firewall de Windows se debe configurar para habilitar la depuración remota. Al iniciar por primera vez la depuración remota, Visual Studio realiza la configuración necesaria en el equipo host de Visual Studio. De igual manera, al ejecutar por primera vez el Monitor de depuración remota en un equipo remoto, el Monitor de depuración remota configura el Firewall de Windows en ese equipo. En Windows XP, esta configuración es completamente transparente y automática, pero en Windows Vista, el nuevo modelo de seguridad requiere la concesión de permiso antes de que el software pueda configurar el Firewall. Este permiso se concede a través del cuadro de diálogo Control de cuentas de usuario. Cuando el Monitor de depuración remota tiene que configurar el Firewall de Windows en el equipo remoto, el cuadro de diálogo Control de cuentas de usuario aparece en el equipo remoto. Si el equipo remoto no está visible, puede que no se haya dado cuenta de que el cuadro de diálogo Control de cuentas de usuario ya ha aparecido en su monitor. En ese caso, puede creer equivocadamente que la depuración remota ha dejado de responder. El Monitor de depuración remota está simplemente esperando que alguien conceda permiso en el cuadro de diálogo Control de cuentas de usuario del equipo remoto. Una manera de evitar este problema es configurar previamente el Firewall en el equipo remoto mediante el Asistente para configuración del depurador remoto. Para configurar el Firewall de Windows mediante el Asistente para configuración del depurador remoto 1. 2. 3. 4. Asegurarse de que los componentes de depuración remota se han instalado en el equipo. Inicio Todos los programas Visual Studio 9.0 Asistente para configuración del depurador remoto. Inicio Todos los programas Visual Studio 9.0 Depurador remoto. Seguir las instrucciones del Asistente para configuración del depurador remoto. Comenzar la depuración remota 1. Asegurarse de tener los permisos de depuración remota necesarios en el equipo remoto. 2. Para la depuración remota distinta de SQL, asegurarse de que está ejecutando el Monitor de depuración remota en el equipo remoto. Si se está depurando SQL, el Monitor de depuración remota se iniciará automáticamente durante la depuración. 3. Iniciar Visual Studio en el host del depurador. Utilizar Visual Studio para asociarse a un programa a desee depurar en el equipo remoto, o iniciar un programa a depurar en el equipo remoto. 20 DEPURAR LAS EXCEPCIONES SIN TRAZAR AL UTILIZAR ASP.NET AJAX: MÉTODOS SYS.DEBUG EN EL CLIENTE; CONEXIÓN DE UN PROGRAMA DE DEPURACIÓN A WINDOWS INTERNET EXPLORER Las aplicaciones ASP.NET habilitadas para AJAX contienen una mezcla de código de servidor y código de cliente. El explorador también puede solicitar datos adicionales de forma asincrónica. Esto puede convertir la depuración de aplicaciones web habilitadas para AJAX en un desafío. Escenarios 84 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Se puede utilizar los enfoques siguientes para depurar una aplicación ASP.NET habilitada para AJAX en las diferentes fases de desarrollo: Habilitar la depuración en el archivo de configuración. Utilizar trazas en el servidor. Utilizar los métodos de la clase Sys.Debug para establecer puntos de interrupción y administrar el resultado del seguimiento. Habilitar la depuración en el explorador. Asociar el depurador de Visual Studio 2008 a la instancia de Internet Explorer o utilizar herramientas externas para depurar en otros exploradores. Utilizar herramientas externas para capturar el tráfico HTTP. Información general La arquitectura de AJAX en ASP.NET ofrece un modelo para los modos de lanzamiento y depuración. El modo de lanzamiento permite la comprobación de errores y el control de excepciones optimizados para el rendimiento, con un tamaño de script mínimo. El modo de depuración dispone de características de depuración más sólidas, como la comprobación de tipos y argumentos. Si se crea versiones de depuración de archivos de script de cliente o recursos de script, ASP.NET ejecuta las versiones de depuración cuando la aplicación está en modo de depuración. Esto permite iniciar excepciones en los scripts de depuración, manteniendo un tamaño mínimo del código de lanzamiento. Una clase de aplicación auxiliar de depuración, Sys.Debug, proporciona métodos para mostrar los objetos con un formato legible al final de una página web. También muestra los mensajes de seguimiento de la traza, permite utilizar aserciones y permite irrumpir en el depurador. La API del objeto Error extendida proporciona información útil sobre las excepciones y admite los modos de lanzamiento y depuración. En las secciones siguientes se proporciona información detallada acerca de las técnicas y herramientas que puede utilizar para depuración y traza. Configurar la aplicación para depuración Para habilitar la depuración, agregar un elemento compilation al archivo raíz Web.config del sitio y, a continuación, establecer el atributo debug en true. En el ejemplo siguiente se muestra una sección de un archivo Web.config que tiene establecido el atributo debug para depuración. Copiar <configuration> <system.web> <compilation debug="true"> <!-- etc. --> </compilation> </system.web> <configuration> Cuando la depuración está habilitada, ASP.NET utiliza la versión de depuración de Microsoft AJAX Library y las versiones de depuración de los archivos de script de cliente personalizados, si están disponibles. Cambiar la aplicación del modo depuración al modo lanzamiento para su implementación Cuando se implemente una versión de lanzamiento de una aplicación ASP.NET habilitada para AJAX, establecer la aplicación en modo de lanzamiento. De esta manera, se asegura de que ASP.NET utiliza la versión de lanzamiento optimizada para el rendimiento de las bibliotecas de AJAX. Si se ha creado versiones de depuración y de lanzamiento de sus archivos de script personalizados y de los recursos del script, ASP.NET también utilizará las versiones de lanzamiento. Para establecer la aplicación en modo de lanzamiento: En el archivo Web.config, si el elemento compilation contiene un atributo debug, asegurarse de que el atributo debug está establecido en false. 85 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Asegurarse de que todas las páginas web que contienen un control ScriptManager tengan su propiedad ScriptMode establecida en Release. El atributo debug de la directiva @ Page no afecta a las aplicaciones de AJAX en ASP.NET. El control ScriptManager sólo utiliza los valores del archivo Web.config y de sus propiedades IsDebuggingEnabled y ScriptMode para determinar si debe representar los scripts de depuración. Trazas en el servidor Si se está utilizando trazas en el servidor para depurar las páginas web que tienen habilitada la representación parcial de la página, se debe utilizar el visor de seguimiento de trazas (Trace.axd) para mostrar el resultado de la traza. Se puede anexar el resultado de la traza al final de la página y se mostrará la primera vez que se represente la página. Sin embargo, la presentación de la traza no se actualiza como resultado de las devoluciones de datos asincrónicas, porque sólo cambia el contenido de los controles UpdatePanel que deban actualizarse. Nota: La representación parcial de la página está habilitada cuando la página contiene un control ScriptManager cuya propiedad EnablePartialRendering está establecida en true. La página también debe contener uno o varios controles UpdatePanel. Clase de aplicación auxiliar de depuración ASP.NET dispone de la clase Sys.Debug para depurar aplicaciones cliente. Mediante llamadas a los métodos de la clase Sys.Debug, puede mostrar los objetos en formato legible al final de la página, mostrar mensajes de seguimiento de la traza, utilizar aserciones e irrumpir en el depurador. Si se utiliza Visual Studio e Internet Explorer, se puede asociar el depurador de Visual Studio al explorador y ver los mensajes de seguimiento del depurador en la ventana Resultados. Si no utiliza Visual Studio, se puede ver los mensajes de seguimiento del depurador en Internet Explorer creando un elemento textarea en la página y estableciendo su id. en TraceConsole. En Mozilla Firefox, se puede ver los mensajes de traza del depurador mediante herramientas disponibles como extensiones. Los exploradores Apple Safari y Opera muestran los mensajes de traza en sus respectivas consolas de depuración. En la siguiente tabla se enumeran los métodos de la clase Sys.Debug. Sys.Debug.assert(condición, mensaje, mostrarLlamador) Comprueba una condición y, si ésta es false, muestra un mensaje y solicita al usuario que irrumpa en el depurador. Sys.Debug.clearTrace() Borra todos los mensajes de seguimiento de la traza del elemento TraceConsoletextarea. Sys.Debug.traceDump(objeto, nombre) Vuelca un objeto a la consola del depurador y al elemento TraceConsoletextarea, si está disponible. Sys.Debug.fail(mensaje) Muestra un mensaje en la ventana de resultados del depurador e irrumpe en el depurador. Sys.Debug.trace(texto) Anexa una línea de texto a la consola del depurador y al elemento TraceConsoletextarea, si está disponible. En el ejemplo siguiente se muestra cómo llamar a los métodos de la clase Sys.Debug: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head id="Head1" runat="server"> <title>Untitled Page</title> 86 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 <script language="javascript" type="text/javascript"> function btnAssert_onclick() { var n; // Insert code intended to set n to a positive integer. if (false) n = 3; // Assert if n is not greater than 0. Sys.Debug.assert(n > 0, "n must be set to a positive integer."); } function btnFail_onclick() { var n; // Insert code intended to set n to a numeric value. if (false) n = 3; // Fail if n is not numeric. if (isNaN(n)) Sys.Debug.fail("The value of n must be a number."); } function btnTrace_onclick() { v = form1.text1.value; Sys.Debug.trace("Name set to " + "\"" + v + "\"."); alert("Hello " + v + "."); } function btnDump_onclick() { Sys.Debug.traceDump(form1.text1, "Name textbox"); alert("Hello " + form1.text1.value + "."); } function btnClear_onclick() { Sys.Debug.clearTrace() alert("Trace console cleared."); 87 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 } </script> </head> <body> <form id="form1" runat="server"> <h2>Sys.Debug Methods Test Page</h2> <asp:ScriptManager ID="ScriptManager1" runat="server" /> <p><b>Use these buttons to demonstrate the assert() and fail() methods:</b><br /> <input id="btnAssert" type="button" value="Assert" style="width: 100px" onclick="return btnAssert_onclick()" /> &nbsp <input id="btnFail" type="button" value="Fail" style="width: 100px" onclick="return btnFail_onclick()" /> </p><hr /> <b>Use the textbox and buttons below to demonstrate tracing.</b> <br /> <p>Enter your name here:<br /> <input id="text1" maxlength="50" type="text" /> <br /> <br /> <input id="btnTrace" type="button" value="Trace" style="width: 100px" onclick="return btnTrace_onclick()" /><br /> <input id="btnDump" type="button" value="TraceDump" style="width: 100px" onclick="return btnDump_onclick()" /><br /> <input id="btnClear" type="button" value="ClearTrace" style="width: 100px" onclick="return btnClear_onclick()" /><br /> <br /></p> View output in the TraceConsole textarea below. <br /> 88 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 <textarea id='TraceConsole' rows="10" cols="50" title="TraceConsole"></textarea> </form> </body> </html> Configurar Internet Explorer para depuración De forma predeterminada, Internet Explorer pasa por alto los problemas que encuentra en JavaScript. Se puede habilitar la depuración utilizando el procedimiento siguiente. Para habilitar la depuración en Internet Explorer 1. 2. En el menú Herramientas, Clic en Opciones de Internet. En la ficha Opciones avanzadas, desactivar la casilla Deshabilitar la depuración de scripts (Internet Explorer) y la casilla Deshabilitar la depuración de scripts (otros). 3. Activar la casilla Mostrar una notificación sobre cada error de script. 4. Para desactivar los mensajes de error descriptivos, desactivar la casilla Mostrar mensajes de error HTTP descriptivos. Si los mensajes de error descriptivos están habilitados y una respuesta de error HTTP 500 del servidor tiene una longitud inferior a 513 bytes, Internet Explorer enmascara el contenido. En lugar de la información de error, Internet Explorer muestra un mensaje destinado a los usuarios finales, no a los programadores. Asociar el depurador de Visual Studio a Internet Explorer Para depurar el script de cliente, debe asociar un depurador a Internet Explorer. En Visual Studio, si inicia su aplicación para depuración (presionando F5 o utilizando el comando Iniciar depuración del menú Depurar ), el depurador se asocia automáticamente. También se puede asociar el depurador de Visual Studio a Internet Explorer cuando la aplicación ya se está ejecutando. Para ello, en el menú Depurar, Clic en Asociar al proceso En el cuadro de diálogo Asociar al proceso, seleccionar la instancia de Internet Explorer (iexplore.exe) a la se que desea asociar el depurador. Nota: Si Internet Explorer está configurado para depuración, la columna Tipo de la instancia pertinente de Internet Explorer muestra Script, x86. Si sólo ve x86 en la columna Tipo, asegurarse de que ese Internet Explorer está configurado para depuración. Si Internet Explorer encuentra un error de script y está configurado para la depuración de scripts, pero no está asociado a ningún depurador, el explorador solicita que seleccione un depurador. Se puede continuar sin depurar o asociar un depurador y ejecutar el código paso a paso. Problemas de depuración conocidos de Internet Explorer y soluciones alternativas Cuando se depuran aplicaciones de ASP.NET AJAX que utilizan Internet Explorer, tener en cuenta los problemas siguientes y las soluciones alternativas: Una vez asociado el depurador de Visual Studio a Internet Explorer, se puede ver una lista de los scripts que se están depurando en la ventana Explorador de scripts. (Para mostrar esta ventana, en el menú Depurar, clic en Ventanas y, a continuación, clic en Explorador de scripts.) La biblioteca de clientes de ASP.NET AJAX aparecerá como un recurso comenzando por ScriptResource.axd?..., que el servidor genera dinámicamente del ensamblado de ASP.NET AJAX. Un problema conocido de Visual Studio podría impedir abrir el archivo. Si Visual Studio muestra un mensaje de error a este respecto, o si pasa por alto los clics en el nombre del archivo, cierre todos los archivos de script que están abiertos. A continuación, abrir la página y seleccione los archivos de script que desea depurar. No puede establecer puntos de interrupción en código JavaScript dentro de los elementos script de una página ASP.NET hasta el depurador haya ejecutado paso a paso el código JavaScript de esa página. Para solucionar este problema, establecer el punto de interrupción en la función de la que proviene la llamada y ejecutar paso a paso el código de la página web ASP.NET. Después de que el depurador se haya detenido en una línea de código JavaScript de la página, se 89 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 puede establecer los puntos de interrupción como de costumbre. Otra manera de que el depurador reconozca los scripts de una página ASP.NET es crear un método en el archivo de paginación de ASP.NET que llame al método Sys.Debug.fail. Cuando se llama a este método, el depurador se detiene en la llamada a Sys.Debug.fail y permite establecer los puntos de interrupción en otra parte. Una tercera alternativa es colocar todo el código personalizado en archivos JavaScript externos. Visual Studio permite establecer puntos de interrupción en la primera línea de una función JavaScript normal, pero no en la primera línea de métodos anónimos, que ASP.NET utiliza en las bibliotecas de AJAX. Si un método anónimo contiene sólo una línea de código, o si debe establecer un punto de interrupción en la primera línea de un método anónimo, inserte una línea ficticia de código. A continuación, puede establecer el punto de interrupción en la segunda línea del método. Problemas conocidos de IIS 7.0 Cuando se ejecutan páginas ASP.NET habilitadas para AJAX mediante IIS 7.0 en Windows Vista, y el modo de canalización administrada está establecido en Integrada, los scripts procesados por la clase ScriptResourceHandler no se almacenan en la memoria caché. Sin embargo, los scripts se almacenan en la memoria caché cuando el modo de canalización administrada está establecido en Clásica. Capturar el tráfico HTTP Al desarrollar aplicaciones web, suele resultar útil supervisar el tráfico HTTP entre el servidor y el cliente. Una herramienta que puede realizar esta tarea es Fiddler, que se puede obtener en Fiddler PowerToy page, en el sitio web de MSDN. Fiddler se ejecuta como un proxy que registra todo el tráfico HTTP. Admite Internet Explorer y otros exploradores. Con Fiddler puede examinar cada solicitud y respuesta, incluidos encabezados, cookies y contenido del mensaje. Depuración en Mozilla Firefox Mozilla Firefox no se integra con el depurador de Visual Studio. Por consiguiente, no se puede utilizar el depurador de Visual Studio para ejecutar paso a paso el código de cliente que se está ejecutando en Firefox. Sin embargo, Firefox admite alguna funcionalidad de depuración, como una consola de JavaScript. También puede instalar las extensiones siguientes disponibles en Mozilla para mejorar sus funciones de depuración: FireBug permite a ejecutar paso a paso el script de cliente y examinar los elementos DOM de HTML. También proporciona una consola de scripts, una línea de comandos y otras herramientas. JavaScript Debugger (también conocido como "Venkman") ofrece un entorno de depuración de JavaScript que incluye un explorador de código fuente y otras características. Web Developer extension permite inspeccionar los estilos DOM y CSS. Fiddler también funciona con Firefox. Sin embargo, debe configurar Firefox para enrutar las solicitudes HTTP a través del proxy que se está ejecutando en el puerto 8888 del equipo local 21 IMPLEMENTAR EL SEGUIMIENTO DE UNA APLICACIÓN WEB: Trace.axd, Trace=True on @Page directive,<trace enabled="true"/> El seguimiento en ASP.NET permite ver información de diagnóstico acerca de una única solicitud para una página ASP.NET. El seguimiento de ASP.NET permite seguir la ruta de acceso de ejecución de una página, mostrar información de diagnóstico en tiempo de ejecución y depurar la aplicación. El seguimiento de ASP.NET se puede integrar en un seguimiento del nivel del sistema que proporciona varios niveles de resultados de seguimiento en aplicaciones distribuidas y de varios niveles. Características La traza de ASP.NET ofrece las siguientes características: Debugging statements Se puede escribir instrucciones de depuración en el código, sin necesidad de quitarlas de la aplicación cuando se implemente en los servidores de producción. También se puede escribir variables o estructuras en una página y seguir la traza de la ruta de ejecución de la página o de la aplicación. Integrated tracing functionality Se puede enrutar mensajes emitidos por la clase System.Diagnostics.Trace al resultado de traza de ASP.NET y enrutar mensajes emitidos por la traza de ASP.NET a System.Diagnostics.Trace. También se puede reenviar los eventos de instrumentación de ASP.NET a System.Diagnostics.Trace. Programmatic access to trace messages Se puede tener acceso y manipular mensajes de traza a partir del código para un control más preciso del formato de los mensajes de traza o para el procesamiento adicional requerido. 90 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Application-level tracing La opción de traza del nivel de aplicación permite ver los datos de traza más recientes disponibles sin necesidad de reiniciar una sesión de traza ni de aumentar el volumen de datos de traza que debe almacenar el servidor. Se muestran los datos más recientes de traza y se descartan los más antiguos. Background El seguimiento de traza anexa la información de diagnóstico y los mensajes de traza personalizados al resultado de la página y envían esta información al explorador que realizó la solicitud. Opcionalmente, se puede ver esta información en otro visor de traza (Trace.axd), que muestra los datos de traza de todas las páginas de la aplicación web ASP.NET. La información de traza puede ayudarle a investigar errores o resultados no deseados mientras ASP.NET procesa una solicitud de página. Se puede configurar páginas individuales para mostrar información de seguimiento. De forma alternativa, se puede configurar el archivo Web.config de la aplicación para que todas las páginas muestren información de seguimiento a menos que la página deshabilite explícitamente el seguimiento. El establecimiento de la traza en el nivel de aplicación es útil ya que no necesita realizar cambios en las páginas individuales para habilitarla y deshabilitarla. Las instrucciones de seguimiento sólo se procesan y se muestran cuando el seguimiento está habilitado. Es posible controlar si el seguimiento se muestra en la página, en el visor de seguimiento o en ambos. Traza de ASP.NET en la aplicación La traza en el nivel de aplicación se habilita mediante el elemento trace del archivo Web.config. Cuando se habilita el seguimiento del nivel de aplicación, ASP.NET recopila la información de seguimiento de cada solicitud realizada a la aplicación, hasta llegar al número máximo de solicitudes especificado. El número predeterminado de solicitudes es 10. De forma predeterminada, cuando el visor de seguimiento alcanza este límite, la aplicación deja de almacenar solicitudes de seguimiento. Se puede configurar la traza para almacenar los datos de seguimiento más antiguos (descartando elementos más recientes) o la información de traza más reciente (descartado elementos más antiguos). Nota: Cuando se habilita la traza para toda la aplicación en el archivo Web.config, la información se recopila y procesa para cada página de la aplicación. Para reemplazar la configuración de la aplicación, se establece el atributo Trace en la directiva @ Page de esa página en false. Las instrucciones Write o Warn que incluya en el código de una página se almacenan y envían únicamente al visor de seguimiento. Ver información de seguimiento Se puede ver la información de traza en la parte inferior de páginas individuales. También se puede utilizar el visor de traza (Trace.axd) para ver información de traza que ASP.NET recopila y almacena en caché cuando la traza está habilitada. Si se desea que la información de seguimiento aparezca al final de la página que está asociada a ella, se puede establecer el atributo PageOutput del elemento trace en true. Si se habilita la traza en el nivel de aplicación pero no se desea que se muestre información de traza de algunas páginas, se puede establecer el atributo Trace de la directiva @ Page de esas páginas en false. De forma predeterminada, el seguimiento de nivel de aplicación se puede ver sólo en el equipo local del servidor Web. Para hacer que la información de seguimiento del nivel de aplicación sea visible desde equipos remotos, puede establecer el atributo LocalOnly del elemento trace en false. Nota: Para ayudar a proteger la aplicación web, se utiliza la capacidad de traza remota únicamente cuando se programa o se instala la aplicación. Asegurarse de que se deshabilita antes de transferir la aplicación a los servidores web de producción. Para ello, se establece el atributo LocalOnly en true en el archivo Web.config. El ejemplo siguiente muestra una configuración de traza de aplicación que recoge información de traza para un máximo de 40 solicitudes. También habilita exploradores en equipos distintos del servidor para mostrar el visor de traza. <configuration> <system.web> <trace enabled="true" requestLimit="40" localOnly="false" /> </system.web> 91 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 </configuration> Escribir mensajes de seguimiento de ASP.NET personalizados Se puede anexar la información de traza personalizada a la presentación de traza de una página ASP.NET o al registro de traza. La información de traza que se escribe en el registro de traza se puede ver con el visor de traza. Puede escribir información de traza mediante los métodos Warn o Write de la clase TraceContext. La diferencia entre los dos métodos es que un mensaje escrito con el método Warn aparece con el texto en rojo. El ejemplo de código siguiente muestra cómo usar la clase TraceContext para mostrar información de traza al final de una página ASP.NET. Se inicia una excepción diferente para cada control LinkButton que produjo la devolución de datos. El mensaje de error que se usa para inicializar las instancias ArgumentException o InvalidOperationException se muestra en el registro de traza. <%@ Page Language="C#" Trace="true" %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <script runat="server"> void Page_Load(object sender, EventArgs e) { try { if (IsPostBack) { switch (Request.Form[" EVENTTARGET"]) { case "WarnLink": throw new ArgumentException("Trace warn."); break; case "WriteLink": throw new InvalidOperationException("Trace write."); break; default: throw new ArgumentException("General exception."); break; } } } catch (ArgumentException ae) { 92 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Trace.Warn("Exception Handling", "Warning: Page_Load.", ae); } catch (InvalidOperationException ioe) { Trace.Write("Exception Handling", "Exception: Page_Load.", ioe); } } </script> <html xmlns="http://www.w3.org/1999/xhtml" > <head runat="server"> <title>Trace Example</title> </head> <body> <form id="form1" runat="server"> <div> <asp:LinkButton id="WriteLink" runat="server" text="Generate Trace Write" /> <asp:LinkButton id="WarnLink" runat="server" text="Generate Trace Warn" /> </div> </form> </body> </html> Leer la información de seguimiento de ASP.NET Se puede ver la información de traza que se anexa al final de una página ASP.NET o en el visor de traza. En ambos casos, la información mostrada es la misma. ASP.NET organiza la información de traza en una serie de tablas. La información de seguimiento aparece en el orden siguiente. 93 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 La sección Detalles de la solicitud muestra información general sobre la solicitud actual y la respuesta. Valor Descripción Id. de sesión Identificación de sesión de la solicitud especificada. Hora de la solicitud Hora en que se efectuó la solicitud. Codificación de la solicitud Codificación de caracteres de la solicitud. Tipo de solicitud Método HTTP (GET o POST). Código de estado Valor de código de estado asociado a la respuesta. Codificación de respuesta Codificación de caracteres para la respuesta. Información de seguimiento La sección Información de seguimiento muestra el flujo de eventos del nivel de página. Si se ha creado mensajes de seguimiento personalizados, los mensajes también se muestran en la sección Información de seguimiento. Valor Descripción Category Categoría de seguimiento personalizada especificada en una llamada al método Warn u Write, si la hay. Message Mensaje de seguimiento personalizado especificado en una llamada al método Warn u Write, si lo hay. Desde los Tiempo transcurrido en segundos desde que se procesó el primer mensaje de seguimiento. El primer mensaje de primeros seguimiento aparece en la parte superior de la lista. Desde los Tiempo transcurrido en segundos entre el procesamiento del mensaje de traza actual y el mensaje de traza últimos anterior. Árbol de control La sección Árbol de control muestra información sobre los controles de servidor ASP.NET que se crean en la página. Valor Descripción Id. de control Identificación del control. Si no ha especificado una propiedad ID para el control, ASP.NET genera ID mediante la propiedad UniqueID. Type Nombre de tipo completo del control. Bytes de tamaño del la Tamaño del control representado en bytes (incluidos los controles secundarios). Se trata del tamaño representación del contenido HTML, XML, etc., real que se envía al explorador. Tamaño en bytes de Tamaño en bytes del estado de vista del control (excluidos los controles secundarios). en bytes de Tamaño en bytes del estado de control del control (excluidos los controles secundarios). ViewState Tamaño ControlState Estado de sesión La sección Estado de sesión muestra información sobre los valores que se almacenan en el estado de sesión, si la hay. 94 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Valor Descripción Clave de sesión Clave para datos almacenados en el estado de sesión, si la hay. Type Tipo completo del objeto que almacena los datos. Valor Representación de cadena de los datos almacenados en el estado de sesión, si la hay. Estado de aplicación La sección Estado de la aplicación muestra información sobre los valores almacenados en el estado de la aplicación, si la hay. Valor Descripción Clave de aplicación Clave para datos almacenados en el estado de aplicación, si la hay. Type Tipo completo del objeto que almacena los datos. Valor Representación de cadena de los datos que se almacenan en el estado de aplicación, si la hay. Colección Cookies Las secciones Cookies de solicitud y Cookies de respuesta muestran información sobre las cookies que se pasan entre el explorador y el servidor en cada solicitud y respuesta. La sección muestra cookies permanentes y de la sesión. ASP.NET crea automáticamente algunas cookies, como las del estado de sesión basada en cookies y las de autenticación de formularios. Valor Descripción Nombre Nombre de la cookie. Valor Valor de la cookie o de las subclaves y valores, en caso de que la cookie tenga valores múltiples. Size Tamaño de la cookie en bytes. Colección Headers La sección Colección de encabezados muestra información sobre los pares nombre/valor de los encabezados de los mensajes de solicitud y respuesta, que proporcionan información sobre el cuerpo del mensaje o el recurso solicitado. La información de encabezado se utiliza para controlar cómo se procesan los mensajes de solicitud y cómo se crean los mensajes de respuesta. Valor Descripción Nombre Nombre del encabezado. Valor Valor del encabezado. Colección Form La sección Colección de formularios muestra pares de nombre/valor que indican los valores de elementos de formulario (valores de control) que se envían en una solicitud durante una operación POST (devolución de datos). Valor Descripción Nombre Nombre de la variable de formulario. Valor Valor de la variable de formulario. 95 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Colección de cadenas de consulta La sección Colección de cadenas de consulta muestra los valores que se pasan a la dirección URL. En una dirección URL, la información de la cadena de consulta se separa de la información de la ruta de acceso mediante un signo de interrogación (?); los elementos múltiples de la cadena de consulta se separan mediante un signo de Y comercial (&). Los pares de nombre/valor de la cadena de consulta se separan mediante un signo igual (=). La propiedad QueryString del objeto HttpRequest devuelve NameValueCollection de variables de la cadena de consulta. Valor Descripción Nombre Nombre de la variable de la cadena de consulta. Valor Valor de la variable de la cadena de consulta. Variables de servidor La sección Variables de servidor muestra una colección de variables de entorno relacionadas con el servidor e información del encabezado de la solicitud. La propiedad ServerVariables del objeto HttpRequest devuelve NameValueCollection de variables del servidor. Valor Descripción Nombre Nombre de la variable de servidor. Valor Valor de la variable de servidor. Seguimiento en ASP.NET y seguimiento de diagnósticos El seguimiento en ASP.NET escribe mensajes que se muestran en las páginas Web ASP.NET y el visor de seguimiento de ASP.NET (Trace.axd). En cambio, la clase System.Diagnostics.Trace se utiliza para seguir la traza de los mensajes de escritura en el resultado de traza de .NET Framework estándar (normalmente una ventana de consola). Para facilitar el seguimiento de la interacción entre las páginas web ASP.NET y los objetos de negocios y otros componentes, se puede integrar el resultado de traza de ASP.NET con la traza de System.Diagnostics. A continuación se puede enrutar todos los mensajes de traza a una de estas salidas. Un escenario común que usa tanto la traza en ASP.NET como System.Diagnostics.Trace son las páginas web que utilizan objetos de negocios de nivel intermedio para interactuar con datos y reglas de negocios. También puede usar System.Diagnostics.Trace en las páginas que usan servicios de la empresa como transacciones y colas. En estas situaciones, los componentes de empresa y negocio representan papeles clave en la ejecución correcta de la página. Además, puede ayudar con el análisis de la aplicación a supervisar el flujo de ejecución entre los diferentes niveles mediante un resultado de traza único. Atributos de configuración del seguimiento La tabla siguiente muestra los atributos que puede utilizar para modificar el comportamiento de la traza en el nivel de aplicación en el elemento trace del archivo Web.config. Atributo Descripción Enabled true para habilitar el seguimiento para a aplicación; de lo contrario, false. De manera predeterminada, es false. Se puede reemplazar esta configuración para las páginas individuales si establece el atributo Trace de la directiva @ Page de una página en true o false. PageOutput true para mostrar el seguimiento tanto en páginas como en el visor de seguimiento (Trace.axd); de lo contrario, false. De manera predeterminada, es false. RequestLimit Número de solicitudes de seguimiento que se almacenan en el servidor. El valor predeterminado es 10. TraceMode Orden en que se muestra la información de seguimiento. Se establece en SortByTime para ordenar en el orden en el que se procesó la información. Establecer en SortByCategory para ordenar alfabéticamente por categorías definidas 96 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 por el usuario. De manera predeterminada, es SortByTime. LocalOnly true para hacer que el visor de seguimiento (Trace.axd) esté disponible sólo para el servidor Web de host; de lo contrario, false. De manera predeterminada, es true. MostRecent true para mostrar la información de traza más reciente como resultado de traza; de lo contrario, false. Si este valor es false, cuando se supera el valor de requestLimit, las nuevas solicitudes no se almacenan. De manera predeterminada, es false. Referencia de clase Clase Descripción System.Diagnostics.Trace La clase principal para implementar la traza. TraceContext Captura y muestra los detalles de ejecución acerca de una solicitud Web. 22 DEPURAR LOS PROBLEMAS DE IMPLEMENTACIÓN: ASPNET_REGIIS.EXE; CREACIÓN DE UNA APLICACIÓN WEB IIS; CONFIGURACIÓN DE LA VERSIÓN DE .NET FRAMEWORK Cuando se ejecutan varias versiones de .NET Framework simultáneamente en un único equipo, la versión de las API de servidor de Internet (ISAPI) de ASP.NET asignada a una aplicación ASP.NET determina qué versión de Common Language Runtime (CLR) se utiliza para la aplicación. La herramienta Registro de IIS en ASP.NET (Aspnet_regiis.exe) permite que un programa administrador o de instalación pueda actualizar fácilmente las asignaciones de secuencias de comandos de una aplicación ASP.NET para que señalen la versión de ISAPI (API de servidor de Internet) de ASP.NET asociada a la herramienta. Esta herramienta también se puede utilizar para mostrar el estado de todas las versiones de ASP. NET instaladas, para registrar la versión de ASP.NET que se corresponde con la herramienta, para crear directorios de secuencias de comandos de cliente y para realizar otras operaciones de configuración. Nota: .NET Framework incluye dos herramientas de registro de IIS: una para los sistemas estándar y otra para los sistemas de 64 bits. La herramienta para los sistemas de 64 bits está ubicada en el directorio Framework64 del directorio Microsoft.NET dentro de la carpeta Windows; por ejemplo, C:\WINDOWS\Microsoft.NET\Framework64\v2.0.50727 contiene la herramienta Registro de IIS. aspnet_regiis [opciones] Opción Descripción -c Instala las secuencias de comandos de cliente para ASP.NET en el subdirectorio aspnet_client de cada uno de los directorios de Internet Information Services (IIS), por ejemplo, secuencias de comandos de validación del cliente. Sólo se instalan las secuencias de comandos del cliente de la versión de ASP.NET asociada a Aspnet_regiis.exe. -disable Deshabilita ASP.NET en la consola de seguridad de IIS. Esta opción sólo se puede combinar con las opciones -i, -ir o -r. No está disponible con las versiones de IIS anteriores a la IIS 6.0. -e Quita las secuencias de comandos del cliente para ASP.NET del subdirectorio aspnet_client de cada uno de los directorios de sitio IIS. Sólo se quitan las secuencias de comandos del cliente de la versión de ASP.NET asociada a Aspnet_regiis.exe. -ea Quita las secuencias de comandos del cliente de todas las versiones de ASP.NET del subdirectorio aspnet_client de cada uno de los directorios de sitio IIS. -enable Habilita ASP.NET en la consola de seguridad de IIS. Esta opción sólo se puede combinar con las opciones -i, -ir o -r. No está disponible con las versiones de IIS anteriores a IIS 6.0 o con versiones de ASP.NET anteriores a la versión 2.0 de ASP.NET. -ga user Concede al usuario o grupo especificado acceso a la metabase de IIS y a otros directorios utilizados por ASP.NET. Esta opción no está disponible en las versiones de ASP.NET anteriores a la versión 2.0 de ASP.NET. -i Instala la versión de ASP.NET asociada a Aspnet_regiis.exe y actualiza las asignaciones de secuencias de comandos ubicadas en la raíz de la metabase de IIS y por debajo de ésta. Sólo se actualizan las asignaciones de secuencias de 97 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 comandos de las aplicaciones que utilizan una versión anterior de ASP.NET. Las aplicaciones que utilizan una versión posterior no se ven afectadas. -ir Instala la versión de ASP.NET asociada a Aspnet_regiis.exe y sólo registra ASP.NET en IIS. Esta opción no actualiza las asignaciones de secuencias de comandos. Para instalar ASP.NET y actualizar dichas asignaciones, utilice la opción -i. -k path Quita las asignaciones de secuencias de comandos (de todas las versiones de ASP.NET) de todas las aplicaciones ASP.NET ubicadas en la ruta de acceso raíz de la aplicación especificada y en los subdirectorios de la misma. -kn path Quita las asignaciones de secuencias de comandos (de todas las versiones de ASP.NET) solamente de la aplicación ASP.NET ubicada en la ruta de acceso raíz de la aplicación especificada. Esta opción no afecta a las aplicaciones de los subdirectorios de la path especificada. -lk Enumera la ruta de acceso y la versión de todas las claves de metabase de IIS asignadas a ASP.NET. No se muestran las claves que heredan asignaciones de secuencias de comandos de ASP.NET de una clave primaria. -lv Enumera el estado y la ruta de instalación de todas las versiones de ASP.NET instaladas en el equipo. - Impide el reinicio del Servicio de publicación en World Wide Web después de instalar o actualizar mapas de la secuencia norestart de comandos de ASP.NET. Si no utiliza esta opción, se reciclan todos los grupos de aplicaciones. Utilizar esta opción con las opciones -i o -r cuando se reinicie manualmente el proceso de trabajo de IIS. -r Actualiza todas las asignaciones de secuencias de comandos ubicadas en la metabase de IIS y por debajo de ésta para que señalen la versión de la ISAPI de ASP.NET asociada a Aspnet_regiis.exe. Todas las asignaciones de secuencias existentes se actualizan para señalar la versión ISAPI de ASP.NET asociada con la herramienta de registro IIS de ASP.NET, independientemente de la versión actual. -s path Instala la asignación de secuencias de comandos que señala la versión de la ISAPI de ASP.NET asociada a Aspnet_regiis.exe en todas las aplicaciones ASP.NET ubicadas en la ruta de acceso raíz especificada de la aplicación y en sus subdirectorios. Se actualizan todas las asignaciones de secuencias de comandos de la ruta de acceso especificada y por debajo de ésta que utilicen una versión anterior de la ISAPI de ASP.NET. -sn path Instala la asignación de secuencias de comandos que señala la versión de la ISAPI de ASP.NET asociada a la herramienta de la aplicación ASP.NET que se encuentra en la ruta de acceso raíz especificada de la aplicación. Se actualizan todas las asignaciones de secuencias de comandos de la ruta de acceso especificada que utilicen una versión anterior de la ISAPI de ASP.NET. Esta opción no afecta a las aplicaciones de los subdirectorios de path. -u Desinstala la versión de ASP.NET que está asociada con la herramienta de registro IIS de ASP .NET del equipo. Las asignaciones de secuencias de comandos de esta versión de la ISAPI de ASP.NET vuelven a asignarse automáticamente a la versión más reciente de la ISAPI de ASP.NET instalada. -ua Desinstala todas las versiones de ASP.NET del equipo. -? Muestra la sintaxis de comandos y las opciones de la herramienta de registro IIS de ASP.NET. OPCIONES DE CONFIGURACIÓN Opción Descripción -config+ Permite el acceso remoto a la configuración de ASP.NET en el equipo. -config- Deshabilita el acceso remoto a la configuración de ASP.NET en el equipo. -pa cuenta del contenedor Concede a la account del usuario o grupo especificado permiso para tener acceso al container de clave especificado. Este argumento acepta los modificadores opcionales siguientes: -pku Sustituye un contenedor especificado por el usuario por el contenedor de equipo predeterminado. - csp provider Especifica el proveedor de contenedores que se va a utilizar. -full Especifica que se debería agregar acceso total, en lugar del acceso de sólo lectura predeterminado. 98 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 -pc contenedor Crea un par de claves RSA públicas/privadas en el contenedor especificado. Este argumento acepta los modificadores opcionales siguientes: -size keySize Especifica el tamaño de la clave. El valor predeterminado son 1024 bytes. –pku Sustituye un contenedor especificado por el usuario por el contenedor de claves predeterminado en el equipo. –exp Especifica las claves privadas que deben poder exportarse. -csp provider Especifica el proveedor de contenedores que se va a utilizar. -pd sección Descifra la sección de configuración. Este argumento acepta los parámetros opcionales siguientes: app virtualPath Especifica que el descifrado debería producirse en el nivel de la ruta de acceso incluida. -location subPath Especifica el subdirectorio para descifrar. -pkm Especifica que debería descifrarse el archivo Machine.config en lugar del archivo Web.config. -pdf sección Descifra la sección de configuración especificada del archivo Web.config en el directorio físico (no webApplicationDirectory virtual) especificado. -pe sección Cifra la sección de configuración especificada. Este argumento acepta los modificadores opcionales siguientes: -prov provider Especifica el proveedor de cifrado que se va a utilizar. - app virtualPath Especifica que el cifrado debería producirse en el nivel de la ruta de acceso incluida. location subPath Especifica el subdirectorio para cifrar. -pkm Especifica que debería cifrarse el archivo Machine.config en lugar del archivo Web.config. -pef section Cifra la sección de configuración especificada del archivo Web.config en el directorio físico (no virtual) webApplicationDirectory especificado. -pi archivo contenedor Importa un par de claves RSA públicas/privadas al container especificado desde el file XML especificado. Este argumento acepta los modificadores opcionales siguientes: -pku Sustituye un contenedor especificado por el usuario por el contenedor de equipo predeterminado. -exp Especifica que se pueden exportar claves privadas. -csp provider Especifica el proveedor de contenedores que se va a utilizar. -pr cuenta del contenedor Quita el permiso para la account del usuario o grupo especificado para tener acceso al container de clave especificado. Este argumento acepta los modificadores opcionales siguientes: -pku Sustituye un contenedor especificado por el usuario por el contenedor de equipo predeterminado. - csp provider Especifica el proveedor de contenedores que se va a utilizar. -px archivo contenedor Exporta un par de claves RSA públicas/privadas del contenedor especificado al archivo XML especificado. Este argumento acepta los modificadores opcionales siguientes: -pku Sustituye un contenedor especificado por el usuario por el contenedor de equipo predeterminado. - csp provider Especifica el proveedor de contenedores que se va a utilizar. -pz contenedor Elimina el contenedor de claves especificado. Este argumento acepta el modificador opcional siguiente:pku Sustituye un contenedor especificado por el usuario por el contenedor de equipo predeterminado 23 SUPERVISAR APLICACIONES WEB: SUPERVISIÓN DE LA SALUD UTILIZANDO WEBEVENT, CONTADORES DE RENDIMIENTO La supervisión de estado de ASP.NET proporciona una manera fácil de supervisar el estado de una aplicación ASP.NET y de obtener información detallada en tiempo de ejecución sobre los recursos de ASP.NET (para instrumentar la aplicación). La supervisión de estado contiene clases de eventos de supervisión de estado web (eventos web) y proveedores de supervisión de estado (agentes de escucha) listos para usar. Los eventos web empaquetan información de eventos de estado. Los proveedores realizan escuchas en los eventos y consumen la información de evento, normalmente mediante el registro de la información o su notificación a un administrador. Puede conectar un evento web a un proveedor (lo que se denomina habilitar el evento) si establece la configuración en el archivo de configuración de la aplicación. El sistema de supervisión System.Web.Management. de estado de ASP.NET se implementa mediante clases en el espacio de nombres 99 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Configurar la supervisión de estado en ASP.NET Se puede configurar las aplicaciones para que usen proveedores de supervisión integrados o personalizados que procesen esta información de supervisión de estado e informen sobre el estado y las características de rendimiento de la aplicación instrumentada. Los proveedores y eventos web se agregan a una aplicación mediante la configuración de la sección healthMonitoring del archivo de configuración. A continuación usa clases integradas o personalizadas para realizar escuchas de los datos de evento y procesarlos. Jerarquía de clases de eventos web Cuando se provoca un evento Web, se crea una instancia de la clase de evento asociada. Los datos del evento se recogen en las propiedades de este objeto. Los proveedores de eventos procesan estos datos. Los eventos Web pueden contener información sobre el proceso de trabajo, el dominio de aplicación, los datos de solicitud, los datos de respuesta, los errores de aplicación y de configuración, así como los eventos de auditoría. Todas las clases de evento secundarias heredan la información de estado de una clase de evento primaria. En la siguiente ilustración se muestran las relaciones entre las clases de eventos web. Jerarquía de clases de eventos Web Jerarquía de clases de proveedores ASP.NET incluye proveedores integrados que se pueden utilizar para procesar los eventos Web. También se puede heredar de las clases integradas para crear un proveedor personalizado, sujeto a las siguientes limitaciones de herencia: Las aplicaciones que se ejecutan con cualquier nivel de confianza pueden heredar la clase WebEventProvider. 100 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Las aplicaciones que se ejecutan con cualquier nivel de confianza pueden heredar la clase BufferedWebEventProvider. Sólo las aplicaciones que se ejecutan con plena confianza pueden heredar la clase SqlWebEventProvider. Las demás clases no las pueden heredar las aplicaciones, independientemente del nivel de confianza. La siguiente ilustración muestra la relación entre las clases de proveedor web del espacio de nombres System.Web.Management. USAR LOS EVENTOS DE SUPERVISIÓN DE ESTADO DE ASP.NET Se Puede trabajar con los eventos de supervisión de estado de ASP.NET de las maneras siguientes: Utilizar clases de proveedor y de evento Web integradas. Normalmente, no será necesario proporcionar implementaciones personalizadas de las clases de evento web de ASP.NET. Tener en cuenta que la aplicación no provoca estos eventos sino que lo hace .NET Framework. Crear clases personalizadas para eventos web o proveedores. Los eventos web personalizados normalmente se crean cuando se debe anexar información personalizada a la que ya proporcionan los eventos web integrados. Los proveedores personalizados se crean normalmente si se desea entregar los datos de eventos a través de un mecanismo distinto del que proporcionan los proveedores integrados. UTILIZAR EVENTOS WEB Y PROVEEDORES INTEGRADOS El uso de eventos web integrados y proveedores para la supervisión de estado es la estrategia más común. Sólo se requiere configurar la aplicación para usar los eventos y proveedores necesarios. Se debe hacer lo siguiente: Agregar la clase de evento web integrada de ASP.NET que necesita al elemento eventMappings de la sección healthMonitoring en el archivo de configuración de la aplicación. Agregar el proveedor que utilice el evento al elemento providers de la sección healthMonitoring. Agregar un elemento al elemento rules que define la asociación entre el evento y el proveedor. De forma predeterminada, las clases de supervisión de estado integradas de ASP.NET se configuran en la sección healthMonitoring del archivo Web.config de la raíz. En la sección healthMonitoring se establece la siguiente configuración predeterminada: Todas las clases de evento Web que se deriven de WebBaseEvent se especifican en el elemento eventMappings. Esta sección se utiliza para asignar un nombre descriptivo a un grupo de clases de evento. Todas las clases de evento que derivan de WebBaseEvent se incluyen al menos en uno de los grupos definidos en el elemento eventMappings. 101 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Los proveedores de eventos EventLogWebEventProvider, WmiWebEventProvider y SqlWebEventProvider se especifican en el elemento providers. Se puede especificar otros proveedores integrados en el elemento providers, como las clases SimpleMailWebEventProvider, TemplatedMailWebEventProvider o TraceWebEventProvider. Las reglas que asocian el error Web y los eventos de error de auditoría a las clases EventLogWebEventProvider se especifican en el elemento rules. Se puede habilitar otros eventos web y proveedores si agrega más elementos rules. Un evento se considera habilitado si está asignado a un proveedor de eventos en el elemento rules. Debe configurar los elementos eventMappings y providers para el evento pero, a menos que ambos estén conectados en el elemento rules, el evento no estará habilitado. Se pueden especificar los valores de parámetro de los elementos configurados. Entre los ejemplos se incluyen parámetros que limitan el número de eventos que se pueden producir, que especifican el intervalo entre dos eventos o que especifican las opciones de almacenamiento en búfer de los eventos para los proveedores de correo y SQL. 24 IMPLEMENTAR FORMULARIOS WEB UTILIZANDO ASP.NET AJAX: EnablePartialRendering, ChildrenAsTriggers, Scripts, Services, UpdateProgress, Timer, ScriptManagerProxy Triggers, El control ScriptManager administra el script de cliente de las páginas web ASP.NET habilitadas para AJAX. De forma predeterminada, el control ScriptManager registra el script de Microsoft AJAX Library con la página. Esto permite al script de cliente usar las extensiones del sistema de tipos y admitir características como la representación parcial de páginas y las llamadas a servicios web. Escenarios Se debe usar un control ScriptManager en una página para habilitar las siguientes características AJAX de ASP.NET: Funcionalidad del script de cliente de Microsoft AJAX Library y cualquier script personalizado que desee enviar al explorador. Representación parcial de páginas, que permite actualizar de forma independiente regiones de la página sin una devolución de datos. Los controles ASP.NET UpdatePanel, UpdateProgress y Timer requieren un control ScriptManager para admitir la representación parcial de página. Clases de proxy de JavaScript para servicios web, que permiten usar script de cliente para tener acceso a servicios web y, en especial, a métodos marcados en páginas ASP.NET. Esto se consigue mediante la exposición de los servicios web y los métodos de página como objetos con establecimiento inflexible de tipos. Clases JavaScript para tener acceso a los servicios de aplicación de autenticación, perfil y funciones de ASP.NET. Información general Si una página contiene uno o varios controles UpdatePanel, el control ScriptManager administra la representación parcial de la página en el explorador. El control interactúa con el ciclo de vida de la página para actualizar las partes de la página que están dentro de los controles UpdatePanel. La propiedad EnablePartialRendering del control ScriptManager determina si una página participa en actualizaciones parciales de la página. De forma predeterminada, la propiedad EnablePartialRendering es true. Por tanto, la representación parcial de página está habilitada de forma predeterminada al agregar un control ScriptManager a la página. Administrar errores de representación parcial de páginas Durante la representación parcial de páginas, se puede administrar los errores de la manera siguiente: Establecer la propiedad AllowCustomErrorsRedirect. De esta forma determina cómo se usa la sección de errores personalizada del archivo Web.config cuando se produce un error durante una devolución de datos asincrónica. Administrar el evento AsyncPostBackError del control ScriptManager, que se provoca cuando hay un error de página durante una devolución de datos asincrónica. Establecer la propiedad AsyncPostBackErrorMessage, que es el mensaje de error que se envía al explorador. Usar las extensiones del sistema de tipos Microsoft AJAX Library agrega extensiones del sistema de tipos, que proporcionan espacios de nombres, herencia, interfaces, enumeraciones, reflexión y funciones auxiliares para las cadenas y matrices, a JavaScript. Estas extensiones proporcionan funcionalidad en el script de cliente similar a la de .NET Framework. Permiten escribir aplicaciones ASP.NET habilitadas para AJAX de una manera estructurada que mejora el mantenimiento, facilita la incorporación de características y facilita la funcionalidad de 102 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 capas. Al agregar un control ScriptManager a una página web ASP.NET se incluyen automáticamente las extensiones del sistema de tipos, de forma que puede usar la biblioteca en el script de cliente. Registrar script personalizado Usar el control ScriptManager para administrar recursos que se han creado para los controles que participan en actualizaciones parciales de la página. Los recursos incluyen scripts, estilos, campos ocultos y matrices. La colección Scripts del control ScriptManager contiene un objeto ScriptReference por cada script disponible en el explorador. Se puede especificar los scripts mediante declaración o mediante programación. El control ScriptManager también expone métodos de registro que puede usar para administrar script de cliente y campos ocultos mediante programación. Si se registra script o campos ocultos que admiten las actualizaciones parciales de página, se debe llamar a los métodos de registro del control ScriptManager. (Para registrar scripts que no se necesitan en las actualizaciones parciales de página, se usan métodos de la clase ClientScriptManager.) Nota: Los scripts de la página que se registran con el control ScriptManager y todo el script de control de eventos deben estar dentro del elemento form de la página. De lo contrario el script no se registrará ni ejecutará. Registrar servicios web Para registrar un servicio web que se desea llamar desde una página ASP.NET habilitada para AJAX, se agrega a la colección Services del control ScriptManager para registrarlo. El marco de trabajo de ASP.NET AJAX genera un objeto proxy de cliente para cada objeto ServiceReference de la colección Services. Las clases de proxy y sus miembros con establecimiento inflexible de tipos simplifican el uso de servicios web desde el script de cliente. Se puede agregar mediante programación los objetos ServiceReference a la colección Services para registrar servicios web en tiempo de ejecución. Usar servicios de autenticación, perfil y función desde script de cliente Microsoft AJAX Library incluye clases de proxy para llamar directamente a los servicios de aplicación de autenticación de formularios, perfil y funciones de ASP.NET 2.0 desde JavaScript. Si se desea usar un servicio de autenticación personalizado, se puede registrar con el control ScriptManager. Clase ScriptManagerProxy Sólo se puede agregar una instancia del control ScriptManager a la página. La página puede incluir directamente el control o bien indirectamente dentro de un componente anidado como un control de usuario, página de contenido de una página maestra o una página maestra anidada. Si una página ya contiene un control ScriptManager, pero un componente anidado o principal necesita características adicionales del control ScriptManager, el componente puede incluir un control ScriptManagerProxy. Por ejemplo, el control ScriptManagerProxy permite agregar scripts y servicios específicos de los componentes anidados. CONTROL TIMER El control Timer de ASP.NET AJAX realiza devoluciones de datos en intervalos definidos. Al utilizar el control Timer con un control UpdatePanel, se puede habilitar actualizaciones parciales de página en un intervalo definido. También se puede utilizar el control Timer para enviar toda la página. Utilizar el control Timer cuando se desea hacer lo siguiente: Actualizar periódicamente el contenido de uno o varios controles UpdatePanel sin actualizar la página web entera. Ejecutar código en el servidor cada vez que un control Timer origine una devolución de datos. Enviar sincrónicamente la página web entera al servidor web en intervalos definidos. El control Timer es un control de servidor que incrusta un componente JavaScript en la página web. El componente JavaScript inicia la devolución de datos desde el explorador cuando transcurre el intervalo que se define en la propiedad Interval. Las propiedades del control Timer se establecen en código que se ejecuta en el servidor y se pasan al componente JavaScript. Cuando se utilice el control Timer, se debe incluir una instancia de la clase ScriptManager en la página web. Cuando el control Timer inicia una devolución de datos, el control Timer provoca el evento Tick en el servidor. Puede crear un controlador de eventos para que el evento Tick realice acciones cuando la página se envíe al servidor. 103 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Establecer la propiedad Interval para especificar la frecuencia con que deben producirse las devoluciones de datos y establecer la propiedad Enabled para activar o desactivar el control Timer. La propiedad Interval se define en milisegundos y presenta un valor predeterminado de 60.000 milisegundos, o 60 segundos. Nota: Si se establece la propiedad Interval de un control Timer en un valor pequeño, puede generar mucho tráfico al servidor web. Usar el control Timer para actualizar el contenido sólo con la frecuencia necesaria. Se puede incluir más de un control Timer en una página web si es necesario actualizar distintos controles UpdatePanel en intervalos diferentes. Como alternativa, una instancia única del control Timer puede usarse como desencadenador de más de un control UpdatePanel en una página web. CONTROL UPDATE PANEL Los controles de ASP.NET UpdatePanel permiten generar aplicaciones web enriquecidas y centradas en el cliente. Los controles UpdatePanel permiten actualizar las partes seleccionadas de una página en lugar de actualizar toda la página con una devolución de datos. Esto se conoce como actualización parcial de la página. Una página web ASP.NET que contiene un control ScriptManager y uno o varios controles UpdatePanel puede participar automáticamente en actualizaciones parciales de la página, sin un script de cliente personalizado. UpdatePanel es un control de servidor que ayuda a desarrollar páginas web con comportamientos de cliente complejos que hacen que una página web parezca más interactiva al usuario final. Normalmente, escribir código que se coordine entre el servidor y el cliente para actualizar sólo las partes especificadas de una página web requiere un conocimiento detallado de ECMAScript (JavaScript). Sin embargo, con el control UpdatePanel puede hacer que una página web participe de las actualizaciones parciales de la página sin escribir ningún script de cliente. Si se desea, se puede agregar el script de cliente personalizado para mejorar la experiencia del usuario cliente. Cuando se utiliza un control UpdatePanel, el comportamiento de la página es independiente del explorador y puede reducir la cantidad de datos que se transfieren entre el cliente y el servidor. Los controles UpdatePanel trabajan especificando las regiones de una página que se pueden actualizar sin actualizar la página entera. Este proceso se coordina mediante el control de servidor ScriptManager y la clase de cliente PageRequestManager. Cuando están habilitadas las actualizaciones parciales de la página, los controles pueden exponer en el servidor de forma asincrónica. Una devolución de datos asincrónica se comporta como una devolución de datos normal en cuanto que la página de servidor resultante ejecuta la página completa y controla el ciclo de vida. Sin embargo, con una devolución de datos asincrónica, las actualizaciones de la página se limitan a las regiones de la página que están incluidas en los controles UpdatePanel y que están marcadas para actualizarse. El servidor envía el marcado HTML al explorador sólo para los elementos implicados. En el explorador, la clase de cliente PageRequestManager realiza la manipulación del Modelo de objetos de documento (DOM) para reemplazar el código HTML existente por un marcado actualizado. Nota: Al utilizar devoluciones de datos asincrónicas o el objeto XMLHTTPRequest, se puede producir un error de devolución de datos si la dirección URL contiene un carácter de doble byte. Se puede resolver este problema incluyendo un elemento de <base href="url"/> en el elemento head de la página, donde el atributo href está establecido en la cadena con codificación URL que hace referencia a la página. Se puede agregar este elemento agregado dinámicamente en el código de servidor. Habilitar actualizaciones parciales de la página El control UpdatePanel requiere un control ScriptManager en la página web. De forma predeterminada, las actualizaciones parciales de la página están habilitadas porque el valor predeterminado de la propiedad EnablePartialRendering del control ScriptManager es true. Especificar el contenido del control UpdatePanel Se puede agregar contenido a un control UpdatePanel mediante declaración, o bien en el diseñador utilizando la propiedad ContentTemplate. En el marcado, esta propiedad se expone como un elemento ContentTemplate. Para agregar contenido mediante programación, se utiliza la propiedad ContentTemplateContainer. Cuando se representa por primera vez una página que contiene uno o varios controles UpdatePanel, se representa todo el contenido de los controles UpdatePanel y se envían al explorador. En las devoluciones de datos asincrónicas posteriores, el contenido de los controles UpdatePanel individuales podría actualizarse. Las actualizaciones dependen de las opciones de configuración del panel, de qué elemento produjo la devolución de datos y del código específico de cada panel. 104 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 ESPECIFICAR LOS DESENCADENADORES (TRIGGERS) DE UPDATEPANEL De forma predeterminada, cualquier control de devolución de datos dentro de un control UpdatePanel produce una devolución de datos asincrónica y actualiza el contenido del panel. Sin embargo, también puede configurar otros controles de la página para actualizar un control UpdatePanel. Para ello, defina un desencadenador para el control UpdatePanel. Un desencadenador es un enlace que especifica qué evento y control de devolución de datos provoca la actualización de un panel. Cuando se provoca el evento especificado del control desencadenador (por ejemplo, un evento Click de un botón), se actualiza el panel. En el ejemplo siguiente se muestra cómo especificar un desencadenador para un control UpdatePanel. <asp:Button ID="Button1" Text="Refresh Panel" runat="server" /> <asp:ScriptManager ID="ScriptManager1" runat="server" /> <asp:UpdatePanel ID="UpdatePanel1" UpdateMode="Conditional" runat="server"> <Triggers> <asp:AsyncPostBackTrigger ControlID="Button1" /> </Triggers> <ContentTemplate> <fieldset> <legend>UpdatePanel content</legend> <%=DateTime.Now.ToString() %> </fieldset> </ContentTemplate> </asp:UpdatePanel> El desencadenador se define utilizando el elemento asp:AsyncPostBackTrigger dentro del elemento Triggers del control UpdatePanel. (Editando la página en Visual Studio, se puede crear desencadenadores utilizando el cuadro de diálogo Editor de la colección UpdatePanelTrigger.) El evento de control de un desencadenador es opcional. Si no se especifica un evento, el evento desencadenador es el evento predeterminado del control. Por ejemplo, en el control Button, el evento predeterminado es el evento Click. Cómo se actualizan los controles UpdatePanel En la lista siguiente se describen los valores de las propiedades del control UpdatePanel que determinan cuándo se actualiza el contenido de un panel durante la representación parcial de la página. 105 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Si la propiedad UpdateMode se establece en Always, el contenido del control UpdatePanel se actualiza en todas las devoluciones de datos que se originen desde cualquier parte de la página. Esto incluye las devoluciones de datos asincrónicas de los controles que están dentro de otros controles UpdatePanel y las devoluciones de datos de los controles que no están dentro de los controles UpdatePanel. Si la propiedad UpdateMode es Conditional, el contenido del control UpdatePanel se actualiza cuando se da una de las siguientes condiciones: Cuando un desencadenador produce la devolución de datos para ese control UpdatePanel. Cuando se llama explícitamente al método Update del control UpdatePanel. Cuando se anida el control UpdatePanel dentro de otro control UpdatePanel y se actualiza el panel primario. Cuando la propiedad ChildrenAsTriggers se establece en true y un control secundario del control UpdatePanel provoca una devolución de datos. Los controles secundarios de los controles UpdatePanel anidados no provocan actualizaciones del control UpdatePanel externo a menos que se definan explícitamente como desencadenadores para el panel primario. Si la propiedad ChildrenAsTriggers se establece en false y la propiedad UpdateMode se establece en Always, se inicia una excepción. La propiedad ChildrenAsTriggers está diseñada para usarse sólo cuando la propiedad UpdateMode se establezca en Conditional. Utilizar los controles UpdatePanel en páginas maestras Para utilizar un control UpdatePanel en una página maestra, se debe decidir cómo incluirá el control ScriptManager. Si incluye el control ScriptManager en la página maestra, puede actuar como control ScriptManager de todas las páginas de contenido. (Si desea registrar scripts o servicios mediante declaración en una página de contenido, puede agregar un control ScriptManagerProxy a esa página de contenido.) Si la página maestra no contiene el control ScriptManager, se puede colocar el control ScriptManager individualmente en cada página de contenido que contenga un control UpdatePanel. La opción de diseño depende de cómo se administre el script de cliente en su aplicación. En algunos casos, el control ScriptManager está en la página maestra y no necesita funciones de representación parcial de la página para una página de contenido. En esos casos, debe establecer mediante programación la propiedad EnablePartialRendering del control ScriptManager en false para esa página de contenido. 25 INTERACTUAR CON LA BIBLIOTECA EN EL CLIENTE ASP.NET AJAX: objetos JavaScript Object Notation (JSON); tratamiento de eventos ASP.NET AJAX INTRODUCCIÓN Al diseñar una aplicación que se comunicará con un equipo remoto, se debe seleccionar un protocolo para el formato e intercambio de los datos. Existe una variedad de opciones abiertas y estandarizadas y la elección ideal depende de los requisitos de las aplicaciones y de la funcionalidad preexistente. Por ejemplo, los servicios web basados en SOAP dan formato a los datos en una carga XML contenida en una envoltura SOAP. Aunque en muchos escenarios de aplicación XML funciona bien, presenta ciertos inconvenientes que hacen que no sea ideal. Las aplicaciones web de estilo Ajax son un espacio en que XML no es ideal. Ajax es una técnica usada para crear aplicaciones web interactivas que ofrecen una experiencia de usuario más ágil mediante el uso de llamadas al servidor web, livianas y fuera de banda, en lugar de devoluciones de página completa. Estas llamadas asincrónicas se inician mediante Javascript en el cliente e implican dar formato a los datos, enviarlos a un servidor web, analizar los datos devueltos y trabajar con éstos. Aunque la mayoría de los exploradores pueden crear, enviar y analizar XML, JavaScript Object Notation (JSON) ofrece un formato estandarizado de intercambio de datos más conveniente para aplicaciones web de estilo Ajax. JSON es un formato de intercambio de datos abierto y basado en texto (RFC 4627). Igual que XML, es legible e independiente de la plataforma, además de tener a su disposición una amplia gama de implementaciones. Los datos con formato según el estándar JSON son ligeros y las implementaciones de JavaScript pueden analizarlos sintácticamente con increíble facilidad, lo que lo convierte en el formato ideal de intercambio de datos para aplicaciones web de Ajax. Puesto que JSON es ante todo un formato de 106 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 datos, no está limitado a las aplicaciones web de Ajax y prácticamente se puede usar en cualquier escenario en que las aplicaciones necesiten intercambiar o almacenar información estructurada como texto. UTILIZANDO SINTAXIS JSON CON AJAX JavaScript Object Notation, o JSON, es una sintaxis utilizada para representar datos. JSON es un subconjunto de JavaScript y consiste de pares clave-valor. JSON está basado en texto y utiliza Unicode. JSON anida elementos de datos de una manera similar a XML. Cada instancia de un documento JSON describe un objeto con objetos anidados, arreglos, strings, números, valores booleanos o valores nulos. JSON es ideal para intercambio de datos con Servicios Web. La sintáxis de JSON es definida en http://www.json.org. Existen varias maneras de utilizar JSOB como un formato de intercambio de datos. Para invocar a un servicio desde una página web ASP.Net se añade un elemento ServiceReference a un control ScriptManager. Esto automáticamente genera una clase proxy de JavaScript. Cuando se utiliza una clase proxy para invocar un servicio, JSON es utilizado como un formato de serialización para los datos intercambiandos entre el servidor y el navegador. Las páginas Web que no son ASP.Net .aspx no pueden utilizar un ScriptManager. DEVOLVIENDO DATOS EN UN FORMATO JSON DESDE UN SERVICIO WEB ASP.NET SOBRE HTTP Para habilitar un servicio Web ASP.Net para devolver datos en un formato JSON en HTTP, se puede marcar la clase del Servicio Web con el atributo ScriptService el cual se encuentra en el espacio de nombres Sytem.Web.Script.Services. El atributo ScriptService fue introducido en la versión 3.5 de ASP.Net. El siguiente ejemplo muestra como agregar el atributo ScriptService a la clase del servicio web para habilitar el servicio para devolver los datos en un formato JSON. 1. using System; 2. using System.Web.Services; 3. using System.Web.Script.Services; 4. [WebService(Namespace = "http://tempuri.org/")] 5. [ScriptService] 6. public class Service : System.Web.Services.WebService 7. { 8. [WebMethod] 9. public string HelloWorld() 10. { 11. return "Hello World"; 12. } 13. } Se puede invocar el método del servicio directamente utilizando el método de Sys.Net.WebServiceProxy, como se muestra en el siguiente ejemplo: 1. 2. Sys.Net.WebServiceProxy.invoke("myservice.asmx", "HelloWorld", true, null, succeededCallback, failedCallback); 107 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 El servicio devuelve datos en un formato JSON. Cuando el requerimiento retorna, los datos en formato JSON son evaluados y pasados al objeto o arreglo JavaScript a la función que es especificada en el parámetro succeededCallback. Agregando el atributo ScriptService también habilita al Servicio Web ASP.Net para automáticamente crear una clase de proxy JavaScript. Referenciando el servicio web y agregando “/js” a la referencia del script, se puede causar a ASP.Net a generar la clase de proxy automáticamente. Por ejemplo, si un Servicio Web ASP.Net se encuentra en un archivo llamado Service.asmx, se puede crear la siguiente referencia al script en lenguaje de marcado. 1. <script type="text/javascript" src="service.asmx/js"></script> También es posible guardar la clase de proxy generada de JavaScript colocando en nombre del archivo del servicio web en el navegador con la extensión “/js” y luego almacenando el archivo de proxy cuando se requiera. Esto permite utilizar la clase del proxy del JavaScript para invocar el servicio llamando al método directamente en el objeto proxy. De nuevo, la data formateada en JSON es devuelta, y luego evaluada y psada como un obejto o un arreglo a la función de callback invocada. ENTENDIENDO EL PARÁMETRO ‘D’ EN LOS DATOS ASP.NET AJAX JSON Si se crea una implementación personalizada que devuelve datos en un formato JSON, se debe tener encuenta el potencial hueco de seguridad. La librería de AJAX ASP.Net envuelve los datos formateados para evitar este problema de seguridad. Un arreglo de objetos JSON puede comprometer la página a un posible ataque de los scripts. Enviando un requerimiento a un servicio JSON como un script, es posible obtener los datos de otro dominio ejecutándose en la sección del cliente. Potencialmente, esto podría proveer accesos a otros sitios donde el cliente se encuentra loggeado en un punto en el tiempo. Debido que la respuesta al requerimiento es en JSON, esto es compilado en una instrucción JavaScript. Por ejemplo, si la respuesta es un conjunto de balances de cuentas bancarias: “$1234.56”, “$4567.34”,”6543.76”, un script malicioso podría tener acceso a estos datos debido a ser una instrucción validad JavaScript. Si un script es inyectado en el sitio contoso.com que requiere datos del bancoxxx.com y se lo envía a espia.datos.com, cualquiera que realice un inicio de sesión en espia.datos.com y luego se dirija a contoso.com podría exponer datos sensitivos a la sesión de bancoxxx.com a espia.datos.com La librería AJAX de Asp.Net utiliza el parámetro “d” para formatear los datos JSON. Esto forza a los datos en el ejemplo a aparecer en la siguiente forma, el cual mno es una instrucción JavaScript valida. 1. { "d" : ["$1234.56", "$4567.34", "$6543.76"] } Porque este script no es una instrucción Javascript valida, no puede ser parseada e instanciada como un objeto nuevo en JavaScript. Esto por lo tanto previene los ataques. El formateo con el parámetro “d” es transperante cuando se utiliza la configuración de la opción enableWebScript en conjunto con los atributos webHttpBinding y WebInvoke. El formateo con el parámetro “d” no es utilizado (y por lo tanto, los datos son vulnerables a los huecos de seguridad) cuando se configura el comportamiento del archivo de configuración a webHttp. AJAX DE ASP.NET: INTERIOR DE LA CADENA DE FECHA Y HORA DE JSON El serializador JSON de AJAX en ASP.NET codifica una instancia DateTime como cadena JSON. Durante sus ciclos preliminares, AJAX de ASP.NET usó el formato "@ticks@", donde ticks representa el número de milisegundos desde el 1 de enero de 1970 en Horario universal coordinado (UTC). Una fecha y hora en UTC como el 29 de noviembre de 1989, a las 4:55:30 a. m. se escribiría como "@62831853071@". Aunque es simple y sencillo, este formato no puede distinguir un valor serializado de fecha y hora de una cadena que se parezca a una fecha serializada pero que no esté pensada para ser deserializada como tal. Consecuentemente, el equipo de AJAX de ASP.NET hizo un en la versión final para solucionar este problema al adoptar el formato "\/Date(ticks)\/". El nuevo formato depende de un pequeño truco para reducir la posibilidad de una mala interpretación. En JSON, un carácter de barra diagonal (/) en una cadena se puede escapar con una barra diagonal inversa (\) aunque estrictamente no sea necesario. Para aprovechar esta situación, el equipo de AJAX de ASP.NET modificó JavaScriptSerializer para escribir en su lugar una instancia de DateTime como la cadena "\/Date(ticks)\/". El escape de las dos barras diagonales es superficial, pero importante para JavaScriptSerializer. Según las reglas de JSON "\/Date(ticks)\/" es técnicamente equivalente a "/Date(ticks)/" pero JavaScriptSerializer deserializará la primera como DateTime y la última como String. Por lo tanto, las posibilidades de ambigüedad son considerablemente menores cuando se comparan con el formato más sencillo "@ticks@" de las versiones preliminares. 108 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 26 USAR SERVICIOS DE SCRIPTS DE CLIENTE CONSUMO DE SERVICIOS DE DATOS MEDIANTE LA BIBLIOTECA AJAX DE ASP.NET En la biblioteca Ajax de ASP.NET, existen dos componentes de JavaScript relacionados con los servicios de datos de WCF: OpenDataServiceProxy y OpenDataContext. OpenDataContext está esencialmente diseñado para administrar las operaciones CRUD desde el cliente web. Se puede considerar como la contraparte JavaScript de la clase DataServiceContext. DataServiceContext, definido en el espacio de nombres System.Data.Services.Client, representa el contexto de tiempo de ejecución del servicio de datos de WCF especificado. OpenDataContext hace un seguimiento a los cambios en las entidades que se utilizan y puede generar de forma inteligente comandos con respecto al servicio back-end. La clase OpenDataServiceProxy está diseñada para ser un proxy adicional ligero para un servicio de datos de WCF. Esencialmente administra escenarios de sólo lectura, pero se puede utilizar para invocar operaciones de servicio adicionales expuestas en el servicio. La clase OpenDataServiceProxy se inicializa de la siguiente manera: var proxy = new Sys.Data.OpenDataServiceProxy(url); En este punto, la clase está en funcionamiento. Normalmente, es necesario invertir más tiempo en la configuración de un objeto OpenDataContext. Aunque, en lo que respecta a la conexión al servicio, sucede de una manera similar: var dataContext = new Sys.Data.OpenDataContext(); dataContext.set_serviceUri(url); Ambas clases se pueden usar como proveedores de datos para DataView. El uso de una u otra depende de lo que se desee hacer. Si cualquier actividad CRUD debe suceder mediante el servicio, probablemente sea mejor utilizar un proxy. Si se tiene lógica en el cliente y el propósito es efectuar un grupo de operaciones CRUD antes de aplicar los cambios, entonces se recomienda usar contexto de datos. A continuación se detalla OpenDataContext. USO DE LA CLASE OPENDATACONTEXT A continuación, se indica cómo crear e inicializar una instancia de la clase OpenDataContext: <script type="text/javascript"> var dataContext; Sys.require([Sys.components.dataView, Sys.components.openDataContext]); Sys.onReady(function() { dataContext = Sys.create.openDataContext( { serviceUri: "/NorthwindService.svc", mergeOption: Sys.Data.MergeOption.appendOnly }); }); 109 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 </script> Se debe tener en cuenta el uso de la función Sys.require para vincular de forma dinámica sólo los archivos de script que cumplen el propósito de los componentes que se utilizan. Si se opta por el enfoque Sys.require, el único archivo de script necesario para vincular en la forma tradicional es start.js: <script src="../../Scripts/MicrosoftAjax/Start.js" type="text/javascript"> </script> Sin embargo, todos los archivos que se utilicen deben estar disponibles en el servidor o se debe hacer referencia a ellos a través de la red de entrega de contenido de Microsoft (CDN). En el fragmento code 2, se puede observar que en el evento preparado del documento, se puede crear una nueva instancia de la clase OpenDataContext. Una vez más se debe tener en cuenta el uso de la sintaxis abreviada más reciente para definir código para eventos comunes y crear una instancia de objetos comunes. La fábrica de la clase OpenDataContext recibe la dirección URL del servicio y alguna configuración adicional. En este punto, se está preparado para usar el contexto de datos como el proveedor de datos para algunos componentes de UI DataView de la página, como se muestra en el fragmento code 1. code 1 Uso de contexto de datos como un proveedor de datos <table> <tr class="tableHeader"> <td>ID</td> <td>Name</td> <td>Contact</td> </tr> <tbody sys:attach="dataview" class="sys-template" dataview:dataprovider="{{ dataContext }}" dataview:fetchoperation="Customers" dataview:autofetch="true"> <tr> <td>{{ CustomerID }}</td> <td>{{ CompanyName }}</td> <td>{{ ContactName }}</td> </tr> </tbody> </table> 110 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Una instancia del componente DataView se crea y utiliza para rellenar la plantilla a la cual está adjunto. DataView proporciona el código adjunto necesario para descargar los datos mediante el servicio de datos de WCF y enlazarlos a la plantilla HTML. ¿Dónde se toma la decisión con respecto a los datos que se descargarán? En otras palabras, ¿cómo se especifica la cadena de consulta para los datos que se desean de vuelta? La propiedad de operación de captura del componente DataView indica el nombre de la operación de servicio que se invocará. Si el proveedor de datos es un proxy normal para el servicio, entonces la propiedad fetchoperation adopta el nombre de un método público en el servicio. Si en lugar de eso, se utiliza la clase OpenDataContext, se espera que el valor de fetchoperation sea una cadena que el tiempo de ejecución del servicio de datos de WCF pueda entender. Puede ser una expresión como cualquiera de las siguientes: Customers('ALFKI') Customers('ALFKI')?$expand=Orders Customers('ALFKI')?$expand=Orders&$orderBy=City Si sólo se especifica el nombre de conjunto de entidades válido, se obtendrá la lista completa de entidades. Otras palabras clave, tales como $expand, $orderBy y $filter, permiten incluir conjuntos de entidades relacionados (un tipo de combinación interna), ordenar en una propiedad y filtrar las entidades devueltas en una condición Boolean. La consulta se puede redactar de forma manual como una cadena, pero respetando el formato URI subyacente. O bien, se puede usar el objeto OpenDataQueryBuilder JavaScript integrado, como se muestra en el code 2. Code 2 Uso del objeto AdoNetQueryBuilder <script type="text/javascript"> var dataContext; var queryObject; Sys.require([Sys.components.dataView, Sys.components.openDataContext]); Sys.onReady(function() { dataContext = Sys.create.openDataContext( { serviceUri: "/NorthwindService.svc", mergeOption: Sys.Data.MergeOption.appendOnly }); queryObject = new Sys.Data.OpenDataQueryBuilder("Customers"); queryObject.set_orderby("ContactName"); queryObject.set_filter("City eq " + "’London’"); queryObject.set_expand("Orders"); }); </script> El generador de consultas se puede usar para crear direcciones URL completas o sólo la parte de consulta de la dirección URL. En este caso, el generador de consultas obtiene el nombre del conjunto de entidades para consulta. Además ofrece un grupo de propiedades para establecer cualquier expansión, filtro y pedido necesario. Los criterios establecidos mediante el objeto del 111 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 generador de consultas se deben serializar en una cadena de consulta efectiva cuando esa fetchoperation esté establecida, como se muestra a continuación: <tbody sys:attach="dataview" class="sys-template" dataview:dataprovider="{{ dataContext }}" dataview:fetchoperation="{{ queryObject.toString() }}" dataview:autofetch="true"> Se usa el método toString para extraer la cadena de consulta del generador de consultas. En el código de muestra, la cadena de consulta resultante es Customers?$expand=Orders&$filter="City eq 'London'"&$orderby=ContactName El servicio devuelve una colección de objetos compuestos que incrustan los datos demográficos del cliente más la información de pedido. En el code 3 se muestra el resultado. Code 3 Consulta de datos mediante el uso de un servicio de datos de WCF Los números en la última columna indican el número de pedidos que ha realizado el cliente. Debido al atributo $expand en la consulta, el flujo de datos de JSON contiene una matriz de pedidos. La plantilla HTML hace referencia a la longitud de la matriz y rellena la columna de la siguiente forma: <td>{{ Orders.length }}</td> Es necesario tener en cuenta que para recuperar correctamente la información del pedido, primero se debe volver al código fuente del servicio de datos de WCF y habilitar el acceso al conjunto de entidades Pedidos: public static void InitializeService(IDataServiceConfiguration config) { config.SetEntitySetAccessRule("Customers", EntitySetRights.All); config.SetEntitySetAccessRule("Orders", EntitySetRights.All); } 27 CREAR Y REGISTRAR UN SCRIPT DE CLIENTE: INLINE, ARCHIVO .JS INCLUIDO, RECURSO JAVASCRIPT INCRUSTADO, CREADO DESDE EL CÓDIGO DE SERVIDOR Script de cliente en páginas web ASP.NET Las aplicaciones web ASP.NET no se limitan a las herramientas y lenguajes basados en servidor. Se Puede incluir ECMAScript (JavaScript o JScript) en las páginas web ASP.NET para crear una funcionalidad enriquecida para explorador. ASP.NET dispone de una amplia gama de características para admitir scripts de cliente. Una opción es crear y agregar fragmentos de código individuales de scripts de cliente a las páginas web ASP.NET para admitir el comportamiento de explorador para la aplicación. Esta opción resulta práctica si se desea incluir sólo algunas partes pequeñas de código JavaScript o si está trabajando con un código JavaScript que ya tiene. Esta opción también permite que el tamaño de las páginas web ASP.NET sea el mínimo. Incluir scripts de cliente personalizados en páginas ASP.NET 112 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Debido a que las páginas web ASP.NET simplemente representan marcado HTML, se puede agregar su propio script de cliente. Las páginas ASP.NET admiten secuencias de comandos de cliente en la medida en que el explorador que solicita la página admite dichas secuencias. Si la página se ejecuta en un explorador de un teléfono u otro dispositivo móvil, el grado de compatibilidad con la secuencia de comandos de cliente variará según el explorador. Existen varias opciones para incluir scripts de cliente en páginas ASP.NET: Se puede incluir el script de cliente estáticamente en un bloque script que incluya código o que utilice un atributo include para hacer referencia a un archivo JavaScript (.js). Utilice esta opción para insertar bloques de scripts o archivos JavaScript que contengan scripts de cliente que no sea necesario crear dinámicamente y que no requieran la funcionalidad AJAX adicional que proporciona Microsoft AJAX Library. Se puede crear y agregar dinámicamente el script de cliente a la página web ASP.NET utilizando la clase ClientScriptManager. Utilizar esta opción si desea crear scripts que dependen de información que sólo está disponible en tiempo de ejecución. Si se desea aprovechar las características AJAX de ASP.NET, puede administrar archivos de script de cliente mediante el control de servidor ScriptManager. El control de servidor ScriptManager también garantiza que Microsoft AJAX Library se carga en el explorador antes de que se ejecuten los scripts. Incluir bloques de script de cliente estáticos Se pueden agregar bloques script a una página ASP.NET del mismo modo que se haría con cualquier página HTML. También se pueden utilizar secuencias de comandos de cliente para escribir controladores de eventos para eventos de cliente como el evento onload de la página. Cuando una página ASP.NET se está ejecutando en el explorador, los elementos de marcado de la página son direccionables en el script de cliente. Provocan todos los eventos de cliente igual que en una página HTML. Nota: Se puede hacer referencia a los controles de servidor ASP.NET en el script de cliente. Una página web ASP.NET también puede tener acceso a un archivo de script haciendo referencia a él en el atributo src de una etiqueta <script>, como en el ejemplo siguiente: <script type="text/javascript" src="MyScript.js"></script> Mantener los scripts de cliente en archivos .js externos en lugar de mantenerlos en las páginas ayuda a organizarlos. También hace que sea más fácil administrar el control de versiones y compartirlos entre las páginas. El explorador almacena en memoria caché los archivos .js externos, de forma similar a como se almacenan en memoria caché las páginas web y las imágenes. Una vez que el explorador carga el script como archivo externo, está disponible en la caché para cualquier página web que lo necesite. Esto puede ayudar a aumentar el rendimiento de la aplicación web. Crear scripts de cliente dinámicamente En muchos casos, la secuencia de comandos de cliente para la página se puede crear mediante declaración, normalmente como un bloque de secuencia de comandos. Sin embargo, se pueden crear los scripts de cliente dinámicamente. Esto resulta útil si el script depende de información que sólo está disponible en tiempo de ejecución. Por ejemplo, puede insertar el script de cliente en una página que direcciona un control de servidor cuyo nombre (identificador) no se conoce hasta que se ejecuta la aplicación, o puede crear un script que depende de los valores que recibe de un usuario. Puede crear e insertar dinámicamente el script de cliente en una página representada llamando a los métodos de la clase ClientScriptManager, como se muestra a continuación: RegisterClientScriptBlock , que inserta un bloque de script en la parte superior de la página representada. RegisterStartupScript , que inserta un bloque de script al final de la página representada. Cómo: Agregar secuencias de comandos de cliente a las páginas Web ASP.NET dinámicamente El uso de código del servidor permite agregar secuencias de comandos de cliente a una página. La creación de secuencias de comandos de cliente en el código del servidor es útil cuando el contenido de dichas secuencias depende de información que 113 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 únicamente está disponible en tiempo de ejecución. La adición de secuencias de comandos de cliente a la página de forma dinámica también resulta útil cuando se desea que dichas secuencias se ejecuten en las situaciones siguientes: Cuando la página ha terminado de cargarse Cuando los usuarios envían la página Nota: También se puede agregar eventos de cliente, como onmouseover y onkeyup, a ciertos controles. Para agregar secuencias de comandos de cliente a una página Web ASP.NET dinámicamente en el código del servidor, llamar a uno de los siguientes métodos. RegisterClientScriptBlock Agrega un bloque de secuencias de comandos a la parte superior de la página. Crear la secuencia de comandos como una cadena y, a continuación, pásarla al método, que la agregará a la página. Se puede utilizar este método para insertar cualquier secuencia de comandos en la página. Tener en cuenta que la secuencia de comandos se podría representar en la página antes de que terminen todos los elementos; por consiguiente, es posible que no pueda hacer referencia a todos los elementos de la página desde la secuencia de comandos. RegisterClientScriptInclude Similar al método RegisterClientScriptBlock, pero agrega un bloque de secuencias de comandos que hace referencia a un archivo .js externo. El archivo de inclusión se agrega antes que cualquier secuencia de comandos agregada dinámicamente; por consiguiente, es posible que no pueda hacer referencia a algunos de los elementos de la página. RegisterStartupScript Agrega un bloque de secuencias de comandos a la página que se ejecuta cuando finaliza la carga de ésta, pero antes de que se produzca el evento onload. La secuencia de comandos no se suele crear como un controlador de eventos o una función; generalmente sólo incluye las instrucciones que se deben ejecutar una sola vez. RegisterOnSubmitStatement Agrega una secuencia de comandos que se ejecuta en respuesta al evento onsubmit de la página. La secuencia de comandos se ejecuta antes de que se envíe la página y ofrece la oportunidad de cancelar el envío. En el ejemplo de código siguiente se muestra cómo agregar una secuencia de comandos de cliente a una página que se ejecuta cuando el usuario hace clic en un botón que envía la página de nuevo al servidor. La secuencia de comandos de cliente muestra una ventana emergente que solicita al usuario que confirme la devolución de datos. protected void Page_Load(Object sender, EventArgs e) { String scriptText = "return confirm('Do you want to submit the page?')"; ClientScript.RegisterOnSubmitStatement(this.GetType(), "ConfirmSubmit", scriptText); } 28 PROGRAMAR DISPOSITIVOS MÓVILES El desarrollo de páginas ASP.NET para exploradores de dispositivos móviles no difiere sustancialmente del desarrollo de páginas para los exploradores de escritorio. Para crear aplicaciones para dispositivos móviles, ASP.NET proporciona un espacio de nombres System.Web.Mobile dedicado específicamente al desarrollo Web móvil. Se puede crear una página Web a partir de la clase base MobilePage y agregar controles del espacio de nombres System.Web.Mobile. Este espacio de nombres define una serie de controles de servidor Web y adaptadores que resultan especialmente útiles al crear aplicaciones que deben estar disponibles para muchos dispositivos móviles diferentes, como los teléfonos móviles. ASP.NET 2.0 también proporciona una arquitectura adaptable de controles que permite crear adaptadores de dispositivos personalizados para los controles de servidor Web ASP.NET 2.0. Estos adaptadores crean una representación personalizada para un control basándose en el explorador que realizó la solicitud. Con la arquitectura adaptable, puede utilizar las páginas ASP.NET que 114 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 heredan de la clase base Page (en lugar de las páginas escritas específicamente para dispositivos móviles) y crear adaptadores personalizados para que los controles de servidor Web ASP.NET representen una salida específica en los dispositivos que tienen acceso a la aplicación. En ambos casos, el desarrollo sigue el modelo orientado a eventos de .NET estándar en el que la aplicación responde a las solicitudes del usuario, a los clics en los botones, etc. Arquitectura de las aplicaciones móviles Aunque ASP.NET integra tecnología para que el desarrollo de aplicaciones Web ASP.NET Mobile siga el mismo modelo que el desarrollo de aplicaciones Web tradicional, el objetivo principal de la arquitectura no es permitir crear páginas únicas que se puedan procesar en exploradores de dispositivos de escritorio o de dispositivos móviles. Se puede crear adaptadores para controles de servidor Web ASP.NET individuales o para controles de servidor Web móviles que permitan representar estos controles en exploradores de dispositivos móviles y de escritorio, pero las limitaciones de los exploradores de los dispositivos móviles a menudo implican que las páginas diseñadas para los exploradores de escritorio no se presentan muy bien en los exploradores de dispositivos móviles. Por ejemplo, crear una página Web ASP.NET que incluye un encabezado de sitio, una barra de exploración en la parte superior de la página, una estructura de exploración secundaria a lo largo de la página y contenido en el resto de la página, ésta se representará tal como se ha diseñado en un explorador de escritorio. En este caso, normalmente hay bastante espacio para representar todos los controles y proporcionar un área de contenido desplazable. Sin embargo, en muchos exploradores de dispositivos móviles, este diseño sería imposible. Una gran cantidad de dispositivos móviles disponen de un área de pantalla más pequeña que los monitores de escritorio, por lo que incluso la exploración se convierte en un proceso de varios pasos en el que el usuario debe hacer clic en varios controles para obtener el contenido de la página. La lógica de la presentación sigue un modelo similar. Por ejemplo, cuando el usuario rellena un formulario Web Forms utilizando un explorador de escritorio, puede ver muchos controles en la pantalla al mismo tiempo. Cuando el formulario se valida en el servidor, los errores de validación se pueden mostrar junto a los controles. Con un dispositivo móvil, la introducción de datos en los formularios y la validación de los mismos pueden ser mucho más difíciles de mostrar en un formato que sea utilizable. Además, en los dispositivos móviles podría optar por proporcionar accesos directos que permitan al usuario rellenar información escribiendo menos, ya que es posible que resulte más difícil escribir en esos dispositivos. Por estas razones, se recomienda crear páginas independientes en la aplicación Web ASP.NET para su uso en exploradores de escritorio y de dispositivos móviles. Una página desarrollada específicamente para los exploradores de dispositivos móviles permite dividir la lógica de presentación en partes más pequeñas que funcionen mejor para el área de presentación y el hardware de entrada de datos del dispositivo. Por consiguiente, cuando decida crear este tipo de páginas, debería utilizar controles de servidor Web móviles si la aplicación debe admitir una amplia gama de dispositivos móviles, exploradores que no utilizan HTML o dispositivos con funciones de presentación y entrada de datos limitadas. Controles de servidor Web móviles El espacio de nombres System.Web.Mobile de ASP.NET 2.0 está diseñado específicamente para el desarrollo Web móvil. Se puede crear una página Web móvil a partir de la clase base MobilePage y agregar controles de servidor Web móviles desde el espacio de nombres System.Web.Mobile. Los controles de servidor Web móviles disponen de varios adaptadores especializados en el marco de trabajo y, por consiguiente, están especialmente orientados al desarrollo de aplicaciones Web móviles para una amplia gama de dispositivos móviles. Los controles de servidor Web ASP.NET y la arquitectura de adaptador unificado Todos los controles de servidor Web ASP.NET 2.0 siguen el modelo de arquitectura de adaptador unificado. Esto significa que todos los controles pueden representar datos y comportarse de forma diferente, según el dispositivo solicitante, mediante una llamada a un adaptador personalizado que proporciona los comportamientos apropiados para dicho dispositivo, como la creación del lenguaje de formato adecuado. Si se ha configurado un adaptador en el archivo de definición del explorador para el dispositivo o el explorador solicitante, ASP.NET lo llamará en cada fase del ciclo de vida de un control de servidor Web. De esta manera, el adaptador podrá ajustar el resultado representado y controlar la lógica de estado de vista específica del dispositivo o las características individuales del dispositivo. Los archivos de definición del explorador se encuentran en la carpeta Browsers del directorio Config de .NET Framework o en la carpeta App_Browsers de una aplicación Web. Se puede crear adaptadores personalizados para cada dispositivo y hacer que el marco de trabajo de páginas ASP.NET los utilice cuando un dispositivo concreto tenga acceso a su página. 115 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Elegir adaptadores personalizados o controles móviles Para la mayoría de desarrolladores de páginas, el método recomendado para el desarrollo móvil consiste en utilizar controles de servidor Web móviles y crear páginas que heredan de MobilePage. Estos controles admiten muchos dispositivos móviles, como los teléfonos móviles. ASP.NET incluye controles de servidor Web móviles para una amplia gama de necesidades específicas de los entornos móviles y de desarrollo Web en general. Además, ya existen adaptadores de dispositivos para controles móviles para los principales dispositivos y sus lenguajes de formato. Microsoft continuará proporcionando actualizaciones de los adaptadores para los controles de servidor Web móviles cuando evolucionen los principales lenguajes de formato. Esto le permitirá admitir nuevos lenguajes de formato con los mismos controles que está utilizando en la actualidad. Por ejemplo, si se está creando un sitio de comercio electrónico que admite exploradores de escritorio, así como una amplia gama de dispositivos móviles, el método recomendado consiste en crear un conjunto de páginas ASP.NET que hereden de la clase Page y otro conjunto de páginas que hereden de la clase base MobilePage y utilicen controles móviles. Esto proporcionará compatibilidad con los dispositivos móviles sin necesidad de crear adaptadores personalizados. Asimismo, los controles de servidor Web móviles siguen el modelo de arquitectura de adaptador unificado, por lo que, si es necesario, puede crear sus propios adaptadores personalizados o modificar los existentes, ya que los nuevos dispositivos determinarán nuevos requisitos de comportamiento en los controles de servidor Web móviles. Hay escenarios en los que tiene sentido el uso de controles de servidor Web ASP.NET y la escritura de adaptadores personalizados. Generalmente, éstos serán aplicaciones para exploradores de escritorio completos en los que son necesarias variaciones de comportamiento en función del explorador o aplicaciones orientadas a cierto tipo de dispositivos muy particulares para los que no se garantizan los controles móviles y su conjunto de características. Por ejemplo, imagine que está creando una aplicación de reclamaciones de seguros que tiene una interfaz basada en explorador para su uso en la oficina y una interfaz para diversos dispositivos para su uso fuera de la oficina. Esta aplicación podría utilizar las mismas clases de página base para las páginas normales y las páginas para diversos dispositivos. Únicamente debería crear adaptadores personalizados para el dispositivo que se ha implementado fuera de la oficina. Una ventaja de la creación de adaptadores personalizados para los controles de servidor Web ASP.NET es que permite utilizar la clase base Page para las páginas Web y aprovechar por completo el conjunto de características de ASP.NET 2.0. ASP.NET MOBILE WEB FORMS Y COMPATIBILIDAD CON ASP.NET Cuando se crean páginas Web de ASP.NET Mobile, se pueden utilizar casi todas las funciones de ASP.NET. Sin embargo, antes conviene considerar algunas cuestiones relacionadas con la compatibilidad. Control e informes de errores Cuando una aplicación ASP.NET encuentra una excepción no controlada o cualquier otro error al procesar una solicitud, genera una página de error. Las excepciones pueden producirse en cualquier momento del procesamiento de una solicitud. Por ejemplo, en la lectura de un archivo de configuración (Web.config), en la compilación o ejecución de una página, etc. Se puede configurar la aplicación para que se generen páginas de error predeterminadas o personalizadas. Si se configura para que se generen páginas de error predeterminadas, ASP.NET establece un código de error en la respuesta y representa una página que describe detalladamente el error. Sin embargo, si la configura para que se generen páginas de error personalizadas, cada solicitud de error se redirige a una página personalizada que se proporciona para tal fin. Muchos dispositivos móviles no pueden representar el contenido detallado de una página de error. En su lugar, dichos dispositivos suelen mostrar únicamente un mensaje de error específico de un dispositivo, o el código de error. Para tratar esta situación, las páginas de ASP.NET Mobile Web Forms intentan dar a la página de error un formato que permita la representación en el dispositivo. Sin embargo, esta representación específica de un dispositivo se limita a las excepciones que se producen durante la ejecución de la página. Por tanto, si está utilizando páginas de error predeterminadas, debe intentar primeramente que la página de formularios Mobile Web Forms de un explorador de escritorio detecte posibles errores de configuración o de compilación. 116 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Si se piensa utilizar páginas de error personalizadas en la aplicación Web ASP.NET Mobile, ASP.NET puede dar a la página de error el formato apropiado para dispositivos móviles diferentes si va a escribir las páginas de error personalizadas utilizando controles móviles. Seguimiento ASP.NET proporciona una funcionalidad de fácil uso denominada Seguimiento que se puede utilizar para depurar las aplicaciones Web. ASP.NET proporciona dos niveles de seguimiento: seguimiento en el nivel de página y seguimiento en el nivel de aplicación. El primero proporciona información de seguimiento como código HTML que se anexa a cada página objeto de seguimiento, mientras que el segundo proporciona información de seguimiento a través de una dirección URL asignada especial (Trace.axd) en la aplicación. Si utiliza seguimiento en el nivel de página en la aplicación Web ASP.NET Mobile, el código HTML anexado a la representación puede evitar que se represente el resultado en el dispositivo móvil. Si embargo, en aplicaciones Web ASP.NET Mobile, debe utilizar seguimiento en el nivel de aplicación e inspeccionar el resultado del seguimiento desde un explorador Web de escritorio. Estado de la sesión y cookies ASP.NET proporciona funciones avanzadas de administración de sesiones que permiten mantener fácilmente el estado a través de solicitudes. Normalmente, la función de estado de la sesión de ASP.NET utiliza cookies en el explorador, pero se puede configurar para que trabaje sin cookies. En ASP.NET, se puede utilizar Session para guardar información relativa a una sesión de usuario a través de varias solicitudes. La administración de sesiones de ASP.NET es escalable y sólida, pudiéndose utilizar incluso en baterías de servidores Web. De forma predeterminada, Session de ASP.NET utiliza una cookie de cliente para almacenar un identificador en el equipo cliente. Se puede utilizar el identificador para localizar una sesión en acciones de ida y vuelta. Además, Session de ASP.NET admite un modo de sesión sin cookies que redirige inicialmente un cliente a una dirección URL nueva que contiene un identificador de sesión. El identificador de sesión se analiza automáticamente fuera de la dirección URL. Al escribir una aplicación Web ASP.NET Mobile, se debe tener en cuenta que algunos dispositivos móviles y puertas de enlace inalámbricas no admiten cookies. Para agregar compatibilidad para estos dispositivos, se debe configurar la aplicación de modo que se utilicen sesiones sin cookies. Consideraciones a tener en cuenta al utilizar el estado de la sesión Cuando se escribe una aplicación Web ASP.NET Mobile que utiliza la administración del estado de la sesión, se han de considerar los factores siguientes: No se permite el uso de controles de ASP.NET en el espacio de nombres System.Web.UI.WebControls en una página de formularios Mobile Web Forms. Las páginas de formularios Mobile Web Forms que utilizan controles Web móviles del espacio de nombres System.Web.UI.MobileControls permiten establecer el atributo EnableSessionState de la directiva @ Page en false. Sin embargo, las páginas de formularios Mobile Web Forms que utilizan un control ASP.NET del espacio de nombres System.Web.UI.WebControls con EnableSessionState establecido en false pueden generar errores en tiempo de compilación. Algunos dispositivos móviles y puertas de enlace no admiten cookies. Para permitir que una página de formularios ASP.NET Mobile Web Forms se ejecute en estos dispositivos, establezca el atributo cookieless del elemento sessionState en true. Algunos dispositivos móviles tienen problemas en el tratamiento de direcciones URL relativas después de haber sido redirigidos mediante la técnica empleada por la administración de sesiones sin cookies. Por ejemplo, si un explorador Openwave abre un archivo .aspx en http://localhost/a.aspx, y el sitio Web redirige el explorador a /12345678/a.apsx, el explorador sigue considerando su ruta de acceso actual como raíz. El explorador solicitará una referencia relativa posterior a b.aspx como /b.aspx. La solución consiste en incluir una dirección URL raíz en la página, como /12345678/a.aspx, en lugar de una dirección URL relativa cuando se efectúa la representación después de una redirección. Los controles de ASP.NET Mobile integrados realizan esta acción automáticamente, pero los adaptadores o los controles que acaban de escribirse deben incluir código que trate la representación después de una redirección. Tanto MobilePage como las clases base de adaptador tienen métodos, como MakePathAbsolute, que ayudan a un desarrollador de controles móviles a escribir direcciones URL raíz. 117 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Utilizar redirecciones Algunos dispositivos y exploradores requieren actualmente direcciones URL completas en respuesta a una redirección para HTTP. Establezca el atributo useFullQualifiedRedirectUrl del elemento httpRuntime en true en la sección System.Web del archivo Machine.config o del archivo Web.config (en el nivel de aplicación). Problemas de sintaxis La sintaxis que es válida en ASP.NET, por ejemplo <%=, no es válida en los controles ASP.NET Mobile, y se debe reemplazar por mecanismos de enlace de datos. Las expresiones de enlace de datos se deben delimitar mediante <%# y %>. 29 ACCESO A LAS CAPACIDADES DEL DISPOSITIVO: TRABAJO CON EMULADORES Cómo: Trabajar con emuladores y exploradores Los controles de ASP.NET Mobile permiten desarrollar aplicaciones para una gran variedad de dispositivos móviles. Los fabricantes de la mayoría de dispositivos móviles proporcionan emuladores que simulan el funcionamiento del hardware y de los exploradores. El software emulador permite ver las páginas Web de ASP.NET Mobile tal y como se verían en los dispositivos de hardware de los fabricantes, así como probar la interfaz del sitio Web tal y como lo harían los usuarios. Es posible, por ejemplo, que después de comprobar cómo se desplazaría un usuario por su sitio Web en un dispositivo determinado, se decida modificar la interfaz y utilizar una plantilla DeviceSpecific para ese dispositivo. Al utilizar emuladores en las fases de desarrollo y comprobación, resulta más fácil evaluar la aplicación Web móvil en una gran variedad de dispositivos antes de llevar a cabo su implementación. Existen dos planteamientos para ver las páginas Web móviles en los emuladores de dispositivos: Instalar y utilizar los emuladores de dispositivos proporcionados por los fabricantes. Utilizar los emuladores que se instalan con algunas ediciones de Visual Studio. Para utilizar esta opción, debe tener una edición de Visual Studio que contenga el Administrador de emuladores de dispositivos y haber instalado la aplicación ActiveSync, que puede descargar desde la página de herramientas de Windows Mobile Developer Center. Agregar un emulador a Visual Studio Se puede agregar un emulador a la lista de exploradores disponibles de Visual Studio. Para agregar el emulador de un fabricante de dispositivos a la lista de exploradores disponibles 1. 2. Compilar la aplicación. Instalar el emulador de dispositivos móviles en el PC de desarrollo. Consultar las instrucciones contenidas en la documentación del emulador. 3. En el menú Archivo, Clic en Explorar con. Visual Studio muestra el cuadro de diálogo Explorar con. 4. Clic en Agregar.Visual Studio muestra el cuadro de diálogo Agregar programa. 5. En el cuadro Nombre del programa, especificar el nombre del archivo del programa ejecutable del emulador. 6. Si el emulador admite argumentos de línea de comandos, especificar estos argumentos en el campo Nombre del programa. Por ejemplo, utilizar %startpage para especificar dónde se debe sustituir la página de inicio de la aplicación en la línea de comandos. 7. En el cuadro Nombre descriptivo, escribir el nombre del explorador tal y como desea que aparezca en Visual Studio. 8. Clic en Aceptar. 9. Si desea que el emulador sea el explorador predeterminado, Clic en Establecer como predeterminado. 10. Clic en Cerrar. Quitar un emulador Si se deja de necesitar un emulador, se puede quitar de Visual Studio. Para quitar un emulador de la lista de exploradores 118 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 1. En el Explorador de soluciones, Clic con el botón secundario del mouse en cualquier archivo .aspx. 2. En el menú contextual, haga clic en Explorar con. El diseñador muestra el cuadro de diálogo Explorar con. 3. Seleccionar un emulador de la lista de exploradores. 4. Clic en Quitar. Visual Studio quita el nombre del emulador de la lista de exploradores. Nota No obstante, no se podrá quitar el explorador designado como explorador predeterminado. Probar páginas con el Administrador de emuladores Todas las ediciones de Visual Studio son compatibles con las páginas Web móviles. Si la edición de Visual Studio también es compatible con aplicaciones de dispositivos móviles (como Pocket PC), tendrá instalado el Administrador de emuladores, que contiene varios emuladores. Sin embargo, los emuladores disponibles en el Administrador de emuladores no se diseñaron para realizar pruebas en páginas Web móviles. Si se desea utilizar el Administrador de emuladores para probar sus páginas Web móviles, se puede instalar ActiveSync, que está disponible para su descarga en la página de herramientas de Microsoft Mobile Developer Center. Si se desea ver su sitio Web con un emulador mediante el Administrador de emuladores 1. 2. Compilar la aplicación. En el menú Herramientas, Clic en Administrador de emuladores. Nota: Si el comando Administrador de emuladores no está disponible, significa que no se tiene instalado Compact Framework. 3. Seleccione un emulador de dispositivos. 4. En el menú Acciones, haga clic en Conectar. Se abre el emulador. Mover el emulador para poder ver el Administrador de emuladores y esperar a que le indique que el dispositivo seleccionado está conectado. 5. En el Administrador de emuladores, clic con el botón secundario del mouse en el emulador de dispositivos conectados de la lista y, en el menú contextual, clic en Colocar en la base. Se inicia ActiveSync. 6. En el cuadro de diálogo Configurar una asociación, seleccione Asociación como invitado y hacer clic en Siguiente. 7. Cuando ActiveSync indicar que el dispositivo está conectado, ciérrelo. Seguirá ejecutándose en segundo plano. 8. En el emulador, desplácese a su sitio Web. Nota: Es posible que el emulador no pueda utilizar una dirección URL del host local para obtener acceso al proyecto del sitio Web. De no ser así, se podrá ver el sitio Web utilizando la dirección URL de la intranet. Depurar páginas Web en el emulador Si Visual Studio no es capaz de iniciar un emulador al depurar un sitio Web, la aplicación se puede depurar asociándola al proceso de trabajo de ASP.NET. Para depurar la aplicación de sitio Web asociándola al proceso de trabajo 1. 2. 3. 4. 5. 6. Definir un punto de interrupción en el código que desea depurar. Compilar la aplicación. En el menú Herramientas, seleccione Asociar al proceso. En la lista Procesos disponibles, seleccione el proceso de trabajo del sitio Web (w3wp.exe o aspnet_wp.exe). Hacer clic en Asociar. Se inicia el depurador de Visual Studio. En el emulador o en el explorador, desplácese hasta su proyecto de sitio Web. El depurador se detiene en el primer punto de interrupción. 30 CONTROLAR EL PROCESAMIENTO ESPECÍFICO DEL DISPOSITIVO: CONTROL DEVICESPECIFIC; FILTROS DE DISPOSITIVO; PLANTILLAS DE CONTROL Métodos de evaluación de dispositivos Los métodos de evaluación de dispositivos permiten crear filtros con nombre para los controles de ASP.NET Mobile que se pueden usar directamente en el método HasCapability. Asimismo, estos filtros se pueden usar de forma indirecta en el archivo Web.config, mediante el elemento <Choice> de la sección <DeviceSpecific>. 119 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Para especificar un filtro con nombre, es preciso agregar una entrada en la sección <deviceFilters> del archivo Web.config. En el ejemplo siguiente se muestra cómo se define un filtro de dispositivo denominado isHTML32. <filter name="isHTML32" compare="PreferredRenderingType" argument="html32" /> En tiempo de ejecución, este filtro compara el valor de la propiedad PreferredRenderingType de la instancia MobileCapabilities de la solicitud actual con el valor html32. En el ejemplo siguiente se muestra cómo definir una nueva función denominada GPSEnabled. namespace MyNamespace { public class MyCapabilityEvaluators { public static bool IsGPSEnabled( System.Web.Mobile.MobileCapabilities capabilities, String unusedArg) { // processing code } } } Escribir el elemento siguiente en el archivo Web.config apropiado para agregar la nueva función: <deviceFilters> <filter name="GPSEnabled" type="MyNamespace.MyCapabilityEvaluators, MyAssembly" method="IsGPSEnabled" /> </deviceFilters> Durante la representación, se selecciona una de las opciones de un elemento <DeviceSpecific> en función de las características del dispositivo de destino. La comparación comprueba primero si el nombre del filtro está entre los definidos para la página. Si existe un método con la firma adecuada en el archivo Web.config o en la jerarquía de configuración, se utiliza dicho método para evaluar la entrada <Choice> en busca de un filtro con el nombre apropiado. El filtrado de dispositivos permite personalizar algunos aspectos de la representación de los controles de servidor Web según el explorador o el dispositivo en que se vayan a visualizar. Cuando un usuario solicita una página Web de un servidor, el explorador realiza una solicitud que contiene información, como el agente de usuario y otros encabezados, que identifican el tipo y versión del explorador. De este modo, ASP.NET puede establecer la correspondencia entre el identificador y un dispositivo determinado definido en un archivo de explorador. Entonces el resultado se puede filtrar en función del dispositivo mediante el identificador de los controles de servidor Web. 120 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Filtrado de dispositivos En el siguiente ejemplo de código declarativo se muestra el uso de un filtro de dispositivo para acortar la propiedad de texto de un control Label de un dispositivo Pocket PC en el que se está ejecutando Pocket Internet Explorer. Éste es un uso común de un filtro de dispositivos: proporcionar texto más conciso para un dispositivo cuyo tamaño de pantalla es reducido. El prefijo "PIE" que aparece delante del segundo atributo Text especifica que el control debe representar esa versión del texto si el identificador del explorador solicitante es "PIE". <asp:Label runat="server" id="title" Text="Welcome to Our Online Shopping Catalog" PIE:Text="Welcome, Shopper" /> Filtros de controles Se puede filtrar el resultado de los controles para dispositivos diferentes aplicando filtros a los elementos siguientes: Propiedades de los controles Atributos personalizados Plantillas Filtros de dispositivos para las directivas También se puede aplicar filtros de dispositivos a los atributos de la directiva @ Page para que se adapte mejor a las funciones de cada dispositivo. Por ejemplo, se puede deshabilitar el estado de vista para determinados dispositivos o utilizar temas diferentes en función del dispositivo que tiene acceso a la página. Algunas de las directivas @ Page que se pueden filtrar son las siguientes: Buffer ClientTarget CodePage ContentType Culture EnableViewState EnableViewStateMac ErrorPage LCID MasterPageFile ResponseEncoding Theme UICulture Si se está trabajando con controles de usuario, también se puede aplicar filtros de dispositivos a los atributos de la directiva @ Control. En general, aunque la directiva @ Control ofrece menos atributos para los que tiene sentido el filtrado de dispositivos, se puede aplicar a atributos como EnableViewState. Por último, se puede aplicar atributos de filtros de dispositivos, utilizados para especificar la propiedades de una página principal, en la directiva @ Master. Nota: En el archivo Web.config no se pueden especificar filtros de dispositivos. 31 AGREGAR CONTROLES WEB MÓVILES A UNA PÁGINA WEB: CONTROLES STYLESHEET; CONTROLES LIST; CONTROLES CONTAINER Espacios de nombres ASP.NET para controles móviles Microsoft ASP.NET proporciona tres espacios de nombres que se utilizan para implementar el comportamiento de controles y componentes móviles en tiempo de diseño y en tiempo de ejecución. Estos espacios de nombres incluyen las interfaces y las clases base fundamentales para implementar atributos, clases, controles y elementos. A continuación se enumeran los espacios de nombres de ASP.NET para controles móviles y las clases que los constituyen: 121 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 System.Web.Mobile. Clases principales de funciones, autenticación y control de errores. Clases MobileCapabilities y MobileFormsAuthentication. System.Web.UI.MobileControls. Clases principales de controles ASP.NET Mobile. Interfaces IObjectListFieldCollection, ITemplateable. Clases AdRotator y DeviceSpecific. System.Web.UI.MobileControls.Adapters. Clases principales de adaptadores que se pueden implementar para crear adaptadores para dispositivos de destino Control StyleSheet Un control StyleSheet puede contener cualquier número de objetos de estilo u objetos de estilo más especializados que heredan de la clase Style. Éstos deben tener propiedades de nombre único. Se puede hacer referencia a continuación a otros controles en la misma página por su propiedad Name. Esta clase no tiene ninguna representación visual. Una página también puede utilizar una hoja de estilos externa y varias páginas pueden compartir la misma hoja de estilos externa. Elemento <Style> , tema Styles. Nota: El control StyleSheet omite sus propios atributos de estilo; establecer un atributo de estilo en el control StyleSheet no tiene ningún efecto en los estilos contenidos como elementos secundarios dentro del control StyleSheet. Control List Representa una lista de elementos como una presentación estática o una lista interactiva. Este control admite la representación con plantilla utilizando los juegos de plantillas de dispositivo y la paginación interna. Control Container 32 IMPLEMENTAR ADAPTADORES DE CONTROL: App_Browsers; procesamiento utilizando ChtmlTextWriter o XhtmlTextWriter La clase HtmlTextWriter se usa para representar HTML 4.0 en exploradores de escritorio. La clase HtmlTextWriter es también la clase base para todos los sistemas de escritura de marcado del espacio de nombres System.Web.UI, incluidas las clases ChtmlTextWriter, Html32TextWriter y XhtmlTextWriter. Estas clases se usan para escribir los elementos, atributos y la información de estilo y diseño de los distintos tipos de marcado. Además, estas las clases de adaptación de página y de control asociadas a cada lenguaje de marcado usan estas clases. En la mayor parte de los casos, ASP.NET usa automáticamente el sistema de escritura apropiado para el dispositivo que realiza la solicitud. Sin embargo, si se crea un escritor de texto personalizado o desea especificar un escritor concreto para representar una página para un dispositivo concreto, debe asignar el sistema de escritura a la página en la sección controlAdapters del archivo .browser de la aplicación. Tipos de adaptadores Para facilitar la compatibilidad con varios dispositivos, la arquitectura de páginas Web de ASP.NET Mobile se basa en un modelo de adaptadores de dispositivos. Las páginas Web móviles y los controles ASP.NET Mobile son de por sí independientes del dispositivo, pero un conjunto de adaptadores de dispositivo debidamente elegidos proporciona una capa de presentación específica del dispositivo para las páginas y controles móviles. Los adaptadores de dispositivos están asociados a combinaciones de controles independientes y dispositivos de destino. Para un dispositivo dado, cada clase de controles móviles puede tener asociada una única clase de adaptadores de controles, y cada instancia de un control está enlazada a una instancia correspondiente de un adaptador. Para cada tipo de dispositivo, se pueden definir las clases siguientes: Clase base de adaptadores de controles. Clase base de la que heredan todos los adaptadores de dispositivos. Adaptador de página. Adaptador asociado a la página. Adaptador de formularios. Adaptador de controles asociado a cada formulario de la página. Adaptadores de controles. Clases de adaptadores de controles que se corresponden con los controles del sistema. Sistema de escritura de texto. Clase que hereda de la clase HtmlTextWriter y que contiene métodos auxiliares específicos del destino. 122 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Como norma, si alguna funcionalidad precisa el contexto de un control, se debe considere la posibilidad de situarlo en la clase base de adaptadores de controles. Clase base de adaptadores de controles Cada conjunto de adaptadores de dispositivos incluye normalmente una clase base para todos los adaptadores del conjunto. La clase base ControlAdapter proporciona funcionalidad utilizada comúnmente y específica de la clase de dispositivos. Por lo general, esto consiste en métodos auxiliares que requieren contexto de control o de página. Entre estos métodos auxiliares se incluyen: Métodos para representar eventos de devolución de datos de controles. Métodos que representan propiedades de estilo del control. Las propiedades de estilo se tratan de forma distinta para cada dispositivo; por tanto, cada adaptador tiene una implementación diferente para la representación de los estilos. Métodos que se pueden reemplazar y que proporcionan información específica del dispositivo al marco de trabajo de páginas ASP.NET, o a adaptadores de la página o formulario contenedor. Propiedades convenientes para obtener acceso a adaptadores de la página o formulario contenedor. Es aconsejable que la clase base de adaptadores de controles que se proporcione herede también de la clase ControlAdapter, que es una clase base general. Esta clase proporciona una implementación predeterminada de la interfaz IControlAdapter que requieren todos los adaptadores. Se recomienda que la implementación de la representación predeterminada de la clase base represente todos los controles secundarios. Esto permite utilizar la clase base como adaptador para los controles compuestos. Clase de adaptadores de páginas Cada conjunto de adaptadores de dispositivos tiene una clase de adaptadores de páginas que está asociada a la página móvil. Cada instancia de una página móvil, o cada clase de páginas heredada de un objeto MobilePage, está enlazada a un adaptador de página específico del dispositivo de destino. Un adaptador de páginas contiene normalmente lo siguiente: Funcionalidad de estado de vista y de devolución de datos específica del dispositivo. Métodos que guardan y cargan el estado de controles específico del dispositivo; por ejemplo, información sobre la paginación. Código de inicialización que prepara la respuesta devuelta al cliente. Esto incluye el establecimiento del tipo MIME de la respuesta en el formato apropiado. Método Render que representa la estructura de la página devuelta al cliente. Por ejemplo, los adaptadores de páginas basados en HTML suelen representar por lo menos las etiquetas <html> de apertura y cierre. Otras funciones en el nivel de página específicas del dispositivo, tales como ensamblar un adaptador de páginas para un dispositivo que admita la posibilidad de devolver varias páginas en una sola respuesta. Una clase de adaptadores de páginas debe proporcionar una implementación completa de la interfaz IPageAdapter. Normalmente, la clase de adaptadores de páginas que se escriba debe heredar también de la clase de adaptadores de controles apropiada. Por ejemplo, si está escribiendo únicamente para un dispositivo basado en WML, desearía heredar de la clase WmlControlAdapter. Clase de adaptadores de formularios Cada conjunto de adaptadores de dispositivos tiene también una clase de adaptadores de formularios que está asociada a la clase Form. Cada instancia de un formulario está enlazada a un adaptador de formularios que es específico del dispositivo de destino. Un adaptador de formularios contiene normalmente lo siguiente: Métodos que tratan la interactividad entre formularios específica del dispositivo. Métodos que tratan la adaptación de un único formulario a distintos dispositivos. Esto podría incluir código para paginar un formulario o para combinar elementos de formulario en un menú. Un método Render que representa la estructura del formulario. Por ejemplo, los adaptadores de páginas basados en WML suelen representar por lo menos las etiquetas <card> de apertura y cierre. Clase de escritores de texto La clase de sistema de escritura de texto no es una clase de adaptador, sino una clase que hereda de la clase System.Web.UI.HtmlTextWriter. Para llevar a cabo la representación, se crea y se pasa mediante cada adaptador una instancia 123 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 de la clase de escritores de texto; es decir, todo el proceso de representación se realiza a través de este objeto. El sistema de escritura de texto contiene normalmente métodos auxiliares para ejecutar tareas tales como la codificación de los datos. ChtmlTextWriter (Clase) Escribe una serie de caracteres específicos de cHTML y texto en la secuencia de salida de un control de servidor ASP.NET. La clase ChtmlTextWriter proporciona funciones de aplicación de formato que los controles de servidor ASP.NET utilizan al enviar contenido cHTML a los clientes. El HTML compacto, o cHTML, es un subconjunto de HTML 2.0, HTML 3.2 y HTML 4.0 diseñado para su uso en dispositivos con memoria y rendimiento de CPU limitados, pantallas pequeñas, capacidades de formato reducidas y un número limitado de opciones de entrada (como el teclado de un teléfono móvil). Por lo tanto, cHTML no admite los siguientes elementos: Imágenes JPEG. Tablas. Mapas de imagen. Varias fuentes y estilos de caracteres. Colores e imágenes de fondo. Marcos. Hojas de estilo. La clase ChtmlTextWriter deriva de la clase Html32TextWriter y gran parte de su funcionalidad la proporcionan la clase Html32TextWriter y la clase base de todos los escritores de texto de marcado, que es la clase HtmlTextWriter. Ejemplo En el siguiente ejemplo de código se muestra la forma de crear una clase denominada CustomChtmlTextWriter derivada de la clase ChtmlTextWriter. Crea dos constructores y reemplaza el método OnAttributeRender para evitar que el atributo de estilo bgcolor se escriba en la secuencia de salida del objeto ChtmlTextWriter. También crea una clase denominada ChtmlCustomPageAdapter que define un método, CreateCustomChtmlTextWriter, que crea y devuelve una instancia de la clase CustomChtmlTextWriter. Después, el objeto CustomChtmlTextWriter representa el contenido cHTML de una página en los dispositivos con exploradores que utilizan el marcado de cHTML. // Create a class that derives from the // ChtmlTextWriter class. using System; using System.IO; using System.Web.UI; using System.Web.UI.WebControls.Adapters; namespace AspNet.Samples.CS { public class CustomChtmlTextWriter : ChtmlTextWriter { // Create two constructors for the new // text writer. public CustomChtmlTextWriter(TextWriter writer) : base(writer, DefaultTabString) { } public CustomChtmlTextWriter(TextWriter writer, String tabString) : base(writer, tabString) { } // Override the OnAttributeRender method to // not render the bgcolor attribute, which is // not supported in CHTML. protected override bool OnAttributeRender(string name, string value, HtmlTextWriterAttribute key) { if (String.Equals("bgcolor", name)) { return false; 124 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 } } } } // Call the ChtmlTextWriter version of the // the OnAttributeRender method. return base.OnAttributeRender(name, value, key); // Derive from the WebControlAdapter class, // provide a CreateCustomChtmlTextWriter // method to attach to the custom writer. public class ChtmlCustomPageAdapter : WebControlAdapter { protected internal ChtmlTextWriter CreateCustomChtmlTextWriter( TextWriter writer) { return new CustomChtmlTextWriter(writer); } } XhtmlTextWriter (Clase) Escribe los caracteres específicos del lenguaje de marcado de hipertexto extensible (XHTML), incluyendo todas las variaciones de módulos XHTML que derivan de XTHML, en el flujo de salida para un control de servidor ASP.NET para los dispositivos móviles. Reemplazar la clase XhtmlTextWriter para proporcionar una representación XHTML personalizada para las páginas ASP.NET y controles de servidor. XHTML es un lenguaje de marcado compatible con XML, que se basa en HTML 4.1, y permite crear los sitios Web convenientes para varios tipos de dispositivo. Combina la facilidad de uso del HTML con las instrucciones de elemento estrictas proporcionadas por XML para generar un lenguaje de marcado con una gama amplia de opciones de formato y de estilo, y menor ambigüedad de la etiqueta de marcado. La clase XhtmlTextWriter incluye funciones de aplicación de formato que los controles de servidor de ASP.NET utilizan al representar contenido XHTML en los clientes. Se puede utilizar el método SetDocType para especificar qué tipo de XHTML representa el sistema de escritura de texto. Los tipos de documento compatibles se definen en la enumeración XhtmlMobileDocType. La clase XhtmlTextWriter representa dos conjuntos de atributos de elementos. Un conjunto es una colección de atributos comunes, según la referencia que consta en la propiedad CommonAttributes. El segundo conjunto es una colección de atributos específicos del elemento, según la referencia que consta en la propiedad ElementSpecificAttributes. Se puede utilizar los miembros de la clase XhtmlTextWriter y cualquier clase derivada para crear los sistemas de escritura de texto personalizados que se usarán en adaptadores de página o de clase personalizados de XHTML. También se puede crear clases derivadas que reemplacen el comportamiento estándar de la clase XhtmlTextWriter. De manera predeterminada, cuando se está trabajando con exploradores que admiten HTML 4.0, los controles y las páginas ASP.NET representan el marcado que es compatible con XHTML 1.1 estándar. El objeto HtmlTextWriter envía XHTML a menos que configure específicamente ASP.NET para no representar el marcado XHTML Ejemplo de Código El ejemplo de código en esta sección contiene cuatro partes. En el primer ejemplo se muestra cómo se crea una clase derivada. En el segundo ejemplo de código se muestra cómo se crea un control personalizado. En el tercer ejemplo de código se muestra cómo utilizar el control personalizado. El cuarto ejemplo de código incluye el código requerido para ejecutar el control personalizado. En el ejemplo de código siguiente se muestra la forma de crear una clase personalizada que deriva de la clase XhtmlTextWriter. Tiene dos constructores, estándar para todas las clases, que heredan directa o indirectamente de la clase HtmlTextWriter. El primer constructor toma un objeto TextWriter como parámetro, llama al segundo constructor y le pasa los dos valores de parámetro siguientes: Instancia de TextWriter. Valor de la propiedad HtmlTextWriter.DefaultTabString que define la sangría de línea predeterminada utilizada por el escritor de texto XHTML. 125 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 En este ejemplo de código también se muestra la forma de reemplazar los métodos OnAttributeRender y OnStyleAttributeRender para filtrar por el tamaño de texto y el estilo de color, respectivamente. Además, reemplaza los métodos BeginRender y EndRender para escribir una cadena de texto antes y después de que se haya representado un control. using using using using using using using System; System.IO; System.Web; System.Security.Permissions; System.Web.UI; System.Web.UI.Adapters; System.Web.UI.WebControls.Adapters; namespace Samples.AspNet.CS { // Create a class that inherits from XhtmlTextWriter. [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Minimal)] [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)] public class CustomXhtmlTextWriter : XhtmlTextWriter { // Create two constructors, following // the pattern for implementing a // TextWriter constructor. public CustomXhtmlTextWriter(TextWriter writer) : this(writer, DefaultTabString) { } public CustomXhtmlTextWriter(TextWriter writer, string tabString) : base(writer, tabString) { } // Override the OnAttributeRender method to // allow this text writer to render only eight-point // text size. protected override bool OnAttributeRender(string name, string value, HtmlTextWriterAttribute key) { if (key == HtmlTextWriterAttribute.Size) { if (String.Compare(value, "8pt") == 0) { return true; } else { return false; } } else { return base.OnAttributeRender(name, value, key); } } // Override the OnStyleAttributeRender // method to prevent this text writer // from rendering purple text. protected override bool OnStyleAttributeRender(string name, string value, HtmlTextWriterStyle key) { 126 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 } if (key == HtmlTextWriterStyle.Color) { if (String.Compare(value, "purple") == 0) { return false; } else { return true; } } else { return base.OnStyleAttributeRender(name, value, key); } // Override the BeginRender method to write a // message and call the WriteBreak method // before a control is rendered. override public void BeginRender() { this.Write("A control is about to render."); this.WriteBreak(); } // Override the EndRender method to // write a string immediately after // a control has rendered. override public void EndRender() { this.Write("A control just rendered."); } } } En el ejemplo de código siguiente se muestra la forma de crear un control Label personalizado denominado TestLabel y un adaptador personalizado denominado XhtmlTestLabelAdapter, que representa el contenido del control en XHTML. using using using using using using System; System.Web; System.Web.UI; System.Web.UI.Adapters; System.Web.UI.WebControls; System.Web.UI.WebControls.Adapters; namespace AspNet.Samples { // Create a simple class that inherits // from the Label class. public class TestLabel : Label { private String _textValue; // Override the Text property. public override string Text { get { return (string)ViewState["Text"]; } set { ViewState["Text"] = value; } } } 127 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 public class XhtmlTestLabelAdapter : WebControlAdapter { // Create a control property that accesses the // methods and properties of the control. protected TestLabel Control { get { return (TestLabel)base.Control; } } protected override void Render(HtmlTextWriter writer) { // Create an instance of the XhtmlTextWriter class, // named w, and cast the HtmlTextWriter passed // in the writer parameter to w. XhtmlTextWriter w = new XhtmlTextWriter(writer); // Create a string variable, named value, to hold // the control's Text property value. String value = Control.Text; // Create a Boolean variable, named attTest, // to test whether the Style attribute is // valid in the page that the control is // rendered to. Boolean attTest = w.IsValidFormAttribute("style"); // Check whether attTest is true or false. // If true, a style is applied to the XHTML // content. If false, no style is applied. if (attTest) w.EnterStyle(Control.ControlStyle); // Write the Text property value of the control, // a <br> element, and a string. w.Write(value); w.WriteBreak(); w.Write("This control conditionally rendered its styles for XHTML."); // Check whether attTest is true or false. // If true, the XHTML style is closed. // If false, nothing is rendered. if (attTest) w.ExitStyle(Control.ControlStyle); } } } En el ejemplo de código siguiente se muestra la forma de utilizar el control TestLabel personalizado en una página Web ASP.NET. <%@ Page Language="C#" %> <%@ Import Namespace="AspNet.Samples" %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1transitional.dtd"> <script runat="server"> protected void Page_Load(object sender, EventArgs e) { TestLabel tl = new TestLabel(); tl.ID = "TestLabel1"; 128 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 PlaceHolder1.Controls.Add(tl); } </script> <html xmlns="http://www.w3.org/1999/xhtml" > <head runat="server"> <title>XHtmlTextWriter Example</title> </head> <body> <form id="form1" runat="server" > <div> <asp:PlaceHolder ID="PlaceHolder1" runat="server"></asp:PlaceHolder> </div> </form> </body> </html> Para utilizar el control personalizado en el ejemplo de código anterior, se agrega el elemento <controlAdapters> siguiente a uno de los dos archivos indicados a continuación. Se puede agregar al archivo adecuado para todos los equipos en el subdirectorio correspondiente a un explorador concreto, como una subcarpeta del directorio de configuración de .NET Framework. Como alternativa, se puede agregarlo a un archivo de explorador personalizado en el directorio App_Browsers del directorio raíz de la aplicación Web. <controlAdapters> <adapter controlType="AspNet.Samples.TestLabel" adapterType="AspNet.Samples.XhtmlTestLabelAdapter" /> </controlAdapters> App_Browsers Contiene definiciones del explorador (archivos .browser) que ASP.NET utiliza para identificar los exploradores individuales y determinar sus funciones. Los archivos de definición del explorador contienen definiciones para exploradores individuales. En tiempo de ejecución, ASP.NET utiliza la información del encabezado de la solicitud para determinar qué tipo de explorador ha realizado la solicitud. A continuación, ASP.NET utiliza archivos .browser para determinar las capacidades del explorador. Los adaptadores de control ASP.NET pueden utilizar esta información para adaptar el comportamiento de un control de servidor web ASP.NET dependiendo del tipo de dispositivo. Por ejemplo, un control de servidor podría generar HTML diferente para un explorador gráfico como Internet Explorer que para un dispositivo móvil. <browsers> <browser id="browser name" parentID="parent browser name" refID="reference ID"> <identification> <userAgent match="regular expression" nonMatch="regular expression" /> <header match="regular expression" name="header name" nonMatch="regular expression" /> <capability match="regular expression" name="capability name" nonMatch="regular expression" /> </identification> <capture> <userAgent match="regular expression" /> <header match="regular expression" name="header name" /> <capability match="regular expression" 129 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 name="capability name" /> </capture> <capabilities> <capability name="capability name" value="capability value" /> </capabilities> <controlAdapters markupTextWriterType="type name"> <adapter adapterType="name of adapter class" controlType="name of control class" /> </controlAdapters> <sampleHeaders> <header name="header name" value="header value" /> </sampleHeaders> </browser> <gateway id="gateway ID" parentID="parent browser ID"> <!-- Same child elements as for <browser>. <identification></identification> <capture></capture> <capabilities></capabilities> <controlAdapters></controlAdapters> <sampleHeaders></sampleHeaders> --> </gateway> <defaultBrowser id="Default" parentID="parent browser ID" refID="reference ID" > <!-- Same child elements as for <browser>. <identification></identification> <capture></capture> <capabilities></capabilities> <controlAdapters></controlAdapters> <sampleHeaders></sampleHeaders> --> </defaultBrowser> </browsers> 33 PERSONALIZAR EL DISEÑO Y APARIENCIA DE UNA PÁGINA WEB: CSS, temas y funciones, páginas principales y elementos Web, App_Themes, StyleSheetTheme App_Themes Contiene una colección de archivos (archivos .skin y .css, así como archivos de imagen y recursos genéricos) que definen el aspecto de las páginas Web y controles ASP.NET. TEMAS Y MÁSCARAS DE ASP.NET Un tema es un conjunto de valores de propiedad que permiten definir la apariencia de las páginas y de los controles y, a continuación, aplicar esa apariencia de manera coherente a las páginas de una aplicación Web, en toda una aplicación Web o en todas las aplicaciones Web de un servidor. Máscaras de temas y control Los temas están formados por un conjunto de elementos: máscaras, hojas de estilos en cascada (CSS), imágenes y otros recursos. Como mínimo, un tema contendrá máscaras. Los temas se definen en directorios especiales en un sitio Web o un servidor web. Máscaras Un archivo de máscara tiene la extensión de nombre de archivo .skin y contiene los valores de propiedades para los controles individuales como Button, Label, TextBox o Calendar. La configuración de las máscaras de control se parece al propio marcado del control, pero sólo contiene las propiedades que se desee establecer como parte del tema. Por ejemplo, lo siguiente es una máscara de control Button: <asp:button runat="server" BackColor="lightblue" ForeColor="black" /> 130 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Los archivos .skin se crean en la carpeta Theme. Un archivo .skin puede contener una o más máscaras de control para uno o más tipos de control. Es posible definir un archivo de máscaras independiente para cada control o definir todas las máscaras para un tema en un archivo único. Hay dos tipos de máscaras de control, máscaras predeterminadas y máscaras con nombre: Una máscara predeterminada se aplica automáticamente a todos los controles del mismo tipo cuando un tema se aplica a una página. Una máscara de control es predeterminada si no tiene un atributo SkinID. Por ejemplo, si se crea una máscara predeterminada para un control Calendar, la máscara de control se aplicará a todos los controles Calendar de las páginas en las que se utilice el tema. (Las máscaras predeterminadas coinciden exactamente atendiendo al tipo de control, de modo que una máscara de control Button se aplica a todos los controles Button pero no a los controles LinkButton ni a los derivados del objeto Button). Una máscara con nombre es una máscara de controles con un conjunto de propiedades SkinID. Las máscaras con nombre no se aplican automáticamente a todos los controles según el tipo. En su lugar, una máscara con nombre se aplica explícitamente a un control estableciendo la propiedad SkinID del control. Al crear máscaras con nombre, se pueden configurar diferentes máscaras para distintas instancias del mismo control en una aplicación. Hojas de estilos en cascada Un tema también puede incluir una hoja de estilos en cascada (archivo .css). Cuando se coloca un archivo .css en la carpeta de temas, la hoja de estilos se aplica automáticamente como parte del tema. La hoja de estilos se define utilizando la extensión de nombre de archivo .css en la carpeta de tema. Gráficos del tema y otros recursos Los temas también pueden incluir gráficos y otros recursos, como archivos de script o archivos de sonido. Por ejemplo, la parte de un tema de página podría incluir una máscara para un control TreeView. Como parte del tema, se pueden incluir los gráficos utilizados con el fin de representar los botones para expandir y contraer. Normalmente, los archivos de recursos del tema están en la misma carpeta que los archivos de máscara de dicho tema, pero pueden estar en cualquier parte de la aplicación Web, por ejemplo, en una subcarpeta de la carpeta de temas. Para hacer referencia a un archivo de recursos en una subcarpeta de la carpeta de temas, se utiliza una ruta de acceso como la que se muestra en esta máscara de control Image: <asp:Image runat="server" ImageUrl="ThemeSubfolder/filename.ext" /> También se puede almacenar sus archivos de recursos fuera de la carpeta de temas. Si utiliza la sintaxis de la tilde (~) para hacer referencia a los archivos de recursos, la aplicación Web encontrará automáticamente las imágenes. Por ejemplo, si se coloca los recursos de un tema en una subcarpeta de la aplicación, puede utilizar rutas de acceso como ~/Subcarpeta/nombreArchivo.ext para hacer referencia a los archivos de recursos, como en el siguiente ejemplo. <asp:Image runat="server" ImageUrl="~/AppSubfolder/filename.ext" /> Ámbito de los temas Se puede definir temas para una aplicación Web única o como temas globales que pueden utilizar todas las aplicaciones en un servidor web. Una vez definido un tema, se puede colocar en páginas individuales utilizando el atributo Theme o StyleSheetTheme de la directiva @ Page, o se puede aplicar a todas las páginas de una aplicación configurando el elemento <pages> en el archivo de configuración de la aplicación. Si el elemento <pages> se define en el archivo Machine.config, el tema se aplicará a todas las páginas de las aplicaciones web en el servidor. Temas de página Un tema de página corresponde a una carpeta de temas con máscaras de control, hojas de estilos, archivos de gráficos y otros recursos creados como una subcarpeta de la carpeta \App_Themes en el sitio Web. Cada tema constituye una subcarpeta diferente con respecto a la carpeta \App_Themes. En el siguiente ejemplo de código se muestra un tema de página típico que define dos temas denominados BlueTheme y PinkTheme. MyWebSite App_Themes 131 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 BlueTheme Controls.skin BlueTheme.css PinkTheme Controls.skin PinkTheme.css Temas globales Un tema global es un tema que puede aplicar a todos los sitios Web en un servidor. Los temas globales permiten definir una apariencia de conjunto para un dominio cuando se mantienen varios sitios Web en el mismo servidor. Los temas globales se parecen a los de página en que ambos tipos incluyen valores de propiedades, la configuración de las hojas de estilos y gráficos. Sin embargo, los temas globales se almacenan en una carpeta denominada Themes que es global al servidor web. Cualquier sitio Web del servidor y cualquier página de cualquier sitio Web pueden hacer referencia a un tema global. Prioridad en la configuración de temas Se puede especificar la prioridad que tiene la configuración del tema sobre la configuración regional del control especificando cómo se aplica el tema. Si se establece la propiedad de una página Theme, los valores de control en el tema y la página se combinan para formar la configuración final para el control. Si la configuración del control se define tanto en el control como en el tema, la configuración del control del tema reemplaza cualquier configuración de la página en el control. Esta estrategia hace posible que el tema pueda crear una apariencia coherente a lo largo de las páginas, incluso si los controles de las páginas ya tuvieran valores de propiedades individuales. Por ejemplo, esto permite aplicar un tema a una página que se creó en una versión anterior de ASP.NET. Asimismo, es posible aplicar un tema como tema de la hoja de estilos estableciendo la propiedad StyleSheetTheme de la página. En este caso, la configuración de la página local tiene prioridad sobre aquellos definidos en el tema cuando la configuración se define en ambos lugares. Éste es el modelo utilizado en las hojas de estilos en cascada. Se podría aplicar un tema como tema de la hoja de estilos si se desea poder establecer las propiedades de controles individuales en la página mientras se sigue aplicando un tema para lograr una apariencia de conjunto. Los elementos de temas globales no pueden reemplazarse parcialmente por elementos de temas de nivel de aplicación. Si crea un tema de nivel de aplicación con el mismo nombre que un tema global, los elementos de tema de nivel de aplicación no reemplazarán los elementos del tema global. Propiedades que se pueden definir mediante temas Como regla general, se pueden usar los temas para definir las propiedades relacionadas con la apariencia de una página o de un control o el contenido estático. Sólo se pueden establecer esas propiedades que tienen un atributo ThemeableAttribute establecidas como true en la clase de control. Las propiedades que especifican explícitamente el comportamiento de los controles en lugar de su apariencia no aceptan valores de tema. Por ejemplo, no se puede configurar la propiedad CommandName de un control Button mediante un tema. De manera similar, no se puede utilizar un tema para configurar la propiedad AllowPaging o DataSource de un control GridView. Tener en cuenta que no puede utilizar generadores de expresiones, que generan expresiones de código para asignarlas a una página en tiempo de compilación, en temas o máscaras. Temas frente a Hojas de estilos en cascada Los temas son similares a las hojas de estilos en cascada en cuanto a que tanto los temas como las hojas de estilos definen una serie de atributos comunes que se pueden aplicar a cualquier página. Sin embargo, los temas se diferencian de las hojas de estilos en los siguientes puntos: 132 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Los temas pueden definir muchas propiedades de un control o de una página, y no sólo las propiedades de un estilo. Por ejemplo, los temas permiten especificar los gráficos de un control TreeView, el diseño de plantilla de un control GridView, etcétera. Los temas pueden incluir gráficos. Los temas no se colocan en cascada de la misma manera que las hojas de estilos. De forma predeterminada, cualquier valor de propiedad definido en un tema al que se haga referencia en la propiedad Theme de una página reemplazará los valores de las propiedades establecidos mediante declaración, a menos que aplique explícitamente el tema mediante la propiedad StyleSheetTheme. Sólo se puede aplicar un tema a cada página. No puede aplicar varios temas a una página, a diferencia de las hojas de estilos que sí se pueden aplicar varias. Consideraciones de seguridad Los temas pueden causar problemas de seguridad cuando se utilizan en el sitio Web. Se pueden utilizar temas malintencionados para: Modificar el comportamiento de un control de forma que no se comporte según lo previsto. Insertar script de cliente, lo que puede suponer un riesgo de scripting entre sitios. Modificar la validación. Divulgar información confidencial. Las formas de mitigar estas amenazas comunes son las siguientes: Proteger los directorios de temas globales y de aplicación con una configuración de control de acceso apropiada. Sólo los usuarios de confianza deben poder escribir archivos en los directorios de temas. No utilizar temas de un origen que no sea de confianza. Examinar todos los temas que no provengan de su organización por si contienen código malintencionado antes de utilizarlos en su sitio Web. No exponer el nombre del tema en los datos de una consulta. Los usuarios malintencionados podrían utilizar esta información para usar temas que el programador no conoce y, de ese modo, divulgar información confidencial. CONTROLES DE SERVIDOR WEB ASP.NET Y ESTILOS DE CSS Se puede controlar el aspecto de los controles de servidor de ASP.NET estableciendo varias propiedades de aspecto como ForeColor, BackColor, Height y Width. Además, algunos controles admiten objetos de estilo que exponen una configuración relacionada con el estilo adicional. Nota: Las páginas Web ASP.NET funcionan como páginas HTML en tiempo de ejecución. Por consiguiente, se puede utilizar hojas de estilo en cascada (CSS) para establecer la apariencia de cualquier elemento en la página que no sea los controles de servidor Web. Además, se puede definir temas de ASP.NET que incluyen la configuración de hojas de estilos en cascada y, a continuación, aplicar los temas a las páginas o al sitio. Las secciones siguientes proporcionan información sobre cómo establecer estilos directamente, incluso cómo trabajar con estilos tanto en tiempo de diseño como mediante programación. Representación de propiedades de apariencia en el explorador Cuando se ejecuta la página, las propiedades de apariencia se representan según las capacidades del explorador del usuario. Si el explorador del usuario admite hojas de estilos en cascada (CSS), las propiedades de apariencia se representan como atributos de estilo de los elementos HTML que componen el control. Por ejemplo, si se define un control de servidor Web HyperLink y establece su propiedad ForeColor en Red, su propiedad Bold en true y su propiedad Size en xx-small, el control se representa como el que se incluye a continuación si el explorador del usuario admite hojas de estilos: <a id="hyperlink1" style="color: red; font-size: xx-small; font-weight: bold;">HyperLink</a> Por otro lado, si el explorador del usuario no admite estilos, el control se representa por otros medios, como un elemento <font>. A continuación se muestra la representación del ejemplo anterior, pero para un explorador que no admite estilos: <a id="a1"><b><font color="red" size="1">HyperLink</font></b></a> Otros ejemplos de propiedades que se representan de forma diferente dependiendo del explorador son BorderWidth y BorderColor. 133 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Algunas propiedades de apariencia, como BorderStyle no se puede representar sin utilizar estilos. Estas propiedades se omiten por consiguiente en exploradores que no admiten estilos. Objetos de estilo del control Además de las propiedades de apariencia como ForeColor y BackColor, los controles exponen uno o varios objetos de estilo que encapsulan propiedades de apariencia adicionales. Un ejemplo lo constituye la propiedad del estilo Font, que expone un objeto de tipo FontInfo que contiene propiedades individuales pertenecientes a la fuente, como Size, Name y Bold. Algunos controles exponen objetos de estilo que puede utilizar para establecer la apariencia de partes específicas del control. Por ejemplo, el control Calendar de servidor Web contiene objetos de estilo como DayStyle (días individuales), SelectedDayStyle (un día, una semana o un mes seleccionado por el usuario) y WeekendDayStyle. Al utilizar, por ejemplo, el objeto de estilo SelectedDayStyle, se pueden establecer las propiedades BackColor y ForeColor del día seleccionado por el usuario. La mayor parte de los objetos de estilo son de tipo Style o TableItemStyle porque establecen los atributos de celdas de tabla. La propiedad Font es de tipo FontInfo. Prioridad y herencia de los objetos de estilo En controles complejos, los objetos de estilo a menudo heredan características de otros objetos de estilo. Por ejemplo, en el control Calendar, el objeto SelectedDayStyle está basado en el objeto DayStyle. Si no establece explícitamente ninguna propiedad para SelectedDayStyle, hereda las características del objeto DayStyle. Esta herencia significa que las propiedades del objeto de estilo que ha establecido tienen un orden de prioridad. Por ejemplo, la siguiente lista muestra el orden de las propiedades del objeto de estilo para el control Calendar, con la mayor prioridad dada a la configuración del último objeto de la lista. 1. Propiedades de apariencia del control Calendar base. 2. Objeto de estilo DayStyle. 3. Objeto de estilo WeekendDayStyle. 4. Objeto de estilo OtherMonthDayStyle. 5. Objeto de estilo TodayDayStyle. 6. Objeto de estilo SelectedDayStyle. Pueden surgir dificultades con los estilos cuando éstos se dividen entre un elemento de contenedor y un elemento de texto. Por ejemplo, suponga que tiene una hoja de estilos para un control, y desea aplicar las propiedades de estilo de texto a un vínculo y aplicar el resto del estilo a un contenedor. Esto es posible si establece los estilos mediante las propiedades de estilo del control, como MenuItemStyle para un control de menú o TodayDayStyle para un control de calendario. Pero es más difícil si se utilizan los estilos definidos por una propiedad CssClass, porque ASP.NET no tiene forma de conocer el contenido de la clase en el servidor. ASP.NET aplica los estilos definidos en la propiedad CssClass a los elementos de texto y de contenedor, y agrega un estilo en línea para suprimir los efectos de esta aplicación doble (bordes dobles, multiplicación de las fuentes proporcionales, etc.). La mejor manera de aplicar estilo a un control es utilizar las propiedades de estilo definidas por el control y usar una hoja de estilos o estilos en línea para realizar pequeños ajustes en los distintos elementos, si es necesario. Para reemplazar un estilo definido por las propiedades de estilo de un control, utilice la regla de CSS importante en un hoja de estilos o en estilos en línea. En el ejemplo de código siguiente se utiliza la propiedad CssClass en el elemento hovernodestyle. Esta clase se define dos veces como myclass y como a.myclass:visited para reemplazar la definición de a:visited. <%@ Page Language="C#" %> <html> <head runat="server"> <asp:sitemapdatasource id="SiteMapSource" runat="server" /> <style type="text/css"> a:visited { 134 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 color: #000066 } myclass, a.myclass:visited { color: #FF0000 } </style> </head> <body> <form runat="server"> <a href="http://www.Contoso.com">Contoso</a> <asp:treeview id="treeview1" runat="server" initialexpanddepth="1" datasourceid="SiteMapSource" forecolor="#444444" font-names="Verdana" font-size="0.8em"> <nodestyle font-bold="true" /> <hovernodestyle cssclass=myclass /> </asp:treeview> </form> </body> </html> Si se utiliza hojas de estilos en cascada (CSS) para personalizar el aspecto de un control, emplear estilos en línea o un archivo CSS independiente, pero no ambos. El uso de estilos en línea y un archivo CSS independiente puede producir resultados imprevistos. Controlar clases y estilos CSS directamente Además de las propiedades de apariencia y objetos de estilo, los controles exponen dos propiedades que permiten manipular estilos CSS de una forma más directa: CssClass y Style. La propiedad CssClass permite asignar una clase de hoja de estilos al control. La propiedad Style permite establecer una cadena de atributos de estilo para que se escriba tal cual en el control. El uso de la propiedad Style permite establecer atributos de estilo que no se exponen a través de otras propiedades. La propiedad Style expone una colección a cuyos métodos, como Add y Remove, puede llamar para establecer directamente los estilos. La configuración realizada en la propiedad Style no se refleja en la propiedad de apariencia individual correspondiente. Por ejemplo, si establece una cadena background-color:red en la propiedad Style, la propiedad BackColor tampoco se establece en rojo, aunque el control se represente con un fondo rojo. Si establece tanto propiedades de apariencia como la propiedad Style, las propiedades de apariencia individuales tienen precedencia sobre la propiedad Style. 135 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 34 TRABAJAR CON OBJETOS INTRÍNSECOS DE ASP.NET: Request, Server, Application, Session, Response, HttpContext Espacio de nombres System.Web El espacio de nombres System.Web ofrece clase en intergaces que habilitan la comunicación entre el servidor y el navegador. Este espacio de nombre incluye la clase HttpRequest, la cual contiene toda la información de un request HTTP; la clase Httpresponse la cual controla la salida HTTP al cliente; y la clase HttpServerUtility la cual prove acceso a los utilitarios del lado del servidor y los procesos. System.Web también incluye clases para la manipulación de “cookies”, transferencia de arhivos, información de excepciones y control del cache. Clase HttpRequest Permite a ASP.NET leer los valores HTTP enviados por un cliente durante una solicitud Web. Los métodos y propiedades de la clase HttpRequest se exponen a través de las propiedades Request de las clases HttpApplication, HttpContext, Page y UserControl. Clase HttpServerUtility Proporciona métodos auxiliares para procesar las solicitudes Web. Los métodos y las propiedades de la clase HttpServerUtility se exponen a través del objeto intrínseco Server proporcionado por ASP.NET. La propiedad Server proporciona acceso mediante programación a las propiedades y los métodos de la clase HttpServerUtility. Como las páginas ASP.NET contienen una referencia predeterminada al espacio de nombres System.Web (que contiene la clase HttpContext), se puede hacer referencia a los miembros de HttpContext en una página .aspx sin la referencia de clase completa a HttpContext. Por ejemplo, se puede utilizar simplemente Server.CreateObject("MyCOMComponent") para crear una instancia de un objeto COM en el servidor. No obstante, si desea utilizar los miembros de HttpServerUtility desde un módulo de código subyacente ASP.NET, debe incluir en el módulo una referencia al espacio de nombres System.Web y, además, una referencia completa al contexto de solicitud/respuesta que esté activo en ese momento y a la clase de System.Web a utilizar. Clase HttpApplication Define los métodos, las propiedades y los eventos comunes a todos los objetos de aplicación incluidos en una aplicación ASP.NET. Esta clase es la clase base para las aplicaciones definidas por el usuario en el archivo Global.asax. Las instancias de la clase HttpApplication se crean en la infraestructura ASP.NET; no las crea directamente el usuario. Una única instancia de la clase HttpApplication puede procesar muchas solicitudes durante su vida útil, pero sólo una cada vez. Por tanto, se pueden utilizar variables miembro para almacenar datos para cada solicitud. Una aplicación ejecuta los eventos administrados por módulos o código de usuario definido en el archivo Global.asax en el orden siguiente: 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. BeginRequest AuthenticateRequest PostAuthenticateRequest AuthorizeRequest PostAuthorizeRequest ResolveRequestCache PostResolveRequestCache Después del evento PostResolveRequestCache y antes del evento PostMapRequestHandler, se crea un controlador de eventos (una página que corresponde a la dirección URL de la solicitud) PostMapRequestHandler AcquireRequestState PostAcquireRequestState PreRequestHandlerExecute PostRequestHandlerExecute ReleaseRequestState PostReleaseRequestState Después del evento PostReleaseRequestState, los filtros de respuesta, si los hay, filtran el resultado. 136 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 15. UpdateRequestCache 16. PostUpdateRequestCache 17. EndRequest Propiedad Page.Session Obtiene el objeto Session actual proporcionado por ASP.NET. Esta propiedad proporciona información sobre la sesión de solicitud actual. Se mantiene un objeto Session para cada usuario que solicita una página o un documento de una aplicación ASP.NET. Las variables almacenadas en el objeto Session no se descartan cuando el usuario se desplaza de una página a otra en la aplicación; en su lugar, estas variables persisten siempre y cuando el usuario esté obteniendo acceso a las páginas de la aplicación. Clase HttpResponse Encapsula la información de la respuesta HTTP de una operación ASP.NET. Los métodos y propiedades de la clase HttpResponse se exponen a través de la propiedad Response de las clases HttpApplication, HttpContext, Page y UserControl. Clase HttpContext Encapsula toda la información específica de HTTP acerca de una solicitud HTTP individual. A las clases que heredan las interfaces IHttpModule y IHttpHandler se les proporciona una referencia a un objeto HttpContext para la actual solicitud HTTP. El objeto proporciona acceso a las propiedades Request, Response y Server intrínsecas de la solicitud. 35 IMPLEMENTAR LA GLOBALIZACIÓN Y ACCESIBILIDAD: archivos de recursos, configuración de cultura, RegionInfo, App_GlobalResources, App_LocalResources, TabIndex, AlternateText , GenerateEmptyAlternateText, AccessKey, Label.AssociatedControlID INFORMACIÓN GENERAL SOBRE LA GLOBALIZACIÓN Y LA LOCALIZACIÓN En el pasado, el término localización se refería a menudo a un proceso que comenzaba después de que un programador de aplicaciones compilase los archivos fuente en el idioma original. Entonces, otro equipo iniciaba el proceso de modificación de los archivos fuente para que pudieran usarse en otro idioma. El idioma original podía ser, por ejemplo, el inglés; y el segundo idioma, el alemán. Este enfoque, sin embargo, es prohibitivo y provoca incoherencias entre versiones. Incluso ha propiciado que algunos clientes se decidieran a comprar la versión original del programa para no tener que esperar la durante varios meses la llegada de la versión localizada. Un modelo más rentable y funcional divide el proceso de desarrollo de aplicaciones de uso internacional en tres partes bien diferenciadas: globalización, localizabilidad y localización. Las principales ventajas de diseñar e implementar aplicaciones que tengan en cuenta y se adapten a las convenciones regionales, a datos en diversos idiomas y a formatos diferentes son: • Se puede lanzar la aplicación al mercado más rápidamente. No se necesita desarrollo adicional para localizar una aplicación una vez que la versión original está completa. • Se aprovechan los recursos de manera más eficaz. Al convertir la adaptación a criterios internacionales en una parte del proceso de desarrollo original, hacen falta menos desarrollo y menos recursos de comprobación que si agregara esa opción una vez iniciado el trabajo. Es más, si agrega la adaptación a criterios internacionales cuando la aplicación esté concluida, es posible que la haga menos estable, y cree problemas que podría haber resuelto al principio. • La aplicación es más fácil de mantener. Si genera la versión localizada de la aplicación desde el mismo conjunto de fuentes que la versión original, sólo algunos módulos aislados necesitarán localización. Por lo tanto, el código será más fácil y barato de mantener si incluye las características de uso internacional. La clave de este aspecto del diseño de software radica en usar archivos de recursos para las versiones localizadas de la aplicación. La globalización es el proceso de diseño y desarrollo de un producto de software que pueda funcionar con diversas culturas o configuraciones regionales. Este proceso requiere: 137 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 • Identificar las culturas o configuraciones regionales que deberá admitir el software • Diseñar características válidas para las diferentes culturas o configuraciones regionales • Escribir código que funcione igualmente bien en cada una de las culturas o configuraciones regionales admitidas En otras palabras, la globalización permite la entrada, presentación y salida de un conjunto definido de secuencias de comandos de idioma perteneciente a una determinada área geográfica. La mejor manera de globalizar estas funciones es utilizar el concepto de culturas o configuraciones regionales. Una cultura o configuración regional es un conjunto de reglas y otro de datos, específicos de un área geográfica e idioma determinados. Estas reglas y datos incluyen información acerca de: • Clasificación de caracteres • Formato de fecha y hora • Convenciones numéricas, monetarias, de pesos y de medidas • Reglas de ordenación CONCEPTOS COMUNES DE RECURSOS La mayor parte de los aspectos de programación en .NET Framework son los mismos para todos los lenguajes compatibles, ya que sus compiladores generan código MSIL (Microsoft Intermediate Language, Lenguaje intermedio de Microsoft) administrado y autodescriptivo. El código MSIL administrado se ejecuta con Common Language Runtime, que proporciona integración entre varios lenguajes, administración de memoria automática, control de excepciones entre lenguajes, mayor seguridad y un modelo simplificado para la interacción entre componentes. Además del motor de tiempo de ejecución, .NET Framework incluye la biblioteca de clases de .NET Framework, a la que también se puede tener acceso desde cualquier lenguaje compatible con .NET. Varios aspectos de este proceso de desarrollo común son particularmente importantes al crear aplicaciones que utilizan recursos. Unidades de creación Las bibliotecas de clases de .NET Framework que se creen también se organizan en espacios de nombres jerárquicos y se almacenan en archivos ejecutables portátiles (PE), normalmente, archivos DLL y EXE. Puede haber varios espacios de nombres, incluso anidados, en un solo archivo PE. Además, un espacio de nombres puede dividirse en varios archivos PE. Se combinan uno o varios archivos PE (y posiblemente otros tipos de archivos, como pueden ser recursos) para crear un ensamblado, que es una unidad física que se puede implementar, volver a utilizar y a la que se puede asignar un número de versión. El motor de tiempo de ejecución utiliza los ensamblados para localizar y enlazar a los tipos a los que se hace referencia. Los recursos también se pueden enlazar en ensamblados, se pueden empaquetar por separado con varios formatos diferentes o incluso se pueden utilizar como archivos individuales, por ejemplo, como imágenes JPEG. La información relativa a lo que contiene un ensamblado, incluidas las clases y recursos, está contenida en el manifiesto del ensamblado. Referencias culturales En .NET Framework, una referencia cultural es el idioma del usuario combinado, opcionalmente, con la ubicación del propio usuario. Al especificar una referencia cultural, es posible utilizar un conjunto de preferencias comunes para determinada información, como cadenas, formato de fechas y formato de números, que corresponde a las convenciones de idioma y ubicación del usuario. La ubicación puede ser un país o una región; esto último puede ser el término geopolíticamente correcto en una ubicación donde un país no se reconoce oficialmente. El idioma y la ubicación se pueden especificar mediante códigos definidos por RFC 1766 de Internet, "Etiquetas para la identificación de idiomas". Los propios códigos reales se definen mediante dos estándares ISO: ISO 639, "Códigos para la representación de nombres de idiomas", e ISO 3166, "Códigos para la representación de nombres de países". Vea el tema "Etiquetas de idioma y de país o región" en el Apéndice A: Información adicional de recursos para obtener información de referencia acerca de estos estándares. Se puede tener acceso a las preferencias detalladas de referencias culturales mediante las instancias de la clase CultureInfo, a las que, a su vez, se tiene acceso mediante etiquetas de referencias culturales. Las etiquetas de referencias culturales utilizan el formato principal[-secundario], donde la etiqueta principal es el idioma y la etiqueta secundaria opcional es el código de país o región. Por convención, la etiqueta de idioma está compuesta de dos letras en minúsculas y la etiqueta de país o región está compuesta de dos letras en mayúsculas. La tabla siguiente contiene ejemplos de referencias de etiquetas culturales. 138 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 de Alemán de-AT Alemán de Austria de-CH Alemán de Suiza en Inglés en-US Inglés de Estados Unidos en-AU Inglés de Australia en-CA Inglés de Canadá fr Francés sp Español En .NET Framework, las etiquetas de dos letras indican referencias culturales neutras, solamente de idioma, como de para alemán. Las etiquetas de cuatro letras indican referencias culturales específicas, tales como fr-CA para el francés que se habla en Canadá. En la mayor parte de las situaciones, la interfaz de usuario se especifica como una referencia cultural específica. Sin embargo, en ciertos casos, como ja-JP para el japonés de Japón, solamente hay una referencia cultural específica. En esta situación, a menudo se utilizan ambas etiquetas indistintamente. Si es necesario que una aplicación pueda establecer una referencia cultural específica, quizás como respuesta a la configuración de un explorador de Internet, la aplicación debe asignar todas las referencias culturales neutras a referencias culturales específicas con el método CreateSpecificCulture Las referencias culturales en .NET Framework ocupan el lugar de la configuración regional de NLS (National Language Support, compatibilidad con el idioma nacional), que utiliza códigos de LCID (Locale Identifier, identificador de configuración regional). La propiedad LCID de la clase CultureInfo proporciona interoperabilidad y facilita la integración con el software basado en NLS. Clases de recursos de .NET La biblioteca de clases de .NET Framework ofrece varias clases para que los programadores puedan trabajar con recursos en sus aplicaciones y herramientas. Clase ResourceManager La clase ResourceManager (del espacio de nombres System.Resources) proporciona un acceso cómodo a recursos de referencias culturales en tiempo de ejecución. Esta clase proporciona una reserva de recursos (normalmente para la referencia cultural neutra) cuando no existe un recurso localizado, permite la serialización de recursos y proporciona el método CreateFileBasedResourceManager para tener acceso a los recursos que no están empaquetados en un ensamblado. Por supuesto, los programadores también pueden derivar clases de ResourceManager al crear soluciones de recursos personalizados. Clase ResourceWriter La clase ResourceWriter (del espacio de nombres System.Resources) escribe recursos en el formato predeterminado del sistema en un archivo o secuencia de salida. Los recursos se especifican como pares de nombre y valor mediante el método AddResource. En los nombres de recursos se distinguen mayúsculas y minúsculas cuando se utilizan para búsquedas, pero ResourceWriter no escribe un nombre de recurso en un archivo de recursos si el nombre varía solamente en las mayúsculas y minúsculas. La clase ResourceWriter proporciona una implementación predeterminada de la interfaz IResourceWriter y el programador la puede reemplazar. Nota Los recursos no se escribirán necesariamente en el mismo orden en que se agregaron con el programa. Clase ResourceReader La clase ResourceReader (del espacio de nombres System.Resources) enumera las secuencias y archivos de recursos, y lee los pares secuenciales de nombre y valor de los recursos. Esta clase proporciona una implementación predeterminada de la interfaz IResourceReader que, como la clase ResourceWriter, el programador puede reemplazar. 139 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Clase ResourceSet La clase ResourceSet (del espacio de nombres System.Resources) almacena todos los recursos localizados para una referencia cultural determinada. Todos los recursos se cargan inmediatamente en la memoria. A diferencia de ResourceManager, ResourceSet no tiene reservas de recursos. Por este motivo, ResourceSet resulta útil principalmente para crear herramientas y utilidades pero no en aplicaciones localizadas. ResourceSet también se puede utilizar para controlar la caché de recursos (por ejemplo, para impedir que se guarden imágenes en caché). Clase CultureInfo La clase CultureInfo (del espacio de nombres System.Globalization) contiene un conjunto de información sobre las preferencias del usuario en función del idioma, idioma secundario, país o región, y convenciones culturales del usuario. Esta clase se utiliza para dar formato a fechas, horas y números, para ordenar cadenas y para determinar la elección del idioma del texto. Clase RegionInfo La clase RegionInfo (del espacio de nombres System.Globalization) se utiliza para determinar la unidad de medida y asignar códigos de región a los nombres de regiones. Método Assembly.GetManifestResourceStream El método Assembly.GetManifestResourceStream (del espacio de nombres System.Reflection) carga directamente en una secuencia los datos de recursos del manifiesto. Resulta particularmente útil cuando los recursos están almacenados con formatos personalizados, que ResourceManager no podría entender de forma nativa. Nota Para usar el método Assembly.GetManifestResourceStream, los recursos deben encontrarse en un ensamblado. Propiedad Thread.CurrentUICulture La propiedad Thread.CurrentUICulture (del espacio de nombres System.Threading) es útil cuando hay que determinar la referencia cultural actual o, lo que es más importante, para establecer la referencia cultural y emular la ejecución en una versión localizada de Windows diferente. Esto es necesario ya que el Panel de control no puede mostrar varios LCID de interfaz en una versión de Windows 2000 que carezca de una interfaz de usuario multilenguaje. En cambio, se puede establecer la referencia cultural mediante programa en tiempo de ejecución o mediante subprocesos. Implementación En el caso más sencillo, un archivo independiente y ejecutable de .NET Framework se puede ejecutar localmente en cualquier equipo donde esté instalado Common Language Runtime. No hace falta más, no se crean entradas en el Registro, nada puede interrumpir otra aplicación ni hacer que se deje de ejecutar y con eliminar el archivo (si se copió localmente) basta para quitar la aplicación sin dejar huellas en el equipo. Las aplicaciones que se ejecutan desde una dirección URL que representa un sitio Web se comportan de forma ligeramente distinta. En estos casos, los ensamblados se instalan en la caché de descarga y después se borran automáticamente. Todas las demás aplicaciones, incluidas las de una dirección URL que representa un archivo, se ejecutan a partir del código fuente y no se guardan en la caché del equipo local. Distribución Por supuesto, la mayor parte de las aplicaciones de cliente se empaquetarán en un formato de distribución común (por ejemplo, en un archivo .cab o .msi) y muchas se instalarán mediante mecanismos de distribución de aplicaciones como Windows 2000 IntelliMirror o Microsoft Systems Management Server (SMS), que utilizan la tecnología Microsoft Installer. CÓMO: CREAR ARCHIVOS DE RECURSOS PARA SITIOS WEB ASP.NET Un archivo de recursos es un archivo XML que puede contener cadenas y otros recursos, como rutas de acceso al archivo de imagen. Estos archivos normalmente se utilizan para almacenar cadenas de la interfaz de usuario que se deben traducir a otros idiomas. Esto se debe a que puede crear un archivo de recursos independiente para cada idioma al que desee traducir una página Web. Los archivos de recursos globales están disponibles en cualquier página o componente del sitio Web. Los archivos de recursos locales se asocian a una sola página Web, a un control de usuario o a una página maestra y contienen los recursos sólo de esa página. 140 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 En Visual Web Developer, puede utilizar el editor de recursos administrados para crear los archivos de recursos globales o locales. En los archivos de recursos locales, también puede generar recursos neutros para la referencia cultural directamente desde una página Web del diseñador. Crear recursos manualmente Para crear un archivo de recursos manualmente 1. Asegurarse de que el sitio Web tiene una carpeta en la que almacenar el archivo de recursos mediante una de las siguientes acciones: Si se está creando un archivo de recursos global, debe tener una carpeta denominada App_GlobalResources. Para crear la carpeta, en Explorador de soluciones, clic con el botón secundario del mouse en el nombre del sitio Web, clic en Agregar carpeta y, a continuación, en Carpeta App_GlobalResources. Sólo puede haber una de estas carpetas en una aplicación y debe estar ubicada en la raíz de la aplicación. Si se está creando un archivo de recursos local, debe tener una carpeta denominada App_LocalResources. Para crear la carpeta, en Explorador de soluciones, clic con el botón secundario del mouse en el nombre del sitio Web, clic en Agregar carpeta y, a continuación, en carpeta App_LocalResources. Puede haber muchas carpetas de este tipo en una aplicación y pueden estar ubicadas en cualquier nivel de la misma. 2. Para crear un archivo de recursos, clic con el botón secundario del mouse en las carpetas App_GlobalResources o App_LocalResources y, a continuación, haga clic en Agregar nuevo elemento. Nota: Los archivos de recursos globales deben estar en la carpeta App_GlobalResources. Si se intenta crear un archivo .resx fuera de esta carpeta, Visual Web Developer le indica que se cree en la carpeta. 3. En la opción Plantillas instaladas de Visual Studio del cuadro de diálogo Agregar nuevo elemento, clic en Archivo de recursos de ensamblado. 4. En el cuadro Nombre, escriba un nombre para el archivo de recursos y, a continuación, clic en Agregar. Visual Web Developer abre el archivo en el Editor de recursos administrados. El editor muestra una cuadrícula donde puede escribir nombres (claves), valores y comentarios opcionales. 5. Escribir los nombres y valores de las claves para cada recurso que necesite en la aplicación y, a continuación, guarde el archivo. Nota: No intente incrustar un gráfico directamente en un archivo de recursos porque los controles no leerán la cadena de recurso como archivo de imagen transmitido. Los archivos de recursos representan los gráficos almacenando la dirección URL del gráfico como cadena. 6. Para crear archivos de recursos para idiomas adicionales, copiar el archivo en el Explorador de soluciones o en el Explorador de Windows y, a continuación, cámbiar el nombre mediante uno de los modelos siguientes: Para archivos de recursos globales: nombre.idioma.resx nombre.idioma-referencia cultural.resx Para archivos de recursos locales: nombreDePáginaOControl.extensión.idioma.resx nombreDePáginaOControl.extensión.idioma-referencia cultural.resx Por ejemplo, si se crea un archivo de recursos global denominado WebResources.resx para la traducción al árabe egipcio, asignar al archivo copiado el nombre WebResources.ar-eg.resx. Para crear un archivo de recursos relacionado para la traducción a español sin especificar una referencia cultural, asignar al archivo copiado el nombre WebResources.es.resx. Tener en cuenta que para los archivos de recursos locales, el nombre del archivo de recursos es el nombre de la página o del control, incluyendo la extensión de nombre de archivo, y a continuación la información de idioma y de referencia cultural. 7. Abrir el archivo copiado y traduzca cada valor, sin cambiar los nombres (claves). 8. Repetir los pasos 6 y 7 por cada idioma adicional que desee utilizar. Crear recursos a partir de una página Web La característica siguiente no está disponible con Visual Web Developer Express. Para generar un archivo de recursos local desde una página Web ASP.NET 1. 2. 3. 4. Abrir la página para la que desee crear un archivo de recursos. Cambiar a la vista Diseño. En el menú Herramientas, clic en Generar recurso local. Visual Web Developer crea la carpeta App_LocalResources si aún no existe. Visual Web Developer crea después un archivo de recursos neutros para la referencia cultural de la página actual, que incluye un par de clave-nombre por cada propiedad de control o de página que requiera localización. Finalmente, Visual Web Developer agrega un atributo meta a cada control de servidor web ASP.NET con el fin de configurar el control para utilizar la localización implícita. Escribir los valores de cada recurso que necesite en la aplicación y, a continuación, guardar el archivo. Nota: No se intente incrustar un gráfico directamente en un archivo de recursos porque los controles no leerán la cadena de recurso como 141 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 archivo de imagen transmitido. Los archivos de recursos representan los gráficos almacenando la dirección URL del gráfico como cadena. 5. Si no se muestran los últimos cambios en los recursos, actualizar la vista Diseño; para ello, cambiar a la vista Código fuente y volver a la vista Diseño. 6. Crear archivos de recursos para otros idiomas siguiendo los pasos 6 y 8 del procedimiento anterior. Para generar un archivo de recursos global en Visual Web Developer 1. En el Explorador de soluciones, clic con el botón secundario en el nombre del sitio web, clic en agregar nuevo elemento y, a continuación, en Archivo de recursos. Visual Web Developer le pregunta si desea colocar el archivo en la carpeta App_GlobalResources y se ofrece para crearla. 2. Clic en Sí. 3. Escribir los valores de cada recurso que necesite en la aplicación y, a continuación, guardar el archivo. Nota No intentar incrustar un gráfico directamente en un archivo de recursos porque los controles no leerán la cadena de recurso como archivo de imagen transmitido. Los archivos de recursos representan los gráficos almacenando la dirección URL del gráfico como cadena. 4. Si no se muestran los últimos cambios en los recursos, actualizar la vista Diseño; para ello, cambiar a la vista Código fuente y volver a la vista Diseño. 5. Para crear archivos de recursos para idiomas adicionales, copiar el archivo en el Explorador de soluciones o en el Explorador de Windows y, a continuación, cambiar el nombre mediante uno de los modelos siguientes: nombre.idioma.resx nombre.idioma-referencia cultural.resx Nota En los nombres de archivos de recursos no incluir .aspx para evitar que se produzcan conflictos de nomenclatura. Por ejemplo, la carpeta del recurso no puede contener dos archivos con nombres como resTestPage.resx y resTestPage.aspx.resx. En este caso, la resolución de los nombres de archivo en la compilación crearía un conflicto de nomenclatura, con el consiguiente error en tiempo de compilación CREAR UNA APLICACIÓN WEB ACCESIBLE La creación de páginas Web accesibles permite llegar al máximo número posible de usuarios. Las personas con discapacidades no son los únicos usuarios que apreciarán que las páginas sean accesibles. Los usuarios de exploradores de sólo texto o de software que interpreta el contenido de las páginas Web, podrían depender de las opciones de accesibilidad. El diseño accesible permite que herramientas de automatización tales como los motores de búsqueda, busquen, indicen y manipulen la información de las páginas. Por último, futuras leyes de telecomunicaciones podrían requerir que la información que se distribuye por Internet sea accesible, igual que el software convencional. Las siguientes sugerencias para diseñar páginas Web accesibles proceden del sitio Web de accesibilidad de Microsoft: Proporcionar texto alternativo (ALT) adecuado para todos los gráficos. Hacer un uso correcto de mapas en imágenes. Redactar texto útil en los vínculos. Implantar un buen desplazamiento por el teclado. Proporcionar páginas alternativas que no utilicen marcos. Utilizar las tablas y sus alternativas correctamente. Proporcionar compatibilidad con las opciones de formato del lector de texto. No exijir la utilización de hojas de estilos. Utilizar formatos de archivo que el lector pueda utilizar. Evitar utilizar marquesinas que se desplacen. Proporcionar títulos para la mayoría de los objetos. Si no se puede cumplir los objetivos de accesibilidad, considere la posibilidad de proporcionar páginas Web alternativas que sólo contengan texto. Los controles ASP.NET son compatibles con muchas de las directrices de accesibilidad. Por ejemplo, la indicación del foco del teclado y de elementos de pantalla. SePuede utilizar las propiedades de los controles ASP.NET para ofrecer compatibilidad con otras directrices de accesibilidad, como se muestra a continuación. TabIndex Se utiliza esta propiedad para crear una ruta de desplazamiento razonable a través del formulario. Es importante que los controles que no tienen etiquetas intrínsecas, tales como los cuadros de texto, vayan precedidos de forma inmediata en el orden de tabulación por sus etiquetas asociadas. En casos en que esto no sea posible o deseable, utilizar la propiedad AssociatedControlID de un control Label para asociarlo a un cuadro de texto. 142 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Text Utilizar el elemento HTML para mostrar el método abreviado de teclado de un control. El uso de teclas de acceso contribuye a proporcionar acceso documentado mediante teclado a todas las funciones. (Utilizar la propiedad AccessKey para habilitar un método abreviado de teclado para un control.) Font Size Utilizar etiquetas de encabezado en lugar de tamaños específicos. AlternateText Proporcionar para todas las imágenes texto alternativo que sea significativo para la comprensión del contenido de la página Web. En algunas instancias, es adecuado no establecer texto alternativo para una imagen, como en el caso de imágenes utilizadas para dar formato gráfico. Para representar la propiedad AlternateText de una imagen como vacía, establecer la propiedad GenerateEmptyAlternateText en true para el control Image. AccessKey Utilizar esta propiedad para proporcionar acceso a los controles mediante el teclado. Clase LocalizableAttribute Especifica si se debe traducir una propiedad. Esta clase no se puede heredar. Cuando se genera código para un componente, los miembros que están marcados con el objeto LocalizableAttribute establecido en true tienen sus valores de propiedad guardados en archivos de recursos. Se pueden traducir estos archivos de recursos sin modificar el código. De forma predeterminada, los valores de propiedad de los miembros que no tienen un atributo traducible o que están marcados con el objeto LocalizableAttribute establecido en false persisten en el código si el tipo de datos lo permite. En caso contrario, si el componente principal se establece en Localizable, todas las propiedades persisten en el archivo de recursos. El valor predeterminado es false. Nota Cuando se marca una propiedad con el objeto LocalizableAttribute establecido en true, el valor de este atributo se establece en el miembro constante Yes. En el caso de las propiedades marcadas con el objeto LocalizableAttribute establecido en false, el valor es No. Por tanto, cuando desee comprobar el valor de este atributo en el código, debe especificar el atributo como LocalizableAttribute.Yes o LocalizableAttribute.No. Propiedad AlternateText Image.AlternateText (Propiedad) Obtiene o establece el texto alternativo que se muestra en el control Image cuando no está disponible la imagen. Los exploradores que admiten la característica de información sobre herramientas muestran este texto como una información sobre herramientas. Texto alternativo que se muestra en el control Image cuando no está disponible la imagen. Utilizar esta propiedad para especificar el texto que se ha de mostrar si la imagen especificada en la propiedad ImageUrl no está disponible. En los exploradores que admiten la característica de información sobre herramientas, este texto se muestra también como una información sobre herramientas. 36 IMPLEMENTAR OBJETOS EMPRESARIALES Y CLASES DE UTILIDAD: App_Code , conjuntos externos Carpetas de código compartido en sitios Web ASP.NET Si la aplicación Web incluye código que desea compartir entre las páginas, puede guardarlo en una de las dos carpetas especiales que hay debajo de la raíz de la aplicación Web, Bin y App_Code. Cuando se crean estas carpetas y se almacenan determinados tipos de archivos en ellas, ASP.NET los trata de manera especial. Carpeta Bin Puede almacenar ensamblados compilados en esta carpeta y el resto del código de cualquier parte de la aplicación Web (como el de las páginas) hará referencia a ella automáticamente. Un ejemplo típico es el código compilado de una clase personalizada. Puede copiar el ensamblado compilado en la carpeta Bin de la aplicación Web y, a continuación, la clase estará disponible para todas las páginas. 143 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Los ensamblados de la carpeta Bin no necesitan registrarse. La presencia de un archivo .dll en la carpeta Bin es suficiente para que ASP.NET lo reconozca. Si cambia el archivo .dll y escribe una nueva versión del mismo en la carpeta Bin, ASP.NET detectará la actualización y utilizará la nueva versión para las nuevas solicitudes de página a partir de ese momento. Seguridad de la carpeta Bin La colocación de los ensamblados compilados en la carpeta Bin pueden comprometer la seguridad. Sin embargo, se deberá tratar el código compilado de la carpeta Bin como cualquier otro código ejecutable. Se debe tener cuidado con el código compilado hasta que se haya probado. Tener en cuenta los siguientes aspectos de seguridad al colocar el código compilado en la carpeta Bin: El ámbito de los ensamblados de la carpeta Bin es la aplicación actual. Por consiguiente, no se pueden tener acceso a recursos ni invocar código que se encuentre fuera de la aplicación Web actual. En tiempo de ejecución, los niveles de acceso de un ensamblado se establecen de acuerdo con el nivel de confianza especificado en el equipo local. Si se está trabajando con un diseñador como Visual Studio, el código de la carpeta Bin se ejecuta en un contexto distinto del contexto en tiempo de ejecución. Carpeta App_Code Si se almacena el código fuente en la carpeta App_Code, se compilará automáticamente en tiempo de ejecución. Al ensamblado resultante puede tener acceso cualquier otro código de la aplicación Web. Por tanto, la carpeta App_Code funciona como la carpeta Bin, salvo que se puede almacenar código fuente en lugar de código compilado. La carpeta App_Code y su estado especial en una aplicación Web ASP.NET permiten crear clases personalizadas y otros archivos que sólo contienen código fuente, y utilizarlos en la aplicación Web sin tener que compilarlos independientemente. Esta carpeta puede contener archivos de código fuente escritos como archivos de clase tradicionales (es decir, archivos con extensión .vb, .cs, etc.). Sin embargo, también puede incluir archivos que no sean explícitamente de un lenguaje de programación específico. Entre los ejemplos cabe destacar los archivos .wsdl (lenguaje de descripción de servicios Web) y los archivos de esquema XML (.xsd). ASP.NET puede compilar estos archivos en ensamblados. La carpeta App_Code puede contener todos los archivos y subcarpetas que se necesiten. Se puede organizar el código fuente de la forma que se crea más conveniente, ASP.NET lo compilará en un solo ensamblado al que podrá tener acceso el código de cualquier parte de la aplicación Web. Nota No se permiten controles de usuario en la carpeta App_Code. Esto afecta tanto a los controles de usuario de un solo archivo como a los controles de usuario que utilizan el modelo de código subyacente. Al colocar un control de usuario en el directorio App_Code, el código del control de usuario se compila fuera de la secuencia requerida y, por tanto, no se permite. Tener en cuenta que no es necesario que los controles de usuario estén en la carpeta App_Code, porque están disponibles para las páginas en cualquier lugar de la aplicación. Deducir el lenguaje de programación de la carpeta App_Code El contenido de la carpeta App_Code no se marca explícitamente como escrito en un lenguaje de programación concreto. ASP.NET deduce el compilador que se debe invocar para la carpeta App_Code basándose en los archivos que contiene. Si la carpeta App_Code contiene archivos .vb, ASP.NET utiliza el compilador de Visual Basic; si contiene archivos .cs, el compilador de C#, etc. Si la carpeta App_Code contiene sólo archivos cuyo lenguaje de programación es ambiguo, como un archivo .wsdl, ASP.NET utilizará el compilador predeterminado para aplicaciones Web, tal como viene configurado en el elemento compilation de la aplicación Web o en el archivo de configuración del equipo. Varios lenguajes de programación en la carpeta App_Code Puesto que el código fuente de la carpeta App_Code se compila en un solo ensamblado, todos los archivos de esta carpeta deben estar escritos en el mismo lenguaje de programación. Por ejemplo, la carpeta App_Code no puede incluir código fuente escrito en Visual Basic y C#. 144 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Sin embargo, es posible configurar la aplicación Web para tratar las subcarpetas de la carpeta App_Code compilables separadas. Cada carpeta puede contener código fuente de un lenguaje de programación diferente. La especifica creando un elemento codeSubDirectories en el elemento compilation del archivo Web.config y agregando la subcarpeta. En el ejemplo siguiente se muestra la configuración de las subcarpetas denominadas VBCode compilar en ensamblados separados: como unidades configuración se una referencia a y CSCode para <compilation debug="false"> <codeSubDirectories> <add directoryName="VBCode" /> <add directoryName="CSCode" /> </codeSubDirectories> </compilation> Las referencias a las subcarpetas VBCode y CSCode no tienen por qué incluir información acerca del lenguaje de programación que contiene la subcarpeta. Como en el caso de la propia carpeta App_Code, ASP.NET deduce el compilador que se va a utilizar basándose en los archivos de la subcarpeta. Seguridad de la carpeta App_Code Los problemas de seguridad relacionados con el código de la carpeta App_Code son básicamente los mismos que los del código de la carpeta Bin (el código se compila en un ensamblado en tiempo de ejecución). Un factor atenuante es que el código de los archivos de la carpeta App_Code se puede leer. Sin embargo, si no se entiende el código, puede seguir comprometiendo la seguridad. Por consiguiente, tratar el código fuente de la carpeta App_Code como si se tratara de código compilado procedente del mismo origen. 37 IMPLEMENTAR EL ESTADO DE SESIÓN, VER EL ESTADO, CONTROLAR EL ESTADO, COOKIES, CACHÉ O ESTADO DE LA APLICACIÓN Información general sobre la administración de estados de ASP.NET Cada vez que la página se envía al servidor, se crea una nueva instancia de la clase de la página Web. En la programación Web tradicional, esto se traduce en que toda la información asociada a la página y sus controles se pierden con cada recorrido de ida y vuelta. Por ejemplo, si un usuario escribe información en un cuadro de texto, dicha información se perderá en el recorrido de ida y vuelta desde el explorador o dispositivo cliente al servidor. Para superar esta limitación inherente de la programación Web tradicional, ASP.NET incluye varias opciones que ayudan a preservar los datos en cada página y en toda la aplicación. Estas características son las siguientes: Estado de vista Estado de control Campos ocultos Cookies Cadenas de consulta Estado de aplicación Estado de sesión Propiedades de perfil Las características de estado de vista, estado de control, campos ocultos, cookies y cadenas de consulta almacenan todas ellas datos en el cliente de formas distintas, mientras que las características de estado de aplicación, estado de sesión y propiedades de perfil almacenan los datos en la memoria del servidor. Cada opción tiene ventajas y desventajas, dependiendo del escenario. Opciones de administración de estado basada en cliente Las siguientes secciones describen opciones para administrar el estado que almacenan la información en la página o en el equipo cliente. En estas opciones, la información no se conserva en el servidor entre acciones de ida y vuelta. 145 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Estado de vista La propiedad ViewState proporciona un objeto de diccionario para conservar valores entre las distintas solicitudes de una misma página. Éste es el método predeterminado que la página utiliza para conservar los valores de las propiedades de la propia página y sus controles entre recorridos de ida y vuelta. Cuando se procesa la página, se calcula el valor de hash del estado actual de la página y de los controles en una cadena y se guarda en la página como campo oculto o varios campos ocultos si el volumen de los datos almacenados en la propiedad ViewState supera el valor especificado en la propiedad MaxPageStateFieldLength. Cuando se devuelve la página al servidor, la página analiza la cadena de estado de vista durante su inicialización y restaura la información de las propiedades en la página. En un estado de vista se puede también almacenar valores. Estado de control En ocasiones es necesario almacenar los datos del estado de control para que un control funcione correctamente. Por ejemplo, si ha escrito un control personalizado con varias fichas que muestran distintos tipos de información, el control debe saber la ficha que se selecciona en los recorridos de ida y vuelta para que funcione tal y como se espera. La propiedad ViewState se puede utilizar para este propósito, pero los desarrolladores pueden desactivar el estado de vista en el nivel de página, interrumpiendo su control eficazmente. Para resolver este problema, el marco de trabajo de la página ASP.NET cuenta con una característica de ASP.NET denominada "estado de control". La propiedad ControlState permite mantener la información de las propiedades que es específica de un control y que no se puede desactivar como ocurre con la propiedad ViewState. Campos ocultos ASP.NET permite almacenar información en un control HiddenField, que se representa como campo oculto estándar HTML. Un campo oculto no se representa visiblemente en el explorador, pero se pueden configurar sus propiedades igual que las de un control estándar. Cuando se envía una página al servidor, el contenido del campo oculto se envía en la colección Form de HTTP junto con los valores de otros controles. Un campo oculto actúa como repositorio de cualquier información específica de página que desee almacenar directamente en la página. Nota sobre la seguridad Es fácil que un usuario malintencionado vea y modifique el contenido de un campo oculto. No almacenar ninguna información que sea confidencial o en la que se base la aplicación para funcionar correctamente en un campo oculto. Un control HiddenField almacena una única variable en su propiedad Value y se debe agregar en la página de forma explícita. Para que los valores de los campos ocultos estén disponibles durante el procesamiento de la página, debe enviarla mediante el método POST de HTTP. Si utiliza campos ocultos y una página se procesa como respuesta a un vínculo o a un comando GET de HTTP, los campos ocultos no estarán disponibles. Cookies Una cookie es una cantidad pequeña de datos que se almacena en un archivo de texto en el sistema de archivos del cliente o que se mantiene en la memoria durante la sesión del explorador cliente. Contiene información específica del sitio que el servidor envía al cliente junto con el resultado de la página. Las cookies pueden ser temporales (con fechas y horas de expiración específicas) o permanentes. Las cookies se pueden utilizar para almacenar información acerca de un cliente, sesión o aplicación específicos. Las cookies se guardan en el dispositivo cliente y, cuando el explorador solicita una página, el cliente envía la información de la cookie junto con la información de la solicitud. El servidor puede leer la cookie y extraer su valor. Uno de los usos típicos es almacenar un símbolo (puede que cifrado) que indica que el usuario ya se ha autenticado en la aplicación. 146 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Nota sobre la seguridad El explorador sólo puede devolver los datos al servidor que creó la cookie. Sin embargo, algunos usuarios malintencionados cuentan con medios para tener acceso a las cookies y leer su contenido. Se recomienda no almacenar información confidencial, como el nombre de usuario o la contraseña, en una cookie. En su lugar, almacene un símbolo (token) en la cookie que identifique al usuario y, a continuación, utilice el símbolo para buscar la información confidencial en el servidor. Cadenas de consulta Una cadena de consulta es información que se anexa al final de la dirección URL de una página. Un ejemplo típico de cadena de consulta podría tener el siguiente aspecto: En la ruta URL indicada, la cadena de consulta empieza por un signo de interrogación (?) e incluye dos pares de atributo-valor; uno de ellos se denomina "category" y el otro, "price". Las cadenas de consulta proporcionan una manera sencilla pero limitada de mantener la información de estado. Por ejemplo, es una manera sencilla de pasar información de una página a otra, por ejemplo, pasar un código de producto de una página a otra donde se procesará. Sin embargo, en algunos exploradores y dispositivos de cliente la longitud de la dirección URL tiene una limitación de 2083 caracteres. Nota sobre la seguridad La información que se pasa en una cadena de consulta puede ser manipulada por un usuario malintencionado. No utilice cadenas de consulta para transmitir información importante o confidencial. Además, un usuario puede marcar la dirección URL o puede enviarla a otros usuarios, pasando esa información con la dirección URL. Para que los valores de las cadenas de consulta estén disponibles durante el procesamiento de la página, debe enviar la página utilizando el método GET de HTTP. Es decir, no puede utilizar las cadenas de consulta si la página se procesa como respuesta a un método POST de HTTP. Opciones de administración de estado basada en servidor ASP.NET proporciona una serie de medios para mantener la información de estado en el servidor, en lugar de conservarla en el cliente. Con la administración de estados basada en servidor, puede reducir la cantidad de información que se envía al cliente para conservar el estado, sin embargo, puede suponer un uso excesivo de los recursos del servidor. En las secciones siguientes se describen tres características de la administración de estados basada en servidor: estado de aplicación, estado de sesión y propiedades de perfiles. Estado de aplicación ASP.NET permite guardar valores utilizando el estado de sesión, que es una instancia de la clase HttpApplicationState, de cada aplicación Web activa. El estado de aplicación es un mecanismo de almacenamiento global al que se puede obtener acceso desde todas las páginas de la aplicación Web. Por tanto, el estado de aplicación resulta útil para almacenar la información que se debe mantener en los recorridos de ida y vuelta del servidor y entre las solicitudes de las páginas. El estado de aplicación se almacena en un diccionario de tipo clave-valor que se crea cada vez que se envía una solicitud a una dirección URL específica. Puede agregar información específica de la aplicación a esta estructura para almacenarla entre las solicitudes de página. Después de agregar la información específica de la aplicación a estado de aplicación, el servidor se encarga de administrarla. Estado de sesión ASP.NET permite guardar valores utilizando el estado de sesión, que es una instancia de la clase HttpSessionState, de cada sesión de una aplicación Web activa. Estado de sesión es similar a estado de aplicación, con la diferencia de que el ámbito es la actual sesión del explorador. Si hay varios usuarios utilizando la aplicación, cada uno de ellos tendrá un estado de sesión distinto. Asimismo, si un usuario sale de la aplicación y vuelve más tarde, el segundo usuario tendrá un estado de sesión distinto al del primero. 147 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 El estado de sesión tiene la estructura de un diccionario de tipo clave-valor para almacenar información específica de cada sesión que se debe conservar en recorridos de ida y vuelta del servidor, así como entre solicitudes de páginas. Puede utilizar el estado de sesión para llevar a cabo las tareas siguientes: Identificar unívocamente las solicitudes del explorador o del dispositivo de cliente y asignarlas a una instancia de sesión individual en el servidor. Almacenar en el servidor datos específicos de la sesión para utilizarlos a través de múltiples solicitudes del explorador o dispositivo dentro de la misma sesión. Producir eventos de administración de sesión adecuados. Adicionalmente, puede escribir código de aplicación para aprovechar estos eventos. Después de agregar la información específica de la aplicación a estado de sesión, el servidor se encarga de administrar dicho objeto. En función de las opciones especificadas, la información de la sesión se puede almacenar en cookies, en un servidor que no forme parte del proceso, o en un equipo que ejecute Microsoft SQL Server. Propiedades de perfiles ASP.NET proporciona una característica denominada "propiedades de perfiles" que permite almacenar datos específicos del usuario. Esta característica es similar al estado de sesión, salvo que los datos del perfil no se pierden cuando expira la sesión de un usuario. La característica propiedades de perfiles utiliza un perfil ASP.NET, que se guarda en un formato persistente y que se asocia con un usuario específico. El perfil ASP.NET permite administrar con facilidad la información sobre el usuario sin que sea necesario crear y mantener una base de datos propia. Además, el perfil hace que la información del usuario esté disponible mediante una API con establecimiento inflexible de tipos a la que puede obtener acceso desde cualquier punto de la aplicación. Puede almacenar objetos de cualquier tipo en el perfil. La característica de perfil de ASP.NET proporciona un sistema de almacenamiento genérico que permite definir y mantener casi cualquier tipo de datos mientras éstos sigan estando disponibles en un modo de seguridad de tipos. Para utilizar las propiedades de perfiles, se debe configurar un proveedor de perfiles. ASP.NET incluye una clase SqlProfileProvider que permite almacenar los datos del perfil en una base de datos SQL, aunque también puede crear una clase propia de proveedor de perfiles que almacene los datos del perfil en un formato personalizado y disponga de un mecanismo de almacenamiento personalizado, como un archivo XML o incluso un servicio Web. Puesto que los datos colocados en las propiedades de perfiles no se almacenan en la memoria de la aplicación, se conservan cuando se reinician Internet Information Services (IIS) y el proceso de trabajo sin pérdida de datos. Además, las propiedades de perfiles se pueden preservar en varios procesos, como en una granja de servidores web o un hospedaje multiproceso en un único equipo. 38 TRATAR EVENTOS Y CONTROLAR EL FLUJO DE PÁGINAS: eventos de página, eventos de control, eventos de aplicación y eventos de sesión, publicaciones en varias páginas; Response.Redirect, Server.Transfer, IsPostBack, configuración de AutoEventWireup Implementar el controlador Generic. MODELO DE EVENTOS DE CONTROL DE SERVIDOR WEB ASP.NET Una característica importante de ASP.NET es que permite programar páginas Web utilizando un modelo basado en eventos similar al de las aplicaciones de cliente. Como ejemplo sencillo, se puede agregar un botón a una página Web ASP.NET y, a continuación, escribir un controlador de eventos para el evento de clic del botón. Aunque esto es habitual en páginas Web que funcionan exclusivamente con un script de cliente (que controla el evento onclick del botón en HTML dinámico), ASP.NET traslada este modelo al procesamiento basado en servidor. Los eventos producidos por los controles de servidor ASP.NET funcionan de manera diferente a los eventos de las páginas HTML tradicionales o de las aplicaciones Web basadas en el cliente. La diferencia se basa principalmente en la separación existente entre el propio evento y el lugar donde se controla el evento. En las aplicaciones basadas en cliente, los eventos se producen y controlan en el cliente. Sin embargo, en las páginas Web ASP.NET, los eventos asociados a los controles de servidor se originan en el cliente (explorador) pero los controla la página ASP.NET en el servidor Web. Para los eventos que se producen en el cliente, el modelo de control de eventos Web ASP.NET necesita que la información del evento se capture en el cliente y que se transmita un mensaje de evento al servidor mediante un envío HTTP. La página debe interpretar el envío para determinar el evento ocurrido y, a continuación, llamar al método apropiado del código del servidor para controlar dicho evento. 148 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 ASP.NET controla la tarea de capturar, transmitir e interpretar el evento. Al crear controladores de eventos en una página Web ASP.NET, no es necesario saber capturar la información del evento y hacer que esté disponible para el código. En cambio, se pueden crear controladores de eventos casi de la misma forma que en un formulario de cliente tradicional. Sin embargo, hay diversos aspectos del control de eventos en las páginas Web ASP.NET que se deben tener en cuenta. Conjunto de eventos para controles de servidor y páginas Debido a que los eventos de controles de servidor ASP.NET requieren un viaje de ida y vuelta al servidor para procesarse, pueden afectar al rendimiento de una página. Por lo tanto, los controles de servidor ofrecen un conjunto limitado de eventos, normalmente sólo de tipo clic. Algunos controles de servidor admiten los eventos de cambio. Por ejemplo, el control CheckBox de servidor Web produce un evento de cambio CheckedChanged cuando el usuario hace clic en el cuadro. Algunos controles de servidor admiten eventos más abstractos. Por ejemplo, el control de servidor Web Calendar provoca un evento SelectionChanged que es una versión más abstracta del evento de clic. Los eventos que tienen lugar con frecuencia (y que pueden provocarse sin que el usuario lo sepa), como onmouseover, no se pueden usar en los controles de servidor. Los controles de servidor ASP.NET siguen pudiendo llamar a los controladores de cliente para esos eventos. Los controles y la propia página también provocan eventos de ciclo de vida en cada paso del procesamiento, como Init, Load y PreRender. Puede aprovecharse de estos eventos de ciclo de vida en la aplicación. Por ejemplo, en el evento Load de una página, puede establecer valores predeterminados para los controles. Argumentos de eventos Los eventos de los controles y de páginas ASP.NET siguen un modelo de .NET Framework estándar para los métodos de controladores de eventos. Todos los eventos pasan dos argumentos: un objeto que representa al objeto que ha provocado el evento, y un objeto evento que contiene la información específica del evento. El segundo argumento suele ser de tipo EventArgs, pero para algunos controles es de un tipo específico de dicho control. Por ejemplo, para un control ImageButton de servidor Web, el segundo argumento es de tipo ImageClickEventArgs, que incluye información sobre las coordenadas donde el usuario ha hecho clic. Nota Los eventos para la página (como Load) pueden aceptar los dos argumentos estándar, pero en estos argumentos no se pasa ningún valor. Eventos Postback y Non-Postback en controles de servidor En los controles de servidor, algunos eventos, generalmente los de clic, hacen que la página se envíe de vuelta inmediatamente al servidor. Los eventos de cambio en los controles de servidor HTML y de servidor Web, como el control TextBox, no ocasionan que se produzca una acción de envío inmediatamente. En su lugar, se generan la próxima vez que tenga lugar una acción de envío. Nota Si el explorador lo admite, los controles de validación pueden comprobar la entrada de datos del usuario mediante scripts de cliente sin realizar un viaje de ida y vuelta al servidor. Una vez enviada de vuelta una página, se generan los eventos de inicialización (Page_Init y Page_Load) de la misma y, a continuación, se procesan los eventos de control. No se debería crear una lógica de aplicación en la que los eventos de cambio se generen en un orden específico a no ser que se conozca con detalle el procesamiento de los eventos de página. Si resulta útil para una aplicación, se puede especificar que los eventos de cambio provoquen el envío de la página. Los controles de servidor Web que admiten un evento de cambio incluyen la propiedad AutoPostBack. Cuando esta propiedad está establecida como true, el evento de cambio del control provoca el envío inmediato de la página, sin esperar a que se produzca un evento de clic. Por ejemplo, de forma predeterminada, el evento CheckedChanged de un control CheckBox no provoca el envío de la página. Sin embargo, si se establece la propiedad AutoPostBack del control en true, en cuanto un usuario active la casilla, la página se envía al servidor para ser procesada. Nota Para que la propiedad AutoPostBack funcione correctamente, el explorador del usuario deberá estar configurado para permitir la ejecución de scripting. Ésta es la configuración predeterminada en la mayoría de casos. Sin embargo, algunos usuarios deshabilitan el scripting por razones de seguridad. 149 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Eventos reenviados Los controles de servidor Web como Repeater, DataList, GridView, FormView y DetailsView pueden contener controles de botón que a su vez generen eventos. Por ejemplo, cada fila de un control GridView puede contener uno o varios botones creados dinámicamente mediante plantillas. En lugar de que cada botón provoque individualmente un evento, los eventos de los controles anidados se reenvían al control del contenedor. El contenedor produce a su vez un evento genérico ItemCommand con parámetros que permite detectar qué control en concreto ha producido el evento original. Respondiendo a este evento único, puede ahorrarse tener que escribir controles de eventos individuales para cada control secundario. El evento ItemCommand incluye los dos argumentos de evento estándar, un objeto que hace referencia al origen del evento y un objeto de evento que contiene información específica del mismo. Nota Los controles GridView, DataList y otros controles de datos admiten eventos adicionales, como EditCommand, DeleteCommand y UpdateCommand, que son casos especiales de eventos reenviados. En el caso de los botones, se puede utilizar la propiedad CommandArgument para pasar una cadena especificada por el usuario al controlador de eventos, con el fin de ayudar a identificar el botón que ha provocado el evento. Por ejemplo, en un control DataList, los botones provocan el evento ItemCommand. Se puede establecer la propiedad CommandArgument de cada botón en un valor distinto (por ejemplo, el valor de un botón puede ser "ShowDetails" y "AddToShoppingCart" el de otro), y más adelante capturar dichos valores en el controlador de eventos. Enlazar eventos a métodos Un evento es un mensaje parecido a "se ha hecho clic en un botón". En una aplicación, se debe traducir el mensaje en una llamada a un método del código. El enlace entre el mensaje del evento y un método específico (es decir, un controlador de evento) se lleva a cabo utilizando un delegado de eventos. En las páginas Web ASP.NET, no es necesario codificar explícitamente delegados si el control se crea mediante declaración (en el marcado) en la página. El enlace de eventos se puede lograr de distintas maneras, dependiendo del evento que se enlace y de qué lenguaje de programación se esté utilizando. Enlazar eventos de control Para controles declarados en la página, se puede enlazar un evento a un método estableciendo un atributo (propiedad) en el marcado del control. El ejemplo de código siguiente muestra cómo enlazar el evento Click de un control ASP.NET Button a un método denominado ButtonClick. <asp:button id="SampleButton" runat="server" text="Submit" onclick="ButtonClick" /> Al compilar la página, ASP.NET busca un método denominado ButtonClick y confirma que éste tiene la firma adecuada (acepta dos argumentos, uno de tipo Object y otro de tipo EventArgs). A continuación, ASP.NET enlaza automáticamente el evento al método. En Visual Basic, también se pueden enlazar los eventos a los métodos utilizando la palabra clave Handles en la declaración del controlador de eventos. Enlazar eventos de página Las páginas ASP.NET provocan eventos de ciclos de vida como Init, Load, PreRender y otros. De manera predeterminada, los eventos de página se pueden enlazar a los métodos utilizando la convención de nomenclatura Page_nombreDeEvento. Por ejemplo, con el fin de crear un controlador para el evento Load de la página, se puede crear un método denominado Page_Load. En tiempo de ejecución, ASP.NET buscará los métodos que se basen en esta convención de nomenclatura y realizará el enlace automáticamente entre el evento y el método. Se puede utilizar la convención Page_nombreDeEvento para cualquier evento expuesto por la clase Page. 150 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Nota Los métodos de control de eventos de página no requieren ningún argumento. Si se prefiere, puede enlazar explícitamente los controladores a los eventos. Una propiedad de página denominada AutoEventWireup controla el enlace automático de los eventos de página en función de la convención de nomenclatura del método. De manera predeterminada, para C#, esta propiedad se establece en true y ASP.NET realiza la búsqueda automática y el enlace descritos anteriormente. También se puede establecer esta propiedad en false agregando el atributo AutoEventWireup=false de la directiva @ Page. A continuación se pueden crear los métodos con cualquier nombre y enlazarlos a los eventos de páginas explícitamente. De forma predeterminada, para Visual Basic, esta propiedad está establecida en false. En Visual Basic, los controladores se enlazan a los eventos mediante la palabra clave Handles. Visual Studio inserta automáticamente esta palabra clave como parte del método que se crea al seleccionar un evento de página en el cuadro desplegable. Una desventaja del atributo AutoEventWireup es que precisa que los controladores de eventos de la página tengan nombres específicos y predecibles. Esto limita su flexibilidad en cuanto al modo de denominar los controladores de eventos. Otra desventaja es el efecto negativo sobre el rendimiento porque ASP.NET busca los métodos en tiempo de ejecución. Para un sitio web con un gran volumen de tráfico, este impacto podría ser significativo. Nota Si incluye enlaces explícitos para los eventos de página, asegurarse de que la propiedad AutoEventWireup esté establecida en false para que no se llame dos veces al método. Enlace explícito para controles dinámicos Si se crea controles declarándolos en el marcado, puede enlazar eventos con métodos mediante un atributo (por ejemplo, onclick) o, en Visual Basic, con la palabra clave Handles. Si los controles se crean dinámicamente (en código), no se puede utilizar ninguno de estos métodos, porque el compilador no tiene una referencia al control en tiempo de compilación. En ese caso, se debe utilizar el enlace de eventos explícito. En Visual Basic, puede utilizar la instrucción AddHandler para enlazar a un método existente un evento creado dinámicamente en un control. En C#, se crea un delegado y se asocia al evento de control. El ejemplo de código siguiente muestra cómo se puede enlazar un método denominado ButtonClick al evento Click de un botón: Button b = new Button; b.Text = "Click"; b.Click += new System.EventHandler(ButtonClick); Placeholder1.Controls.Add(b); Responder a eventos de cliente y de servidor en controles de servidor ASP.NET En este tema se explica cómo trabajar con eventos generados en el código de servidor. Los controles representan los elementos para el explorador y esos elementos también pueden provocar eventos de cliente que se pueden controlar en los scripts de cliente. Mediante el uso de scripts de cliente, se puede agregar la capacidad de control de eventos de mouse y de teclado a los controles de servidor ASP.NET. Eventos de aplicación y de sesión Aparte de los eventos de página y de control, ASP.NET proporciona formas de trabajar con eventos de ciclo de vida que pueden provocarse al iniciarse o detenerse la aplicación, o cuando la sesión de usuario de un individuo determinado se inicia o se detiene, incluido lo siguiente: Los eventos de aplicación se provocan para todas las solicitudes que se hacen a una aplicación. Por ejemplo, el evento BeginRequest del objeto HttpApplication (Application_BeginRequest)) se genera cuando se solicita cualquier página Web ASP.NET o servicio Web XML en una aplicación. Este evento le permite inicializar recursos que se utilizarán para cada solicitud a la aplicación. Un evento correspondiente, el evento EndRequest del objeto HttpApplication (Application_EndRequest), le proporciona la oportunidad de cerrar o eliminar los recursos utilizados por la solicitud. 151 GALA Manual 70-562 TS: Desarrollo de Aplicaciones ASP.Net Utilizando la Plataforma Microsoft .Net 3.5 Los eventos de sesión son similares a los de aplicación (existen los eventos Start y un evento End), pero se producen con cada sesión única dentro de la aplicación. Una sesión comienza cuando un usuario solicita una página por primera vez desde la aplicación y termina cuando la aplicación cierra explícitamente la sesión o cuando la sesión excede el tiempo de espera. Nota El evento Session_End no se provoca en todas las circunstancias. Se pueden crear controladores para estos tipos de eventos en el archivo Global.asax. PagesSection.AutoEventWireup (Propiedad) Obtiene o establece un valor que indica si los eventos para las páginas ASP.NET se conectan automáticamente a las funciones de control de eventos. Valor de propiedad Es true si los eventos para las páginas ASP.NET se conectan automáticamente a las funciones de control de eventos; de lo contrario, es false. El valor predeterminado es true. Cuando AutoEventWireup es true, ASP.NET no exige que los eventos especifiquen los controladores de eventos como Page_Load o Page_Init. Esto significa que, en la página de formulario Web Forms en Visual Basic, no es necesaria la palabra clave Handles en la secuencia de comandos del servidor. De manera predeterminada, cuando la aplicación Web ASP.NET se crea en Visual Studio, el valor del atributo AutoEventWireup de la página .aspx o del control .ascx se establece en false y no se crean controladores de eventos automáticamente. No se establezca AutoEventWireup en true si el rendimiento es una consideración clave. HttpResponse.Redirect (Método) Redirecciona un cliente a una nueva dirección URL y especifica la nueva URL. Parámetros url Ubicación de destino. HttpException La redirección se intenta cuando se han enviado los encabezados HTTP. Llamar a Redirect equivale a llamar a Redirect con el segundo parámetro establecido en true. Redirect llama a End, que inicia una excepción ThreadAbortException al finalizar. Nota: Únicamente en el caso de páginas móviles, si la aplicación se basa en sesiones sin cookies o puede recibir solicitudes de dispositivos móviles que requieren sesiones sin cookies, el uso de una tilde ("~") en una ruta de acceso puede dar lugar a la creación inadvertida de una nueva sesión y a la pérdida potencial de los datos de la sesión. Para establecer una propiedad en un control móvil con una ruta de acceso como "~/ruta de acceso", resuelva la ruta utilizando ResolveUrl "~/ruta de acceso" antes de su asignación a la propiedad. 152
