Manual de ASP NET

Tema 1.
INTRODUCCIÓN AL DESARROLLO DE APLICACIONES WEB _______ 1
Tema 2. REQUISITOS DEL ASP.NET (.NET FRAMEWORK) _______________ 11
Tema 3. CONCEPTOS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS ___ 19
Tema 4. CREANDO UNA PÁGINA BÁSICA ____________________________ 31
Tema 5. CONCEPTOS DE WEB FORMS ______________________________ 55
Tema 6. COMPONENTES (DATALIST, DATAGRID) ______________________ 83
Tema 7. DIRECTIVAS DE PÁGINA ___________________________________ 91
Tema 8. CONFIGURACIÓN DE IIS ___________________________________ 99
Tema 9. EL ARCHIVO GLOBAL.ASAX_______________________________ 111
Tema 10. EL ARCHIVO WEB.CONFIG ______________________________ 119
Tema 11. MÓDULOS Y MANEJADORES http_________________________ 129
Tema 12. SEGURIDAD EN ASP.NET ________________________________ 135
GLOSARIO_______________________________________________________ 143
INTRODUCCIÓN AL
Tema 1 DESARROLLO DE
APLICACIONES
WEB
1.1. ASP 3_________________________________________________ 5

1.2. JAVA (JSP, SERVLETS) __________________________________ 6
1.3. PHP __________________________________________________ 7
1.4. DHTML________________________________________________ 9
-1-
El desarrollo de aplicaciones para el entorno Internet ha cambiado mucho desde su aparición hace
algunos años. El mundo de la informática avanza rápidamente, y las necesidades básicas de un sitio Web
han cambiado. Al principio, el desarrollo de páginas Web se limitaba prácticamente al uso del lenguaje de
marcado HTML (lenguaje de marcado de hipertexto), un HTML sencillo basado en la especificación 3.2,
sin capas ni estilos, con lo que se obtenían páginas estáticas cuya labor únicamente era suministrar
información personal del autor o de la empresa (de forma textual o a través de imágenes), pero, sin
proporcionar ninguna interacción con el usuario.
Actualmente, un sitio Web suele soportar la recogida de datos a través de formularios, inclusiones de
archivos (subir ficheros al servidor, como imágenes o documentos), envío de correos electrónicos, acceso
a bases de datos, redireccionamiento de acuerdo al perfil del usuario, etc. En definitiva, hoy día, las
aplicaciones Web se diseñan con el propósito de suministrar al usuario una serie de servicios más
complejos.
Como ejemplo podemos citar una plataforma de teleformación que soporte matriculación de alumnos,
subida de cursos, exámenes, almacenamiento de notas, estadísticas de tiempos sobre conexiones al
centro virtual, visitas por curso y alumno, etc.
Cada vez que el alumno entra en la plataforma y se loga (introduce su nombre de usuario y contraseña),
se le presenta una página personalizada (con acceso a cada uno de los cursos en que está matriculado),
y cada vez que el alumno realiza un ejercicio o examen, el sistema puede comprobar los resultados
introducidos y otorgarle una nota, que almacena para él en una base de datos, y del que va formando un
expediente. Estos son ejemplos de páginas dinámicas, cuyo aspecto final va a depender de las acciones
del usuario, de la forma de interactuar que tenga con la aplicación (en cuántos cursos se ha matriculado,
si ha aprobado o suspendido un examen, los temas o respuestas que ha dado en los foros de su curso,
etc.).
Entre las aplicaciones típicas desarrolladas en la actualidad, se encuentran los portales, las tiendas o
comercios virtuales, B2C (Business-To-Consumer, proveedor y cliente), aplicaciones publicitarias, de
venta (de billetes de avión, subastas), de ocio (portales de juegos) ...
Estos desarrollos se caracterizan por el alto número de usuarios que tienen que soportar y por la calidad
de la interfaz de usuario, el diseño y el sistema de navegación presentados.
-3-
Ejemplo de aplicación Web actual: Plataforma de Teleformación
Los desarrollos Internet se implementan sobre los protocolos y lenguajes de Internet.
A su vez, estos protocolos son estándares que implementan una serie de mecanismos básicos para
permitir el paso de información entre los equipos clientes de los usuarios (que contienen los navegadores
de Internet) y los equipos servidores (que contienen la aplicación), y son principalmente, TCP/IP
(Protocolo de Control de Transmisión / Protocolo de Internet y HTTP (Protocolo de Transmisión de
Hipertexto).
A mayor complejidad de aplicaciones, mayor complejidad y potencia de herramientas y nuevas

tecnologías usadas en su programación. A continuación, vamos a ver una serie de tecnologías de
desarrollo Web utilizadas en la actualidad:
-4-
1.1. ASP 3
Es la versión previa a la tecnología ASP.NET, y por tanto, también la solución inicial de Microsoft a la
programación Web. Sus siglas se correponden con Active Server Pages en su versión 3 (Páginas Activas
de Servidor), y funcionaban bajo las versiones del servidor Web de Microsoft, IIS (Internet Information
Server, Servidor de Información de Internet) en sus versiones 3, 4 y 5. Este sistema se basaba en la
ejecución de una serie de lenguajes de script (principalmente, VBScript y Jscript) embebidos en páginas
HTML. La extensión de estas páginas es .asp (son las comúnmente llamadas páginas ASP, y que aún
hoy siguen utilizándose en la programación de multitud de sitios Web).
Su proceso de desarrollo es relativamente rápido, está integrado con el modelo COM (Modelo de Objetos
Componentes) de Windows y se encuentra muy extendido (ha sido uno de los más utilizados en los
últimos tiempos). Sin embargo, su modelo de desarrollo es más bien funcional, y no totalmente orientado
a objetos.
En esta dirección puede encontrarse abundante documentación sobre ASP
-5-
A partir de la versión 5 de su servidor Web, IIS, Microsoft da soporte a su nueva solución de
programación Web, ASP.NET, (aunque existe compatibilidad con el código ASP anterior). ASP.NET
mejora en los lenguajes y herramientas de desarrollo, asume el modelo de programación orientada a
objetos, mejora el rendimiento general del sistema, etc. (a lo largo del manual veremos las técnicas más
comunes utilizadas con esta tecnología).
Uno de los sitios Web más populares dedicados a ASP.NET
1.2. JAVA (JSP, SERVLETS)
Es la solución de SUN Microsystems para el desarrollo de aplicaciones Web. Consta de un conjunto de

librerías y API (Interfaz de Programación de Aplicaciones) de desarrollo, que incluye un conjunto de
objetos de servidor o Servlets, y un sistema de programación de páginas con un modelo similar al de ASP
(introduciendo código java embebido en páginas HTML), páginas JSP (Java Server Pages, Páginas de
Servidor Java).
-6-
Este modelo de Servlets y páginas JSP, al estar directamente basado en Java, presenta todas las
ventajas de este lenguaje, como la orientación a objetos, disponibilidad de todas las librerías adicionales
de Java (generación de imágenes, comunicaciones, seguridad, encriptación, etc). Podríamos decir que
esta solución es más potente y completa para desarrollar aplicaciones Web que la solución de páginas
ASP.
Sitio Web de SUN Microsystems dedicado a Java
Java continúa siendo la gran alternativa al desarrollo de aplicaciones Web con tecnología Microsoft (ASP,
ASP.NET).
1.3. PHP
PHP corresponde a las iniciales de Personal Home Page, Procesador de Hipertexto. Este lenguaje de
programación tiene una sintaxis similar a los lenguajes C y Perl, se interpreta por un servidor Web
Apache bajo sistemas Unix/Linux (también han salido al mercado versiones para sistemas Windows,
aunque no siempre podremos utilizar todas sus características bajo este sistema operativo).
-7-
Presenta una técnica similar a las páginas ASP de Microsoft, es decir, las páginas HTML incluyen el
código PHP embebido en ellas, y al ejecutarlas, se genera código HTML dinámicamente.
Por otro lado, es preciso mencionar que soporta clases, pero no está orientado a objetos, aunque dispone
de una gran número de librerías de funciones para realizar operaciones avanzadas como acceso a bases
de datos, correo electrónico, transferencia de ficheros, comunicaciones, etc.
Las páginas PHP también se han extendido mucho en los últimos años (son las páginas Web que vemos
con extensión .php o .phtml), aunque parece ser que se tiende a utilizar las soluciones de Java y
ASP.NET en las nuevas aplicaciones.
En esta dirección podemos encontrar toda documentación necesaria sobre PHP, como manuales, la
referencia del lenguaje, entornos, etc. y además en varios idiomas.
-8-
1.4. DHTML
Sus siglas significan Dinamic HTML (HTML dinámico). Se forma de una conjunción de HTML, hojas de
estilo en cascada (CSS) y lenguajes de script como JavaScript o VBScript. Estos lenguajes de script se
ejecutan en la máquina cliente (en el navegador del usuario que solicita una página). De hecho, ésta es
una gran diferencia con el resto de las anteriores tecnologías que hemos visto en los apartados
anteriores. Normalmente, un desarrollador Web, utilizará alguna de las tecnologías anteriores, basadas
en servidor, que implementa la lógica principal y fundamental de la aplicación, en conjunción con el HTML
dinámico, ya que gracias a éste, podemos conseguir efectos muy vistosos en nuestras páginas, como
formateo más completo al HTML, alternancia de imágenes, capas (contenido de la página cuya posición y
tamaño puede cambiar), con lo que obtenemos desplazamiento de imágenes, banners, cambios de
visibilidad en los elementos de la página (partes de la página que aparecen o desaparecen en función de
los eventos o acciones del usuario), validaciones de entradas del usuario antes de enviar los datos al
servidor, etc.
En esta dirección podemos encontrar una referencia muy completa del lenguaje JavaScript
-9-
RECUERDE
- El desarrollo de aplicaciones Web ha evolucionado rápidamente en los últimos años. Las páginas
estáticas que usaban únicamente el lenguaje HTML 3.2, han pasado a sitios Web interactivos que
ofrecen multitud de servicios a los usuarios.
- Actualmente se utilizan tecnologías como DHTML (HTML, CSS y lenguajes de script, como VBScript
o JavaScript, que se ejecutan en el cliente), y ASP 3, PHP, JSP y Servlets, y ASP.NET (tecnologías
que se ejecutan en el servidor).
- 10 -
REQUISITOS DEL
Tema 2 ASP.NET
(.NET FRAMEWORK)
2.1. MICROSOFT .NET FRAMEWORK _________________________ 14

2.2. CLS ________________________________________________ 16
2.3. CTS ________________________________________________ 16
2.4. IL (MSIL) ____________________________________________ 17
- 11 -
En este capítulo vamos a comentar los programas necesarios para poder desarrollar aplicaciones
ASP.NET:
- Sistema operativo Windows 2000 Server/Professional. (ASP.NET no es soportado por

Windows NT ni por Windows 9x).
- El Servidor Web Internet Information Server 5.0 (IIS 5.0). (Viene incluido como parte del
sistema operativo Windows 2000, debemos dejarlo incluido como parte de la instalación del
sistema operativo).
- Microsoft .NET Framework SDK (Software Development Kit): es la implementación de la

plataforma .NET sobre la que se ejecutarán las páginas ASP.NET. Es decir, el .NET
Framework SDK contiene todas las clases que componen la plataforma .NET. Para poder
instalarlo necesitamos tener instalado, al menos, el navegador Internet Explorer 6.0 y el
Service Pack 2 de Windows 2000.
Su distribución es gratuita y podemos descargárnoslo del sitio Web de desarrolladores de
Microsoft en http://msdn.microsoft.com. Además, en esta dirección podemos encontrar
abundante documentación sobre el tema.
También es recomendable, aunque no obligatorio, disponer de la aplicación Visual Studio .NET, que es
un entorno de desarrollo para la plataforma .NET. Este entorno integrado ofrece una serie de ayudas
visuales y utilidades muy interesantes, además de valiosa documentación que nos ayudarán en el
desarrollo, prueba y depuración de nuestras aplicaciones ASP.NET.
Además, las distribuciones de la aplicación de Visual Studio .NET, suelen incluir el paquete Microsoft
.NET Framework SDK, como parte opcional de la instalación, por si el equipo donde va a ser instalado el
Visual Studio .NET, no lo tiene todavía.
También podemos conseguir una versión de evaluación de Visual Studio .NET en el sitio Web de MSDN
(http://msdn.microsoft.com/vstudio/productinfo/trial.asp).
Este entorno es muy recomendable, pero no imprescindible para escribir nuestras aplicaciones ASP.NET.
De hecho, también puede usarse cualquier otro editor de texto común, como el bloc de notas de
Windows, o la aplicación EditPlus, aunque éstos no proporcionan las utilidades del entorno Visual Studio.
NET.
- 13 -
En el sitio Web de Microsoft podemos descargarnos gratuitamente el paquete .NET Framework
2.1. MICROSOFT .NET FRAMEWORK
ASP.NET se engloba dentro de la tecnología denominada Microsoft .NET, que, aparte de la tecnología
Web, nos ofrece toda una gama de tecnologías para el desarrollo y explotación de aplicaciones. Es decir,
ASP.NET es un subconjunto de la tecnología .NET de Microsoft, la parte relativa a la programación Web.
Pero, el paquete .NET también incluye las clases necesarias para soportar las aplicaciones tradicionales
de Windows, las denominadas aplicaciones Windows Forms (generación de formularios, con
características avanzadas), y también las aplicaciones que son servicios del sistema, que no requieren
interfaz del usuario. Así, por ejemplo, con el paquete .NET, también es posible la creación de servicios
para Windows 2000.
.NET Framework permite el desarrollo de aplicaciones a través del uso de un conjunto de herramientas y
servicios que proporciona, y que podemos agrupar en tres bloques principales:
- 14 -
- El Entorno de Ejecución Común o Common Language Runtime (CLR). Es el núcleo de .NET
Framework, se encarga de la gestión del código, su ejecución, los temas de manipulación de
memoria, etc.
- La jerarquía de clases básicas de la plataforma o .NET Framework Base Classes.

Constituyen un API de servicios para usar en la programación de nuestras aplicaciones, por
ejemplo, las clases para acceder a bases de datos (ADO.NET), para gestionar ficheros XML,
gestión de hilos (threading), etc.
- El motor de generación de interfaz de usuario, que permite crear interfaces para la web (con
la tecnología ASP.NET) o para el tradicional entorno Windows (Windows Forms).
Podemos ver esta estructura de una forma más representativa a través del siguiente esquema de
componentes de la plataforma .NET Framework:
ASP.NET Windows Forms
.NET Framework Basse Classes (clases básicas de la plataforma)
ADO.NET XML THREADING Etc.
CLR, Common Language Runtime (Entorno común de ejecución de lenguajes)
CTS CLS MSIL Gestión de memoria
En este manual vamos a centrarnos en la parte de ASP.NET, que, como hemos dicho, constituye la
solución de Microsoft para desarrollar aplicaciones Web, aunque su base sobre la que se apoya, el
paquete .NET, es común para desarrollar otro tipo de aplicaciones para Windows.
- 15 -
A continuación, vamos a ver una serie de términos relacionados con el CLR del .NET, que le dan la
funcionalidad para permitir ser un entorno común de ejecución de lenguajes:
2.2. CLS
Como vemos, el CLR es la base del sistema Microsoft .NET. Este motor hace que sea posible el
desarrollo basado en múltiples lenguajes, y que sea posible la integración y ejecución de todos ellos en el
entorno .NET.
Esto se realiza gracias al seguimiento de las especificaciones del CLR por parte de los creadores de
lenguajes y herramientas de desarrollo. Esta Especificación Común de Lenguajes se conoce como CLS
(Common Language Specification), y consiste en un conjunto de características comunes que deben
cumplir todos los lenguajes de la plataforma, para poder integrarse entre sí.
Esta integración se refiere a que, por ejemplo, es posible escribir una clase en C#, y heredar de dicha
clase desde VB.NET. Esto se produce gracias a que el entorno de ejecución es común, y el código
compilado no pasa directamente a código ejecutable puro, sino a un código intermedio (como veremos en
el apartado de IL).
Por ello, podemos decir que la plataforma .NET tiene soporte multi-lenguaje. Actualmente, están
soportados los lenguajes VB.NET, C#, C++ y Jscript.NET.
2.3. CTS
Estas siglas corresponden a Common Type System, Sistema Común de Tipos. Es el mecanismo del CLR
que permite definir el modo en que los tipos serán creados y manipulados por el entorno de ejecución de
.NET Framework.
Así, todos los lenguajes pueden trabajar basándose en una serie de especificaciones de datos que hacen
posible el intercambio de información y trabajo con las librerías básicas de la plataforma .NET.
- 16 -
2.4. IL (MSIL)
Estas siglas corresponden a Microsoft Intermediate Languaje, Lenguaje Intermedio de Microsoft. Es un

lenguaje parecido al bytecode de Java, hacia el cual cualquier compilador integrado con Microsot .NET
deberá compilar su código fuente, ya que es el único entendible por el CLR.
Este código es independiente de la plataforma y del lenguaje que lo haya originado.
La siguiente figura muestra un diagrama con el proceso de generación de lenguaje intermedio a partir del
código fuente:
Código fuente
(C#, VB.NET,C++,...)
Compilador
Código IL
- 17 -
RECUERDE
- Para desarrollar aplicaciones ASP.NET necesitamos: el sistema operativo Windows 2000

Server/Professional, el servidor Web Internet Information Server 5.0 y el paquete Microsoft .NET
Framework SDK (Software Development Kit) (además del navegador Internet Explorer 6.0 y el
Service Pack 2 de Windows 2000).
- También es recomendable disponer de la aplicación Visual Studio .NET, que es un entorno de

desarrollo para la plataforma .NET. Aunque no es imprescindible, nuestras páginas ASP.NET
podemos escribirlas en cualquier editor de textos.
- ASP.NET es un subconjunto de la tecnología .NET de Microsoft, la parte relativa a la programación

Web. El paquete .NET también incluye las clases necesarias para soportar las aplicaciones
tradicionales de Windows, las denominadas aplicaciones Windows Forms.
- La plataforma .NET tiene soporte multi-lenguaje. Actualmente, están soportados los lenguajes
VB.NET, C#, C++ y Jscript.NET.
- 18 -
CONCEPTOS DE LA
Tema 3 PROGRAMACIÓN
ORIENTADA A
OBJETOS
3.1. OBJETOS ____________________________________________ 21

3.2. ENCAPSULACIÓN ______________________________________ 21
3.2. ABSTRACCIÓN ________________________________________ 22
3.3. MENSAJES ___________________________________________ 23
3.4. CLASES______________________________________________ 23
3.5. HERENCIA____________________________________________ 24
3.6. MÉTODOS ____________________________________________ 26
3.7. POLIMORFISMO _______________________________________ 26
3.8. SOBRECARGA ________________________________________ 26
3.9. MODELO DE OBJETOS__________________________________ 27
3.10. RELACIONES ENTRE CLASES ___________________________ 27
3.11. VENTAJAS DE LA POO_________________________________ 28
3.12. INCONVENIENTES DE LA POO___________________________ 28
- 19 -
En este capítulo vamos a tratar aspectos genéricos de la Programación Orientada a Objetos (POO),
necesarios para poder utilizar correctamente el lenguaje en que vamos a programar nuestras páginas
ASP.NET, es decir, el lenguaje C#.
3.1. OBJETOS
El objeto es el concepto principal sobre el cual se fundamenta la tecnología orientada a objetos. Un

objeto puede ser visto como una entidad que posee un conjunto de atributos y que es capaz de realizar
una serie de acciones. Esto es lo que define al objeto. También podemos verlo como una representación
o modelización de un objeto real perteneciente a nuestro mundo. Por ejemplo, podemos tener un objeto
bicicleta que represente a una bicicleta dentro de nuestra realidad, o bien un objeto factura, automóvil o
persona. Estos objetos son casos particulares de entidades llamadas clases en donde se definen las
características comunes a tales objetos. Veamos el caso particular del objeto automóvil, podemos
mencionar como atributos de éste: el modelo, la marca, el color, el número de matrícula, número de
bastidor, entre otros. Algunas acciones que es capaz de realizar un automóvil son: frenar, acelerar y
cambiar la velocidad. Este objeto automóvil, es una instancia particular de la clase automóvil.
Los parámetros o variables que definen el estado de un objeto se denominan atributos o variables
miembro, y las acciones que pueden realizar los objetos, se denominan métodos o funciones miembro.
Si lo comparamos con la programación estructurada podríamos hacer la siguiente aproximación: los
atributos, propiedades o variables miembro serían variables y los métodos o funciones miembro serían
procedimientos y funciones.
3.2. ENCAPSULACIÓN
Es la técnica de ocultar la implementación interna de un objeto, es decir, cómo está construido y de qué
se compone. Los atributos de un objeto deben encontrarse ocultos al resto de los objetos, esto es, no
podemos acceder directamente a los atributos de un objeto para modificar su estado o consultarlo. Para
acceder a los atributos de un objeto debemos utilizar métodos.
Normalmente, un objeto ofrece una parte pública que será utilizada por otros objetos para interactuar
entre sí, pero también contiene una parte oculta para encapsular los detalles de implementación del
objeto.
- 21 -
Por tanto, podemos ver un objeto como una “caja negra” que tiene un estado determinado que podemos
conocer y cambiar mediante una serie de métodos públicos, que representan la interfaz del objeto.
Como los atributos y la implementación de cada objeto queda oculta a los demás objetos que
interaccionan en el programa, se favorece la protección de los datos y la localización de errores en los
programas (ya que cada objeto está altamente especializado, y sólo se encarga de su tarea). Esto
consigue una mayor modularidad y facilita el diseño en equipo de programas y la reutilización de clases
(componentes), ya que podemos escribir código de manera independiente de cómo se encuentren
construidos los diferentes objetos que vamos a utilizar. Ocultando los detalles de implementación,
podremos realizar cambios en el código interno de los objetos sin que ello afecte a otros objetos que los
utilicen o dependan de ellos.
3.2. ABSTRACCIÓN
Es la capacidad de ignorar los aspectos de implementación de los objetos en los pasos iniciales, con lo
que sólo necesitamos conocer qué es lo que hace un objeto, y no cómo lo hace, para definir un objeto y
establecer las relaciones de éste con otros objetos. Por ejemplo, cuando necesitemos indicarle al objeto
automóvil que mencionábamos antes, que acelere, no nos interesa conocer cómo realiza este proceso
internamente el objeto (a través de un cambio de marcha, mayor consumo de gasolina, etc.) sino
únicamente la forma de indicarle que realice dicho comportamiento.
Un objeto lo podemos representar como dos circunferencias, una interna que contiene todos los detalles
de implementación (variables y métodos privados), y que permanece oculta al resto de objetos, y otra
circunferencia concéntrica externa, que representa lo que el objeto muestra al mundo exterior, la interfaz
pública que permite interactuar con él. Dicho de otro modo, no es necesario entender la implementación
interna de un objeto para poder utilizarlo.
Métodos Públicos (interfaz del objeto)

Atributos y Métodos
Privados (encapsulados)
- 22 -
3.3. MENSAJES
Son el mecanismo mediante el cual dos objetos pueden interactuar, comunicarse entre sí. Un objeto
solitario generalmente no es muy útil. En cambio, casi siempre aparece como un componente de un
programa mayor o una aplicación que contiene muchos otros objetos. A través de la interacción de esos
objetos, conseguimos una funcionalidad mayor.
Los objetos interactúan y se comunican mediante el envío de mensajes. Así, cuando un objeto A quiere
que otro objeto B realice una acción (un método de la interfaz de B), el objeto A envía un mensaje al
objeto B. Por tanto, un mensaje enviado a un objeto representa la invocación de un determinado método
sobre dicho objeto, es decir, la ejecución de una operación sobre el objeto. De esta forma, los dos objetos
implicados se comunican, ya que la ejecución de ese método devolverá el estado del objeto invocado o lo
modificará (cambiará su estado).
Los mensajes a los que un objeto puede responder representan el comportamiento, las acciones que
dicho objeto puede realizar. En nuestro ejemplo, el objeto coche es capaz de realizar la acción de
cambiar de marchar, pero necesita de otro objeto (por ejemplo, un objeto persona) que interactúe con él,
que le indique la acción a realizar (también podrá frenar, acelerar, etc.), y además necesitará recibir la
marcha a la que deseamos cambiar.
Por tanto, para enviar un mensaje necesitamos:
- El objeto al que vamos a enviar el mensaje, en nuestro ejemplo, el objeto automóvil,

- El nombre del método (acción o comportamiento que queremos que realice), cambiar de
marcha en nuestro automóvil, etc.
- Los parámetros necesarios para el método en cuestión, la marcha a la que deseamos
cambiar.
3.4. CLASES
Una clase es una plantilla, molde o prototipo en el que se definen los atributos (variables) y las acciones
(métodos) comunes para todos los objetos de un tipo determinado. Mediante las clases podremos crear
(instanciar) objetos de un mismo tipo, estos objetos se distinguirán unos de otros a través de su estado,
es decir, el valor de sus atributos.
- 23 -
Siguiendo con el mismo ejemplo, nuestro coche es una instancia de la clase de objetos denominada
Coches. Esta clase tiene algunos estados (marcha actual, número de marchas, color, potencia...) y
comportamiento (frenar, girar, encender luces...) en común. Sin embargo, el estado de cada objeto coche
es independiente y puede ser diferente al del resto de objetos coche.
La especificación común para todos los objetos del mismo tipo es lo que denominamos clase. Dicho de
otro modo, la clase la vamos a utilizar para definir la estructura de un objeto, es decir, estado (atributos) y
comportamiento (métodos). Una vez implementada una clase podremos instanciar (crear) objetos que
pertenezcan a esa clase. Utilizaremos la misma clase para crear distintos objetos.
3.5. HERENCIA
Es el mecanismo mediante el cual podemos reutilizar clases ya definidas. Una vez definida una clase,
podemos usarla como base para complicarla o especializarla. Es decir, los métodos y atributos de una
clase pueden transmitirse a las clases que descienden de ella. La clase hija puede añadir atributos,
métodos y redefinir los métodos de la clase padre. Por eso, podemos ver la herencia como una sucesiva
especialización de las clases. La clase de la que se hereda se denomina clase padre o superclase, y la
clase que hereda se denomina clase hija o subclase. A través de este mecanismo de la POO, podemos
agregar funcionalidades nuevas a una clase existente, reutilizando todo el código que ya teníamos
disponible en la clase padre.
Por ejemplo, un turismo y una limusina son distintos tipos de coches. En una aplicación orientada a
objetos, el turismo y la limusina podrían ser subclases de la clase coche. El turismo y la limusina
comparten los atributos ‘velocidad actual’, ‘marcha actual’, ‘número de plazas’, etc. definidos en la clase
Coche. Igualmente, cada subclase también hereda el mismo comportamiento definido en la superclase,
por lo que, un turismo y una limusina también pueden realizar las acciones (métodos) definidos en la
clase Coche: frenar, cambiar de marcha, girar, etc.
Para verificar que la herencia entre dos clases es correcta, debemos hacernos la pregunta “¿es un tipo de
...?”. En nuestro ejemplo tenemos una clase Limusina que hereda de la clase Coche. Esta herencia
contesta claramente a esta pregunta: ¿una limusina es también un coche?, cierto.
Cada subclase puede definir atributos y métodos propios para ella, que permiten diferenciar a la subclase
de su superclase. Por ejemplo, una limusina puede incluir un teléfono incorporado, una nevera o una
televisión, características que no tiene un coche normal.
- 24 -
Las subclases también pueden sobrescribir métodos de la superclase para proporcionar un
comportamiento especial. Por ejemplo, la clase Coche puede contener un método
ObtenerNúmeroDeMarchas() que siempre devuelva 5, mientras que un fórmula 1 puede tener hasta 6
marchas, por lo que sobrescribiría este método para devolver 6 en lugar de 5.
No hay límite en cuanto al nivel de herencia. Podríamos seguir definiendo nuevas clases que hereden de
la clase Turismo, por ejemplo, las clases Monovolumen o Deportivo. Esto da lugar a una jerarquía de
clases.
La herencia puede ser simple, si la clase hija hereda de una única clase padre, o múltiple, si hereda de
varias clases. El lenguaje que usaremos en la programación de las páginas ASP.NET de este manual,
C#, soporta herencia simple.
También podemos definir clases abstractas, que son clases que definen comportamientos genéricos, y
en las que algunos métodos no han sido implementados (son métodos abstractos). El comportamiento
de estos métodos es totalmente libre para las subclases que hereden de ésta y que deberán implementar
dichos métodos abstractos para poder ser instanciadas.
Ejemplo de jerarquía de clases (herencia simple)
Coche
Turismo Limusina
Deportivo Monovolumen
- 25 -
3.6. MÉTODOS
Como ya hemos comentado anteriormente, los métodos son las acciones que se pueden realizar con los
objetos. También podemos considerar un método como la implementación de un mensaje.
Dentro de un objeto existen métodos de uso interno, ocultos (privados), y métodos públicos, que
constituyen la interfaz del objeto con el resto de objetos con quienes puede interaccionar. Cuando un
objeto le envía un mensaje a otro, se produce la llamada o invocación de un método de dicho objeto.
Los métodos consultan o modifican el estado de un objeto. Son funciones dentro de un objeto, y como
tales, pueden retornar un valor (información sobre el estado del objeto), o realizar una acción sobre el
estado del mismo.
3.7. POLIMORFISMO
Es otra más de las características propias de la POO. Expresa la posibilidad de que el mismo mensaje,
enviado a objetos distintos, ejecute métodos distintos. Por lo tanto, es posible definir operaciones con el
mismo nombre dentro de clases distintas. Cada operación tendrá la implementación necesaria y propia
para cada clase.
Esto nos permite crear un interfaz común para una serie de clases. Por ejemplo, supongamos que
tenemos en nuestra aplicación, una clase Enteros para modelar un número entero, y una clase Matrices,
para modelar una matriz matemática. Ambas clases necesitarán saber cómo se suman (cómo se suman
dos objetos enteros, y cómo se suman dos objetos matrices). Podemos definir un método suma() para la
clase Enteros y otro método suma() para la clase Matrices (ambas clases comparten el mismo nombre
para esa operación, pero la implementación de estos métodos será distinta en cada clase, ya que no es lo
mismo sumar enteros que matrices).
3.8. SOBRECARGA
Otra de las técnicas usadas en la POO. Se refiere a la posibilidad de tener en una misma clase, métodos
con el mismo nombre, pero que difieren en el tipo de los parámetros que reciben, en el número de ellos, o
bien en el tipo y número de parámetros.
- 26 -
Por ejemplo, podemos tener, en la clase Matriz, dos métodos sumar(), uno de ellos recibiría un entero
para sumar a la matriz, y el otro método sumar(), podría recibir otro objeto matriz. El primer método
implementa la suma matemática entre un entero y una matriz, y el segundo, la suma de matrices.
3.9. MODELO DE OBJETOS
Una vez definido e identificado el problema que deseamos solucionar en nuestra aplicación, debemos
realizar una representación lógica de los objetos que forman parte del problema en el mundo real, y
utilizar en nuestro programa estos objetos computacionales (objetos dentro de nuestro código), y las
relaciones existentes entre dichos objetos, para que nuestra aplicación funcione adecuadamente. Para
ello, debemos aplicar los principios de la POO que hemos introducido en los apartados anteriores:
abstracción, encapsulación, herencia y polimorfismo.
3.10. RELACIONES ENTRE CLASES
Cada clase en nuestra aplicación estará especializada en una función o tarea específica, es decir, cada
clase tiene su cometido. Para ofrecer una mayor funcionalidad y realizar tareas más complejas es
necesario que exista una relación entre distintas clases, una forma de interacción o comunicación entre
ellas. Así, una clase puede relacionarse con otra a través de:
- Una relación de composición: cuando una clase está compuesta de otras clases. Esto
ocurre cuando los atributos de una clase se implementan como objetos de otra clase. Por
ejemplo, la clase Coche tiene atributos como son la clase Puerta, Motor, Rueda, Chasis, etc.
- Una relación de uso: cuando una clase se relaciona con otra a través de los mensajes que
le envía, pasándole una instancia de una clase como parámetro del método invocado por el
mensaje. Por ejemplo, al invocar al método suma de una matriz, le pasamos un objeto
entero para que lo sume a un objeto matriz.
- Una relación de herencia: ya la hemos visto en el apartado de la Herencia. Consiste en

que una clase hereda de una clase padre o superclase, obteniendo así toda la funcionalidad
ofrecida por la clase padre y pudiendo añadir nuevas funcionalidades. Con esta forma de
relación conseguimos una mayor reutilización del código y una mayor especialización a
través de la jerarquía de clases. Las clases iniciales en esta jerarquía son más generales, y
a medida que profundizamos en la jerarquía de la descendencia, las clases hijas están más
especializadas, implementan tareas más concretas.
- 27 -
3.11. VENTAJAS DE LA POO
- Facilita la reutilización del software, como ya hemos comentado, a través de la herencia.

Además, la encapsulación nos facilita el uso de objetos que no hemos implementado
todavía, pero de los que conocemos qué hacen.
- Facilita el mantenimiento de los programas y la detección de errores. La encapsulación nos

garantiza que las modificaciones realizadas en el núcleo de un objeto tendrán un efecto
limitado y localizado, su interfaz de comunicación con el resto de objetos se mantendrá, por
lo que podremos seguir comunicándonos con él de igual forma.
- Las tareas de análisis, diseño e implementación son más intuitivas, ya que los objetos en
nuestros diseños van a representar objetos presentes en el mundo real.
3.12. INCONVENIENTES DE LA POO
- La curva de aprendizaje suele ser más larga que la necesaria en la programación

estructurada, debido principalmente a que implica un cambio de mentalidad además de
aprender un nuevo lenguaje orientado a objetos.
- Dificultad en determinar las características de un objeto, porque debemos tener en cuenta

las relaciones con otros objetos. A veces, el establecimiento de nuevas relaciones puede
implicar un cambio en la definición del objeto.
- Jerarquías de herencia complejas, que pueden llegar a ser confusas, en el caso de la

herencia múltiple (una clase puede heredar de más de una clase). C#, el lenguaje que
usaremos en nuestras páginas ASP.NET, soporta herencia simple (cada clase sólo puede
heredar de una única superclase).
- 28 -
RECUERDE
- Los lenguajes de programación orientados a objetos permiten el encapsulamiento, la abstracción, la

herencia y el polimorfismo.
- El encapsulamiento separa la interfaz de la implementación ocultando los datos dentro del objeto y
permitiendo el acceso a los datos de dicho objeto a través de funciones miembro (métodos).
- Las subclases heredan las funciones miembro y las variables de sus clases padre, haciendo sencilla
la reutilización de las funcionalidades de las clases padre.
- El polimorfismo permite crear código genérico y reutilizable que podrá funcionar con una amplia
gama de clases diferentes.
- 29 -
CREANDO UNA
Tema 4 PÁGINA
BÁSICA
4.1. COMENTANDO EL EJEMPLO_____________________________ 34

4.2. SINTAXIS DE C# _______________________________________ 36
4.3. DECLARACIÓN DE VARIABLES ___________________________ 37
4.4. COMENTARIOS ________________________________________ 37
4.5. SENTENCIAS CONDICIONALES ___________________________ 38
4.5.1. Condicional if .. else______________________________ 38
4.5.2. Condicional múltiple switch ________________________ 38
4.6. BUCLES______________________________________________ 40
4.6.1. Bucle do .. while _________________________________ 40
4.6.2. Bucle while _____________________________________ 40
4.6.3. Bucle for _______________________________________ 41
4.6.4. Bucle foreach .. in ________________________________ 41
4.7. OPERADORES ________________________________________ 42
4.7.1. Operadores aritméticos____________________________ 42
4.7.2. Operadores lógicos_______________________________ 42
4.7.3. Operadores de asignación _________________________ 43
4.7.4. Operadores de comparación________________________ 43
4.7.5. Operador de concatenación ________________________ 43
4.7.6. Otros operadores ________________________________ 43
4.8. MANEJADORES DE EVENTOS ____________________________ 44
4.9. TRATAMIENTO DE ERRORES ____________________________ 44
4.10. DEFINICIÓN DE CLASES________________________________ 46
4.11. INSTANCIACIÓN DE CLASES ____________________________ 47
4.12. MODIFICADORES _____________________________________ 51
4.12.1. Modificadores de acceso__________________________ 51
4.12.2. Otros modificadores _____________________________ 52
- 31 -
En este capítulo vamos a realizar una página ASP.NET que muestra el famoso mensaje “Hola Mundo”
cuando pulsemos sobre el botón incluido en la página.
Utilizaremos el lenguaje C# a lo largo del manual, por ser un lenguaje de última generación, pensado para
los desarrolladores Web, y que se adapta mejor a los estándares de C++ y Java. Por tanto, tras comentar
nuestro primer ejemplo, veremos una introducción a la sintaxis de C#.
Nuestra primera página ASP.NET:
holaMundo.aspx
<html>
<head>
<title>Mi primera página ASP.NET</title>
</head>
<body>
<script language=”C#” runat=”server”>
void pulsado (Object origen, EventArgs args) {
etiqueta.Style[“font-size”]=”20”;
etiqueta.Text=”¡Hola Mundo!”;
}
</script>
<form id=”formulario” runat=”server” method=”post”>
<asp:label id=”etiqueta” runat=”server”></asp:label>
<asp:button id=”boton” runat=”server” onclick=”pulsado” text=”Púlsame”></asp:button>
</form>
</body>
</html>
Para poder ejecutar esta página ASP.NET, debemos escribir el código anterior en un fichero con
extensión .aspx, colocarlo en un directorio de publicación en Internet (que además posea el permiso de
ejecución de secuencias de comandos) y ejecutar la página a través del servidor Web (por ejemplo,
escribiendo en nuestro navegador http://localhost/holaMundo.aspx).
- 33 -
Al hacerlo, aparecerá una página vacía que presenta únicamente un botón con el texto ‘Púlsame’. Si
hacemos click sobre él, se mostrará el mensaje ‘¡Hola Mundo!’.
Editando el código de nuestra primera página ASP.NET en el entorno Visual Studio .Net
4.1. COMENTANDO EL EJEMPLO
El fragmento de código que aparece entre las etiquetas <script>, donde se especifica que dicho código
está escrito en C# (si hubiésemos utilizado otro lenguaje de los soportados por la plataforma .NET, se
indicaría aquí, como por ejemplo, VB.NET), define un método que se ejecutará cuando el usuario pulse el
botón que pertenece al Web Form (formulario Web en ASP.NET). Este método trata el evento de
pulsación del botón (onclick=”pulsado” en la definición del control <asp:button>).
Este método no devuelve ningún valor (void) y recibe dos parámetros, que ofrecen información acerca del
evento que se ha producido (aunque en este ejemplo no usamos dichos parámetros porque no es
necesario para mostrar nuestro mensaje). Dentro del método accedemos al estilo de la etiqueta
<asp:label id=”etiqueta”>, para darle un tamaño determinado, y a continuación, establecemos el valor de
la propiedad Text de la etiqueta con el mensaje “¡Hola Mundo!”.
- 34 -
Podemos observar que, el delimitador de sentencias en C# es el punto y coma (;), y el delimitador de
bloques de código, los corchetes ({}).
A continuación de la definición del método y del cierre de las etiquetas <script>, nos encontramos con la
definición de un Web Form (formulario Web), que será el que va a contener la etiqueta y el botón.
Podemos ver que las sintaxis es muy similar a la utilizada para definir un formulario típico HTML, la
diferencia está en la inclusión de la propiedad runat que posee el valor server, para indicar que se trata de
un formulario de servidor.
Dentro del formulario se encuentran dos controles Web que pertenencen a las clases Label y Button (en
el capítulo 5 veremos los controles Web con más detalle).
El control Label representa a la etiqueta que mostrará el mensaje en la página, y el objeto Button es el
botón que invocará el método pulsado( ) cuando el usuario haga click sobre él. Estos dos controles tienen
un atributo id, que es el nombre a través del cual podremos acceder a sus propiedades. Así, en el método
pulsado utilizamos el identificador “etiqueta” para acceder al objeto Label, y modificar su propiedad Text,
que inicialmente no tenía valor.
El control Button posee la propiedad onclick, en la que podemos indicar el método responsable de tratar
el evento de pulsación.
Mediante los Web Forms de ASP.NET, tenemos acceso a todos los controles, ya que forman parte de la
página y se comportan como propiedades de la misma.
Resultado de la ejecución de nuestra página holaMundo.aspx en el navegador
- 35 -
4.2. SINTAXIS DE C#
El lenguaje C# presenta una serie de palabras básicas reservadas para el propio lenguaje, y que por
tanto, no podremos usar en nuestros nombres de clases, variables, propiedades, funciones o métodos.
Estas palabras reservadas son:
abstract event new struct

as explicit null switch
base extern object this
bool false operator throw
break finally out true
byte fixed override try
case float params typeof
catch for private uint
char foreach protected ulong
checked goto public unchecked
class if readonly unsafe
const implicit ref ushort
continue in return using
decimal int sbyte virtual
default interface sealed volatile
delegate internal short while
do is sizeof
double lock stackalloc
else long static
enum namespace string
C# se asimila bastante a lenguajes como C++ o Java. Distingue entre mayúsculas y minúsculas. Por lo
tanto, debemos tener cuidado al escribir nuestro código, por ejemplo, si queremos declarar una variable
de tipo “long”, debemos escribir “long” y no “Long” o “LONG” (para el compilador del lenguaje estas tres
palabras son palabras distintas).
Por convención, los nombres de métodos y las clases tienen la primera letra de cada una de sus partes
en mayúsculas, así por ejemplo, tenemos la clase DropDownList. Los tipos simples del lenguaje C# se
escriben con todas sus letras en minúscula.
- 36 -
Todas las instrucciones en C# acaban con un punto y coma “;”. El separador de bloques de código, como
ya hemos mencionado, son los corchetes ({}).
4.3. DECLARACIÓN DE VARIABLES
Para declarar una variable (tanto si es una referencia a un objeto o a un tipo simple), primero indicamos el
tipo de la variable, es decir, el tipo simple o clase, y a continuación el nombre de la variable. Si la variable
posee algún modificador de acceso (como private o public) o de otro tipo, este modificador debe aparecer
antes del tipo de la variable. (Veremos los modificadores al final del capítulo).
Ejemplo:

string cadena;
int num_aleatorio;
public DateTime fechaActual;
</script>
4.4. COMENTARIOS
Podemos usar comentarios de línea simple o de un grupo de líneas:
// Código comentado de línea simple

/*
Código comentado que ocupa varias líneas.
Siguiente línea de comentario.
El código comentado no se ejecutará.
*/
- 37 -
4.5. SENTENCIAS CONDICIONALES
4.5.1. Condicional if .. else
Su sintaxis es la siguiente (la inclusión de la sentencia “else” es opcional, por eso va entre corchetes):
if (expresión) {
código para expresión “verdadera”
} [else {
código para expresión “falsa”
}]
Veamos un ejemplo de su uso:
<%@ Page language=”C#” %>

<html>
<body>
<%
string color1= “rojo”;
string color2= “azul”;
if ( color1.Equals(color2) ) {
Response.Write (“Los colores son iguales”);
}else {
Response.Write (“Los colores son distintos”);
}
%>
</body>
</html>
4.5.2. Condicional múltiple switch
switch (expresión) {
case expresión_constante1:
código
break;
- 38 -
case expresión_constante2:
código
break;
...
[default:
código
break; ]
}
Veamos un ejemplo de su uso:

<html>
<body>
<%
int respuesta = 3;
switch (respuesta) {
case 1:
Response.Write (“Ha elegido la respuesta 1”);
break;
case 2:
break;
case 3:
break;
default:
Response.Write (“Debe elegir una de estas respuestas: 1, 2, 3”);
break;
}
%>
</body>
</html>
- 39 -
4.6. BUCLES
4.6.1. Bucle do .. while
do {
código
} while (expresión)
Ejemplo de su uso:
<%
int contador= 7;
do {
Response.Write (“Quedan “ + contador + ”segundos para el final<br>”);
contador = contador – 1;
} while (contador > 0);
%>
4.6.2. Bucle while
while (expresión) {
código
}
Ejemplo de su uso:
<%
int contador= 0;
while (contador <= 10) {
Response.Write ( contador + “<br>”);
contador++;
}
%>
- 40 -
4.6.3. Bucle for
for (inicialización; expresión; iteradores) {

código
}
Ejemplo de su uso:
<%
for (int i=0; i<=10; i++) {
Response.Write ( i + “<br>”);
}
%>
4.6.4. Bucle foreach .. in
foreach (tipo identificador in expresión) {

código
}
Este bucle suele utilizarse para recorrer los elementos de un array o de una colección, y por tanto, la
expresión en este bucle será el nombre de un array o colección.
Ejemplo de su uso:
<%
string [] colores = {“rojo”,”azul”,”negro”,”naranja”,”blanco” };
foreach (string color in colores) {
Response.Write ( color + “<br>”);
}
%>
- 41 -
4.7. OPERADORES
En este apartado veremos los principales operadores del lenguaje C#, algunos de los cuales ya hemos
usado en los ejemplos anteriores para formar sentencias o expresiones condicionales.
4.7.1. Operadores aritméticos
+ Suma.
- Resta.
* Multiplicación.
/ División.
% Módulo (resto de la división).
++ Operador de incremento.
-- Operador de decremento.
4.7.2. Operadores lógicos
& Devuelve true si las dos expresiones son verdaderas.

| Devuelve true si una de las dos expresiones es verdadera.
^ Devuelve true si sólo una de las expresiones es verdadera.
¡ Cambia una expresión de verdadera a falsa y viceversa.
&& Similar a &, pero en el caso de que no se cumpla alguna expresión, el resto de las
comparaciones (tomándolas de izquierda a derecha) no se evaluarán y devolverá false.
| | Similar a |, pero en el caso de que se cumpla alguna expresión, el resto de las
comparaciones (tomándolas de izquierda a derecha) no se evaluarán y devolverá true.
true Literal y operador que devuelve el valor booleano de “verdadero”.
false Literal y operador que devuelve el valor booleano de “falso”.
- 42 -
4.7.3. Operadores de asignación
= Operador básico de asignación.

^= Operador de potencia.
*= Operador de multiplicación.
/= Operador de división.
+= Operador de suma.
-= Operador de resta.
&= Operador de concatenación de cadenas.
%= Operador de módulo.
4.7.4. Operadores de comparación
== Igual que.
¡= Distinto que.
> Mayor que.
< Menor que.
>= Mayor o igual que.
<= Menor o igual que.
4.7.5. Operador de concatenación
Este operador sirve para unir dos cadenas de texto (tipo string) en una sola, y es el operador “más” (+).
4.7.6. Otros operadores
. Acceso a miembros de objetos (propiedades y métodos).

[] Operador de índice, para acceder a los distintos elementos de un array.
?: Realiza una operación condicional en una sola línea. Su formato es:
expresion? Caso-si-verdadero : caso-si-falso
is Para ver si un objeto es de un determinado tipo (o es compatible con dicho tipo
debido a la herencia).
sizeof Devuelve el tamaño en bytes de un tipo de datos.
typeof Devuelve el tipo de un objeto.
- 43 -
4.8. MANEJADORES DE EVENTOS
Estos son métodos especiales que se encargan del tratamiento de eventos en el cliente (por ejemplo,
pulsar un botón o cambiar la opción de un desplegable), pero que ejecutarán código de servidor.
Estos métodos para el tratamiento de eventos poseen parámetros (recordemos el método “pulsado” de
nuestra primera página ASP.NET, que mostraba el mensaje “Hola mundo” al hacer click sobre el botón
“púlsame”, al comienzo de este capítulo). El primero de estos parámetros es el control que generó el
evento (en dicho ejemplo, el botón “púlsame”), y el segundo parámetro serán los argumentos adicionales
que necesite el método, y que normalmente dependerán del tipo de evento a tratar.
La sintaxis general de un método para el tratamiento de eventos es la siguiente:
void NombreMétodo (Object origen, EventArgs argumentos) {

código de tratamiento del evento
}
Veremos con más detalle este tipo de métodos en el capítulo siguiente, en el que trataremos los Web
Forms y los controles de ASP.NET.
4.9. TRATAMIENTO DE ERRORES
C# dispone de una serie de sentencias y mecanismos orientados a capturar los errores o situaciones
anómalas que puedan ocurrir dentro de nuestros programas, para poder tratarlos de forma adecuada.
Este tratamiento se conoce como gestión estructurada de excepciones, que manejamos con las
siguientes palabras reservadas:
- try: Con esta palabra clave definimos la zona de nuestro código que va a ser inspeccionada
y tratada bajo la gestión estructurada de excepciones.
- catch: Con esta palabra clave definimos el código que debe ejecutarse cuando se produce
la excepción o situación anómala. Podemos tener múltiples catch para un solo try, se
- 44 -
ejecutará aquel catch que tenga el tipo de excepción u error que se haya producido en la
zona del try para esa ejecución.
- finally: Esta palabra clave define el código que se ejecutará siempre después de ejecutar
un código dentro de una sentencia try, es decir, el código que pongamos en este bloque, se
ejecutará siempre, independientemente de si se ha producido o no una excepción.
- throw: Esta sentencia se utiliza para “lanzar” una excepción, debe ir seguida de un objeto
que representa la excepción que se ha producido (debe ser un objeto que hereda de la clase
System.Exception). Lanzar la excepción significa que dicho error puede propagarse y ser
tratado en otro punto de la secuencia de llamadas a métodos.
La sintaxis de un bloque try-catch-finally es la siguiente:
try {
código a inspeccionar
} catch (tipo de excepción variable) {
tratamiento de esta excepción
} catch (tipo de excepción variable) {
tratamiento de esta excepción
}
[ ... ]
finally {
código que siempre se ejecutará, se produzca o no una excepción en el bloque try
}
Veamos un ejemplo. En el siguiente código se intenta realizar una operación matemática de división de
un número por cero, lo que dentro del entorno de ejecución causará una excepción del tipo
“System.DivideByZeroException”, que deriva directamente de la clase “System.Exception”, y que nos
encargaremos de capturar de forma adecuada mediante una sentencia “catch” para presentar al usuario
un mensaje de error controlado.

<html>
- 45 -
<body>
<%
int numero1 = 50;
int numero2 = 0;
int resultado;
try {
resultado = numero1 / numero2;
}catch ( System.DivideByZeroException error ) {
Response.Write (“Se ha producido un error. No se puede dividir por cero.
Excepcion: ” + error.Message);
}
%>
</body>
</html>
4.10. DEFINICIÓN DE CLASES
La sintaxis general para declarar una clase en C# es:
using Namespace;
namespace NombreDeEspacio {
modificadores class NombreDeClase : ClasePadre {
implementación de la clase
}
}
Incluiremos una sentencia using por cada uno de los espacios con nombre (NameSpace) que
necesitemos. Un namespace es una forma de clasificar y organizar clases, para evitar conflictos de
nombres (podemos tener clases con igual nombre en distintos namespaces). Cada namespace contiene
un conjunto de clases relacionadas (como una librería).
Podemos definir nuestra clase dentro de un Namespace, para ello utilizaremos la palabra clave
namespace seguida del nombre que le damos a nuestro espacio con nombre.
- 46 -
Entre las llaves del Namespace incluimos la declaración de la clase. En esta declaración aparecen los
modificadores de la clase (veremos lo modificadores en el siguiente apartado, sirven para definir las
características de nuestra clase), la palabra reservada class y el nombre que hemos elegido para la clase
que estamos definiendo.
Si nuestra clase hereda de una clase padre (superclase), lo indicaremos poniendo los dos puntos ( : ) y a
continuación, el nombre de la clase de la que heredamos. Después, entre las dos llaves escribimos la
implementación de la clase, donde definimos sus propiedades y métodos.
4.11. INSTANCIACIÓN DE CLASES
Para crear una nueva instancia de una clase (nuestra o de las proporcionadas por el entorno), utilizamos
el operador new. Este operador informa al sistema de que queremos crear un nuevo objeto y asignarlo a
un nombre de objeto que elegimos. Cuando se utiliza este operador, el sistema llama automáticamente al
constructor de la clase, donde se inicializan las propiedades de la actual instancia (objeto) que estamos
creando.
Su sintaxis es la siguiente:
Clase nombre_objeto = new Clase ( );
El operador new se utiliza para crear nuevos objetos, no para tipos básicos como int, long, bool, char, etc.
Para los tipos básicos es suficiente una declaración indicando el tipo de la variable, seguido del nombre
dado a la variable, por ejemplo:
int numero;
string cadena=”Hola mundo”;
El CLR de Microsoft .NET cuenta con un recolector de basura que se encarga de liberar automáticamente
todos los objetos creados mediante el operador new cuando detecta que el objeto deja de ser utilizado.
Veamos un ejemplo de clases. Vamos a utilizar dos archivos distintos. Por un lado, el archivo
“vehiculo.cs” que contiene una clase denominada “vehiculo”, dentro del espacio de nombres
“aplicacionWeb” y, por otro lado, la página ASP.NET pagina.aspx.
- 47 -
Esta técnica de separación de código es muy utilizada en la plataforma ASP.NET (se denomina Code-
Behind, código por detrás o código oculto), consiste en separar la interfaz de usuario de la lógica de la
aplicación. La lógica se encuentra en el archivo .cs (la definición de la clase), y la interfaz de usuario (la
presentación de la aplicación) en el archivo .aspx.
Archivo vehiculo.cs
using System;
namespace aplicacionWeb {
public class vehiculo {
private int n_puertas = 0;
private string marca = ” ”;
public vehiculo (int num_puertas, string nombre_marca) {
n_puertas = num_puertas;
marca = nombre_marca;
}
public string getMarca( ) {
return marca;
}
public int getNumeroPuertas( ) {
return n_puertas;
}
}
}
- 48 -
Editando el código del archivo vehículo.cs en Visual Studio .NET
Archivo pagina.aspx
<%@ Page language=”c#” %>

<%@ Assembly src=”vehiculo.cs” %>
<%@ import namespace=”aplicacionWeb” %>
<html>
<head>
<title> Ejemplo de clases </title>
</head>
<body>
<%
vehiculo coche1 = new vehiculo(5,”Renault”);
%>
La marca del coche es:
<% =coche1.getMarca() %>
- 49 -
<br>
El número de puertas es:
<% =coche1.getNumeroPuertas() %>
</body>
</html>
Editando el código del archivo pagina.aspx en Visual Studio .NET
La directiva Assembly indica la localización del código fuente (en el archivo vehiculo.cs), y la directiva
import especifica el espacio de nombres utilizado.
En este ejemplo, creamos una nueva instancia de la clase “vehiculo” mediante el operador new. Lo
inicializamos con 5 puertas y marca Renault (valor para sus propiedades), y una vez que ya tenemos
creado nuestro objeto, podemos acceder a sus métodos miembro disponibles (getMarca y
getNumeroPuertas).
- 50 -
Resultado de la ejecución de nuestro ejemplo de clases
4.12. MODIFICADORES
Los modificadores son palabras clave cuya función es especificar el ámbito o cualidades de nuestras
clases, objetos, variables o métodos.
4.12.1. Modificadores de acceso
Estos modificadores se encargan de especificar el nivel de accesibilidad de los miembros de las clases
(propiedades y métodos). Disponemos de los siguientes:
- public: Informa al entorno de que la propiedad o método es accesible desde cualquier clase
o parte del programa. Este modificador otorga el máximo nivel de accesibilidad.
- private: Con este modificador informamos al sistema de que la propiedad o método

únicamente es accesible desde los métodos internos de la misma clase (es decir, sólo
podemos acceder a un miembro private desde la propia clase, no desde otras clases, ni
siquiera desde las subclases que hereden de la clase que contiene los miembros private).
- 51 -
- protected: Los miembros protected son accesibles desde la propia clase donde se
encuentran, y desde las clases derivadas de ella.
- internal: Los miembros que llevan este modificador sólo son accesibles desde los archivos
del mismo proyecto.
4.12.2. Otros modificadores
El lenguaje C# dispone de otra serie de modificadores, aplicables a clases o miembros de clase:
- abstract: Las clases abstractas son aquellas que no tienen la implementación de todos sus
métodos, sino que contienen algún método no implementado. Las clases abstractas no
pueden ser instanciadas directamente (mediante el operador new), sino que sirven como
clase base a otras clases, donde se proporcionará la implementación de esos métodos no
implementados.
- const: Este modificador indica que la propiedad de clase o variable es una constante, es
decir, tiene carácter de sólo lectura, y su valor no puede modificarse.
- extern: Este modificador se aplica a un método, e indica que la implementación de dicho

método es realizada de forma externa, mediante la inclusión de alguna librería externa a
.NET Framework.
- readonly: Este modificador marca a una propiedad como de sólo lectura (pero puede
inicializarse dentro de un constructor de dicha clase).
- sealed: Es aplicable exclusivamente a las clases, y significa que la clase no se puede

heredar.
- static: Este modificador indica que la propiedad o método de una clase pertenece al propio
tipo o clase, es decir, el elemento static no se crea por cada instancia de la clase. Podemos
acceder a los miembros estáticos a través de su clase, sin tener que crear un nuevo objeto
de esa clase.
- 52 -
- virtual: Este modificador marca a un método para que las clases derivadas puedan
implementarlo.
- override: Se utiliza para generar una nueva implementación de una función virtual de una
clase. Aparece en las clases derivadas de una clase base (abstracta) para implementar
funcionalidad específica a dichas clases derivadas.
- 53 -
RECUERDE
- C# es uno de los lenguajes más utilizados en la plataforma .NET.
- Es un lenguaje orientado a objetos, que permite aplicar los mecanismos propios de la POO, como
derivación, abstracción o encapsulamiento.
- Su sintaxis es bastante similar a C++ o Java.
- Distingue entre mayúsculas y minúsculas.
- Cuenta con las estructuras típicas (sentencias condicionales, bucles, operadores, modificadores, etc).
- Permite una gestión estructurada de excepciones, con la que controlar los errores o las situaciones
anómalas que puedan ocurrir durante la ejecución de nuestra aplicación.
- Permite separar la interfaz de usuario de la lógica de la aplicación (técnica Code-Behind).
- 54 -
Tema 5 CONCEPTOS DE
WEB FORMS
5.1. LA CLASE PAGE _______________________________________ 57

5.1.1. Eventos de la página _____________________________ 57
5.1.2. Propiedades de la clase Page ______________________ 59
5.1.3. Métodos de la clase Page __________________________ 61
5.2. WEB FORMS __________________________________________ 61
5.3. INTRODUCCIÓN A LOS CONTROLES DE SERVIDOR DE ASP.NET 63
5.4. INTRODUCCIÓN A LOS CONTROLES HTML _________________ 64
5.5. EJEMPLOS CON CONTROLES HTML ______________________ 66
5.6. INTRODUCCIÓN A LOS CONTROLES WEB __________________ 71
5.7. EJEMPLOS CON CONTROLES WEB _______________________ 74
- 55 -
En este capítulo veremos una introducción a los controles Web que pueden utilizarse en un Web Form
(formulario ASP.NET). Estos controles los incluiremos en una página ASP.NET, por lo que antes vamos a
ver la clase Page, ya que podemos representar a la página ASP.NET actual como un objeto de esta
clase.
5.1. LA CLASE PAGE
Cada vez que pedimos una página ASP.NET a un servidor Web, es decir, un cliente a través de un
navegador Web solicita una URL que indica un fichero .ASPX en el servidor, se crean una serie de
componentes que constituyen la página solicitada y que se compilan en una unidad. Estos componentes
pueden ser: el fichero .ASPX solicitado, los controles de la página, las clases que contiene el código de la
página, etc.
Los distintos componentes compilados dan lugar a un objeto de la clase

Object.Control.TemplateControl.Page. Esta clase se crea de forma dinámica, y se instanciará cada vez
que se realice una petición del fichero .ASPX.
Dentro del código de una página siempre vamos a tener acceso a la clase Page, ya que podemos decir
que el objeto instancia de esta clase Page, representa a la página ASP.NET actual. Este objeto nos sirve
como contenedor de todos los componentes que constituyen la página, y nos permite acceder a sus
propiedades, métodos y eventos.
A continuación, vamos a comentar los principales eventos, propiedades y métodos que nos ofrece la
clase Page:
5.1.1. Eventos de la página
ASP.NET nos ofrece una serie de eventos que nos permiten estructurar el código en las páginas. Estos
eventos no existían en la versión anterior de ASP.
Los eventos se producen en un orden determinado a lo largo de la carga de la página:
- Init: este evento es lanzado cuando la página es inicializada. En ese momento, todavía no
se han creado por completo los distintos controles de la página. Este evento es tratado en el
método Page_Init.
- 57 -
- Load: este evento se lanza a continuación del método Init y tiene lugar cuando la página se
ha cargado. En este momento, todos los controles de la página ya han sido creados. Este
evento se lanzará cada vez que la página es ejecutada. Este evento lo tratamos en el
método Page_Load.
- PreRender: este evento tiene lugar justo antes de enviar la información al cliente. Siempre
es lanzado después del evento Load. Lo tratamos en el método Page_PreRender.
- UnLoad: este evento se lanzará en último lugar, después de haber tenido lugar todos los
anteriores. En este momento, la página ha finalizado de procesarse, se ha terminado la
ejecución de la página y toda la información ha sido enviada al cliente. Este evento lo
tratamos en el método Page_UnLoad
Veamos un sencillo ejemplo de uso de estos métodos:
ejemploEventos.aspx
<html>
<head>
<title>Ejemplo de ejecución de los eventos en una página ASP.NET</title>
</head>
void Page_Init (Object origen, EventArgs args) {
Page.Response.Write (“Se ha lanzado el Evento Init<br>”);
}
void Page_Load (Object origen, EventArgs args) {
Page.Response.Write (“Se ha lanzado el Evento Load<br>”);
}
void Page_PreRender (Object origen, EventArgs args) {
Page.Response.Write (“Se ha lanzado el Evento PreRender<br>”);
}
</script>
<body>
- 58 -
<asp:label id=”etiqueta” runat=”server”>Eventos de la página</asp:label>
</form>
</body>
</html>
Al ejecutar este ejemplo veremos una serie de mensajes que ilustran el orden de ejecución de los
distintos eventos que tratamos:
5.1.2. Propiedades de la clase Page
Para acceder a una propiedad de la clase Page podemos indicar delante de la propiedad la clase Page o
utilizar la propiedad directamente, por ejemplo:
Page.Response.Write (“Hola Mundo”);

es equivalente a:
Response.Write (“Hola Mundo”);
- 59 -
Las propiedades principales de la clase Page son:
- Application: esta propiedad es una referencia a un objeto de la clase

System.Web.HttpApplicationState. Nos permite almacenar y acceder a información
compartida y común a toda la aplicación Web. Esta propiedad es equivalente al objeto
integrado Application de ASP 3.
- ClientTarget: es un objeto de la clase String, nos permite sobrescribir la detección

automática de navegador Web ofrecida por ASP.NET.
- EnableViewState: propiedad de tipo Boolean, nos permite desactivar el mantenimiento del

estado entre distintas llamadas de los controles Web de la página. Por defecto, su valor es
true.
- IsPostBack: propiedad de tipo Boolean, devuelve true si la página actual ya ha sido enviada
al servidor en alguna ocasión. Si tiene el valor false significa que es la primera vez que se
carga la página. Este indicador nos servirá para inicializar los controles Web y propiedades
de la página.
- Request: esta propiedad es una referencia a un objeto de la clase System.Web.HttpRequest

(es equivalente al antiguo objeto integrado Request del ASP 3). Esta propiedad nos permite
acceder a toda la información necesaria de la petición del protocolo HTTP que ha sido
utilizada para solicitar la página del servidor Web.
- Response: esta propiedad es una referencia a un objeto de la clase

System.Web.HttpResponse (es equivalente al antiguo objeto integrado Response del ASP
3). Esta propiedad nos permite manipular la respuesta devuelta al cliente que ha realizado la
petición de la página, es decir, este objeto representa la respuesta HTTP que se envía al
cliente.
- Server: este atributo es una referencia a un objeto de la clase System.Web.HttpServerUtility

(tiene la misma funcionalidad del antiguo objeto integrado Server del ASP 3). Entre sus
principales funcionalidades estaba la creación de componentes existentes en el servidor. En
ASP.NET los objetos se crean de distinta manera, importamos el espacio de nombres
- 60 -
necesario (para tener acceso a todas sus clases) y a través del operador new creamos
nuevas instancias de objetos.
- Session: esta propiedad es una referencia a un objeto de la clase

System.Web.SessionState.HttpSessionState. Nos permite almacenar información entre
diferentes páginas incluidas en una misma aplicación ASP.NET para cada usuario. Esta
propiedad es equivalente al objeto integrado Session de ASP 3.
- User: esta propiedad devuelve información sobre el usuario que ha solicitado la página
ASP.NET.
5.1.3. Métodos de la clase Page
Veamos una descripción de algunos de los métodos que nos ofrece la clase Page:
- FindControl: este método realiza una búsqueda en la página del control Web cuyo nombre
se pasa como parámetro, y devuelve dicho control (si lo encuentra). El parámetro que recibe
es un objeto de la clase String que representa el nombre del control buscado, y el objeto
devuelto corresponde a la clase Control. Sobre este objeto debemos aplicar el casting al
control Web esperado para poder acceder a sus miembros.
- MapPath: este método devuelve un objeto de la clase String que representa una ruta virtual
construida a partir de la ruta física que se le pasa como parámetro, que también es un objeto
de la clase String.
- ResolveUrl: método que convierte una URL virtual, que le pasamos como parámetro, en
una URL absoluta.
5.2. WEB FORMS
Los Web Forms (formularios Web) son una característica de ASP.NET que ofrece un nuevo modelo
programación (no existía en versiones anteriores de ASP), y nos va a permitir generar contenidos
dinámicos de una forma más sencilla.
- 61 -
Los Web Forms sustituyen a los formularios HTML dentro del entorno de programación de ASP.NET. Es
un Web Form quien va a generar el código HTML correspondiente al formulario que estamos diseñando.
Permiten el tratamiento de los eventos del cliente con código ASP.NET, es decir, con código que será
ejecutado en el servidor Web.
Este modelo de programación ofrece algunas ventajas con respecto al modelo anterior de ASP:
- Ofrece un modelo de programación más visual (en el entorno Visual Studio .NET
podemos usar los distintos controles que nos suministran distintas paletas, y arrastrarlos y
soltarlos hasta la vista de diseño). Se ahorra tiempo de desarrollo en crear la interfaz de
usuario y además podemos reutilizar estos controles que encapsulan su funcionalidad.
- El código resultante es más limpio en la página, ya que no aparece mezclado con código
HTML como ocurría en las versiones anteriores de ASP (donde lo habitual es mezclar
código HTML con código ASP). ASP.NET ofrece una mayor separación entre la lógica de la
aplicación y la presentación de la misma.
- Integra el tratamiento de eventos del cliente con el código correspondiente en el servidor.
- Lleva a cabo el mantenimiento del estado del formulario de forma automática entre
peticiones, esto significa que, si seleccionamos una serie de valores en el Web Form, al
enviarlo, de forma automática se van a mantener estos valores en el caso de que se vuelva
a recargar el formulario.
Para crear un formulario Web únicamente debemos utilizar una etiqueta <form>, al estilo de las etiquetas
del lenguaje HTML, e incluir la propiedad runat con el valor server. Por ejemplo:
<form id=”MiWebForm” method=”post” runat=”server”>

</form>
Dentro del formulario Web colocaremos los distintos controles de servidor de ASP.NET que necesitemos
para recoger la información correspondiente. Estos controles van a realizar las mismas funciones que los
típicos controles del lenguaje HTML que constituían los campos de un formulario.
- 62 -
5.3. INTRODUCCIÓN A LOS CONTROLES DE SERVIDOR DE ASP.NET
Los controles ASP.NET son una serie de objetos de servidor que generarán el correspondiente código
HTML para que el usuario pueda visualizarlos y utilizarlos en la página cargada en su navegador. Estos
controles se encargan de manejar los eventos generados por el cliente (como la pulsación de un botón,
selección de una opción en un desplegable, etc).
Con este nuevo modelo, ya no es necesario utilizar los típicos campos de formulario de HTML que
usábamos junto con ASP 3. Cada control de servidor se corresponde con una clase determinada
perteneciente a un espacio de nombres determinado. Existe un gran número de controles de servidor y
cada uno de ellos pertenece a una clase del paquete .NET Framework.
Podemos realizar la siguiente clasificación:
- Controles HTML: representan controles puramente HTML, los que este lenguaje define
para su uso en formularios.
- Controles Web: son otros componentes que ASP.NET trae preconfigurados y que
implementan elementos más complejos.
- Controles de lista: utilizados para distribuir y mostrar datos en una página (son los
controles DataList y DataGrid, éstos los veremos en el próximo capítulo).
- Controles avanzados : cada vez se desarrollan más controles de este tipo, que ofrecen
funcionalidades avanzadas, como controles para rotar anuncios en nuestras páginas o para
simular un calendario completo.
Cuando utilizamos Visual Studio .NET para diseñar nuestras páginas Web, podemos utilizar dos formas
distintas de definir el posicionamiento de nuestros controles:
- GridLayout: permite un posicionamiento dinámico de los elementos, mediante coordenadas

X e Y. Se realiza gracias a la integración en los navegadores de las hojas de estilo en
cascada y su posicionamiento dinámico de elementos HTML.
- FlowLayout: este sistema utiliza el método tradicional de HTML de posicionamiento,

mediante párrafos y tablas, colocando los elementos de forma secuencial.
- 63 -
5.4. INTRODUCCIÓN A LOS CONTROLES HTML
La sintaxis que ofrecen los controles HTML de servidor es muy similar a la sintaxis de los controles
clásicos del lenguaje HTML. Estos controles ofrecen la potencia de los Web Forms y mantienen la
familiaridad y facilidad de uso de las etiquetas HTML que representan los campos de un formulario.
Estos controles tienen el mismo aspecto que una etiqueta HTML, a excepción de que presentan el
atributo runat con el valor server. Otra diferencia es que posee un atributo especial para el tratamiento
de eventos del cliente con código del servidor. Para realizar el tratamiento de eventos de estos controles
con código de servidor, utilizaremos el atributo onserverevento. A este atributo se le indica como valor el
nombre del método que queremos ejecutar.
Para identificar de forma única un control ASP.NET, debemos utilizar la propiedad id. Mediante este
identificador podemos hacer referencia al objeto correspondiente en la página, y así utilizar el código de
servidor para acceder a sus métodos o manipular sus propiedades. Cada control del formulario es un
objeto (objetos de la página ASP.NET), es decir, una instancia de una clase determinada, y por lo tanto
cada uno de ellos poseerá sus propiedades y métodos.
Así, la sintaxis general de un control HTML es:
<input type=”elementoHTML” id=”identificador” runat=”server”>
Los controles HTML están disponibles para mantener la compatibilidad con versiones anteriores de ASP,
de manera que, si queremos que una etiqueta HTML pase a ser un control HTML, simplemente debemos
indicar la propiedad runat con el valor server. Normalmente, se utilizan el siguiente tipo de controles, los
controles Web (que también veremos en este capítulo).
A continuación vamos a ver una descripción de las distintas clases que se corresponden con los controles
HTML. Estas clases se encuentran dentro del espacio de nombres System.Web.UI.HtmlControls. Éstas
son las clases que ofrecen al desarrollador el acceso en el servidor a las distintas etiquetas HTML que
finalmente se enviarán al cliente Web como resultado de la ejecución de la página ASP.NET
correspondiente.
La lista de los controles HTML que vienen predefinidos en el sistema ASP.NET son los siguientes:
- 64 -
- HTMLAnchor: Representa a la etiqueta <a>, es decir, es el control HTML que nos permite
manejar enlaces.
- HTMLButton: Representa a la etiqueta <button> de HTML, que es un botón de pulsación.
- HTMLForm: Representa a la etiqueta <form> de HTML. Esta clase permite definir un Web
Form, que va a realizar la labor de contenedor para los controles de servidor dentro de la
página, es decir, todos los controles que deseemos enviar al servidor (método post)
debemos incluirlos dentro de un control de la clase HtmlForm.
- HTMLGenericControl: Esta clase se utiliza para respresentar las etiquetas HTML que no
tienen una correspondencia directa con las clases del paquete .NET Framework (como las
etiquetas <span>,<div> o <body>).
- HTMLImage: Representa a la etiqueta <img> de HTML, que se utiliza para mostrar

imágenes.
- HTMLButton: Representa a los botones de pulsación para formularios HTML del tipo button,
submit y reset (botón normal, de envío y de restauración del formulario).
- HTMLInputCheckBox: Representa al elemento <input type=”checkbox”>, que es una casilla

de verificación de HTML.
- HTMLInputFile: Representa al elemento <input type=”file”>, que se utiliza para subir

ficheros desde el cliente al servidor.
- HTMLInputHidden: Representa al elemento <input type=”hidden”>, que es un control

invisible para almacenar valores alfanuméricos.
- HTMLInputimage: Representa al elemento <input type=”image”>, que es una imagen que

presenta una funcionalidad de envío de un formulario HTML.
- HTMLInputRadioButton: Representa al elemento <input type=”radio”>, que es una casilla

de opción de HTML.
- 65 -
- HTMLInputText: Representa a los elementos <input type=”text”> y <input
type=”password”>, que son cajas de texto y contraseña de un formulario HTML.
- HTMLSelect: Representa al elemento <select”> que es un desplegable de un formulario

HTML.
- HTMLTable: Este control se corresponde con una

tabla del lenguaje HTML, y por tanto, permite el
acceso desde el servidor a una etiqueta <table>. Esta
clase posee una colección llamada Rows, que
contiene objetos de la clase HTMLTableRow.
- HTMLTableRow: Es el control HTML que permite

manipular una fila de una tabla.
- HTMLTableCell: Esta clase permite el acceso a las

celdas de una tabla, es decir, se corresponde con las
etiquetas <td> y <th>.
- HTMLTextArea: Este control permite manipular en el

servidor la etiqueta <textarea>, que es una caja de
texto de gran capacidad en un formulario HTML.
Paleta de controles HTML en Visual Studio .NET
5.5. EJEMPLOS CON CONTROLES HTML
ejemplo1.aspx
<%@ Page language =”c#” %>

<html>
<head>
<title>Ejemplo de uso de controles HTML en una página ASP.NET</title>
- 66 -
</head>
void cambia (Object origen, EventArgs args) {
etiqueta.InnerText=lista.Value;
}
</script>
<body>
<select id=”lista” runat=”server”>
<option selected>Azul</option>
<option>Rojo</option>
<option>Verde</option>
<option>Blanco</option>
</select>
<input type=”button” id=”boton” runat=”server” value=”Seleccione un color”
onserverclick=”cambia”>
<div id=”etiqueta” runat=”server”></div>
</form>
</body>
</html>
Este ejemplo muestra una lista desplegable con una serie de nombres de colores y un botón. Al pulsar el
botón se muestra el elemento seleccionado de la lista en un texto de un elemento <div>.
Podemos comprobar que no se ha utilizado la colección Form del objeto Request para obtener los valores
de los elementos enviados en el formulario (como se hacía habitualmente en ASP 3), sino que hemos
accedido a las propiedades de los controles a través del nombre con el que los hemos declarado (el valor
del atributo id, que permite tener acceso a las propiedades y métodos de cada control del formulario).
Accedemos a la propiedad innerText de la etiqueta para asignarle el valor obtenido de la lista
desplegable.
Si hacemos distintas llamadas al formulario, podremos observar que se mantiene el estado del mismo, es
decir, en el combo se mantiene el elemento seleccionado, sin que tengamos que escribir ningún código
adicional para controlarlo. Esto es posible gracias a que el Web Form genera un campo oculto que
conserva los valores de los campos del formulario.
- 67 -
Resultado de ejecutar ejemplo1.aspx en el navegador
Ejemplo2.aspx

<html>
<head>
</head>
void cambiaColor (Object origen, EventArgs args) {
cuerpo.Style[“background-color”]=lista.Value;
}
</script>
<body id=”cuerpo” runat=”server”>
<select id=”lista” runat=”server”>
<option value=”blue” selected>Azul</option>
<option value=”red”>Rojo</option>
- 68 -
<option value=”yellow”>Amarillo</option>
<option value=”green”>Verde</option>
</select>
<input type=”button” id=”boton” runat=”server” value=”Seleccione un color”
onserverclick=”cambiaColor”>
</form>
</body>
</html>
En este ejemplo utilizamos un control HTML de la clase HtmlGenericControl, y dos objetos de las clases
HtmllnputButton y HtmlSelect, que se corresponden con el botón y la lista desplegable del formulario. Al
seleccionar un elemento de la lista (un color), y pulsar el botón, se mostrará el documento HTML con el
color de fondo seleccionado en el combo.
En este ejemplo podemos ver cómo aplicar estilos a los controles ASP.NET. Para ello, usamos la
propiedad Style del control, que funciona como una colección permitiendo acceder a las distintas
propiedades del control que representan los atributos de las hojas de estilo. En este caso se manipula la
propiedad background-color, para establecer el color de fondo de la página actual.
- 69 -
Ejemplo3.aspx

<html>
<head>
</head>
void cambiaImagen (Object origen, EventArgs args) {
imagen.Src=texto.Value;
}
</script>
<body id=”cuerpo” runat=”server”>
<input type=”text” runat=”server” id=”texto”>
<input type=”button” id=”boton” runat=”server” value=”Cambia” onserverclick=”cambiaImagen”>
<img src=”imagen1.gif” runat=”server” id=”imagen”>
</form>
</body>
</html>
En este ejemplo se muestra la imagen que se indica en la caja de texto. La imagen se actualiza con la
que indiquemos cada vez que se pulse el botón del formulario.
- 70 -
5.6. INTRODUCCIÓN A LOS CONTROLES WEB
Estos controles cumplen la misma funcionalidad que los anteriores, los controles HTML, pero su sintaxis
es distinta, está basada en XML, y además, no existe una correspondencia directa entre los controles y
las etiquetas HTML que se generan (como sucedía con los controles HTML).
Estos controles pertenecen al espacio de nombres System.Web.UI.WebControls. Ofrecen un nivel de

abstracción mayor que los anteriores, y su modelo de objetos no refleja la sintaxis HTML necesariamente
(cuando la página se carga en el navegador, el control Web determina el navegador que ha realizado la
petición, y de acuerdo con esta información genera el código HTML apropiado y específico para ese
navegador Web).
La sintaxis general de un control Web es :
<asp:nombreControl id=”identificador” runat=”server”></asp:nombreControl>
Cuando el control Web no tiene cuerpo, también podemos usar esta otra forma de sintaxis:
<asp:nombreControl id=”identificador” runat=”server” />
Además de la diferencia de sintaxis, entre los controles HTML y controles Web, algunos nombres de
propiedades también cambian, por ejemplo, el control HTML button posee la propiedad value, y sin
embargo el control Web equivalente posee la propiedad text para mostrar el texto del botón.
Para indicar los métodos para el tratamiento de eventos de la pulsación de un botón del ratón en los
controles HTML hemos visto que utilizamos la propiedad onserverclick, pues, en los controles Web
utilizamos la propiedad OnClick.
En los controles HTML se debe distinguir si se trata de un evento de cliente o de servidor (ya que
podemos tratar ambos tipos, de servidor como hemos visto en el apartado de controles HTML, y de
cliente, a través de algún lenguaje de script de cliente, como JavaScript). Sin embargo, desde los
controles Web sólo tenemos la posibilidad de utilizar eventos de servidor, es decir, eventos que son
tratados por rutinas, código que se ejecuta en el servidor.
- 71 -
Al igual que ocurría con los controles HTML, para permitir hacer referencia a los controles dentro del
código fuente de la página, debemos utilizar el atributo id, de esta forma podemos utilizar el objeto que se
corresponde con el control de servidor para utilizar sus métodos o manipular sus propiedades.
A continuación vamos a ver los principales controles Web que vienen predefinidos en el sistema
ASP.NET (para una referencia completa de todos ellos, debemos consultar la referencia técnica de
Microsoft):
- Button: Este control Web representa un botón. Se corresponde con la etiqueta <input
type=”submit”>, es decir, un botón que envía el contenido de un formulario al servidor. Para
tratar el evento de pulsación del botón, utilizamos la propiedad OnClick de la clase Button.
- CheckBox: Este control Web representa una casilla de verificación. Se corresponde con la
etiqueta <input type=”checkbox”>. El evento que se lanza al pulsar sobre un CheckBox es el
evento CheckedChanged. Para utilizar checkbox múltiples podemos usar el control
CheckBoxList.
- CheckBoxList: Este control permite utilizar una lista de selección múltiple de elementos
checkbox. Este objeto posee una colección Items que contiene todos los objetos CheckBox.
- DropDownList: Este control representa una lista desplegable, y se corresponde con la

etiqueta <select> de HTML.
- HiperLink: Representa un elemento de hipervínculo (enlace) a otra página, por lo tanto,

generará en el cliente una etiqueta <a>.
- Image: Este control representa una imagen. Generará como resultado de su ejecución una
etiqueta <img> de HTML. Para indicar la imagen que queremos mostrar, utilizaremos la
propiedad ImageURL.
- ImageButton: Este control representa una imagen que actúa como botón tipo submit, es
decir, al pulsar sobre la imagen se envían los contenidos del formulario al servidor. Generará
como resultado de su ejecución una etiqueta <input type=”image”> de HTML.
- 72 -
- Label: Representa una etiqueta de texto. Generará como resultado de su ejecución una
etiqueta <span> de HTML.
- LinkButton: Este control representa un botón que presenta un estilo similar a los enlaces,
su apariencia es similar a un control Hiperlink, pero ofrece la misma funcionalidad que un
control Button, es decir, presenta un texto a modo de enlace que al pulsarlo enviará el
formulario en el que se encuentre al servidor.
- ListBox: Representa a un cuadro de lista, es similar al control DropDownList, pero en este

caso se muestran varios elementos de la lista y se permite la selección múltiple. En su
propiedad Rows indicamos el número de filas visibles que va a mostrar el control, y en la
propiedad SelectionMode indicamos si se permite la selección múltiple (valor Multiple) o bien
la selección simple (valor Single, es el valor por defecto).
- Panel: Este control se utiliza para agrupar controles (actúa como contenedor de otros
controles). Posee una propiedad Controls que es una colección que contiene todos los
controles incluidos dentro del objeto Panel.
- RadioButton: Representa un botón de opción que se corresponde con el elemento <input

type=”radio”> de HTML. Permite seleccionar una opción dentro de un mismo grupo de
opciones. Las opciones se agrupan mediante la propiedad GroupName.
- RadioButtonList: Este control representa una lista selección múltiple de elementos

RadioButton. Posee una colección Items que contiene todos los objetos RadioButton. Este
control es parecido al control CheckBoxList, pero en este caso se utilizan controles
RadioButton en lugar de CheckBox.
- Style: Este control representa al estilo (CSS) de un control de servidor, es decir, podemos
usar estilos para mejorar y personalizar el aspecto los controles.
- Table, TableRow y TableCell: Estos controles están muy relacionados entre sí, mediante la
utilización de todos ellos podemos generar tablas en HTML. El control Table representa una
tabla (etiqueta <table> de HTML). Esta clase posee una colección llamada Rows, que
contiene objetos de la clase TableRow, y que representan las filas de la tabla. A su vez, el
objeto TableRow tiene una colección llamada Cells, que contiene las columnas para esa fila
de la tabla.
- 73 -
- TextBox: Este control representa una caja de texto.
- Xml: Este control se utiliza para mostrar un documento XML en la página.
Creando un Web Form en la vista diseño de Visual Studio .NET
5.7. EJEMPLOS CON CONTROLES WEB
ejemplo4.aspx

<html>
<head>
<title>Ejemplo de uso de controles Web en una página ASP.NET</title>
</head>
void cambia (Object origen, EventArgs args) {
etiqueta.Text=”Ha seleccionado ” + lista.SelectedItem.Text;
- 74 -
}
</script>
<body>
<asp:ListBox id=”lista” runat=”server”>
<asp:ListItem selected>Java</asp:ListItem>
<asp:ListItem>ASP</asp:ListItem>
<asp:ListItem> PHP</asp:ListItem>
<asp:ListItem>JSP</asp:ListItem>
</asp:ListBox>
<asp:Button id=”boton” runat=”server” Text=”Seleccione un lenguaje” OnClick=”cambia” /><br>
<asp:Label id=”etiqueta” runat=”server” />
</form>
</body>
</html>
Este ejemplo muestra un formulario con una lista desplegable con los nombres de distintos lenguajes de
programación, y un botón. Al seleccionar un elemento de la lista y pulsar el botón, se muestra el elemento
elegido de la lista en una etiqueta.
- 75 -
ejemplo5.aspx

<html>
<head>
</head>
void obtenerFecha (Object origen, EventArgs args) {
DateTime ahora;
ahora = DateTime.Now;
etiqueta.Text = ”Fecha/Hora actuales: ” + ahora.ToString();
}
</script>
<body>
<asp:Button id=”boton” runat=”server” Text=”Obtener fecha” OnClick=”obtenerFecha” /><br>
</form>
</body>
</html>
En este ejemplo se muestra la fecha y hora actuales en un objeto de la clase Label al capturar el evento
de pulsación del botón.
- 76 -
Ejemplo6.aspx

<html>
<head>
</head>
void compruebaCasilla (Object origen, EventArgs args) {
if (casilla.Checked == true) {
etiqueta.Text = ”La casilla de verificación está marcada ”;
}else {
etiqueta.Text = ”La casilla de verificación no está marcada ”;
}
}
</script>
<body>
<asp:CheckBox id=”casilla” runat=”server” Text=”Casilla de verificación” /><br>
<asp:Button id=”boton” runat=”server” Text=”Comprobar” OnClick=”compruebaCasilla” /><br>
</form>
</body>
</html>
En este ejemplo al pulsar el botón se comprueba si el objeto de la clase Checkbox se encuentra marcado
o no y se muestra un mensaje indicándolo en un objeto de la clase Label.
- 77 -
Ejemplo7.aspx

<html>
<head>
<style>
.estilo{ font: 14px verdana; color: red; background-color:#CCCCCC }
</style>
</head>
<body>
<asp:Label id=”etiqueta” runat=”server” CssClass=”estilo” > Ejemplo de aplicación de estilos
sobre un control Web Label</asp:Label>
</body>
</html>
Podemos aplicar un estilo a un control Web a través de la propiedad CssClass. A esta propiedad le
asignaremos el nombre de la clase que define el estilo que se desea aplicar al control.
- 78 -
Ejemplo8.aspx

<%@ Import Namespace =”System.Drawing” %>
<html>
<head>
</head>
void PageLoad (Object origen, EventArgs args) {
Style estilo = new Style();
estilo.BorderColor=Color.Green;
estilo.BorderStyle=BorderStyle.Dashed;
estilo.ForeColor=Color.Blue;
estilo.BackColor=Color.Pink;
estilo.Font.Name=”Courier”;
estilo.Font.Size=16;
estilo.Font.Italic=true;
etiqueta.ApplyStyle(estilo);
}
</script>
<body>
<asp:Label id=”etiqueta” runat=”server” > Ejemplo de aplicación de estilos sobre un control Web
</asp:Label>
</body>
</html>
Otra forma de aplicar un estilo a un control Web es a través del método ApplyStyle. Este método recibe
como parámetro un objeto de la clase Style (cuyas propiedades contienen los valores del estilo). En este
ejemplo hemos importado el espacio de nombres System.Drawing, para tener acceso a las clases Color y
BorderStyle.
- 79 -
Ejemplo9.aspx

<html>
<head>
</head>
void cambiaImagen (Object origen, EventArgs args) {
imagen.ImageUrl=lista.SelectedItem.Value;
imagen.AlternateText=lista.SelectedItem.Text;
}
</script>
<body>
<asp:Image id=”imagen” runat=”server” ImageUrl=” ” AlternateText=”” />
<asp:DropDownList AutoPostBack=”True” id=”lista” OnSelectedIndexChanged=”cambiaImagen”
runat=”server” >
<asp:ListItem value=”imagen1.gif”>imagen 1</asp:ListItem>
- 80 -
<asp:ListItem value=”imagen2.jpg”>imagen 2</asp:ListItem>
<asp:ListItem value=”imagen3.gif”>imagen 3</asp:ListItem>
</ asp: DropDownList >
</form>
</body>
</html>
Este Web Form tiene un objeto de la clase DropDownList con nombres de ficheros de imagen, y un objeto
de la clase Image que mostrará la imagen que seleccionemos en la lista desplegable (capturamos el
evento OnSelectedIndexChanged para actualizar la imagen cada que seleccionemos un elemento de la
lista). Este evento se produce cada vez que se modifica la selección de un elemento de la lista y además,
la propiedad AutoPostBack del objeto DropDownList tiene el valor true.
- 81 -
RECUERDE
- Podemos representar a la página ASP.NET actual como un objeto de la clase Page. Este objeto nos
sirve como contenedor de todos los componentes que constituyen la página, y nos permite acceder a
sus propiedades, métodos y eventos.
- Los Web Forms sustituyen a los formularios HTML dentro del entorno de programación de ASP.NET.
- Dentro del formulario Web colocaremos los distintos controles de servidor de ASP.NET que
necesitemos para recoger la información correspondiente.
- Existe un gran número de controles de servidor y cada uno de ellos pertenece a una clase del
paquete.NET Framework.
- Existen controles HTML, controles Web, controles de lista y controles avanzados.
- Los Web Forms ofrecen un modelo de programación más visual, el código resultante es más limpio,
permiten una mayor separación entre la lógica de la aplicación y la presentación de la misma,
integran el tratamiento de eventos del cliente con el código correspondiente en el servidor y llevan a
cabo el mantenimiento del estado del formulario de forma automática entre peticiones.
- 82 -
COMPONENTES
Tema 6 (DATA LIST,
DATA GRID)
6.1. EL CONTROL DATALIST_________________________________ 85

6.2. EL CONTROL DATAGRID ________________________________ 87
- 83 -
En este capítulo veremos una introducción a los controles Web de lista DataList y DataGrid. Estos
controles están especializados en mostrar listados de datos en las páginas ASP.NET.
6.1. EL CONTROL DATALIST
Este control permite mostrar un listado de datos. Podemos personalizar su apariencia a través de las
propiedades RepeatDirection, RepeatLayout y RepeatColumns, que permiten indicar de qué forma se
mostrarán y distribuirán los datos:
- RepeatLayout: esta propiedad indica la distribución que tomarán los datos presentados.
Puede tomar dos valores, Table, para presentar un formato de distribución de tabla típico de
HTML, (se generará todo el código de filas y columnas de una tabla HTML), o el valor Flow,
para que los datos se distribuyan de forma lineal. El valor por defecto es Table.
- RepeatDirection: esta propiedad indica la orientación que tomarán los datos contenidos en
el DataList, es decir, si se mostrarán de forma horizontal o vertical. Los valores que puede
tomar son Vertical y Horizontal. Por defecto toma el valor Vertical.
- RepeatColumns: en esta propiedad indicaremos el número de columnas utilizado para

mostrar los datos. Por defecto el valor que toma es 1.
Veamos un ejemplo de este control:
datalist.aspx

<%@ Import Namespace =”System.Data” %>
<%@ Import Namespace =”System.Data.SqlClient” %>
<html>
<head>
<title>Ejemplo de uso del control Web DataList en una página ASP.NET</title>
</head>
- 85 -
if (!Page.IsPostBack) {
SqlConnection con= new SqlConnection(“server=platon; database=bdprueba;
uid=user; pwd=prueba ”);
SqlDataAdapter comando= new SqlDataAdapter (“Select nombre, apellido from
Clientes”, con);
DataSet datos=new DataSet();
comando.Fill(datos, “Clientes”);
listado.DataSource = datos.Tables[“Clientes”].DefaultView;
listado.DataBind();
}
}
</script>
<body>
<asp:DataList id=”listado” runat=”server”
RepeatDirection=”Vertical” RepeatLayout=”Table” RepeatColumns=”3” GridLines=”Both” >
<ItemTemplate>
<%# ((DataRowView)Container.DataItem)[“nombre”] %>
<%# ((DataRowView)Container.DataItem)[“apellido”] %>
</ItemTemplate>
</asp:DataList>
</body>
</html>
Como el resto de controles Web que hemos visto, la etiqueta del control tiene el atributo runat con el valor
server. Este ejemplo mostrará los datos en una tabla que muestra todos los bordes, con tres columnas
en cada fila y con una distribución vertical de la información. El valor Both en la propiedad GridLines
indica que deben mostrarse las líneas de separación de la tabla.
Debido a que el control DataList está asociado a unos datos, hemos importado en el ejemplo los espacios
de nombres System.Data y System.Data.SqlClient, que proporcionan las clases del .NET para
- 86 -
conectarnos a una base de datos y enviar comandos. En este caso, nos conectamos a una base de datos
llamada bdprueba, con el usuario user y contraseña prueba. El conjunto de resultados obtenidos de la
consulta lo asociamos a un objeto DataSet, que está vinculado a nuestro control DataList, con id listado.
Al ejecutar esta página obtendríamos en nuestro navegador una tabla HTML que contiene los datos
obtenidos de la consulta a la tabla Clientes.
6.2. EL CONTROL DATAGRID
Este control muestra la información en forma de tabla con celdas y columnas, es decir, se generará el
código HTML necesario para formar la tabla que visualiza los datos.
Veamos un ejemplo que ilustre su uso.
datagrid.aspx

<%@ Import Namespace =”System.Data” %>
<%@ Import Namespace =”System.Data.SqlClient” %>
- 87 -
<html>
<head>
<title>Ejemplo de uso del control Web DataGrid en una página ASP.NET</title>
</head>
if (!Page.IsPostBack) {
SqlConnection con= new SqlConnection(“server=platon; database=bdprueba;
uid=user; pwd=prueba ”);
SqlDataAdapter comando= new SqlDataAdapter (“Select nombre, apellido,
edad from Clientes”, con);
DataSet datos=new DataSet();
comando.Fill(datos, “Clientes”);
tabla.DataSource = datos.Tables[“Clientes”].DefaultView;
tabla.DataBind();
}
}
</script>
<body>
<asp:DataGrid id=”tabla” runat=”server” GridLines=”Both” BorderWidth=”1”
HeaderStyle-BackColor=”pink” HeaderStyle-Font-Bold=”True” >
</asp:DataGrid>
</body>
</html>
Como en el ejemplo anterior, nos conectamos a la base de datos y obtenemos un conjunto de resultados
que vinculamos al control DataGrid.
Por defecto, este control genera una columna por cada campo presente en el origen de datos. Por su
parte, l/os valores de los campos se mostrarán en cada columna como etiquetas de texto y el nombre de
los campos aparecerá en la primera fila de la tabla generada (como cabecera de los datos).
- 88 -
El código HTML que genera este ejemplo y que le llega al cliente que solicita la página ASP.NET, es el
siguiente:
<html>
<head>
<title>Ejemplo de uso del control Web DataGrid en una página ASP.NET</title>
</head>
<body>
<table cellspacing="0" rules="all" border="1" id="tabla"
style="border-collapse:collapse; border-style:solid; border-width:1px">
<tr style="background-color:pink;font-weight=bold">
<td>Nombre</td><td>Apellido</td><td>Edad</td>
</tr>
<tr><td>Laura</td><td>Hermoso</td><td>25</td></tr>
<tr><td>Susana</td><td>Ortiz</td><td>30</td>/tr>
<tr><td>Nerea</td><td>Barranco</td><td>31</td></tr>
<tr><td>Luis</td><td>Costa</td><td>23</td></tr>
<tr><td>Sergio</td><td>Ruano</td><td>29</td></tr>
<tr><td>Antonio</td><td>Aguilar</td><td>28</td></tr>
</table>
</body>
</html>
- 89 -
RECUERDE
- Los controles Web de lista DataList y DataGrid son controles especializados en mostrar listados de
datos en las páginas ASP.NET.
- Están vinculados a un conjunto de datos.
- ASP.NET genera el código HTML necesario para representar los datos adecuadamente en forma
tabular o lineal.
- 90 -
Tema 7 DIRECTIVAS DE
PÁGINAS
7.1. LA DIRECTIVA @PAGE__________________________________ 93

7.2. LA DIRECTIVA @IMPORT ________________________________ 95
7.3. LA DIRECTIVA @IMPLEMENTS ___________________________ 96
7.4. LA DIRECTIVA @ASSEMBLY _____________________________ 96
- 91 -
Una directiva es un identificador que incluimos en una nuestra página ASP.NET y que informa al entorno
de ejecución de ciertas características clave de dicha página, como el lenguaje en que está programada
(recordemos que la plataforma .NET soporta varios lenguajes) o las librerías que se importarán. Es decir,
mediante estas directivas podremos declarar una serie de atributos de la página ASP.NET actual, que
tendrán repercusión a la hora de crearla.
Estas directivas de página tienen el siguiente formato:
<%@ directiva atributo=valor [atributo=valor ...] %>
Lo primero que escribimos es el nombre de la directiva, seguida de una serie de pares “atributo-valor” que
definen los datos relativos a cada una de las directivas. Estos pares “atributo-valor” van separados por el
carácter espacio y el valor va entrecomillado.
Podemos situar estas directivas en cualquier lugar de la página, pero por convención, se suelen situar al
principio del código.
Cada directiva comienza con el identificador “<%@” y termina con “%>”. Esta sintaxis es parecida a los
identificadores de código ASP, sólo que con un símbolo de arroba al final del identificador de apertura.
A continuación vamos a ver las directivas disponibles en ASP.NET:
7.1. LA DIRECTIVA @PAGE
Esta directiva es la más utilizada de todas, y la que mayor número de atributos tiene. Esta directiva
soporta los atributos existentes para la única directiva que se podía utilizar en versiones anteriores de
ASP. Por ejemplo, la directiva <%@ Language=”VBScript” %> de ASP, equivale en ASP.NET a <%@
Page Language=”VB” %>.
En cada página únicamente puede existir una directiva Page. Los valores principales que puede llevar
esta directiva son los siguientes:
- AspCompat: Valores: true ó false. Valor por defecto: false. El sistema ASP.NET guarda
compatibilidad con ASP 3.0. Debemos poner este atributo a true para poder ejecutar DLL
ActiveX desarrolladas para el sistema anterior de páginas ASP.
- 93 -
- AutoEventWireup: Valores: true ó false. Valor por defecto: true. Este atributo indica si los
eventos de la página (UnLoad, Load, Init, etc) se van a lanzar de forma automática.
- Buffer: Valores: true ó false. Valor por defecto: true. Se utiliza para activar o desactivar el
búfer de la página ASP.NET actual.
- ClassName: Esta propiedad contiene un valor de cadena que indica el nombre de la clase
de la página actual.
- ContentType: Contiene una cadena que describe el tipo MIME devuelto por la página. Esta
información se enviará como cabecera HTTP al navegador. Habitualmente, este tipo será
“text/html” o “text/plain”.
- EnableSessionState: Valores: true, false o ReadOnly. Valor por defecto: true. Este atributo
informa al sistema si esta página tendrá acceso al sistema de gestión y mantenimiento de
sesiones, es decir, si se permite o no la utilización de la propiedad Session de la clase Page.
El valor “ReadOnly” indica que la página únicamente podrá leer variables de sesión, pero no
modificarlas ni crear variables nuevas.
- EnableViewState: Valores: true ó false. Valor por defecto: true. Esta propiedad permite
activar o desactivar el mantenimiento automático de los valores de los controles Web dentro
de un formulario.
- ErrorPage: Valores: URL de la página de error. Este atributo contiene la página de error que
se va a utilizar en el caso de que se produzca una excepción no tratada en la ejecución de la
página.
- Inherits: Valores: nombre de clase. Con esta propiedad informamos al compilador que la
página actual hereda de la clase especificada.
- Language: Valores: “vb”, “c#” e identificadores de lenguajes compatibles con Microsoft .NET
true ó false. Valor por defecto: “vb”. Define el lenguaje en que está programada la página
actual, es el lenguaje al que se compilará todo el código fuente de la página.
- Src: Este atributo contiene el nombre de un fichero que contiene código que podrá ser
utilizado en la página (es una forma de separación de código, permite tener un bloque de
código en un fichero separado de la página ASP.NET).
- 94 -
- WarningLevel: Valores: de 0 a 4. Define el nivel de información que queremos utilizar al
compilar nuestras páginas. Cuanto mayor nivel especifiquemos, más estricto será el
compilador a la hora de informar sobre potenciales fallos de sintaxis o funcionamiento de
nuestro código fuente.
Ejemplo de uso de esta directiva:
<%@ Page Language=”C#” ContentType=”text/html” EnableSessionState=”ReadOnly” %>
En este caso hemos indicado que el lenguaje utilizado en el código fuente de la página es C#, que el tipo
de contenido que va a devolver la página ASP.NET es HTML (text/html) y que únicamente podremos leer
las variables de sesión.
7.2. LA DIRECTIVA @IMPORT
Esta directiva la usaremos para importar de forma explícita un espacio de nombres (NameSpace)
determinado. Al importar un espacio de nombres determinado tendremos acceso a todas las clases
definidas en él. Este espacio de nombres puede ser propio de la plataforma .NET Framework, o bien un
espacio de nombres definido por nosotros.
Únicamente podemos indicar un espacio de nombres por directiva Import, por lo que si queremos
importar más de un espacio de nombres, deberemos utilizar una directiva Import por cada uno.
Su sintaxis es:
<%@ Import NameSpace=”valor” %>
El sistema importa automáticamente una serie de espacios de nombres para las páginas ASP.NET, por lo
que no tenemos que importarlas de forma explícita con la directiva Import, y tendremos acceso a todas
sus clases. Éstos son:
- System
- System.Collections
- 95 -
- System.Collections.Specialized
- System.Configuration
- System.IO
- System.Text
- System.Text.RegularExpressions
- System.Web
- System.Web.Caching
- System.Web.Security
- System.Web.SessionState
- System.Web.UI
- System.Web.UI.HtmlControls
- System.Web.UI.WebControls
7.3. LA DIRECTIVA @IMPLEMENTS
Esta directiva nos permite implementar un interfaz determinado dentro de una página ASP.NET.
Implementar un interfaz significa dar contenido a sus métodos, propiedades y eventos.
Al igual que ocurría con la directiva anterior, si deseamos implementar varios interfaces en la página,
debemos utilizar varias directivas Implements, una por cada interfaz.
Su sintaxis es:
<%@ Implements Interface=”nombreInterfaz” %>
7.4. LA DIRECTIVA @ASSEMBLY
Esta directiva importa una librería DLL o Assembly dentro de nuestra aplicación, haciendo visibles todos
sus espacios de nombres y clases a nuestro código.
Normalmente, esta directiva no se utiliza, ya que cuando una librería DLL se encuentra en el directorio bin
de la aplicación Web, no es necesario indicar dicha librería mediante la directiva Assembly, porque ya se
encuentra disponible por encontrarse en este directorio especial.
- 96 -
Si deseamos hacer referencia a varias librerías DLL, debemos utilizar una directiva por cada una.
Esta directiva cuenta con los siguientes atributos:
- Name: Especifica el nombre del assembly compilado (sin extensión).

- Src: Especifica la ruta del fichero de código fuente que define el assembly, en este caso sí
debemos indicar la extensión correspondiente. El sistema compilará de forma dinámica el
código fuente en vez de encontrarse con el Assembly ya compilado.
Ejemplo de su uso:
<%@ Assembly Name=”Librería” %>

<%@ Assembly Src=”Librería.cs” %>
En la documentación técnica de Visual Studio .NET podemos encontrar una referencia completa de todas
las directivas en ASP.NET.
- 97 -
RECUERDE
- Hemos visto las directivas @Page, @Import, @Implements y @Assembly.
- Las directivas son identificadores que suelen añadirse al principio de cada página ASP.NET y que
informan al sistema de ciertas características clave de dicha página.
- Cada directiva puede contener uno o más pares “atributo-valor”.
- Nos permiten especificar datos como el lenguaje en que está programada la página, tipo de acceso a
las variables de sesión, tipo de contenido devuelto por la página, importación de los espacios de
nombres necesarios, etc.
- 98 -
Tema 8 CONFIGURACIÓN DE
IIS
8.1. HERRAMIENTA DE ADMINISTRACIÓN DE SERVICIOS DE INTERNET 103

8.2. CONFIGURACIÓN DE IIS___________________________________ 104
8.2.1. Ficha Sitio Web ____________________________________ 105
8.2.2. Ficha Directorio particular ___________________________ 105
8.2.3. Ficha Documentos _________________________________ 106
8.2.4. Ficha Rendimiento _________________________________ 107
8.3. LA APLICACIÓN WEB _____________________________________ 108
- 99 -
Internet Information Server(IIS) es un servidor Web que permite publicar información en una intranet o en
Internet. Este servidor Web se apoya sobre el protocolo de transferencia de hipertexto (HTTP), para
transmitir la información y comunicarse con los clientes.
Es el servidor Web sobre el que se ejecutan las páginas ASP.NET. Desde su versión 3 incluye las
versiones anteriores de ASP. Al instalar IIS 5.0 se instala por defecto ASP 3.0. ASP.NET es compatible
con ASP, es decir, podemos tener aplicaciones Web basadas en ASP y ASP.NET funcionando en el
mismo servidor Web Internet Information Server 5.0. Las páginas ASP tienen la extensión .asp y son
procesadas por la DLL ASP.DLL, mientras que las páginas ASP.NET poseen la extensión .aspx y son
procesadas con el entorno de ejecución .NET Framework.
El servidor Web atiende las peticiones de páginas de los clientes, identifica de qué tipo de página se trata,
las procesa y les envía el resultado a los navegadores.
Internet Information Server 5.0 es un servidor Web para plataformas Windows 2000 (está totalmente
integrado con el sistema operativo, forma parte de la instalación de Windows 2000 y permite disponer de
un servidor Web tanto en el entorno de una Intranet como en el entorno de Internet).
Podemos acceder a su administración a través del Administrador de servicios de Internet, es un entorno

escalable basado en los componentes cliente/servidor que se pueden integrar dentro de las aplicaciones
Web.
Podemos saber si tenemos instalado IIS 5.0 en nuestra máquina escribiendo la siguiente URL:
http://localhost en el navegador Web. Si aparece una ventana similar a la que presentamos a
continuación, significa que lo tenemos instalado.
- 101 -
También podemos comprobarlo viendo si tenemos el Administrador de servicios de Internet dentro del
grupo de programas Herramientas administrativas en el menú Inicio de Windows.
Por defecto, la ruta del directorio de publicación en Internet es c:\Inetpub\wwwroot.
- 102 -
8.1. HERRAMIENTA DE ADMINISTRACIÓN DE SERVICIOS DE INTERNET
A través de la consola del Administrador de Servicios de Internet podemos administrar y configurar en un

mismo entorno todos los servicios del servidor IIS 5.0. Su uso es bastante intuitivo.
Esta consola se divide en dos paneles. El panel de la izquierda es denomina panel de alcance y el de la
derecha, panel de resultados.
Consola del Administrador de Servicios de Internet
En el panel de alcance aparecen los servidores que podremos administrar, se representan mediante un
icono de un ordenador acompañado del nombre del servidor. El asterisco (*) señala el servidor local (IIS
también permite realizar la administración remota de otros servidores IIS 5.0)
Cada uno de los nodos del árbol que aparece en el panel de alcance son instancias de servicios
individuales, y a su vez, éstos pueden contener un conjunto de objetos administrables. Podemos acceder
a las propiedades de cualquiera de estos nodos a través del menú desplegable que aparece pulsando el
botón derecho del ratón.
El panel de resultados visualiza los contenidos referentes al nodo seleccionado en el panel de alcance.
- 103 -
8.2. CONFIGURACIÓN DE IIS
A lo largo de los siguientes apartados veremos las opciones de configuración necesarias y más
relacionadas con la ejecución de páginas ASP.NET.
La configuración de IIS se basa en la utilización de hojas de propiedades, a las que accedemos como
hemos visto, pulsando el botón derecho del ratón sobre el elemento a configurar, y seleccionando la
opción Propiedades que aparece en este menú contextual.
Cada hoja de propiedades mostrará una serie de parámetros para configurar, dependiendo del elemento
seleccionado (directorio, sitio Web o fichero).
Hoja de propiedades de un sitio Web
- 104 -
Para publicar documentos en el sitio Web, debemos copiar los ficheros correspondientes al directorio de
publicación del sitio Web (que por defecto es, c:\Inetpub\wwwroot, pero lo podemos cambiar a través de
su hoja de propiedades, a cualquier otro directorio del disco duro).
8.2.1. Ficha Sitio Web
Es necesario que cada sitio Web tenga un directorio de publicación. Además, cada sitio Web debe tener
asignada una dirección IP y un número de puerto (para poder identificarlo). Por defecto, el servicio Web
se encuentra en el puerto 80. Podemos acceder y cambiar todos estos valores desde la hoja de
propiedades del sitio Web.
Otro de los valores configurables es el número de conexiones de clientes que aceptamos a nuestro sitio
Web (podemos indicar un número, o elegir la opción Ilimitado). También podemos indicar el tiempo de
espera máximo (time-out) utilizado para establecer una conexión. Esto asegura que se cerrarán todas las
conexiones si el protocolo HTTP no puede establecer una conexión desde el cliente en el tiempo
especificado (por defecto son 900 segundos).
Otra de las opciones configurables es la activación o no del registro de los accesos al sitio Web y el
formato de archivo en el que se almacena esta información.
8.2.2. Ficha Directorio particular
En la ficha Directorio particular de la hoja de propiedades, podemos modificar el directorio de publicación

del sitio Web, indicar si deben registrarse las visitas, y el tipo de acceso que va a tener el usuario:
- Acceso al código fuente de secuencias de comandos.

- Lectura.
- Escritura.
- Examinar directorios.
La opción Permisos de ejecución es relativa a la ejecución de aplicaciones ASP/ASP.NET, y significa:
- Ninguno: no permite la ejecución de programas ni secuencias de comandos en el directorio.

- Sólo secuencias de comandos: para permitir la ejecución de las páginas ASP y ASP.NET.
- 105 -
- Sec. Comandos y ejecutables: permite ejecutar cualquier aplicación en el directorio.
Ficha Directorio particular de la hoja de propiedades de un sitio Web
8.2.3. Ficha Documentos
En esta ficha de la hoja de propiedades, podemos indicar la página por defecto del sitio Web (es la página
que se presentará cuando no especifiquemos ningún fichero en concreto de nuestro sitio). Este
documento predeterminado puede ser una página HTML, una página ASP o una página ASP.NET.
El orden en el que indiquemos estos documentos es significativo, ya que el servidor Web devolverá el
primero que encuentre de ellos.
- 106 -
Ficha Documentos de la hoja de propiedades de un sitio Web
8.2.4. Ficha Rendimiento
En esta hoja podemos configurar el ajuste del rendimiento de nuestro servidor atendiendo al número de
accesos que se espera por día:
- Menos de 10.000
- Menos de 100.000
- Más de 100.000
También podemos limitar el ancho de banda a los KB/s que estimemos apropiados y asignar un límite de
proceso de uso de la CPU (expresado en tanto por ciento).
- 107 -
Ficha Rendimiento de la hoja de propiedades de un sitio Web
8.3. LA APLICACIÓN WEB
Una aplicación Web es un conjunto de ficheros que se ejecutan dentro de un conjunto definido de
directorios del sitio Web. Desde la consola de administración de IIS 5.0 deberemos indicar el punto de
arranque de la aplicación y hasta dónde se extiende.
Podemos distinguir los directorios de arranque de una aplicación Web porque el Administrador de
servicios de Internet los muestra con un icono especial, con una pequeña bola con un aspa metida en una
caja.
En cada aplicación ASP.NET podemos distinguir dos tipos de contextos o estados, uno de aplicación
(información accesible y compartida por todos los clientes) y otro de sesión (información por cada usuario
de la aplicación). Lo veremos más detalladamente en el capítulo dedicado al archivo Global.asax.
- 108 -
Para crear el punto de inicio de una aplicación Web, y por tanto, crear la aplicación ASP.NET, debemos
seleccionar en el Administrador de servicios de Intenet el directorio raíz o inicial que contiene sus
páginas, y en la ficha Directorio de su hoja de propiedades, pulsar el botón Crear (dentro del apartado
Configuración de la aplicación). De forma automática se creará la aplicación y aparecerán dos nuevos
botones Quitar y Configurar. El botón Quitar se utiliza para eliminar la aplicación creada, y el segundo
botón para configurarla.
ASP.NET ofrece un sistema de configuración de aplicaciones basado en ficheros XML, de modo que,
cada aplicación poseerá un fichero de configuración denominado Web.config. Veremos este fichero en el
próximo capítulo.
- 109 -
RECUERDE
- Las páginas ASP.NET se ejecutan sobre el servidor Web Internet Information Server 5.0. (IIS 5.0
forma parte de la instalación de Windows 2000).
- ASP.NET es compatible con ASP. El servidor Web atiende las peticiones de páginas de los clientes,
identifica de qué tipo de página se trata, las procesa y les envía el resultado a los navegadores.
- A través de la consola del Administrador de Servicios de Internet podemos administrar y configurar

en un mismo entorno todos los servicios del servidor IIS 5.0.
- A través de la hoja de propiedades del sitio Web podemos configurar el directorio de publicación de
nuestras páginas, el número de conexiones de clientes que aceptamos, el tiempo de espera máximo
(time-out) utilizado para establecer una conexión, permisos de ejecución, la página por defecto,
establecer límites sobre el ancho de banda utilizado para el sitio Web, etc.
- Debemos indicar el punto de inicio de una aplicación ASP.NET para crearla. Esto lo podemos hacer a
través de la hoja de propiedades del directorio inicial de la aplicación en la consola del Administrador
de Servicios de Internet.
- Cada aplicación ASP.NET posee un fichero de configuración denominado Web.config.
- 110 -
Tema 9 EL ARCHIVO
GLOBAL.ASAX
9.1. EVENTOS DE SERVIDOR _______________________________ 113

9.2. GESTIÓN DEL ESTADO DE LA APLICACIÓN ASP.NET ________ 115
- 111 -
En la versión anterior del sistema de páginas activas ASP, disponíamos de la opción de utilizar el fichero
GLOBAL.ASA. Este fichero estaba situado en el directorio raíz de nuestro servidor Web o de nuestro
directorio virtual, y se ejecutaba al iniciarse nuestra aplicación Web.
Este fichero se utilizaba para insertar en él el código a ejecutar en los eventos de inicio y finalización de
las distintas sesiones de usuario y de la aplicación.
En el nuevo sistema ASP.NET disponemos de un mecanismo similar, representado por el fichero

GLOBAL.ASAX. En él se sigue un formato similar al de la páginas ASP.NET:

[Mëtodos para el tratamiento de eventos,
inicialización de objetos con ámbito de Sesión y Aplicación]
</script>
9.1. EVENTOS DE SERVIDOR
Veamos los principales eventos que podemos tratar en el fichero GLOBAL.ASAX:
- Application_OnStart: este evento se lanza cuando se inicia la ejecución de la aplicación

ASP.NET correspondiente, y tiene lugar cuando el primer usuario carga una página
ASP.NET perteneciente a la aplicación. Dentro de este evento indicaremos el código de
inicialización de la aplicación.
- Application_OnEnd: es el evento contrario al anterior. Se lanza cuando finaliza la ejecución

de la aplicación ASP.NET. Esta finalización de la ejecución puede ocurrir por varios motivos:
cuando finaliza la última de las sesiones de un usuario con la aplicación, cuando se apaga el
servidor Web o si se modifica el código fuente del fichero GLOBAL.ASAX (porque ello fuerza
una compilación del fichero). Dentro de este evento colocaremos el código de limpieza de la
aplicación (como liberar los recursos utilizados) o que deba ejecutarse al finalizar nuestra
aplicación.
- 113 -
- Session_OnStart: este evento se lanza cuando se inicia una nueva sesión dentro de una
aplicación ASP.NET. El inicio de sesión se produce para cada usuario cuando solicita la
primera página de la aplicación. Dentro de este evento colocaremos el código que debe
ejecutarse antes de que se cargue la primera página de la aplicación, como el código para
inicializar las variables para toda la sesión (la identificación del usuario o sus preferencias
por ejemplo) para que estos valores estén disponibles para ese usuario mientras su sesión
permanezca activa. Para que se produzca este evento, se debe haber lanzado previamente
el evento Application_OnStart.
- Session_OnEnd: es el evento contrario al evento Session_OnStart. Se lanza cuando

finaliza una sesión de usuario. Este hecho puede producirse porque haya caducado la
sesión al permanecer inactiva el tiempo indicado en su propiedad Timeout, o bien, porque se
ha forzado mediante una llamada al método Abandon() de la clase
System.Web.SessionState.HttpSessionState (clase que representa la sesión de un usuario
en la aplicación ASP.NET). Si finaliza la ejecución de la aplicación se ejecutarán todos los
eventos Session_OnEnd de cada sesión de usuario antes de lanzarse el evento
Application_OnEnd.
- Application_OnDisposed: este evento es lanzado cuando la aplicación ASP.NET inicia su

descarga de memoria, y se producirá antes del evento Application_OnEnd.
Los eventos Application_OnStart, Application_OnDisposed y Application_OnEnd se lanzan una única vez

durante toda la vida de la aplicación ASP.NET, mientras que los eventos Session_OnStart y
Session_OnEnd se ejecutarán repetidas veces durante la vida de la aplicación, dependiendo de las
sesiones que hayan iniciado los usuarios con la aplicación ASP.NET.
El esquema siguiente muestra el orden en que se producen los eventos que hemos visto, y también la
circunstancia que provoca el lanzamiento de cada evento:
- 114 -
El primer usuario se conecta y solicita una página de la aplicación
Application_OnStart
Un usuario inicia una sesión con la aplicación Session_OnStart
La sesión caduca
Se llama al método Abandon() de Session Session_OnEnd
Termina la última sesión con la aplicación

Finaliza el servidor Web Application_OnDisposed
Se modifica el fichero GLOBAL.ASAX
Application_OnEnd
9.2. GESTIÓN DEL ESTADO DE LA APLICACIÓN ASP.NET
La gestión del estado de la aplicación ASP.NET consiste en la permanencia de objetos o valores a lo

largo de la vida de la aplicación y a lo largo de cada sesión de usuario en la aplicación.
No se puede mantener el estado entre diferentes páginas Web a través del protocolo HTTP (protocolo
sobre el que se apoya el sistema ASP.NET, ya que es un protocolo sin estado). ASP.NET nos permite
almacenar información entre diversas solicitudes de páginas dentro de una aplicación a través de los
objetos Session y Application (estos objetos ya se encontraban disponibles en la versión anterior de
ASP). Estos objetos integrados en encuentran en las dos propiedades del mismo nombre del objeto Page
(que representa a una página ASP.NET, lo vimos en el capítulo 5), y también en la clase HttpApplication
(clase que representa a una aplicación ASP.NET), a través de las propiedades Application y Session:
- El objeto Session: este objeto nos permite almacenar el estado de cada usuario que ha
iniciado una sesión con la aplicación. Esta información se mantendrá a lo largo de toda la
vida de cada sesión particular para cada usuario, es decir, cada usuario tendrá sus variables
y sus valores. Este objeto es una instancia de la clase
- 115 -
System.Web.SessionState.HttpSessionState. La sintaxis para almacenar un objeto en el
objeto Session y recuperarlo, es:
Session[“CadenaClave”]=objeto;
objeto=Session[“CadenaClave”];
- El objeto Application: este objeto nos permite almacenar la información que es común para
toda la aplicación. Las variables almacenadas dentro de este objetos son accesibles a todos
los usuarios que están utilizando la misma aplicación ASP.NET en cualquiera de sus
páginas. En contraposición al objeto Session, cuyas variables son particulares para cada
uno de los usuarios conectados, no se comparten y son propias de la sesión de cada uno.
Este objeto es una instancia de de la clase System.Web.HttpApplicationState. El
almacenamiento de los objetos se basa en una estructura en forma de pares clave/valor,
como en el objeto Session. Así, la sintaxis para almacenar objetos en el estado de la
aplicación y recuperarlos es:
Application[“CadenaClave”]=objeto;
objeto=Application[“CadenaClave”];
- 116 -
RECUERDE
- En ASP.NET disponemos del fichero GLOBAL.ASAX, de propósito similar al GLOBAL.ASA de ASP.

Se encuentra situado en el directorio raíz de nuestro Servidor Web o de nuestro directorio virtual, y se
ejecuta al iniciarse nuestra aplicación Web.
- Presenta un formato similar al de las páginas ASP.NET
- En él incluiremos el código para el tratamiento de los eventos Application_OnStart,

Application_OnEnd, Session_OnStart, Session_OnEnd y Application_OnDisposed y el código de
inicialización de objetos con ámbito de Sesión y Aplicación.
- 117 -
Tema 10 EL ARCHIVO
WEB.CONFIG
10.1. FORMATO DE LOS FICHEROS DE CONFIGURACIÓN ________ 122

10.2. CONFIGURACIÓN GENERAL ___________________________ 123
10.3. CONFIGURACIÓN DE LA PÁGINA _______________________ 124
10.4. CONFIGURACIÓN DE LA SESIÓN________________________ 125
- 119 -
En las versiones anteriores de ASP, la configuración de las aplicaciones Web se realizaba a través del
Administrador de servicios de Internet, y la información relativa a la configuración de las aplicaciones ASP
se almacenaba en el repositorio binario denominado metabase del Internet Information Server. Este
sistema de configuración de las aplicaciones Web basado en el servidor Web IIS ya no es válido para las
aplicaciones ASP.NET.
La configuración de las aplicaciones ASP.NET se basa en ficheros XML, es decir, se utilizan ficheros XML
de configuración. Este nuevo sistema presenta las siguientes ventajas:
- Valores de configuración en formato reconocible. Podemos abrir el fichero XML y leer y

modificar los valores de configuración que contiene.
- Actualizaciones inmediatas. Los cambios en los ficheros de configuración se toman de forma

inmediata y automática en el sistema sin necesidad de reiniciar el Servidor Web o para los
servicios.
- Portabilidad de las configuraciones. Para tener una aplicación ASP.NET en un servidor con
la misma configuración que otra aplicación distinta, únicamente es necesario copiar los
ficheros XML de configuración a la aplicación correspondiente.
- Bloqueo de valores de configuración. Es posible bloquear los valores de configuración que

no deban ser sobrescritos.
Existen dos tipos de ficheros de configuración:
- Configuración del servidor. Esta configuración se almacena en un fichero denominado

machine.config, se encuentra en el directorio [WinNT]\Microsoft.NET\ Framework\[version]
\config. Este fichero representa la configuración por defecto de todas las aplicaciones
ASP.NET existentes en el servidor.
- Configuración de la aplicación. La infomación de configuración relativa y específica a una

aplicación ASP.NET se encuentra en el fichero web.config de su directorio raíz. Puede
haber otros ficheros web.config dentro de una misma aplicación, en otros directorios más
anidados. La configuración del fichero web.config sobrescribe los valores especificados en el
- 121 -
fichero machine.config, y a su vez, cada fichero web.config sobrescribirá los valores de
configuración utilizados en los ficheros web.config de directorios superiores (a no ser que
dichos valores se hayan bloqueado para evitar ser sobrescritos).
10.1. FORMATO DE LOS FICHEROS DE CONFIGURACIÓN
Los dos ficheros de configuración para una aplicación ASP.NET, machine.config y web.config, se
diferencian únicamente en el nombre (además de su localización como hemos visto), ya que
internamente presentan el mismo formato XML.
Debemos tener en cuenta que el sistema de configuración de ASP.NET distingue entre mayúsuculas y
minúsculas.
Cada fichero de configuración contiene una jerarquía anidada de etiquetas y subetiquetas XML con
atributos que especifican los valores de configuración. Las etiquetas deben encontrarse bien construidas,
y siguen el siguiente criterio:
- Los nombres de etiquetas y atributos comienzan con letra minúscula y las primeras letras de
cada una de las siguientes palabras que forman el nombre van en mayúscula.
- Los valores de los atributos de las etiquetas comienzan siempre por mayúscula y las
primeras letras de cada una de las siguientes palabras que la formen van también en
mayúscula. Existe una excepción, los valores true y false se escriben con todas las letras en
minúsculas.
Dentro de los ficheros de configuración, el elemento raíz es siempre la etiqueta <configuration>. Dentro
de este elemento, entre sus etiquetas de comienzo y fin, aparecerán las distintas secciones de
configuración para aplicar a la aplicación ASP.NET:
<configuration>
<!—Configuración para aplicar a la aplicación ASP.NET -->
</configuration>
- 122 -
A continuación veremos las secciones principales y más comunes en la configuración de una aplicación
ASP.NET. En los próximos capítulos 11 (Módulos y manejadores HTTP) y 12 (Seguridad en ASP.NET)
seguiremos tratando estos ficheros, ya que estos temas dependen de la configuración de otras de sus
secciones.
10.2. CONFIGURACIÓN GENERAL
Esta sección se encuentra en la etiqueta <httpRuntime>. En ella podemos indicar una serie de
parámetros de configuración genéricos para la aplicación ASP.NET. Los atributos que contiene esta
etiqueta son:
- executionTimeout: en este atributo indicaremos el tiempo de espera en segundos que se

aplicará a la ejecución de un recurso solicitado. Si se supera este tiempo de espera, la
aplicación ASP.NET finalizará la ejecución del recurso. El valor por defecto que presenta
este atributo es de 90 segundos.
- maxRequestLength: este atributo indica el tamaño máximo de una petición. Se expresa en

KB, y por defecto presenta el valor de 4096 KB.
- userFullyAQualifiedRedirectUrl: indica cómo se le va a devolver una URL al cliente,

completa o relativa. Puede tomar los valores true o false, por defecto tiene el valor false, por
lo se enviará una ruta relativa.
El código siguiente muestra los valores que presenta por defecto esta sección en el fichero
machine.config (y que serán aplicables a todas las aplicaciones ASP.NET del servidor, si no son
sobrescritos en algún fichero web.config de la aplicación correspondiente):
<configuration>
<system.web>
<httpRuntime
executionTimeout=”90”
maxRequestLength=”4096”
useFullyQualifiedRedirectUrl=”false”
- 123 -
/>
</system.web>
</configuration>
10.3. CONFIGURACIÓN DE LA PÁGINA
Aquí veremos la etiqueta <pages>, donde podemos controlar algunos de los comportamientos de las
páginas ASP.NET. Veamos sus principales atributos:
- autoEventWireup: este atributo indica si los eventos de la página (Load, Init, UnLoad, etc,
los vimos en el capítulo 5) se van a lanzar de forma automática. Puede tomar los valores
true o false, por defecto tiene el valor true, por lo que estos eventos de la clase Page (que
representa una página ASP.NET), se lanzarán automáticamente.
- buffer: este atributo se utiliza para activar o desactivar el búfer de las páginas ASP.NET de
la aplicación actual. Puede tomar los valores true o false. Por defecto tiene el valor true, con
lo que ASP.NET ejecuta por completo las páginas antes de enviar algo del resultado al
usuario (el contenido del búfer no es enviado al navegador hasta que no se haya terminado
de ejecutar la página).
- enableSessionState: este atributo permite activar o desactivar el estado de sesión, a través

del objeto Sessión que vimos (permite almacenar información común a la sesión actual del
usuario en la aplicación Web). Puede tomar los valores true, false o readOnly (con este
valor, las páginas podrán leer variables de sesión pero no modificarlas ni crear nuevas
variables). Por defecto tiene el valor true.
- enableViewState: con este atributo podemos activar o desactivar el mantenimiento

automático de los valores de los controles Web dentro de los formularios Web (este tema lo
tratamos en el capítulo 5). Por defecto tiene el valor true, por lo que los controles Web
mantienen su estado entre distintas recargas del formulario Web.
Estos atributos se corresponden con los atributos del mismo nombre de la directiva @Page (descrita en el
capítulo 7), por lo que podemos sobrescribir estos valores de configuración de la aplicación para una
página ASP.NET en concreto, usando en ella esta directiva.
- 124 -
Un ejemplo de uso de la etiqueta <pages> en un fichero de configuración podría ser:
<configuration>
<system.web>
<pages buffer=”true” enableSessionState=”true” autoEventWireup=”true”
enableSessionState=”true”
/>
</system.web>
</configuration>
Si en el fichero web.config de una aplicación concreta deseamos sobrescribir alguno de los valores
anteriores, por ejemplo, el uso del buffer, sólo tenemos que incluir la etiqueta <pages> con el atributo a
sobrescribir:
<configuration>
<system.web>
<pages buffer=”false” />
</system.web>
</configuration>
10.4. CONFIGURACIÓN DE LA SESIÓN
Podemos configurar el estado de sesión mediante la etiqueta <sessionState>. Sus atributos más
comunes son:
- cookieless: este atributo indica si el objeto Session utilizará el mecanismo de cookies para
almacenar el identificador de sesión. Puede tomar los valores true o false. Por defecto tiene
el valor false, por lo que ASP.NET se apoyará en las cookies para manterner la sesión.
Cuando tiene el valor true, la sesión se mantiene a través del mecanismo de URLs (el
identificador de la sesión se añade a la ruta de las páginas ASP.NET solicitadas).
- Timeout: este atributo indica el intervalo de tiempo en minutos de inactividad para el objeto
Session. Esta inactividad significa que si el usuario no actualiza o solicita una página
- 125 -
durante ese tiempo, la sesión termina. Por defecto presenta el valor de 20 minutos. También
podemos modificar este valor en la aplicación a través de la propiedad Timeout del objeto
Session.
Por ejemplo, para aumentar el timeout de la sesión hasta 30 minutos y evitar el uso de cookies para
mantener la sesión, tendríamos la siguiente configuración:
<configuration>
<system.web>
<sessionState
cookieless=”true”
timeout=”30”
/>
</system.web>
</configuration>
- 126 -
RECUERDE
- La configuración de las aplicaciones ASP.NET se basa en los ficheros XML machine.config y

web.config.
- Estos ficheros de configuración contienen una jerarquía anidada de etiquetas y subetiquetas XML
con atributos que especifican los valores de configuración. Se distingue entre mayúsculas y
minúsculas.
- Los cambios en los ficheros de configuración se toman de forma inmediata y automática en el

sistema sin necesidad de reiniciar el Servidor Web o para los servicios.
- Podemos configurar el tiempo de ejecución de un recurso, el timeout de la sesión, el uso de cookies

para mantener la sesión, activar el uso del buffer, el mantenimiento automático del estado de los
controles Web, etc.
- 127 -
MÓDULOS Y
Tema 11 MANEJADORES
http
11.1. EJEMPLO DE MANEJADOR http___________________________ 132
- 129 -
Los módulos HTTP son los responsables de filtrar cada solicitud/respuesta en una aplicación ASP.NET,
por ejemplo, son quienes determinarán si una solicitud determinada debería ser servida al cliente desde
la caché, o bien ser dirigida al manejador HTTP correspondiente.
Esta sección se encuentra en la etiqueta <httpModules> de los ficheros de configuración web.config o

machine.config.
Los manejadores HTTP son los encargados de servir las peticiones de una extensión particular dentro de
ASP.NET, como puede ser la extensión de las páginas .aspx. Se encuentran en la sección
<httpHandlers> de los ficheros de configuración XML. Dentro de esta sección podemos añadir
manejadores personalizados o bien eliminar manejadores existentes. Esto es posible porque ASP.NET se
basa en una arquitectura ampliable, que es denominada entorno de ejecución HTTP.
En el fichero machine.config se indican una serie de manejadores HTTP, los básicos para ASP.NET, que
tomarán todas las aplicaciones del servidor Web, a no ser que se sobrescriban en algún web.config de la
aplicación. Los más comunes que podemos encontrar son los manejadores para páginas ASP.NET
(extensión .aspx), para controles de usuario (extensión .ascx) y ficheros de configuración (extensión
.config).
Para indicar estos manejadores, usaremos la subetiqueta <add> de la etiqueta <httpHandlers>. Esta
etiqueta tiene los siguientes atributos:
- verb: este atributo contiene el tipo de verbo HTTP correspondiente al manejador que va a
procesar la petición. Estos valores pueden ser Get, Head, Post, etc y también el carácter
asterisco (*) para indicar que el manejador tratará todos los verbos o acciones del protocolo
HTTP.
- path: en este atributo indicamos la ruta del recurso que se debe tratar. También acepta el
carácter especial de asterisco, que generalmente se utiliza seguido de la extensión de los
ficheros a tratar.
- type: este atributo contiene el nombre de la clase que implementa el manejador HTTP.
- 131 -
11.1. EJEMPLO DE MANEJADOR HTTP
Podemos añadir nuestros propios manejadores incluyendo una nueva etiqueta <add> en la sección de
los manejadores HTTP, que haga referencia a la clase que implementa nuestro manejador.
Esta clase, que realizará las funciones de un manejador HTTP, debe implementar el interfaz
System.Web.IHttpHandler. Este interfaz contiene el método ProcessRequest(), que será el método
responsable de procesar la solicitud que se ha asociado con el manejador.
También es necesario implementar la propiedad IsReusable, de sólo lectura, y que simplemente

devuelve el valor true.
En el ejemplo que vamos a ver, el método ProcessRequest() generará código HTML sencillo, que
presentará una cadena de texto con un saludo y el parámetro que se ha pasado a la página
(recuperaremos este valor mediante la colección QueryString del objeto Request asociado al contexto de
la página asociada al manejador).
using System;
using System.Web;
namespace Componentes.Pruebas {
public class miManejador:IHttpHandler {
public void ProcessRequest (HttpContext entorno) {
HttpRequest solicitud=entorno.Request;
HttpResponse respuesta=entorno.Response;
respuesta.Write(“<html><body><h2>”);
respuesta.Write (“Saludos ” + solicitud.QueryString[“nombre”] );
respuesta.Write(“</h2></body></html>”);
}
public bool IsReusable {
get {
return true;
}
}
}
}
- 132 -
Una vez compilada la clase y generado el assembly correspondiente, debemos copiar el assembly
(librería) al directorio BIN de la aplicación, donde se encuentran las DLL disponibles en esa aplicación. El
código que aparecería en el fichero web.config sería:
<configuration>
<system.web>
<httpHandlers>
<add verb=”*” path=”pruebaManejador.aspx”
type=”Componentes.Pruebas.miManejador, Componente” />
</httpHandlers>
</system.web>
</configuration>
En este ejemplo, la clase del manejador es miManejador, que se encuentra en el espacio de nombres
Componentes.Pruebas, y el assembly es Componente.dll.
Si solicitamos la página pruebaManejador.aspx, sería la clase del manejador (miManejador) la que

atendería la solicitud, y mostraría una página con el mensaje “Saludos Luis”, por ejemplo.
- 133 -
RECUERDE
- Los módulos HTTP son los responsables de filtrar cada solicitud/respuesta en una aplicación
ASP.NET. Se indican en la etiqueta <httpModules> de los ficheros de configuración XML.
- Los manejadores HTTP son los encargados de servir las peticiones de una extensión particular
dentro de ASP.NET, como puede ser la extensión de las páginas .aspx. Se encuentran en la sección
<httpHandlers> de los ficheros de configuración XML.
- Podemos añadir nuestros propios manejadores incluyendo una nueva etiqueta <add> en la sección
de los manejadores HTTP, que haga referencia a la clase que implementa nuestro manejador.
- La clase del manejador HTTP debe implementar la propiedad IsReusable y el método

ProcessRequest() del interfaz System.Web.IHttpHandler.
- 134 -
Tema 12 SEGURIDAD EN
ASP.NET
12.1. BLOQUEAR VALORES DE CONFIGURACIÓN ______________ 137

12.2. AUTENTIFICACIÓN Y AUTORIZACIÓN ____________________ 137
12.3. AUTENTIFICACIÓN BASADA EN FORMULARIOS ___________ 138
12.4. AUTORIZACIÓN DE USUARIOS _________________________ 140
- 135 -
ASP.NET configura de manera automática el servidor Web IIS para que no sea posible que un cliente
realice una petición directa a un fichero global.asax o web.config, y que de esta forma pueda ver el código
de inicialización o la configuración de nuestra aplicación. Esto puede resultar muy peligroso porque
podemos dejar ver la estructura de directorios que tenemos, dar idea de la ubicación de archivos
confidenciales, opciones de compilación, de los manejadores HTTP responsables de tratar cada petición,
usuarios autenticados en la aplicación, política de seguridad seguida, etc.
Así, si un usuario indica en la ruta de su navegador algo parecido a http://localhost/aplicacionWeb/

web.config o http://localhost/aplicacionWeb/global.asax, se le mostrará un mensaje de acceso denegado.
12.1. BLOQUEAR VALORES DE CONFIGURACIÓN
Es posible bloquear valores en el fichero machine.config para que no exista la posibilidad de que sean
sobrescritos en los ficheros web.config de las aplicaciones ASP.NET particulares.
Para ello, debemos incluir el atributo allowOverride=”false” en la etiqueta correspondiente para indicar que
no se permita la sobrescritura de los valores de configuración.
Si intentamos sobrescribir el valor de configuración, se producirá una excepción.
12.2. AUTENTICACIÓN Y AUTORIZACIÓN
Es importante tener la capacidad de identificar usuarios y controlar el acceso a los recursos en nuestras
aplicaciones Web. La autenticación es el acto de determinar la identidad del usuario solicitante. Por lo
general, el usuario deberá identificarse, normalmente, presentando su nombre de usuario y contraseña,
para ser autenticado. Una vez autenticado, debe determinarse si esa identidad puede tener acceso a un
recurso específico. Este proceso se conoce como autorización.
ASP.NET proporciona dos tipos de servicios de autorización:
- Comprobaciones de permisos sobre un recurso para determinar si la cuenta de usuario

autenticada puede obtener acceso a los recursos. Estos permisos se configuran para un
- 137 -
determinado archivo o directorio mediante la ficha Seguridad de la página de propiedades
del Explorador.
- Autorización de URL, que autoriza a una identidad el acceso a partes del espacio Web.
A continuación, vamos a ver la autenticación basada en formularios que proporciona ASP.NET:
12.3. AUTENTICACIÓN BASADA EN FORMULARIOS
La autenticación basada en formularios es un servicio de autenticación de ASP.NET que permite a las

aplicaciones suministrar su propia interfaz de inicio de sesión y hacer su propia verificación de identidad
del usuario. ASP.NET permite autenticar usuarios y desviar a los usuarios no autenticados hacia una
página de inicio de sesión, además de realizar todas las tareas de administración de cookies sobre las
que se apoya el mecanismo de autenticación.
Para que una aplicación pueda utilizar autenticación basada en formularios, debemos configurar la
etiqueta <authentication> con la opción Forms y denegar el acceso a los usuarios anónimos. Para ello,
nuestro web.config debería presentar una configuración como ésta:
<configuration>
<system.web>
<authentication mode="Forms"/>
<authorization>
<deny users="?" />
</authorization>
</system.web>
</configuration>
Podemos configurar el nombre de la cookie a usar, el tipo de protección, la dirección URL para la página
de inicio de sesión, el tiempo de validez de la cookie y la ruta de acceso que se debe utilizar para la
cookie suministrada. Estos datos se indican en los distintos atributos de la etiqueta <forms>, que es un
subelemento de la etiqueta <authentication mode="Forms">.
<authentication mode="Forms">
- 138 -
<forms name=".COOKIE_AUT" loginUrl="paginaLogin.aspx" protection="all" timeout="30" path="/">
</forms>
</authentication>
Los atributos de la etiqueta <forms> son:
- loginUrl: URL de la página de inicio de sesión a la que se desvían los usuarios para
autentificarse.
- name: este atributo indica el nombre de la cookie que se va a utilizar para el mecanismo de
autenticación.
- timeout: este atributo indica el tiempo, en minutos, de permanencia de la cookie. Pasado

este tiempo, la cookie caduca. El valor predeterminado es 30 minutos.
- path: aquí se indica la ruta de acceso para la cookie.
- protection: este atributo indica el método utilizado para proteger los datos de la cookie.
Dejaremos el valor “all” que es el predeterminado y sugerido (se basa en el algoritmo Triple
DES para su cifrado).
Las solicitudes no autenticadas se desvían a la página de inicio de sesión indicada (paginaLogin.aspx), la

cual debe presentar un formulario que pida los datos de autenticación del usuario (login y password).
Después de validar la identidad del usuario, se le vuelve a dirigir hacia la URL original solicitada.
Podemos suministrar una lista de credenciales válidas a través de la etiqueta <credentials>, que es una
subetiqueta de la etiqueta <authentication>. Dentro de <credentials>, indicaremos en la etiqueta <user>
el nombre de usuario y contraseña válidos para los usuarios autenticados.
<authentication>
<credentials passwordFormat="SHA1" >
<user name="usuario1" password="BADE125DS2855DS22DSE" />
- 139 -
<user name="usuario2" password="AETDS43ASDFE2814ASDF" />
</credentials>
</authentication>
Según se indique en el atributo passwordFormat de la etiqueta <credentials>, las contraseñas se

pueden almacenar en texto no cifrado (valor “Clear” ) o cifrado como código de tipo SHA1 o MD5 (valor
“SHA1” o “MD5”).
La aplicación ASP.NET realizará una llamada al método FormsAuthentication.Authenticate, con el
nombre de usuario y contraseña, y se encargará de verificar que el usuario es un usuario válido.
12.4. AUTORIZACIÓN DE USUARIOS
En ASP.NET podemos permitir o denegar el acceso a grupos de usuarios. Para ello, utilizaremos las
subetiquetas <allow> y <deny> de la etiqueta <authorization> en nuestro fichero web.config.
<authorization>
<allow users="usuario1" />
<deny users="*" />
</authorization>
En este ejemplo, se concede acceso al usuario llamado usuario1, y se deniega el acceso a todos los
demás usuarios.
Cada elemento <allow> o <deny> debe contener un atributo users donde especificar al usuario al que se
le da acceso o se le deniega. Podemos especificar varios usuarios en un único elemento mediante una
lista de valores separados por comas. Por ejemplo:
<allow users="usuario1,usuario2,usuario3" />
Para indicar el método HTTP utilizaremos el atributo Verb de las etiquetas <allow> y <deny>:
<allow VERB="POST" users="usuario4,usuario5" />

<deny VERB="POST" users="*" />
- 140 -
<allow VERB="GET" users="*" />
En esta configuración, permitimos a usuario4 y usuario5 utilizar el método POST de HTTP en los recursos
solicitados, mientras que sólo dejamos utilizar el método GET de HTTP al resto de los usuarios.
Existen dos nombres de usuario especiales que podemos usar en el atributo users:
- El carácter (*): significa todos los usuarios.

- El carácter (?): significa usuarios anónimos (es decir, no autenticados).
Por ejemplo, podríamos usar el carácter (?) para denegar el acceso a los usuarios no autenticados y usar
una atenticación basada en formularios (como hemos visto en el apartado anterior), para asegurarnos de
que únicamente los usuarios autenticados podrán acceder a nuestros recursos:
<authorization>
<deny users="?" />
</authorization>
Debemos tener en cuenta que el archivo web.config predeterminado permite el acceso a todos los
usuarios.
- 141 -
RECUERDE
- Como mecanismo de seguridad en ASP.NET, no está permitido realizar peticiones directas a los
ficheros global.asax o web.config.
- Es posible bloquear valores de configuración en los ficheros de configuración XML para evitar que
puedan sobrescribirse en un nivel inferior.
- Podemos establecer mecanismos de autenticación y autorización de usuarios en las aplicaciones

ASP.NET mediante la configuración de las etiquetas <authentication> y <authorization> en los
ficheros web.config.
- 142 -
GLOSARIO
A
ASP. Active Server Pages. Se trata de las páginas activas del servidor Internet Information Server. ASP 3
es la anterior versión de ASP a las nuevas páginas ASP.NET.
C
CLR. Common Language Runtime o Motor de Ejecución Común incluido en el paquete Microsoft .NET.
CSS. Cascading Style Sheets, Hojas de Estilo en Cascada. Se utilizan para dar formato a documentos
HTML o XML, separando los datos del formato de presentación.
CTS. Common Type System. Especificación de tipos básicos para la integración de distintos lenguajes de
programación en Microsoft .NET (como C#, Visual Basic .NET, Jscript. .NET).
C#. Lenguaje creado por Microsoft para su plataforma .NET, es parecido a C++ y Java.
D
DHTML. Dinamic HTML (HTML dinámico). Se forma de una conjunción de HTML, hojas de estilo en
cascada (CSS) y lenguajes de script como JavaScript o VBScript.
H
HTML. HiperText Markup Language. Lenguaje para la creación de páginas Web relacionadas entre sí por
hipertexto.
HTTP. HiperText Transport Protocol. Protocolo de comunicaciones utilizado por los navegadores de
Internet para el acceso a recursos Web, como ficheros de imágenes, de video, páginas HTML, páginas
ASP, páginas ASPX, etc.
I
IIS. Internet Information Server. Es el servidor Web de Microsoft. ASP.NET funciona sobre sobre IIS 5.0.
J
Java. Lenguaje de programación orientado a objetos desarrollado por Sun Microsystems.
- 143 -
JavaScript. Lenguaje de script desarrollado por Netscape y utilizado en los navegadores de Internet.
J2EE. Java 2, Enterprise Edition. Modelo de desarrollo y aplicación propuesto por SUN y basado en el
desarrollo de componentes Java.
JSP. Java Server Pages. Solución de SUN Microsystems para el desarrollo de aplicaciones Web. Se
basan en la especificación de Servlets de SUN.
M
MSIL. Lenguaje intermedio para la ejecución de aplicaciones en Microsoft .NET.
P
PHP. Personal Home Page, Procesador de Hipertexto. Las páginas PHP presentan una técnica similar a
las páginas ASP de Microsoft, es decir, las páginas HTML incluyen el código PHP embebido en ellas, y al
ejecutarlas, se genera código HTML dinámicamente.
V
VBScript. Visual Basic Script. Lenguaje de script desarrollado por Microsoft.
X
XML. eXtensible Markup Language, Lenguaje de marcado extensible. Se utiliza para la construcción de
documentos de datos estructurados multi-propósito.
- 144 -

Manual de ASP NET

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual de ASP NET

Uploaded by

Copyright:

Available Formats

Tema 1.

INTRODUCCIÓN AL DESARROLLO DE APLICACIONES WEB _______ 1

Tema 2. REQUISITOS DEL ASP.NET (.NET FRAMEWORK) _______________ 11

Tema 3. CONCEPTOS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS ___ 19

Tema 4. CREANDO UNA PÁGINA BÁSICA ____________________________ 31

Tema 5. CONCEPTOS DE WEB FORMS ______________________________ 55

Tema 6. COMPONENTES (DATALIST, DATAGRID) ______________________ 83

Tema 7. DIRECTIVAS DE PÁGINA ___________________________________ 91

Tema 8. CONFIGURACIÓN DE IIS ___________________________________ 99

Tema 9. EL ARCHIVO GLOBAL.ASAX_______________________________ 111

Tema 10. EL ARCHIVO WEB.CONFIG ______________________________ 119

Tema 11. MÓDULOS Y MANEJADORES http_________________________ 129

Tema 12. SEGURIDAD EN ASP.NET ________________________________ 135

1.1. ASP 3_________________________________________________ 5

Los desarrollos Internet se implementan sobre los protocolos y lenguajes de Internet.

A mayor complejidad de aplicaciones, mayor complejidad y potencia de herramientas y nuevas

En esta dirección puede encontrarse abundante documentación sobre ASP

Uno de los sitios Web más populares dedicados a ASP.NET

1.2. JAVA (JSP, SERVLETS)

Es la solución de SUN Microsystems para el desarrollo de aplicaciones Web. Consta de un conjunto de

Sitio Web de SUN Microsystems dedicado a Java

2.1. MICROSOFT .NET FRAMEWORK _________________________ 14

- Sistema operativo Windows 2000 Server/Professional. (ASP.NET no es soportado por

- Microsoft .NET Framework SDK (Software Development Kit): es la implementación de la

2.1. MICROSOFT .NET FRAMEWORK

- La jerarquía de clases básicas de la plataforma o .NET Framework Base Classes.

ASP.NET Windows Forms

.NET Framework Basse Classes (clases básicas de la plataforma)

ADO.NET XML THREADING Etc.

CLR, Common Language Runtime (Entorno común de ejecución de lenguajes)

CTS CLS MSIL Gestión de memoria

Estas siglas corresponden a Microsoft Intermediate Languaje, Lenguaje Intermedio de Microsoft. Es un

Este código es independiente de la plataforma y del lenguaje que lo haya originado.

- Para desarrollar aplicaciones ASP.NET necesitamos: el sistema operativo Windows 2000

- También es recomendable disponer de la aplicación Visual Studio .NET, que es un entorno de

- ASP.NET es un subconjunto de la tecnología .NET de Microsoft, la parte relativa a la programación

3.1. OBJETOS ____________________________________________ 21

El objeto es el concepto principal sobre el cual se fundamenta la tecnología orientada a objetos. Un

Métodos Públicos (interfaz del objeto)

Por tanto, para enviar un mensaje necesitamos:

- El objeto al que vamos a enviar el mensaje, en nuestro ejemplo, el objeto automóvil,

Ejemplo de jerarquía de clases (herencia simple)

3.9. MODELO DE OBJETOS

3.10. RELACIONES ENTRE CLASES

- Una relación de herencia: ya la hemos visto en el apartado de la Herencia. Consiste en

- Facilita la reutilización del software, como ya hemos comentado, a través de la herencia.

- Facilita el mantenimiento de los programas y la detección de errores. La encapsulación nos

3.12. INCONVENIENTES DE LA POO

- La curva de aprendizaje suele ser más larga que la necesaria en la programación

- Dificultad en determinar las características de un objeto, porque debemos tener en cuenta

- Jerarquías de herencia complejas, que pueden llegar a ser confusas, en el caso de la

- Los lenguajes de programación orientados a objetos permiten el encapsulamiento, la abstracción, la

4.1. COMENTANDO EL EJEMPLO_____________________________ 34

Nuestra primera página ASP.NET:

4.1. COMENTANDO EL EJEMPLO

Resultado de la ejecución de nuestra página holaMundo.aspx en el navegador

abstract event new struct

4.3. DECLARACIÓN DE VARIABLES

<script language=”C#” runat=”server”>

Podemos usar comentarios de línea simple o de un grupo de líneas:

// Código comentado de línea simple

4.5.1. Condicional if .. else

Veamos un ejemplo de su uso:

<%@ Page language=”C#” %>