0% encontró este documento útil (0 votos)

49 vistas410 páginas

Guía Completa de ASP.NET y C#

Este documento presenta una introducción a ASP.NET y C# para el desarrollo web. Explica conceptos clave como qué es ASP.NET, sus requisitos e instalación, el uso de Microsoft Visual Studio y un ejemplo básico. Luego profundiza en temas como el funcionamiento de ASP.NET, controles web, diseño de páginas, programación orientada a eventos y elementos básicos de C# para programación. Finalmente, cubre tópicos como ADO.NET para el acceso a datos y el uso de controles web en ASP.NET.

Cargado por

boleta18

Derechos de autor

Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.

Formatos disponibles

Descarga como PDF, TXT o lee en línea desde Scribd

0% encontró este documento útil (0 votos)

49 vistas410 páginas

Guía Completa de ASP.NET y C#

Cargado por

boleta18

Derechos de autor

Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.

Formatos disponibles

Descarga como PDF, TXT o lee en línea desde Scribd

ASP.

NET C#
Material

ÍNDICE GENERAL
1. Introducción....................................................................................................................................................... 7
ÍNDICE...............................................................................................................................................................................9
OBJETIVOS.................................................................................................................................................................. 11
INTRODUCCIÓN......................................................................................................................................................... 12
1.1. ¿Qué es [Link]?................................................................................................................................................. 13
1.2. Fundamentos y características de la programación Web................................................................................... 14
1.3. Requisitos e instalación........................................................................................................................................ 18
1.4. Microsoft Visual Studio 2010................................................................................................................................ 20
1.5. Ejemplo.................................................................................................................................................................. 25
RESUMEN..................................................................................................................................................................... 29

2. Introducción a [Link]............................................................................................................................. 31
ÍNDICE............................................................................................................................................................................ 33
OBJETIVOS.................................................................................................................................................................. 35
INTRODUCCIÓN......................................................................................................................................................... 36
2.1. Introducción a .NET............................................................................................................................................... 37
2.2. Funcionamiento [Link]...................................................................................................................................... 41
2.3. Controles [Link]................................................................................................................................................. 49
2.4. Vinculaciones......................................................................................................................................................... 51
2.5. Diseño páginas Web [Link]............................................................................................................................... 54
2.6. Web forms.............................................................................................................................................................. 57
RESUMEN..................................................................................................................................................................... 85

3. Introducción a C#......................................................................................................................................... 87
ÍNDICE............................................................................................................................................................................ 89
OBJETIVOS.................................................................................................................................................................. 91
INTRODUCCIÓN......................................................................................................................................................... 92
3.1. Introducción a C#.................................................................................................................................................. 93
3.2. Elementos básicos en la POO............................................................................................................................... 94
3.3. Elementos básicos en C#..................................................................................................................................... 99
3.4. Estructuras de control......................................................................................................................................... 111

3
[Link] C#

3.5. Cadenas............................................................................................................................................................... 118

3.6. Estándar de codificación de C#.......................................................................................................................... 119
3.7. Ejemplo................................................................................................................................................................ 143
RESUMEN................................................................................................................................................................... 149

4. Elementos de [Link]............................................................................................................................ 151

ÍNDICE.......................................................................................................................................................................... 153
OBJETIVOS................................................................................................................................................................ 155
INTRODUCCIÓN....................................................................................................................................................... 156
4.1. Programación basada en eventos...................................................................................................................... 157
4.2. Postback.............................................................................................................................................................. 164
4.3. Objetos................................................................................................................................................................. 171
4.4. Más objetos en [Link]................................................................................................................................... 177
4.5. Relaciones entre clases...................................................................................................................................... 182
4.6. Estructuras de datos........................................................................................................................................... 188
RESUMEN................................................................................................................................................................... 201

5. [Link]........................................................................................................................................................... 203
ÍNDICE.......................................................................................................................................................................... 205
OBJETIVOS................................................................................................................................................................ 207
INTRODUCCIÓN....................................................................................................................................................... 208
5.1. Bases de datos.................................................................................................................................................... 209
5.2. [Link]............................................................................................................................................................... 210
5.3. Objetos [Link]................................................................................................................................................. 212
5.4. Trabajando con datos.......................................................................................................................................... 226
RESUMEN................................................................................................................................................................... 249

6. Controles Web con [Link]................................................................................................................ 251

4
Material

INTRODUCCIÓN....................................................................................................................................................... 256
6.1. Controles HTML y de usuario............................................................................................................................. 257
6.2. Controles de servidor [Link]........................................................................................................................... 262
6.3. Ciclo de vida de una página [Link]................................................................................................................. 265
6.4. Tipos de controles en [Link]........................................................................................................................... 276
6.5. Code-Behind........................................................................................................................................................ 293
6.6. Ciclo de vida de una página [Link]................................................................................................................. 296
RESUMEN................................................................................................................................................................... 311

7. Manejo de errores..................................................................................................................................... 313

ÍNDICE.......................................................................................................................................................................... 315
OBJETIVOS................................................................................................................................................................ 317
INTRODUCCIÓN....................................................................................................................................................... 318
7.1. ¿Qué hacer para evitar errores?........................................................................................................................ 319
7.2. Tipos de errores................................................................................................................................................... 320
7.3. Pruebas para detectar errores............................................................................................................................ 327
7.4. Localizar errores.................................................................................................................................................. 334
7.5. Control de errores manualmente....................................................................................................................... 349
RESUMEN................................................................................................................................................................... 363

8. Protección y seguridad para

[Link]. Personalización ............................................................................................................................. 365
ÍNDICE.......................................................................................................................................................................... 367
OBJETIVOS................................................................................................................................................................ 369
INTRODUCCIÓN....................................................................................................................................................... 370
8.1. Principios de seguridad...................................................................................................................................... 371
8.2. Seguridad............................................................................................................................................................. 377
8.3. Proveedor Membership....................................................................................................................................... 399
RESUMEN................................................................................................................................................................... 409

5
1 1
[Link] con C#
DIDÁCTICA
UNIDAD

1. Introducción
1: Introducción

9
1: Introducción

OBJETIVOS
■ Conocer los fundamentos básicos Web.

■ Saber qué es [Link].

■ Saber cómo instalar Microsoft Visual Studio 2010.

■ Realizar un ejemplo ilustrativo de programación con [Link].

11
[Link] con C#

INTRODUCCIÓN

En esta unidad vamos a realizar una breve introducción Para poder desarrollar todo el trabajo durante este
al mundo de [Link] usando el lenguaje de curso vamos a necesitar varias herramientas como el
programación C#. Para ello haremos un breve repaso .NET Framework SDK, que vienen incorporadas por
sobre algunos de los aspectos más importantes sobre defecto en las versiones más recientes de Microsoft
programación Web y veremos cómo ha evolucionado Visual Studio. En esta unidad procederemos a mostrar
ASP hasta [Link]. Desde luego estamos ante una cómo instalar la versión de Microsoft Visual Studio
de las tecnologías más potentes para el desarrollo de 2010 con SQL Server.
páginas Web dinámicas e interactivas. El aprendizaje Hoy en día, la gran mayoría de empresas en el mundo
de [Link] es una de las mejores opciones para tienen su propia página Web y mucha gente está
empezar a programar este tipo de páginas. creando la suya propia. Por eso, ésta es una de las
mejores opciones para ir aprendiendo a hacer tu
propia página Web.

12
1: Introducción

1.1. ¿Qué es [Link]?

[Link] es una tecnología que apareció en el año 2002 como una versión actualizada
de Active Server Pages (ASP) comercializada por Microsoft. Hoy en día es una de las
tecnologías más usadas por los programadores Web para el desarrollo de páginas
Web dinámicas e interactivas debido a su facilidad de uso, utilidad y sobre todo por
su potencia. Con este modelo de desarrollo se permite al programador escribir código
[Link] usando diversos tipos de lenguajes como C#, Visual Basic o JScript.

Eso sí, para el desarrollo de [Link] son necesarios tener ciertos conocimientos
y estar familiarizado con el lenguaje HTML, lo cual nos ayudará a una realización
más rápida de nuestros trabajos. HTML (HyperText Markup Language) es el lenguaje
predominante en la realización de páginas Web. Se denomina lenguaje de marcado y
su mayor característica es que se desarrolla con etiquetas para describir la estructura
y contenido de la página. Las etiquetas van entre los signos “< >”.

Como hemos dicho anteriormente, [Link] es la versión actualizada de Active

Server Pages (de aquí en adelante ASP). Podemos afirmar que [Link] es la
convergencia entre ASP y .NET. ASP, siendo una de las primeras tecnologías usadas
en la programación Web y, al igual que su sucesora, permitía una manera efectiva
y rápida para la creación de páginas Web dinámicas permitiendo el uso de Scripts,
componentes y HTML. La otra parte es .NET, que es una tecnología más moderna
que ASP, diseñada por Microsoft. De esta forma podemos decir que [Link] es una
potente tecnología para la creación de Webs dinámicas.

1.1.1. [Link] y ASP

Evidentemente entre [Link] y ASP existen diferencias. Con la tecnología ASP se
utilizaban estrictamente lenguajes interpretados o scripts como JavaScript o VBScript,
lo cual cambia radicalmente con la aparición de [Link] que soporta lenguajes
compilados a códigos intermedios como C#, Visual Basic o cualquiera que soporte
.NET.

Gracias a este soporte se pueden crear páginas de forma más rápida y más complejas
y además con C# nos puede resultar mucho más sencillo, ya que fue desarrollado
como parte de la plataforma .NET, a diferencia de los otros lenguajes que hemos
nombrado, que han sido adaptados a las necesidades de .NET. Como venimos
diciendo, .NET nos proporciona la ayuda necesaria para poder realizar aplicaciones
de forma rápida, segura y económica. Además, hoy en día, .NET soporta más de
20 lenguajes de programación, lo que pone de manifiesto la universalización de esta
tecnología.

13
[Link] con C#

1.2. Fundamentos y características de la programación

Web
La programación Web no es algo trivial, ya que requiere fundamentos y conocimientos
de varios campos. No hay duda de que con cierta experiencia y conocimientos se
pueden desarrollar desde pequeños elementos Web hasta páginas completas, pero
también es cierto que para realizar una página con éxito son necesarios muchos
componentes (tiempo, financiación económica, personal…). Hoy en día, las páginas
Web más complejas necesitan desde programadores hasta diseñadores gráficos,
analistas o supervisores de contenido. Nosotros durante el curso vamos a proporcionar
ciertos conocimientos necesarios para poder realizar aplicaciones Web y tener una
visión general sobre el mundo de las tecnologías Web.

1.2.1. Tipos de páginas Web

Para empezar debemos conocer los tipos de páginas que nos podemos encontrar:

■■ Páginas Web estáticas.

■■ Páginas Web dinámicas.

Páginas Web estáticas

Son aquellas que están escritas directamente en HTML o XHTML y guardadas como
tal. Son páginas que carecen de movimiento, donde el autor para modificar el código
tiene que acceder directamente al servidor. Este tipo de Webs carecen de foros, bases
de datos y aquellas aplicaciones en las que el usuario no puede modificar datos a su
voluntad. Por ejemplo:

<html>
<head>
<title>Primera</title>
</head>
<body>
<h1> Mi primera página Web </h1>

Esta es la primera página Web estática que realizamos.

</body>
</html>

El resultado del código sería el siguiente:

14
1: Introducción

Figura 1.1. Salida aplicación en explorador.

Simplemente lo que se hace es que el autor escribe un código, lo guarda como .HTML
en el servidor para luego poder solicitar desde su navegador la página escrita, la
cual es buscada por el servidor donde se ha guardado y éste la envía por la red al
navegador donde ya se puede ver la página solicitada.

Páginas Web dinámicas

Son aquellas en las que se puede modificar en tiempo real por parte del usuario el
contenido de la misma, ya sea escribir un mensaje en un foro, modificar elementos
en una base de datos o cualquier actualización de la misma. Es decir, que el propio
usuario puede ver cambios en el aspecto o en el contenido de la página desde el
momento en el que los realiza. Por parte del diseñador también dispone de muchas
ventajas, donde la principal de ellas es que cualquier modificación que se quiera
realizar de la página no necesita entrar en el servidor.

El proceso de creación de Webs dinámicas se puede resumir desde el momento

en el que el diseñador escribe el código HTML con algunas instrucciones en otro
lenguaje. Desde ese instante puede buscar en el navegador la página que se solicita
al servidor y éste puede actuar de dos maneras. O bien, el propio servidor procesa las
instrucciones para mostrar la página Web, o bien manda el código al navegador para
que sea éste quién traduzca la información para poderla mostrar.

Es importante indicar que en el proceso existe una interacción cliente-servidor, donde

el cliente Web es quien ejecuta las aplicaciones en el equipo del usuario que esté
usando la página mediante aplicaciones denominadas applets o de JavaScript y el
servidor es aquel que ejecuta la aplicación. Una vez ejecutada, el servidor toma el
código HTML que se crea y se envía al cliente.

15
[Link] con C#

1.2.2. ¿Qué es un servidor Web?

Servidor Web
Podemos denominarlo como un pequeño elemento software que es capaz
de administrar páginas Web para poder hacerlas visibles al cliente a través
del servidor.

Normalmente el servidor y el cliente pueden estar a miles de kilómetros, aunque

también es posible que el servidor y el cliente se encuentren en la misma máquina.
Aún así, el modo de acceso al servidor por parte del cliente es el mismo. A partir de
ahora cuando hagamos referencia al cliente, estaremos hablando del navegador.

También debemos conocer cómo el cliente y el servidor se comunican a través de

Internet mediante el protocolo HTTP. Sabemos que Internet es una red de millones de
nodos interconectados que sirven para transportar información de un punto a otro.
Esta información es solicitada por el cliente a través del navegador al servidor Web y
lo hace usando el HyperText Tansfer Protocol (HTTP). Es evidente que todo el mundo
que ha usado alguna vez Internet ha podido ver en la URL la dirección de la página
con el prefijo [Link] lo que quiere decir es que el protocolo de Internet que se usa es
el HTTP.

El funcionamiento es básico: o bien desde el cliente se solicita una página al servidor

y éste responde mostrando la página Web en caso de que exista, o bien con un
mensaje de error en caso de que no. Es verdad que, cuando desde el navegador
se solicita la página Web que se quiere visitar, no solo se le está pasando al servidor
el nombre de la página; en realidad se le pasan una serie de directivas en las cuales
no vamos a profundizar. Por ejemplo, para solicitar la página, la primera línea que se
escribe es: “GET/[Link] HTTP/1.1”. Las primitivas utilizadas para la petición son
GET, POST, PUT, DELETE, TRACE, CONNECT y OPTIONS. La respuesta es similar a
la solicitud y un ejemplo de respuesta podría ser: “HTTP/1.1 200 OK”.

De esta forma, un ejemplo de lo que en realidad ocurre al solicitar una Web sería el
siguiente:

GET/[Link] HTTP/1.1

Host: [Link]

User-Agent: Mozilla/4.5 [en]

Accept: image/jpeg, image/gif, text/html

Accept-language: en

Accept-Charset: iso-8859-1

HTTP/1.1 200 OK

16
1: Introducción

Date: Thu, 5th Aug 2010, 14:00:00 GMT

Server: Microsoft-IIS/7.0

Last-modified: Wed, 13th Oct 2010, 03:00:00 GMT

El protocolo HTTP está orientado a la conexión, es decir, que necesita de un canal

entre el servidor y el cliente, empleando un protocolo de comunicaciones como puede
ser TCP/IP.

Existe una versión de HTTP denominada HTTPS que incluye un protocolo de seguridad
denominado SSL, que se utiliza normalmente en servidores orientados al correo
electrónico donde se usan datos personales.

Tanto para el usuario como para el programador las directivas mostradas arriba se
realizan de forma transparente, es decir, que no son visibles.

17
[Link] con C#

1.3. Requisitos e instalación

Para poder usar [Link] hacen falta una serie de requisitos. En realidad se puede
usar de varias formas. Si no se dispone de Microsoft Visual Studio se tendrían que usar
una serie de recursos que proporciona Windows y que serían necesarios activarlos.
Como se puede intuir, Microsoft Visual Studio proporciona los elementos necesarios.
Es indispensable tener un servidor Web, el cual es proporcionado automáticamente
por la herramienta Microsoft Visual Studio y también es recomendable tener conexión
a Internet para poder visualizar nuestras creaciones en tiempo real.

Lo más fácil para poder usar [Link] es instalarse Microsoft Visual Studio 2010.
Nosotros vamos a usar la versión Express, puesto que nos la podemos descargar de
forma gratuita desde la siguiente dirección:

[Link]
editions/visual-web-developer-express

Y pulsamos Install Now, entonces comenzará la instalación de forma normal. Si

en algún momento se nos solicita contraseña y usuario debemos marcar la casilla:
“Autenticación Integrada de Windows” y continuar.

Durante la descarga probablemente nos irán apareciendo varias ventanas

necesarias para la ejecución de permisos para la instalación del programa
y en todas ellas hay que aceptar. La descarga y posterior instalación puede
llevar un tiempo bastante considerable, desde 30 minutos hasta más de una
hora en algunos casos. Es posible que además en medio de la instalación
tengamos que reiniciar el ordenador.

Una vez instaladas todas las herramientas nos debería salir una ventana con los
productos y herramientas instaladas. Además, nos saldrá alguna ventana en la que
nos recomiende instalar otras herramientas de Microsoft, las cuales no nos interesan
para este curso.

Para comprobar que se ha instalado correctamente debemos buscar en la lista de

programas Microsoft Visual Studio 2010 Express y debemos acceder a él.

En realidad lo que hemos instalado ha sido una versión de evaluación de 30 días,

aunque Microsoft nos da la posibilidad de instalarnos una versión permanente. Para
ello debemos de seguir los siguientes pasos:

1. Pinchamos sobre la pestaña “Ayuda” y “Acerca de Micosoft Web Developer

2010 Express” (Help y About Microsoft Visual Studio si ha instalado una versión
en inglés) y observar que en la esquina superior derecha aparece un contador
con los días que nos quedan para registrar la versión permanente.

18
1: Introducción

2. Para registrar nuestro producto vamos a ir a la misma pestaña de Ayuda y

le damos a “Registrar Producto”, tras lo cual nos saldrá un cuadro en el que
debemos pichar “Obtener una clave de registro en línea”

Figura 1.2. Registro producto.

3. Iniciar con su cuenta de correo. Esa cuenta debe ser válida registrada en
Passport. En el caso de que no la tengamos habrá que crearse una nueva. Una
vez dentro de nuestra cuenta habrá que rellenar un formulario.

4. A continuación se nos proporciona un código, el cual lo tenemos que copiar y

pegar en el cuadro que nos salía anteriormente.

5. Ya estamos registrados. Para comprobarlo vemos que el contador ya no aparece.

19
[Link] con C#

1.4. Microsoft Visual Studio 2010

Esta herramienta sirve para programar de una manera un poco más fácil, ya que trae
ayuda asistida, es decir, mientras se va programando va avisando de los posibles
fallos que vamos cometiendo. Aparte de este detalle lo que realmente puede llegar a
ayudarnos en nuestros inicios a la hora de programar es que MVS 2010 trae plantillas
para empezar a construir nuestro programa. He aquí una serie de consejos que
podemos seguir a la hora de programar:

Se sabe que prácticamente todas las páginas Web están formadas por otras
páginas Web más pequeñas, es decir, es un conjunto de páginas Web. MVS nos
da la posibilidad de crear un proyecto y dentro de éste podemos ir incluyendo todas
las páginas Web que queramos. Por ejemplo, si queremos tener una página Web
con datos de los países del sudeste asiático, crearemos un proyecto que se llame
“SudesteAsiatico” y posteriormente iremos agregando elementos que se llamen
“[Link]”, “[Link]”, “[Link]”, etcétera.

Cuando abrimos MVS nos saldrá una pantalla de bienvenida con varias opciones.
Existe una opción que es “Nuevo sitio Web”, de modo que podemos acceder desde
ahí o desde el menú Archivo -> Nuevo Sitio Web.

Figura 1.3. Crear un proyecto WEB.

Una vez hecho este paso nos saldrá la siguiente ventana en la que elegiremos que
queremos hacer un “Sitio Web [Link]” y muy importante es elegir el código en el
que queremos escribir nuestros programas, que en nuestro caso es C#. Es necesario
saber la ubicación de nuestra página. Como hemos dicho antes, si queremos una
que sea de países del sudeste asiático, nos tendremos que crear una carpeta donde
queramos y en la parte de abajo donde pone “Ubicación Web” escribiremos su ruta.

20
1: Introducción

Figura 1.4. Ubicación WEB

Ahora llegaremos a la siguiente pantalla. La pantalla principal es donde debemos

escribir nuestro código. Al principio nos saldrá esta plantilla que puede servirnos de
ayuda. De momento a nosotros no nos importa mucho y podemos borrar todo el
código que aparece y escribir el nuestro. A la derecha nos aparece una pequeña
ventana que es el Explorador de Soluciones que es un pequeño árbol donde tenemos
cada una de las pequeñas páginas que conforman lo que es la página Web completa.
Aquí nos aparecerán otra serie de opciones que pueden sernos útiles como la creación
de una página Master que veremos en el siguiente capítulo.

Figura 1.5. Entorno de trabajo.

En la primera pantalla que nos sale se nos ha creado como “[Link]”. Tenemos la
opción de cambiarla yéndonos al explorador de soluciones, pinchando sobre el botón
derecho de “[Link]” y dandole a “Cambiar nombre”:

21
[Link] con C#

Figura 1.6. Cambiar nombre proyecto.

En este punto es importante indicar que tenemos que tener una página raíz a través
de la cual debemos ir incorporando los elementos necesarios para poder construir
una página Web. Como se ha podido apreciar, Microsoft Visual Studio lo proporciona
por defecto y ésta es la página [Link]. Sería interesante mantener este nombre y
sobre este fichero se puede crear algún menú a través del cual ir creando las páginas.

Una vez llegados aquí empezamos a decidir qué páginas incluimos en nuestro
proyecto. Para ello debemos irnos al explorador de soluciones y con el botón derecho
pinchar sobre el nombre del proyecto y después darle a “Agregar Nuevo Elemento”.

Figura 1.7. Agregar Nuevo Elemento.

Ahora llegaremos al siguiente menú y en él podemos elegir qué queremos hacer.

Hay varios tipos de documentos que podemos agregar, desde formularios hasta
documentos HTML pasando por documentos XML y así bastantes opciones que nos
pueden ser muy útiles. Como hicimos anteriormente, podemos elegir el lenguaje en
el que escribir esta parte de la página y, por supuesto, debemos decidir qué nombre
darle. Por defecto las páginas vienen como .aspx.

22
1: Introducción

Figura 1.8. Extensión.

Para ver un ejemplo de cómo actuaría vamos a coger la opción Web Forms y nos
saldrá la siguiente pantalla en la que nos aparece una plantilla con los elementos
obligatorios para poder hacer un Web Form.

Es necesario reseñar que durante todos los ejemplos de este curso vamos a necesitar
siempre dos ficheros sobre los que programar. Para ello es importante explicar que
debemos tener marcada la opción “Poner código en archivo independiente”, que
como se puede apreciar en la imagen superior, aparece en la esquina inferior derecha.
En el caso de que no aparezca dicha opción no tenemos por qué preocuparnos,
puesto que por defecto es la que MVS usa.

Figura 1.9. Código en archivo independiente.

Para realizar nuestras páginas vamos a necesitar, al menos, dos ficheros principalmente.
Uno será el [Link] y el otro será el [Link] (o el nombre que deseemos
darle, aunque lo ideal es que lo dejemos tal cual, ya que el servidor lo primero que
busca es el fichero [Link]).

23
[Link] con C#

Es en estas dos ventanas donde empezaremos a escribir nuestro código y si queremos

ver el resultado que tendría nuestra página, debemos pinchar sobre el botón derecho
de la ventana [Link] y “Ver en el explorador”. De esta forma se nos abrirá una
ventana en nuestro navegador predeterminado en el que podemos ver el resultado.
Es muy importante que no se nos olvide guardar los cambios que vayamos haciendo
para así poder ver la evolución del código en nuestro navegador.

Figura 1.10. Ver en el explorador.

MVS es una herramienta bastante potente y que nos puede ayudar mucho a la hora
de programar, puesto que mientras escribimos nos salen ayudas a la derecha con
los posibles elementos que podemos escribir. Por ejemplo, si escribimos una palabra
clave como runat = …, nos aparecerá un menú de ayuda en el que pondrán server
para que no tengamos que escribirla y pinchar directamente sobre ella.

Aparte de esta herramienta hay muchas más que pueden hacer las mismas funciones
que Microsoft Visual Studio como HTML Kit, Eclipse u otros programas en los que no
vamos a incidir.

A continuación, vamos a desgranar la pantalla principal de MVS 2010 Express.

Como podemos observar en las imágenes anteriores, tenemos dos secciones bien
diferenciadas. La primera sección es la principal que es donde escribimos nuestro
código. Ésta a su vez, tiene tres pestañas. La pestaña de código es la que hemos
visto, la de diseño es una vista que nos puede resultar de gran ayuda, puesto que
podemos ir rellenando sobre la plantilla sin necesidad de tener que escribir código y la
tercera es la pestaña de dividir que es una vista compartida de las dos anteriores. La
segunda sección es la de exploración. En ella tenemos el explorador de soluciones y
el explorador de equipo. La que nos interesa es la de soluciones, puesto que en ella
aparece todo lo relacionado con los ficheros que necesitamos.

24
1: Introducción

1.5. Ejemplo
Ya es el momento de poner en práctica los primeros conocimientos que hemos
adquirido. Ahora vamos a seguir paso a paso el siguiente ejemplo:

La forma que nosotros vamos a utilizar durante todo el curso es a través de Microsoft
Visual Studio. Ya hemos visto en el punto anterior cómo se crearía un proyecto y ya
solamente nos queda escribir el código. Para ello vamos a hacerlo siempre de la misma
forma. Lo primero que debemos hacer por motivos de comodidad es tener siempre
abierto el explorador de soluciones, que se encuentra en la pestaña “Ver” y según
una versión u otra podemos encontrar directamente “Ver explorador de soluciones” o
tenemos que acceder a “Otras ventanas” y marcar la que buscamos. Una vez abierto
tenemos la siguiente imagen:

Figura 1.11. Explorador de soluciones.

Como podemos observar, en la imagen tenemos un árbol cuya raíz es nuestra página
Web y sobre ella caen las distintas páginas y ficheros de configuración. Nosotros
vamos a centrarnos en “[Link]”. Como hemos indicado, éste es el fichero
inicial y es donde vamos a escribir nuestro código en HTML y vemos también que de
este fichero nace otro fichero denominado “[Link]” que es donde vamos
a escribir todo nuestro código en C#. Así de esta manera vamos a realizar nuestro
primer ejemplo.

Abrimos “[Link]” y vamos a escribir el siguiente código:

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]

<head id=”Head1” runat=”server”>

<title> Hora Web Server </title>

25
[Link] con C#

</head>
<body>
<h1> Bienvenidos a mi primera página Web [Link]</h1>
La hora actual es:
<asp:label id = “time” runat = “server” />
</body>
</html>

Y sobre el fichero “[Link]” escribiremos el siguiente código:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

Sobre el fichero “[Link]” pinchamos con el botón derecho y le damos a “Ver

en el explorador” y nos debería salir lo siguiente en nuestro explorador que tengamos
puesto por defecto.

26
1: Introducción

Figura 1.12. Salida explorador.

Para comprobar lo que hace la página le damos a actualizar o F5 y vemos que la hora
ha cambiado.

Vamos a explicar un poco el código que hemos escrito. Como podemos observar,
tenemos dos partes bien diferenciadas, una se encuentra escrita en el lenguaje
deseado, que es C# y la otra se encuentra escrita en HTML que se deben escribir entre
las etiquetas <html> y </html>. Como vemos, el cuerpo del programa son solamente
tres líneas que nos indican la hora del reloj del sistema y en el bloque HTML hacemos
una llamada al bloque [Link] para que en el código HTML aparezca la hora. En
el código HTML simplemente tenemos el código para que muestre por pantalla la
bienvenida y la hora actual.

Es un programa sencillo que nos ilustra el funcionamiento de [Link] y HTML y que

es una base para lo que podemos ir construyendo a lo largo de este curso.

Como podemos observar, al abrir cada uno de los dos ficheros, Microsoft Visual
Studio nos proporciona un código que es necesario y prácticamente común a todos
los ejemplos que vamos a ver a lo largo del curso. En primer lugar vemos que en el
fichero .[Link] que es donde escribimos el código en C#, apreciamos que lo primero
que aparece son una serie de directivas del tipo “using …” seguido de un parámetro.
Estos parámetros son elementos propios de [Link] y se denominan Namespaces
y son necesarios importarlos a nuestro código para poder usar estos recursos. No
todos ellos son necesarios en nuestros ejemplos, sino que va a depender de las
instrucciones que usemos y de los elementos de programación que queramos usar.

En los ficheros del tipo .aspx observamos que también se nos proporciona un código
por defecto, pero cabe comentar que en la primera instrucción se indica el lenguaje
que vamos a usar. Recordamos que [Link] soporta varios tipos de lenguaje. Sobre
esa misma instrucción también se observa que se hace referencia a nuestro fichero
“[Link]” que es donde está la otra parte de nuestra página. Es importante
hacer la llamada a ese fichero porque de lo contrario tendremos problemas a la hora
de crear nuestra página Web.

27
1: Introducción

RESUMEN
■ [Link] es la convergencia de las tecnologías ASP y .NET.

■
[Link] es una potente tecnología para el desarrollo de páginas Web de forma
dinámica e interactiva.

■ [Link] soporta varios lenguajes de programación.

■ ASP solo utiliza lenguajes de scripts.

■
Existen páginas Web dinámicas y estáticas. Nosotros haremos hincapié en las
dinámicas.

■ Las estáticas no permiten interactuar con el usuario y las dinámicas sí.

■
Un servidor Web es un espacio de programa capaz de administrar páginas Web para
mostrarlas al cliente a través del servidor.

■ El protocolo HTTP es un elemento fundamental para el éxito de Internet.

■
Para poder trabajar con [Link] necesitamos un servidor, el propio [Link] y .NET
Framework SDK.

■
Para hacer una página con [Link] tenemos que tener algunos conocimientos de
HTML.

■
Anteriormente, para la creación de páginas Web [Link] era necesario haber instalado
correctamente [Link] y .NET Framework SDK, pero las versiones más modernas de
Microsoft Visual Studio traen incorporados todos estos elementos.

■
Existen multitud de herramientas para la ayuda de creación de páginas Web como
Microsoft Visual Studio que pertenece a Microsoft al igual que [Link], lo que nos
proporcionará bastantes recursos que pueden sernos útiles.

29
2
[Link] con C#
2
DIDÁCTICA
UNIDAD

2. Introducción a [Link]
2: Introducción a [Link]

33
2: Introducción a [Link]

OBJETIVOS
■ Saber cómo está compuesto el .NET Framework.

■ Aprender el funcionamiento de la tecnología [Link].

■ Conocer el uso de los controles de [Link].

■ Conocer ciertas directivas y el uso de “Namespace”.

■ Saber cómo actúa [Link] ante el uso de recursos externos.

■ Analizar el diseño de las Webs [Link].

■ Aprender a usar páginas principales y secundarias y páginas anidadas.

■ Usar formularios Web.

■ Conocer los tipos de controles de formularios HTML.

■ Conocer los tipos de controles de formularios [Link].

35
[Link] con C#

INTRODUCCIÓN

En esta unidad vamos a desarrollar [Link]. Como fichero poder llamarlo con una simple línea de código.
venimos hablando en la unidad anterior, [Link] Así en esta unidad veremos algunas técnicas en las
es una tecnología muy potente para la creación de que se usa esto.
páginas Web dinámicas e interactivas; por eso vamos Hoy en día, mientras navegamos por la red podemos
a hacer un repaso a la tecnología [Link] y al .NET hacer millones de cosas, pero una de las cosas que
Framework. hacemos más frecuentemente es interactuar con el
En el mundo del diseño Web es importante saber servidor a través de formularios. Un formulario es una
cuáles son los objetivos de la página que estemos conversación entre el usuario y el servidor a través del
diseñando, cómo va a ser su diseño estéticamente cual se envía y recibe información. Una búsqueda en
hablando y, por supuesto, saber de antemano Google o cuando abres tu cuenta de correo electrónico
cuáles serán los contenidos. Para poder realizar es una interacción entre servidor y usuario. En casi
esta tarea a gran escala se necesitan muchas todas las Webs podemos encontrar formularios, así
personas bien coordinadas y mucho trabajo aparte que es de vital importancia saber manejar los tipos
de muchos recursos. Para poder realizar una página de formularios que existen y cómo, cuándo y dónde
probablemente tengamos que tirar de ficheros o usarlos.
archivos externos a nuestra página, como por ejemplo Así que vamos a realizar un pequeño viaje por las
una foto o simplemente tengamos que usar una entrañas de [Link] y a aprender a programar cada
base de datos, así que en nuestro diseño tendremos vez más con [Link].
que empezar a reutilizar código, datos o ficheros. Y
como se dice habitualmente: “No reinvente la rueda,
simplemente úsela”. Esto quiere decir que no es
necesario escribir el mismo código varias veces, sino
simplemente se puede escribir una vez y desde otro

36
2: Introducción a [Link]

2.1. Introducción a .NET

.NET
Es un Framework diseñado por Microsoft para ayudar con los problemas
fundamentales a los que se enfrentan los programadores. Con esta tecno-
logía Microsoft pretende ganar terreno en el sector Web a Sun Microsytems
y a Java. Cada vez el mercado de la tecnología Web es más amplio y existe
más competencia, por lo que Microsoft sacó esta tecnología en 2002 con
la intención de proveer al programador una serie de herramientas seguras,
rápidas y sobre todo fáciles de usar. Actualmente el Framework de .NET
viene incluido en las versiones más recientes de Windows, aunque también
puede ser instalado en versiones más antiguas de dicho sistema operativo,
al igual que una norma publicada por Microsoft permite su uso en otros
sistemas operativos.

Podemos resumir diciendo que [Link] es una biblioteca de clases que contiene un
gran número de funciones para trabajar con él. Para ello se dispuso el .NET Framework
que permite al programador contar con una cantidad importante de recursos para el
desarrollo de cualquier tipo de aplicación. Como ya hicimos en la unidad anterior, el
.NET Framework SDK lo instalamos en el paquete [Link].

El .NET Framework lo podemos diseccionar en varios temas específicos. Aquí

describiremos los más importantes:

■■ Lenguajes intermedios de Microsoft (MSIL: MicroSoft Intermediate Language).

Cuando escribimos un código éste es traducido, o mejor dicho, compilado a un
código más abstracto.

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

que se encarga de ejecutar el código MSIL en el ordenador. Se encarga de
todos los temas relacionados con Windows e IIS.

■■ La biblioteca de clases de .NET (.NET Framework Class Libraries). Contiene una

gran cantidad de bibliotecas con recursos útiles que podemos usar de forma
muy fácil en nuestro código para poder hacer de nuestra aplicación una mucho
más compleja.

■■ Los lenguajes de programación .NET. Éstos son los lenguajes de programación

propiamente dichos, luego pueden ser compilados a MSIL.

■■ [Link], emplea para compilar el código el .NET Framework, incluido al instalar

Visual Studio, sólo que se muestra a través de un navegador web.

Una vez vistos estos diferentes temas, pasaremos a desgranarlos, no sin antes hacer
un breve repaso a ciertos términos y aspectos relacionados con la codificación.

37
[Link] con C#

2.1.1. MSIL
Como todos sabemos, el lenguaje de los ordenadores es el binario, es decir, se
compone por 0’s y 1’s, pero nadie en su sano juicio es capaz de recordar una cadena
de palabras traducida a binario. Vamos a hacer un repaso por los distintos tipos de
niveles de lenguajes.

Vamos a dividir los lenguajes desde el nivel más alto al más bajo. Evidentemente el
nivel de lenguajes más alto es el lenguaje natural, que es el que hablamos los humanos
y lógicamente es el más fácil de entender.

■■ Nivel 5: lenguaje de alto nivel. Para pasar al nivel 4 lo que se hace es traducir,
que en informática se conoce como compilación.

■■ Nivel 4: lenguaje ensamblador. Para pasar al nivel 3 lo que se hace es el

ensamblado.

■■ Nivel 3: sistema operativo. Para pasar al nivel 2 lo que se hace es una

interpretación parcial.

■■ Nivel 2: nivel ISA. Viene a ser el lenguaje máquina y para pasar al nivel 1 lo que
se hace es la interpretación o secuenciación de instrucciones.

■■ Nivel 1: nivel micro-arquitectura. Lenguaje que existe entre los distintos

componentes de la arquitectura del ordenador.

■■ Nivel 0: este es el nivel más bajo. No es un lenguaje propiamente dicho. Se le

denomina Lógica Digital y es el conjunto de transistores con los que se hacen
los principales elementos del ordenador como la placa base.

Para hacernos una idea de lo complejo que es vamos a ver un ejemplo de cómo se
pasaría del nivel 5 al nivel 2.

void main (void)

{
printf (“Hola Mundo\n”);
return 0;
}
L4:
.data
CADENA DB “Hola Mundo “, 10.0
.code
PUSH EBP
PUSH EBP, ESP
PUSH OFFSET CADENA
CALL_printf
ADD ESP, n
MOV EAX, 0
MOV ESP, EBP

38
2: Introducción a [Link]

POP EBP
RET
L2:

Aquí sólo pondremos un pequeño fragmento debido a la altísima complejidad del

lenguaje:

0x0004 1010 55 = PUSH EBP

0x0004 1011 8B EC = MOV EBP, ESP
0x0004 1013 68 30 2A 41 00 = PUSH OFFSET CADENA
0x0004 1018 E8 23 00 00 00 = CALL_printf
…

2.1.2. CLR
El Common Language Runtime es la piedra angular de la máquina virtual de .NET
de Microsoft. Su principal función es cuidar la ejecución del código que ha sido
introducido y tratar con las tareas complicadas que Windows necesita para su correcto
funcionamiento.

Aparte, el CLR usa otro compilador que es el JIT (Just-In-Time, en español, en tiempo
de ejecución) para compilar el verdadero código máquina y gracias a ello podemos ir
actualizando al minuto nuestro código.

2.1.3. .NET Framework Class Libraries

También denominado como BCL (Base Class Library) que son bibliotecas disponibles
para todos los lenguajes .NET. Dentro de estas clases están, por ejemplo, la lectura
o escritura de ficheros, la manipulación de documentos que lógicamente facilitan la
tarea del programador.

Se usan los namespaces, que pueden ser traducidos como áreas de trabajo,
para agrupar las clases con funcionalidad parecida, por ejemplo, para los temas
relacionados con dibujos y gráficos utilizaremos la librería [Link]. Para poder
usarla tenemos que importarla y usaríamos la siguiente sentencia:

using System.nombre_de_la_libreria

En esta dirección se pueden encontrar las librerías que existen: [Link]

com/en-us/libr<[Link].

Aquí mostramos la cabecera de un programa que usa Namespaces:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

39
[Link] con C#

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

2.1.4. Los lenguajes de programación

En esta parte del .NET Framework incluiríamos los lenguajes de programación
compatibles con dicha herramienta. .NET Framework soporta varios de ellos, y nuestra
herramienta de programación nos da la opción de usar entre Visual Basic y C#, pero
nosotros nos vamos a centrar en C#, lenguaje que desarrollaremos en la próxima
unidad.

40
2: Introducción a [Link]

2.2. Funcionamiento [Link]

Cuando instalamos el .NET Framework algunos procesos se configuran de manera
automática para buscar nuestros ficheros con extensión .aspx y usar [Link] para
manejarlo. Evidentemente no es algo trivial todo el proceso que existe desde que le
damos al botón INTRO en el navegador hasta cuando ponemos nuestra página http://
[Link], pero es algo que ahora mismo no es importante.

Es fundamental que tengamos en cuenta que todas las páginas que vayamos a
escribir deben ser guardadas con la extensión .aspx, ya que las páginas [Link]
están identificadas con esta misma extensión. También podemos guardar páginas
con código HTML con .aspx, pero no ocurrirá nada distinto, al igual que también
podemos usar páginas con scripts y guardadas con la extensión .htm, pero no serán
interpretadas como código [Link] y probablemente en el navegador tengamos
problemas a la hora de acceder o a la hora de visualizar ciertos componentes utilizados
en la página.

Como se ha podido intuir la mejor manera de diferenciar qué es un código HTML y

uno [Link] es la separación de códigos. Por un lado usaremos un fichero para C#
con extensión .[Link] y otro en Html. Además, con la tecnología [Link] utilizamos
diferentes lenguajes de programación y para definirlo utilizaremos la siguiente línea:

<%@ Page language=“c#” %>

Entre las etiquetas iría el código escrito en C#. Como sabemos el lenguaje original de
[Link] es Visual Basic .NET, así que tenemos que hacer la declaración anterior para
evitar errores de compilación.

Vamos a probar qué ocurriría si introducimos este código HTML y lo guardamos como
[Link] en nuestro proyecto que nos creamos en la unidad anterior y abriremos la
página creada a través del botón derecho y “Ver en el explorador”. Es obligatorio que
el nombre de nuestro fichero y el asignado a CodeFile coincidan.

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]

<head>
<title>Ejemplo</title>
</head>
<body>
Hola <br />
Buenas tardes <br />

41
[Link] con C#

¿Cómo estás? <br />

¿Te gusta programar? <br />
¿Y con [Link]? <br />
¿A qué mola? <br />
</body>
</html>

El navegador nos debería mostrar la siguiente imagen:

Vamos a probar ahora qué pasaría si introdujésemos ahora código [Link] con C#.
Dicho código lo vamos a colocar en el fichero .[Link]

Recuerda que lo tienes que guardar en tu proyecto creado en el capítulo anterior con
el nombre ejemplo2. El siguiente código debe ser escrito en un fichero .[Link]

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

42
2: Introducción a [Link]

Éste debe ser el resultado final:

43
[Link] con C#

Finalmente, vamos a realizar una última prueba. Sin cambiar nada de lo escrito vamos
a coger el bloque que está en el fichero .[Link] y lo vamos a incluir entre dos etiquetas
<script> y a su vez vamos a incrustarlo en el código HTML. Hacemos el mismo
proceso que anteriormente.

Lo guardamos como [Link]

<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01

Transitional//EN”>

<html>
<head>
<title>Ejemplo</title>
</head>
<body>
Hola <br />
Buenas tardes <br />
¿Cómo estás? <br />
¿Te gusta programar? <br />
¿Y con [Link]? <br />
¿A qué mola? <br />

<script language=”c#” runat=”server”>
void Page_Load()
{
[Link](“Hola, soy [Link] <br />”);
[Link](“Buenas tardes HTML. Soy [Link] <br
/>”);
[Link](“¿Cómo estás HTML. Te recuerdo que soy
[Link] <br />”);
[Link](“¿Te gusta programar con [Link]? <br
/>”);
[Link](“Con [Link] mejor que con HTML <br
/>”);
[Link](“¿A que mola [Link]? <br />”);
}
</script>
</body>
</html>

Y este debe ser su resultado al abrirlo en su navegador:

44
2: Introducción a [Link]

Como podemos observar, el resultado es exactamente idéntico al obtenido en el

ejemplo 2. Antes que nada debemos decir que aunque los dos últimos ejemplos
sean [Link] obviamente ninguno de ellos nos muestra una página dinámica. Ahora
vamos a explicar el porqué los dos ejemplos nos da el mismo resultado aún siendo
códigos “distintos”. El motivo es porque el servidor Web analiza el código en busca
de alguna etiqueta <script> y es lo primero que ejecuta. Es por esta razón por lo que
las primeras líneas en el tercer ejemplo son las escritas con código [Link]. Como
hemos podido observar siempre se ejecuta primero lo que haya en el fichero .[Link].

Probablemente nos hayamos dado cuenta de que existe un problema respecto a

lo anterior. ¿Qué pasa si queremos intercalar código HTML y código [Link] si lo
primero que se evalúa es lo se procesa en el servidor? Como era de pensar, los
desarrolladores de [Link] no iban a dejar este asunto sin resolver. He aquí un
ejemplo de una posible solución a ello.

Guardamos como siempre.

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

45
[Link] con C#

<html xmlns=”[Link]

<head>
<title>HTML vs [Link]</title>
</head>
<body>
Hola, soy HTML, ¿Tú quién eres? <br />
<% [Link] (“Hombre, ¿qué tal?, yo soy ASP.
NET <br />”); %>
HTML es mejor que [Link] <br />
<% [Link] (“No me vaciles. [Link] es mejor
que HTML <br />”); %>
HTML, HTML, HTML <br />
<% [Link] (“[Link], [Link], [Link] <br
/>”); %>
</body>
</html>

Como resultado nos debería dar la siguiente conversación entre los dos lenguajes:

Podemos observar que aunque no hemos utilizado en ningún momento la etiqueta

No es la única manera de insertar código [Link] entre código HTML. Hay otra forma
que es por medio de llamadas al código.

Es decir, el código [Link] se escribe fuera y desde el código HTML se hace una
referencia a dicho código. Vamos a guardar en .[Link] el siguiente código:

46
2: Introducción a [Link]

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
[Link] = “Yo soy el código [Link]”;
}

Y en el código .aspx lo siguiente:

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title>HTML vs [Link]</title>
</head>
<body>
Hola, soy HTML, ¿Tú quién eres? <br />
<asp:Label id = “Message” runat=”server” /> <br />
HTML es mejor que [Link] <br />
HTML, HTML, HTML <br />
</body>
</html>

47
[Link] con C#

Quedándonos como resultado lo siguiente:

En realidad esta técnica es mucho más efectiva que la primera, primero porque la
escritura de código es mucho más fácil, sobre todo cuando tenemos mucha cantidad
de código, y luego porque es bastante más eficiente.

Dentro de este ejemplo, vamos a fijarnos en la línea de código siguiente:

[Link] = “Yo soy el código [Link]”;

Vemos que usamos [Link]. El nombre “Message” debe coincidir con la id de

la etiqueta label:

<asp:Label id = “Message” runat=”server” />

48
2: Introducción a [Link]

2.3. Controles [Link]

Hasta ahora hemos visto ciertos ejemplos básicos sobre el desarrollo de páginas Web
con [Link], pero hay ciertos comandos que debemos usar. En realidad las páginas
[Link] deben seguir ciertas estructuras y un orden y como ya hemos visto en los
ejemplos la primera parte es la parte de directivas, y quizás la más importante para
saber en qué lenguaje vamos a desarrollar nuestra página y qué namespaces vamos
a usar. Hasta ahora nosotros hemos podido ver la directiva @Page y @Import, aunque
existen muchas más. Éstas son todas las posibles directivas a las que podemos llamar:

■■ @Assembly

■■ @Control

■■ @Implements

■■ @Import

■■ @Master

■■ @MasterType

■■ @OutputCache

■■ @Page

■■ @PreviousPageType

■■ @Reference

■■ @Register

□□ Todas las directivas deben ir entre <% %>. Las más importantes son las ya
vistas Page e Import. En la directiva Page definimos nuestro lenguaje a usar:
<%Page language=”c#”>. Con la directiva @Import estamos haciendo una
llamada a los namespaces que vamos a utilizar. También es posible declarar
varios namespaces, aunque no se utilicen, con la única salvedad de que
estamos consumiendo bastantes recursos en memoria y eficiencia.

□□ También es posible que dentro del código queramos escribir algún comentario.
Para ello tenemos que poner delante de la línea que queramos comentar
dos barras: //. Ahora bien, si estamos programando fuera del bloque donde
iría nuestro código en C# y queremos incluir comentarios en cualquier otra
parte del código que no queremos que sea evaluado por [Link], debemos
escribir <%- -Comentarios de una sola línea --%>.

□□ Finalmente, nos encontramos con el código HTML y con las llamadas que
hagamos al código [Link]. De hecho, para poder programar con [Link]
son necesarios algunos conocimientos HTML.

Por el otro lado en el fichero .[Link] vamos a encontrarnos varias partes bien
diferenciadas:

49
[Link] con C#

□□ Las directivas del tipo “using System…” que sirven para hacer referencias a
bibliotecas propias de [Link]. Como ya indicamos en apartados anteriores,
cada una de ellas tiene una función y las usaremos dependiendo de nuestro
cometido a la hora de programar. Son los también denominados namespaces.

□□ Posteriormente, nos encontramos con una clase dada por defecto y dentro
de ella, el método “Page_Load (object sender, EventArgs e)”, que es donde
vamos a introducir todo el código en C# que queremos que se ejecute al
cargar la página.

Dentro de una página [Link] también podemos encontrar formularios que es

una interacción del usuario con la página que envía cierta información. Si existe un
formulario en la página Web, debe incluir algún elemento tipo form.

En temas posteriores veremos también los controles de servidores Web. Éstos

son elementos como botones, cuadros o combos, los cuales también tienen sus
respectivos códigos para su creación.

50
2: Introducción a [Link]

2.4. Vinculaciones
Con [Link] podemos realizar vinculaciones a ficheros o archivos externos, por
ejemplo, a una base de datos o a un documento tipo XML o PHP. Cuando hacemos
esto tenemos que hacer alguna llamada desde el código a la ruta del fichero donde
tenemos ubicado nuestra base de datos o nuestro documento .XML. Por ejemplo,
para la conexión a una base de datos se hará de la siguiente manera:

■■ Crea un código XML en nuestro editor.

■■ Guarda el código en una carpeta PrimerASP o según la hayas llamado, como

[Link].

■■ Crea el código .aspx. en otra página del editor de texto y guárdalo como edificios.
aspx.

■■ Abre el ejemplo en el navegador web que tengas por defecto en tu equipo.

Vamos a ir detallando cada uno de los pasos anteriores.

A continuación, se muestra el código XML.

Es un código sencillo con cuatro elementos o ítems y varias características, para que
después se nos muestre en una pequeña tabla:

<?xml version=”1.0” encoding=”utf-8” ?>

<EDIFICIOS>
<ITEM>
<NOMBRE>Burj Dubai</NOMBRE>
<CIUDAD>Dubai</CIUDAD>
<PAIS>Emiratos Arabes Unidos</PAIS>
<ALTURA>828</ALTURA>
</ITEM>
<ITEM>
<NOMBRE>Taipei 101</NOMBRE>
<CIUDAD>Taipei</CIUDAD>
<PAIS>Taiwan</PAIS>
<ALTURA>509</ALTURA>
</ITEM>
<ITEM>
<NOMBRE>Torres Petronas</NOMBRE>
<CIUDAD>Kuala Lumpur</CIUDAD>
<PAIS>Malaysia</PAIS>
<ALTURA>452</ALTURA>
</ITEM>
<ITEM>
<NOMBRE>Sears Tower</NOMBRE>

51
[Link] con C#

<CIUDAD>Chicago</CIUDAD>
<PAIS>Estados Unidos</PAIS>
<ALTURA>442</ALTURA>
</ITEM>
</EDIFICIOS>

Una vez guardado nuestro código XML procedemos a escribir nuestro código ASP.
NET en el fichero .[Link]:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

Y nuestro código en HTML en el .aspx:

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]

52
2: Introducción a [Link]

<head>
<title>Edificios</title>
</head>
<body>
<asp:DataGrid id = “DataGrid1” runat=”server” />
</body>
</html>

Y como resultado en el navegador debemos obtener algo parecido a lo siguiente:

Desgranando el código [Link] vemos que en la primera línea del código HTML
definimos el lenguaje con el que queremos trabajar. En las primeras líneas del .aspx.
cs debemos importar los namespaces, que como hemos dicho anteriormente, son
bibliotecas con funciones ya definidas que nos pueden ser útiles para la realización
de nuestro proyecto. En este caso hemos definido [Link], que proporciona
el acceso a las clases [Link] que veremos más adelante. [Link], como
podemos intuir, compatibiliza Xml con nuestro código.

Luego en la línea “String xmlFilename =@”Ruta del fichero”;” es donde llamamos a

nuestro fichero XML que hemos creado antes; en nuestro caso [Link]; después
creamos una variable para en la siguiente línea poder leer el documento XML. El resto
del código sirve para adjuntar el código XML al control DataGrid. DataGrid es un
control de una lista enlazada a datos que muestra los elementos del origen de los
mismos en una tabla. Finalmente, en la parte de código HTML se hace la llamada al
código [Link] a través de la etiqueta <asp: … />.

Es muy importante tener en cuenta que a veces los lenguajes de programación no

reconocen las tildes, por eso uno de los errores más comunes es intentar introducir
las tildes directamente, aunque si conocemos el código ISO de las tildes, podemos
usarlo.

53
[Link] con C#

2.5. Diseño páginas Web [Link]

Crear una página Web no es algo trivial, no consiste en escribir un código simplemente
y nada más. Para ello debe haber un gran trabajo detrás de todo eso y no empezar
por cualquier sitio. Tenemos que tener un objetivo, saber a quién va dirigida la página,
qué contenidos queremos que tenga y sobre todo saber cómo deseamos que sea su
diseño, algo que probablemente si tenemos hecho antes de programar nos evitará
muchas horas de trabajo.

Está claro que una página Web no es solo una página a la que accedes y la ves y ya
está. Casi el 100% de las páginas a las que accedemos están compuestas de una
página principal y varios vínculos a páginas secundarias dentro de la misma. Con
[Link] se permite definir el aspecto, diseño y comportamiento que vayan a tener
las páginas secundarias de la Web. Por lo tanto, podemos decir que el primer paso
para crear una página Web es saber cuáles son los contenidos de la página principal
y cómo vamos a diseccionar la información en otras páginas secundarias.

Así de esta forma en nuestro código tendremos que indicar cuál es nuestra página
inicial. Para ello usamos la directiva @Master y, además, debemos guardar las páginas
como .master. Por lo tanto:

<%@ Master Language=”c#” %>

Ahora vamos a ver qué se hace con las páginas secundarias. Para ello creamos
tantos ficheros como páginas secundarias queramos .aspx. En todos estos ficheros
debemos incluir la siguiente directiva:

<%@ Page Language=”c#” MasterPageFile=”[Link]”

Title =”Título” %>

La principal ventaja que nos aporta la creación de páginas Web [Link] con una
jerarquía es que si queremos que haya cierto contenido que aparezca en varios sitios
o un diseño de letra y color, por ejemplo, no tenemos la necesidad de copiar y pegar
código tanto en la página principal como en la secundaria, sino que utilizando las
directivas anteriores y, además, haciendo uso de los controles Content podemos
visualizar el mismo contenido escribiendo una sola vez el código, reemplazando
únicamente lo que nos interese. Los controles Content son directivas que nos permiten
englobar cierta parte del código.

Así, en la página principal se puede definir uno o varios controles content nombrados
como ContentPlaceHolder para describir la sección que puede ser reemplazable.

<asp: contentplaceholder id=”contenido1” runat=”server” />

<asp: contentplaceholder id=”contenido2” runat=”server” />
<asp: contentplaceholder id=”contenidoN” runat=”server” />

Y en la página secundaria habría que escribir la página tal cual la queremos, pero
añadiéndole el siguiente trozo de código:

54
2: Introducción a [Link]

<asp:Content ID=”c1” ContentPlaceHolderID=”contenido1”

Runat=”Server”>
Contenido del documento.
</asp:Content>

También existe la posibilidad de encontrar páginas anidadas, que son páginas que
hacen referencia a otras y éstas a otras y así, sucesivamente en un orden jerárquico.
Es decir, que nos encontremos una página principal con el tema País, que a su vez
tiene una referencia hacia una página secundaria Comunidad, que llama a Provincia
y ésta finalmente llama a Ciudad. Esto se puede hacer de la siguiente manera: en la
página inicial o principal se define, como hemos visto antes, qué es la página Master:

<%@ Master Language=”c#” %>

Y dentro del código:

<asp:ContentPlaceHolder ID=”Pais” runat=”server” />

Luego en la página secundaria, que sería en este caso, Comunidad, debemos indicar
que viene desde la página principal y a su vez debemos señalar que también es la
página Master de otra página:

■■ <%@ Master Language=”C#” MasterPageFile=”~/[Link]”%>

■■ <asp:Content id=”C1” ContentPlaceholderID=”País”

runat=”server”>

Y dentro del código:

<asp:ContentPlaceHolder ID=”Comunidad” runat=”server” />

Así sucesivamente hasta que lleguemos al último elemento de la jerarquía en el que el

código debería ser:

<%@ Page Language=”C#” MasterPageFile=”~/Provincia.

master”%>
<asp:Content id=”CN” ContentPlaceholderID=”Provincia”
runat=”server”>

Un ejemplo claro de lo que puede ser una página de este tipo son aquellas que tienen
una cabecera común o una parte con anuncios a la derecha e izquierda y lo que se va
modificando según la página en la que estemos sería el contenido del centro:

55
[Link] con C#

Como vemos tenemos una zona de contenidos comunes que son la cabecera, el pie
de página y la zona de la derecha, dejando la zona principal de la página para mostrar
los diferentes contenidos según la página en la que estemos.

56
2: Introducción a [Link]

2.6. Web forms

Formulario Web
Es un elemento de las páginas Web que permite interactuar en cierto modo
al usuario con el servidor, en el cual el usuario introduce datos que son en-
viados a dicho servidor. Hay varios tipos de controles, como por ejemplo,
rellenar una casilla o señalar una opción entre varias o varias opciones entre
varias.

Para señalar que estamos ante un Web form utilizamos la etiqueta <form>. Esta
etiqueta puede contener varios atributos, aunque utilizaremos solo los principales,
como <form action=”direccion_url”> que define el nombre de la página
Web que va a recibir nuestro formulario o el <form method…> que a su vez tiene dos
opciones: GET y POST. Cuando usamos estas directivas lo que en realidad estamos
haciendo es enviar el formulario al servidor Web. Probemos con el siguiente ejemplo,
guardándolo como .html.

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>
<html>
<head>
<title>Datos Personales</title>
</head>
<body>
<form action=”[Link]” method=”get”>
Nombre: <input name=”TextBox” name=”text” />
<br />
<br />
Primer Apellido: <input name=”Ape1” name=”text” />
<br />
<br />
Segundo Apellido: <input name=”Ape2” name=”text” />
<br />
<br />
Lugar de Nacimiento: <input name=”Lugar” name=”text” />
<br />
<br />
<input type=”submit” value=”Aceptar” />
</form>

</body>
</html>

57
[Link] con C#

Con el siguiente resultado:

Aquí hemos programado un pequeño formulario a través del cual podemos escribir
nuestros datos. Si le damos al botón de aceptar, lógicamente nos saldrá un error
porque hemos puesto una dirección inexistente. También podemos observar como
en la caja de URL del navegador aparecen ciertos caracteres que el propio navegador
coloca al detectar en nuestro formulario espacios, texto o cualquier otro elemento
“extraño” para el mismo.

El método POST es básicamente igual al GET con la diferencia de que en la URL no

aparece la información enviada.

Ahora bien, ¿qué pasaría si creásemos la página “[Link]”? Propongamos este

código:

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”Default2” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head runat=”server”>
<title>Datos Personales</title>
</head>
<body>
<form id=”form1” runat=”server”>

58
2: Introducción a [Link]

Al darle al botón Aceptar el resultado sería el siguiente:

Es importante reseñar que aunque no estemos escribiendo ningún tipo de código el

fichero .[Link] debe de existir, porque de lo contrario encontraríamos una serie de
errores. Se puede dejar de la siguiente manera:

using System;
using [Link];
using [Link];

59
[Link] con C#

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{

En un formulario web, podemos añadir varios tipos de controles diferenciados por el

lugar donde se crean y se ejecutan, por un lado tenemos los llamados controles de
cliente o de HTML, estos controles solo son definiciones HTML sin ningún tipo de
comportamiento en servidor, los controles de servidor al contrario pueden responder
a eventos ejecutando acciones de servidor, podemos encontrarnos los mismos
controles en formato HTML y en formato Servidor, normalmente usaremos los de
servidor, a no ser que tengamos claro que no queremos ningún tipo de evento de
servidor y que se van a manejar los controles desde cliente con Javascript, JQuery o
cualquier otro lenguaje de programación en cliente, a continuación se detallan más en
profundidad estos dos tipos de controles.

2.6.1. Controles de formularios HTML

Vamos a explicar los tipos de controles que podemos encontrar en una página Web:

■■ Cajas de texto: es una caja donde el usuario introduce un texto. Se usa la

etiqueta <input> y type=”text”.

■■ Área de texto: igual que el anterior pero puede usar varias líneas. Se usa la
etiqueta <textarea>.

■■ Botones de selección única: botones para elegir una única opción. Se usa la
etiqueta <input> y en type=”radio”.

■■ Botones de selección múltiple: permite al usuario elegir varias opciones. Se usa

la etiqueta <input> y type=”checkbox”.

■■ Campo de contraseña: permite al usuario introducir su contraseña. Se usa la

etiqueta <input> y type=”password”.

■■ Lista de opciones: permite al usuario elegir una opción de una lista. Se usa la
etiqueta <select>.

60
2: Introducción a [Link]

■■ Botón de confirmación: permite al usuario enviar la información del formulario.

Se usa la etiqueta <input> y type=”submit”.

■■ Botón de reset: permite al usuario borrar el contenido del formulario antes de

que se haya enviado. Se usa la etiqueta <input> y type=”reset”.

■■ Botón normal: es un botón que sirve para confirmar una acción. Se usa la
etiqueta <input> y type=”button”.

Veamos en una página Web todos los elementos a los que hacemos referencia:

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>
<html>
<head>
<title>Datos Personales</title>
</head>
<body>
<form action=”[Link]” method=”get”>
Nombre de usuario: <input name=”TextBox” name=”text” />
<br />
<br />
Contraseña: <input type=”password” name=”TextBox”
name=”password” />
<input type=”button” value=”Confirmar” />
<br />
<br />
Comentarios: <br /> <textarea></textarea>
<br />
<br />
Botón de selección única:<br />
<input type=”radio” name=”sexo” value=”Hombre” />
Hombre<br />
<input type=”radio” name=”sexo” value=”Mujer” /> Mujer
<br />
<br />
Botón de selección múltiple: <br />
<input type=”checkbox” name=”aficiones” value=”Deporte” />
Deportes<br />
<input type=”checkbox” name=”aficiones” value=”Leer” />
Leer<br />
<input type=”checkbox” name=”aficiones” value=”Viajar” />
Viajar<br />
<input type=”checkbox” name=”aficiones” value=”Ver TV” />

61
[Link] con C#

Ver TV<br />

<input type=”checkbox” name=”aficiones” value=”Salir” />
Salir<br />
<br />
<br />
Lista de selección:
<select>
<option value=”18-30”>18 - 30 años</option>
<option value=”30-50”>30 - 50 años</option>
<option value=”50-70”>50 - 70 años</option>
<option value=”+70”>Mayor 70 años</option>
</select>
<br />
<br />
<input type=”submit” value=”Aceptar” />
<input type=”reset” value=”Reset” />
</form>

</body>
</html>

El primer elemento al que hacemos referencia es a la caja de texto donde existe el

campo nombre de usuario, luego el de contraseña y el del botón normal que serviría
para confirmar la contraseña. Posteriormente, aparece un ejemplo de área de texto
que permite escribir cualquier texto dentro de ella.

Luego los botones de selección única para elegir el sexo y los botones de selección
múltiple para elegir las aficiones. Finalmente, aparece una lista de selección para elegir
el rango de edad y un botón para enviar la información al servidor Web y otro para
resetear la información.

Éste sería el aspecto que presentaría el formulario perteneciente al código escrito:

62
2: Introducción a [Link]

2.6.2. Controles de formularios de servidor

Una vez visto cuáles son los elementos típicos de los Web forms en HTML vamos a ver
cómo serían los mismos con [Link]. En este tipo de controles siempre nos vamos
a encontrar que tienen la etiqueta ruant = ”server”, motivo por el que se caracterizan.

[Link]. Etiqueta <asp:label>

Para empezar vamos a hablar de la etiqueta principal que usa [Link], <asp:label>.
Con esta etiqueta ya decimos que vamos a trabajar con [Link] y que además
podemos añadirle ciertos atributos como el color del texto, color del fondo, anchura,
altura, etcétera. Así por ejemplo, si queremos ver las letras en cierto color, usaremos
la siguiente línea de código:

<asp:label id=”color” forecolor=”red” runat=”server”>

Nombre del color </asp:label>.

Así como para el color de la letra usamos la palabra forecolor, para el resto de atributos
de diseño se usan las siguientes:

63
[Link] con C#

■■ Backcolor: para elegir el color del fondo.

■■ Forecolor: color del texto.

■■ Height: altura en píxeles de la etiqueta.

■■ Weight: anchura de la etiqueta.

■■ Id: nombre único al elemento de la etiqueta.

Hay más atributos para el diseño, pero solo hemos nombrado los más básicos y
utilizados. Hemos de decir que una etiqueta puede tomar tantos atributos como
se desee, es decir, que para una etiqueta cualquiera le podemos dar un tamaño,
un color de fondo y uno de letra a la vez poniendo todas las directivas después de
<asp:label … atributos>.

[Link]. Etiqueta <asp:dropdownlist>

Esta etiqueta corresponde a lo que sería la lista de opciones de HTML (etiqueta
<select>).

Con este control podemos elegir un elemento de una lista desplegable y la forma en
que se utiliza es la siguiente:

<asp:dropdownlist id=”nombre de la lista” runat=”server”>.

Al igual que en la etiqueta anterior se le pueden aplicar los atributos que queramos
a esta etiqueta. Veamos un ejemplo de cómo podría trabajar DropDownList. Primero
mostramos el fichero .[Link] y posteriormente el .aspx.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
if ([Link][“list1”] != “”)
{

64
2: Introducción a [Link]

[Link] = “Has elegido la opción: “ +

[Link][“list1”];
}
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Lista Desplegable </title>
</head>
<body>
<asp:Label forecolor = “blue” id = “Message” runat
= “server” />
<br />
<form id = “Form1” runat = “server”>
Elija una opcion
<br />
<br />
<asp:DropDownList forecolor = “red” ID = “list1”
runat = “server”>
<asp:ListItem> Casado </asp:ListItem>
<asp:ListItem> Soltero </asp:ListItem>
<asp:ListItem> Divorciado </asp:ListItem>
<asp:ListItem> Viudo </asp:ListItem>
</asp:DropDownList>
<br />
<br />
<input type = “submit” />
</form>
</body>
</html>

65
[Link] con C#

Podemos observar cómo hay cambios respecto a HTML, ya que en éste se usaban
las etiquetas <option> y aquí usamos <asp:ListItem>.

[Link]. Etiqueta <asp:listbox>

Esta etiqueta es básicamente igual que la anterior, pero además tiene la opción de que
el usuario pueda elegir múltiples opciones. Para ello en la etiqueta hay que escribir lo
siguiente:

<asp:listbox id=”nombre de lista” runat=”server”

selectionmode=”multiple”>

Así de esta manera podemos poner el código de antes cambiando esta etiqueta y la
de cierre:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
if ([Link][“list1”] != “”)
{

66
2: Introducción a [Link]

[Link] = “Su deporte favorito es: “ +

[Link][“list1”];
}

}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Lista Desplegable </title>
</head>
<body>
<asp:Label forecolor = “blue” id = “Message” runat
= “server” />
<br />
<form id = “Form1” runat = “server”>
Elija su deporte favorito para practicar
<br />
<br />
<asp:listbox forecolor =
“red” ID = “list1” runat = “server” SelectionMode =
“Multiple”>
<asp:ListItem> Fútbol </asp:ListItem>
<asp:ListItem> Tenis </asp:ListItem>
<asp:ListItem> Baloncesto </asp:ListItem>
<asp:ListItem> Prefiero estar en el sofá </
asp:ListItem>
</asp:listbox>
<br />
<br />
<input type = “submit” />
</form>
</body>
</html>

67
[Link] con C#

Para poder seleccionar más de una opción hay que pulsar el botón CTRL.

[Link]. Etiqueta <asp:radiobutton>

Esta etiqueta es equivalente al Radio Button de HTML, en el que obligamos al usuario
a escoger una sola opción de entre todas las posibles. Así de esta manera podemos
usar nuestra etiqueta de la siguiente forma:

<asp:radiobutton id=”opción” runat=”server” />

Esta etiqueta habría que ponerla para cada una de las opciones que tengamos.
También existe una etiqueta que se llama radiobuttonlist que se usa de la siguiente
forma:

<asp:radiobuttonlist id=”cuestionario” runat=”server”>

<asp:listitem id=”opción” runat=”server” value=”A” />

Primero usamos una cabecera con la etiqueta radiobuttonlist y después vamos

poniendo todas las posibles opciones que haya en el formulario.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

68
2: Introducción a [Link]

using [Link];
using [Link];

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> RadioButton </title>
</head>
<body>
<asp:Label forecolor = “blue” id = “Message1”
runat = “server” /> <br />
<br />
<form id = “Form1” runat = “server”>
Elija una opcion:
<br />
<br />
<asp:radiobuttonlist forecolor = “red” ID =
“radio1” runat = “server”>
<asp:ListItem id = “opcion1” runat = “server”
Value = “Soltero” />
<asp:ListItem id = “opcion2” runat = “server”
Value = “Casado” />
<asp:ListItem id = “opcion3” runat = “server”
Value = “Divorciado” />

69
[Link] con C#

<asp:ListItem id = “opcion4” runat = “server”

Value = “Viudo” />
</asp:radiobuttonlist>
<br />
<br />
<input type = “submit” />
</form>
</body>
</html>

Y debería quedar algo así parecido a la imagen:

[Link]. Etiqueta <asp:checkbox>

Con esta etiqueta, que es equivalente a la Check Box de HTML, tenemos la opción de
elegir múltiples opciones entre varias posibles. La forma en que se usa es la siguiente:

<asp:checkbox id”eleccion” runat = ”server” />

En este caso ocurre lo mismo que con radiobutton, es decir, que existe la etiqueta
checkboxlist y se usa de la misma manera. El código es exactamente igual al de
radiobuttonlist, solamente cambiando la cabecera de la etiqueta y evidentemente el
cierre.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

70
2: Introducción a [Link]

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
string s = “Has elegido las siguientes opciones:
<br />”;

if ([Link][0].Selected) s = s + eleccion.
Items[0].Text + “<br />”;
if ([Link][1].Selected) s = s + eleccion.
Items[1].Text + “<br />”;
if ([Link][2].Selected) s = s + eleccion.
Items[2].Text + “<br />”;
if ([Link][3].Selected) s = s + eleccion.
Items[3].Text + “<br />”;
[Link] = s;

}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> CheckBox </title>
</head>
<body>
<asp:Label forecolor = “blue” id = “Message1”
runat = “server” /> <br />
<br />

71
[Link] con C#

<form id = “Form1” runat = “server”>

Elija los deportes que más le gusten:
<br />
<br />
<asp:checkboxlist forecolor = “red” ID =
“eleccion” runat = “server”>
<asp:ListItem id = “opcion1” runat = “server”
Value = “Fútbol” />
<asp:ListItem id = “opcion2” runat = “server”
Value = “Tenis” />
<asp:ListItem id = “opcion3” runat = “server”
Value = “Baloncesto” />
<asp:ListItem id = “opcion4” runat = “server”
Value = “Estar tirado en el sofá” />
</asp:checkboxlist>
<br />
<br />
<input type = “submit” />
</form>
</body>
</html>

Y el resultado debe ser el siguiente:

72
2: Introducción a [Link]

Hemos de tener en cuenta varias cosas. [Link] va a reconocer todas las opciones,
pero siempre va a empezar a contar a partir de 0. Así la opción 1 que nosotros
tengamos, para que sea reconocida tendremos que codificarla en la recepción de
datos con el índice 0. Como se puede observar, hay que escribir al principio del
código tantos Ítems como número de opciones tengamos para que el servidor pueda
reconocerlos todos.

[Link]. Etiqueta <asp:textbox>

La etiqueta TextBox es equivalente a la caja de texto en HTML (text), pero además es
capaz de hacer las funciones del área de texto (textarea) y de contraseña (password).
Para ello se utilizan ciertos atributos dentro de la etiqueta principal:

<asp:textbox id=”texto” runat=”server” atributos

restantes>

Los posibles atributos que podemos usar para esta etiqueta son textmode y habría
que darle valor “multiline” si queremos que sea un área de texto y además, si queremos
designarle un número concreto de líneas, lo haremos con el atributo rows al que le
tendríamos que dar el valor que quisiéramos que tuviese (rows solo funciona, si se ha
declarado un área de texto multilínea). Si también queremos que tenga un número
concreto de columnas, habría que escribir columns, actúa como rows. Textmode
también puede tomar como valor password para que actúe como contraseña, es
decir, ocultando los caracteres por asteriscos. Veamos un ejemplo:

73
[Link] con C#

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

74
2: Introducción a [Link]

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Textos </title>
</head>
<body>
<asp:Label forecolor = “blue” id = “nombre1” runat =
“server” />
<br />
<asp:Label forecolor = “blue” id = “apellidos1” runat =
“server” />
<br />
<asp:Label forecolor = “blue” id = “amigos1” runat =
“server” />
<br />
<asp:Label forecolor = “blue” id = “passwd1” runat =
“server” />
<br />
<form id = “Form1” runat = “server”>
¿Cómo se llama?
<br />
<br />
<asp:textbox ID = “nombre” runat = “server”></asp:textbox>
<br />
<br />
¿Cuáles son sus apellidos?
<br />
<br />
<asp:textbox ID = “apellidos” runat = “server”></
asp:textbox>
<br />
<br />
¿Quiénes son sus amigos?
<br />
<br />
<asp:TextBox id = “amigos” runat = “server” TextMode =
“MultiLine” Rows = “5”></asp:TextBox>
<br />

75
[Link] con C#

<br />
Dígame una contraseña. Ponla difícil
<br />
<br />
<asp:TextBox id = “passwd” runat = “server” TextMode =
“password”></asp:TextBox>
<br />
<br />
<input type = “submit” />
</form>
</body>
</html>

[Link]. Controles ocultos

Existen otro tipo de controles para formularios denominados controles ocultos. Son
controles que no están visibles para el usuario y que pueden tener cierta utilidad. No
tiene etiqueta propia, sino que se usa de la siguiente forma:

<input name=”campo oculto” type=”hidden” value=”texto que

se oculta”>

Una posible aplicación para el siguiente control sería la siguiente:

76
2: Introducción a [Link]

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control Oculto </title>
</head>
<body>
<asp:Label forecolor = “blue” id = “Message1”

77
[Link] con C#

runat = “server” /> <br />

<asp:Label forecolor = “blue” id = “Message2”
runat = “server” /> <br />
<br />
<form id = “Form1” runat = “server”>
¿Quién es la actual campeona del mundo de fútbol?
<asp:TextBox ID = “respuestauser” runat = “server”
/>
<br />
<input name = “respuesta” type = “hidden” value =
“España” />
<br />
<input type = “submit” value = “Respuesta
Correcta” />
</form>
</body>
</html>

Y el resultado que obtenemos al escribir este código es éste:

Finalmente, vamos a ver un ejemplo donde se combinan todos los controles anteriores,
pero además usando una llamada a otro fichero para ver las respuestas.

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]

78
2: Introducción a [Link]

<head id=”Head1” runat = “server”>

<title>Formulario completo</title>
</head>
<body>
<form id = “Form1” action = “[Link]” method =
“post” runat = “server”>
Bienvenidos a Raianair, su compañía de muy muy muy
bajo coste (o no tanto).
<br />
<br />
Introduzca su nombre y apellidos:
<br />
Nombre: <asp:TextBox ID = “nombre” runat = “server” />
<br />
Apellidos: <asp:TextBox ID = “apellidos” runat =
“server” />
<br />
<br />
Ciudad origen:
<asp:DropDownList ID = “origen” runat = “server”>
<asp:ListItem Value = “Barcelona” />
<asp:ListItem Value = “Bilbao” />
<asp:ListItem Value = “Madrid” />
<asp:ListItem Value = “Sevilla” />
<asp:ListItem Value = “Valencia” />
<asp:ListItem Value = “Zaragoza” />
</asp:DropDownList>
Ciudad destino:
<asp:DropDownList ID = “destino” runat = “server”>
<asp:ListItem Value = “Barcelona” />
<asp:ListItem Value = “Bilbao” />
<asp:ListItem Value = “Madrid” />
<asp:ListItem Value = “Sevilla” />
<asp:ListItem Value = “Valencia” />
<asp:ListItem Value = “Zaragoza” />
</asp:DropDownList>
<br />
<br />
Tipo de viaje:
<asp:RadioButtonList ID = “viaje” runat = “server”>
<asp:ListItem Value = “Ida” />
<asp:ListItem Value = “Ida y Vuelta” />
</asp:RadioButtonList>
<br />

79
[Link] con C#

Descuentos aplicables:
<br />
<asp:ListBox ID = “descuentos” SelectionMode =
“Multiple” runat = “server”>
<asp:ListItem Value = “Residente Canarias” />
<asp:ListItem Value = “Jubilado” />
<asp:ListItem Value = “Familia numerosa” />
<asp:ListItem Value = “Descuentos por puntos” />
</asp:ListBox>
<br />
<br />
Observaciones: <br />
<asp:TextBox ID = “observaciones” Rows = “3” TextMode
= “MultiLine” runat = “server” />
<br />
<input type = “submit” value = “Confirmar” />
<input type = “reset” value = “Cancelar” />
</form>
</body>
</html>

Rellenando los campos nos daría algo parecido a esto:

80
2: Introducción a [Link]

Ahora bien, ¿qué ocurre si pulsamos el botón de confirmar? Si miramos al principio del
código tenemos la siguiente línea:

<form action = “[Link]” method = “post” runat =

“server”>

que nos indica que el servidor nos va a redireccionar a la página [Link] que la
tenemos que crear, y cuyo código será el siguiente:

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”Default2” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head runat=”server”>
<title>Confirmación reserva</title>

81
[Link] con C#

</head>
<body>
<form id = “form1” runat = “server”>
<div>
<% [Link](“<b>Nombre:</b> “ + Request.
Form[“nombre”] + “<br />”);%>
<% [Link](“<b>Apellidos:</b> “ + Request.
Form[“apellidos”] + “<br />”);%>
<% [Link](“<b>Salida:</b> “ + Request.
Form[“origen”] + “<br />”);%>
<% [Link](“<b>Llegada:</b> “ + Request.
Form[“destino”] + “<br />”);%>
<% [Link](“<b>Tipo de viaje:</b> “ +
[Link][“viaje”] + “<br />”);%>
<% [Link](“<b>Descuentos:</b> “ + Request.
Form[“descuentos”] + “<br />”);%>
<% [Link](“<b>Observaciones:</b> “ +
[Link][“observaciones”] + “<br />”);%>
<br />
<input type = “submit” value = “Confirmar
definitivamente” />
<br />
Gracias por confiar en nosotros. Desde Raianair les
deseamos un feliz viaje.

</div>
</form>
</body>
</html>

Es muy importante que creemos los dos ficheros en la misma carpeta para que el
servidor no se líe. En otro caso, tendremos que poner la ruta del fichero entera o a
través de su ruta relativa de la forma /../[Link] o ~/../[Link].

Lo que ocurre al darle al botón confirmar del código anterior es que nos lleva a esta
página y nos debería mostrar una Web así:

82
2: Introducción a [Link]

Si para el diseño de páginas Web estamos usando el Visual Studio, puede

ser que tengamos problemas a la hora de ejecutar la página. En ese caso
debemos abrir el fichero “[Link]” y dentro de la etiqueta <pages>
hay que añadirle la siguiente cadena: enableViewStateMac=”false”
porque si no es muy probable que tengamos algún problema a la hora de
llamar a la página “[Link]”.
Hay que reseñar que si le damos al botón de “Confirmar definitivamente”
no va a ocurrir nada, puesto que no está redireccionado a ningún sitio.

Y con este ejemplo finalizamos la unidad en la que hemos aprendido a usar formularios
y el funcionamiento de [Link].

83
2: Introducción a [Link]

RESUMEN
■
El .NET Framework se compone del MSIL, CLR, .NET Framework Class Libraries y de
distintos lenguajes de programación que son soportados por dicha tecnología.

■
Dentro de un programa con código HTML y [Link] va a interpretar primero el ASP.
NET, puesto que lo que primero hace es buscar el código en C#.

■
Para leer en el orden que queramos el código e intercalar código HTML con [Link]
podemos usar ciertas directivas como [Link].

■
Cuando estemos creando una página [Link] al principio del código debemos indicar
el lenguaje en el que se va a escribir y declarar las directivas y los namespaces que nos
van a ser útiles.

■
Para realizar páginas Web probablemente tengamos que usar recursos externos a
nuestro código, por lo que necesitaremos saber dónde están los recursos y hacer la
llamada a éstos correctamente.

■
Para poder realizar páginas principales y secundarias que dependan de la principal
debemos utilizar la directiva @Master y los controles Content y ContentPlaceHolder.

■
En los formularios existen varios tipos de controles según los datos que necesitemos.
Los más importantes son las cajas de texto, las áreas de texto, campo contraseña,
botones de selección única, botones de selección múltiple, lista de opciones, botón de
confirmación, botón de reset y botón normal.

■
En [Link] tenemos muchas etiquetas, indicamos algunas de ellas: <asp:textbox>
para cajas de texto, áreas de texto y campo contraseña, <asp:checkbox> para
los botones de selección múltiple, <asp:listbox > para selección única o múltiple de
opciones de un menú desplegable, <asp: dropdownlist> para selección única
de un menú desplegable, <asp:radiobutton> para elegir una opción de entre las
posibles. Además, disponemos de un control para campos ocultos que hay que indicar
con la palabra “hidden”.

■
Los controles en HTML y [Link] son prácticamente los mismos con la salvedad
de que en [Link] tenemos interactividad con el código servidor gracias al runat =
“Server”, cosa que no se puede hacer con HTML.

85
3
[Link] con C#
3
DIDÁCTICA
UNIDAD

3. Introducción a C#
3: Introducción a C#

ÍNDICE
ÍNDICE............................................................................................................................................................................ 89
OBJETIVOS.................................................................................................................................................................. 91
INTRODUCCIÓN......................................................................................................................................................... 92
3.1. Introducción a C#.................................................................................................................................................. 93
3.2. Elementos básicos en la POO............................................................................................................................... 94
3.2.1. Objeto................................................................................................................................................................. 94
3.2.2. Interfaz................................................................................................................................................................ 94
3.2.3. Clases................................................................................................................................................................. 96
3.2.4. Herencia.............................................................................................................................................................. 98
3.2.5. Hola mundo......................................................................................................................................................... 98
3.3. Elementos básicos en C#..................................................................................................................................... 99
3.3.1. Palabras clave....................................................................................................................................................... 99
3.3.2. Tipos de datos...................................................................................................................................................... 99
3.3.3. Variables, constantes y enumerados....................................................................................................................... 104
3.3.4. Operadores........................................................................................................................................................ 106
3.4. Estructuras de control......................................................................................................................................... 111
3.4.1. Estructuras de salto............................................................................................................................................. 111
3.4.2. Estructuras de bucles........................................................................................................................................... 115
3.5. Cadenas............................................................................................................................................................... 118
3.6. Estándar de codificación de C#.......................................................................................................................... 119
3.6.1. Reglas generales................................................................................................................................................. 119
3.6.2. Regiones........................................................................................................................................................... 120
3.6.3. Declaraciones..................................................................................................................................................... 120
3.6.4. Encapsulación variable miembro–propiedades en clases........................................................................................... 121
3.6.5. Inicializaciones.................................................................................................................................................... 121
3.6.6. Sentencias......................................................................................................................................................... 121
3.6.7. Estilos de mayúsculas.......................................................................................................................................... 124
3.6.8. Distinción de mayúsculas y minúsculas................................................................................................................... 124
3.6.9. Abreviaturas....................................................................................................................................................... 125
3.6.10. Elección de palabras.......................................................................................................................................... 126
3.6.11. Evitar confusión de nombres de tipos................................................................................................................... 129
3.6.12. Instrucciones de nomenclatura de spacename....................................................................................................... 130
3.6.13. Instrucciones de nomenclatura de clases.............................................................................................................. 131
3.6.14. Instrucciones de nomenclatura de interfaces.......................................................................................................... 132
3.6.15. Instrucciones de nomenclatura de parámetros....................................................................................................... 132
3.6.16. Instrucciones de nomenclatura de métodos........................................................................................................... 133
3.6.17. Instrucciones de nomenclatura de propiedades...................................................................................................... 134
3.6.18. Instrucciones de nomenclatura de eventos............................................................................................................ 135

89
[Link] con C#

3.6.19. Comentarios..................................................................................................................................................... 136

3.6.20. Comentarios de implementación.......................................................................................................................... 137
3.7. Ejemplo................................................................................................................................................................ 143
RESUMEN................................................................................................................................................................... 149

90
3: Introducción a C#

OBJETIVOS
■ Aprender conceptos básicos de C#.

■ Conocer sobre la programación orientada a objetos y sus principales términos.

■ Saber los tipos que podemos usar en C#.

■ Conocer los operadores en C#.

■ Conocer los tipos de estructuras de control que podemos hallar en C#.

■ Aprender a usar cada una de las estructuras en C#.

■ Saber cómo implementar un programa en C# y [Link].

91
[Link] con C#

INTRODUCCIÓN

Uno de los aspectos más importantes de la informática queremos realizar una aplicación Web, utilizaremos
son los lenguajes de programación. Podemos definir un lenguaje adecuado como HTML, XML o PHP.
un lenguaje de programación como un idioma que Si queremos hacer alguna aplicación para nuestro
habla un ordenador, de hecho, gracias a determinadas ordenador, utilizaremos JAVA o C++. Existen lenguajes
herramientas los ordenadores pueden llegar a entender orientados a objetos, para programación funcional o
casi todos los lenguajes. De esta forma una persona le para dispositivos móviles.
habla al ordenador con un lenguaje de programación El lenguaje que nosotros vamos a utilizar es C#, que
y éste lo interpreta y nos muestra el resultado de esa es un lenguaje propio de Microsoft orientado a objetos
interpretación de una forma mucho más entendible. y que tiene cierto parecido a C o C++, puesto que
Existen muchos lenguajes de programación y son predecesores suyos. Aparte de la tecnología ASP.
cada día más, porque también están apareciendo NET, C# puede ser usado para la programación de
progresivamente más dispositivos electrónicos que otros tipos de aplicaciones, así como para distintos
soportan lenguajes de programación, en algunos dispositivos móviles. De hecho, hoy en día .NET es
casos, casi exclusivos para ese dispositivo. Según el una de las tecnologías más usadas para la creación
tipo de aplicación que queramos realizar utilizaremos de aplicaciones para los distintos tipos de dispositivos
un lenguaje de programación u otro. Por ejemplo, si que nos podemos encontrar en el mercado.

92
3: Introducción a C#

3.1. Introducción a C#
C# es un lenguaje orientado a objetos, desarrollado por Microsoft para poder ser
usado para la plataforma .NET. Este lenguaje es resultado de la evolución que ha
tenido C a lo largo del tiempo. Primero fue el lenguaje C y posteriormente C++ para
que finalmente apareciera C#. En realidad C es un lenguaje que nació como evolución
del lenguaje anterior B y está orientado a la implementación de UNIX, un sistema
operativo.

Como dijimos en temas anteriores, C# es parte del Common Language Runtime

(CLR), de hecho es el más importante y por eso pretende ser el lenguaje base de la
plataforma .NET. Además, este lenguaje fue expresamente creado para ser utilizado
en .NET, así que para ello se tuvo que hacer una migración de código de las bibliotecas
anteriores al lenguaje nuevo, C#.

Como hemos dicho C# es la evolución de C y C++, pero éste simplifica muchas de las
complejidades que tenían sus predecesores. Además, con este lenguaje se admiten
métodos y tipos genéricos que permiten mayor eficacia y rendimiento. También se
pueden utilizar los iteradores que sirven para recorrer listas de manera eficiente. Este
lenguaje, además, permite el desarrollo de aplicaciones software de manera sencilla
gracias a ciertas características.

C# también dispone de interoperabilidad que sirve para interactuar con elementos

externos como elementos básicos de la arquitectura de nuestro sistema operativo.

Para finalizar, hay algunos aspectos que debemos tener en cuenta:

■■ C# no soporta la herencia múltiple, es decir, una clase Discman no puede heredar

de la clase ReproductorMúsica y de una clase DispositivoElectrónico a la vez.

■■ .NET dispone de un recolector de basura que elimina aquellos elementos que no

son instanciados para ahorrar memoria, además de los que estén instanciados
y no son usados.

■■ El manejo de errores se hace a través del manejo de excepciones.

93
[Link] con C#

3.2. Elementos básicos en la POO

Hemos nombrado varias veces lenguaje de programación orientado a objetos, pero,
¿a qué nos referimos como programación orientada a objetos? Un lenguaje de POO
es aquél que cumple con ciertos conceptos como son los objetos, interfaz, herencia
y clases.

3.2.1. Objeto
Un objeto es una instancia de una clase que realiza tareas de un programa en tiempo
de ejecución, puesto que tienen cierta información y capacidades necesarias para
solventar dichas tareas. Por lo tanto, podemos definir a un objeto como un ente que
tiene un comportamiento y un estado. Cuando nos referimos a estado de un objeto
estamos hablando de las propiedades que definen al objeto. Por ejemplo, supongamos
que nos referimos al registro de una persona en una base de datos. La persona dentro
de la base de datos sería un objeto y los valores de sus propiedades, tales como
nombre, apellidos, edad, NIF… conformarían lo que es el estado de la persona. Cuando
hablamos de comportamiento estamos refiriéndonos a lo que se ofrece a través de
los métodos. Estos métodos pueden ser consultores o modificadores del estado de
los objetos y sirven para comunicarse con el exterior. Por ejemplo, si tomamos el
objeto persona anterior y queremos modificar el domicilio de una persona, estaremos
utilizando algún método definido como modificador para realizar los cambios sobre el
objeto persona.

Dentro de la definición de objeto no podemos pasar por alto el término encapsulación,

que se refiere a la ocultación de la forma en que se almacenan los atributos que
determinan el estado del objeto que estemos estudiando. De esta forma la interacción
con los atributos se tiene que hacer a través de ciertos métodos implementados para
ese asunto. A la hora de programar se decide qué es lo que debe ser visible para el
usuario y qué debe ser privado. Si por ejemplo vamos a unos grandes almacenes y
queremos comprar con nuestra tarjeta de crédito un ordenador que cuesta 1000 euros,
y al pasar la tarjeta al dependiente le aparece un aviso diciendo que el cliente no tiene
suficiente dinero para hacer dicha compra, nosotros que somos los programadores
podemos decidir ocultar la información sobre la cantidad de la que dispone un cliente.
En realidad, esa información está ahí, aunque no pueda ser visible para el dependiente
y además, se utiliza para calcular la cantidad de dinero restante que le quedaría al
cliente después de hacer la compra. Éste sería un típico caso de encapsulación.

Como resumen podemos decir que un objeto es un tipo que contiene unos atributos
que definen sus características y unos métodos para acceder a sus atributos e
implementar su comportamiento.

3.2.2. Interfaz
Genéricamente hablando, una interfaz es un punto de interacción entre distintos
componentes, que sirve de anclaje para éstos y que comprende todos los campos en
común entre ellos.

94
3: Introducción a C#

Éste es uno de los elementos fundamentales de la programación orientada a objetos

(POO), que se encarga de establecer qué se puede hacer con un objeto de determinada
clase, pero sin importarle cómo lo hace. Una interfaz contiene los nombres y la
signatura de los métodos que nos permiten consultar y modificar los atributos de los
objetos. Cada interfaz tiene un contrato, que es un comportamiento que deben tener
los objetos de una clase que implementen ese contrato de manera obligatoria.

Es aconsejable seguir unos pasos para la creación de una interfaz:

■■ Establecer las propiedades que debe tener cada contrato.

■■ Indicar los tipos de las propiedades y ver si es consultable o modificable.
■■ Escribir los métodos get y set.
■■ Escribir el resto de métodos.
Supongamos que tenemos una interfaz televisor con varias propiedades como volumen,
brillo, contraste, etcétera. Elegimos las propiedades que pueden ser modificables por
el usuario. Todas las características anteriores son modificables, entonces nuestro
código quedaría de la siguiente forma:

using System;
using [Link];
using [Link];
using [Link];

interface ITelevisor
{
int Volumen
{
get;
set;
}
int Brillo
{
get;
set;
}
int Contraste
{
get;
set;
}
}

//Definición de otros métodos

//Definición de las clases
//Definición de la clase principal

95
[Link] con C#

Con el método “get” se recoge el valor de cada uno de los atributos y con el “set” se
pueden modificar.

3.2.3. Clases
Gracias a las clases podemos definir el estado interno de un objeto, a través de
sus atributos, definir la forma en la que se crean los objetos mediante los métodos
constructores y calcular sus propiedades a partir de los atributos del objeto. Las
clases en C# permiten herencia (más adelante veremos su definición). Según el nivel
de acceso que le queramos imponer a las clases existen ciertos comportamientos que
debemos aplicarle a las mismas. Existen las siguientes palabras:

■■ Public: si definimos una clase como public estamos dándole apenas restricción
y cualquiera puede crear objetos a partir de esta clase.

■■ Private: es un modificador del nivel más restrictivo. Los miembros privados solo
son accesibles desde el cuerpo de la clase o desde la estructura en la que se
declaran.

■■ Protected: una clase que es protected, solo es accesible desde su clase y sus
derivadas.

■■ Internal: en una clase internal, los tipos o miembros internos solo son accesibles
dentro de los archivos del mismo ensamblado.

Podemos declarar una clase de la siguiente manera:

public class Televisor

{
//Métodos, propiedades...
}

También podemos crear objetos a partir de la clase de la siguiente forma:

TelevisorHD obj = new Televisor();

TelevisorLCD obj2 = new Televisor();

De esta forma estamos creando objetos de tipo Televisor con las propiedades de esa
clase.

Para el ejemplo anterior del televisor podemos seguirlo con el siguiente código:

class Televisor : ITelevisor

{
private int vol;
private int bril;
private int cont;
//Definimos los constructores
public Televisor(int volumen, int brillo, int
contraste)

96
3: Introducción a C#

{
vol = volumen;
bril = brillo;
cont = contraste;
}
public int Volumen
{
get
{
return vol;
}

set
{
vol = value;
}
}
public int Brillo
{
get
{
return bril;
}
set
{
bril = value;
}
}
public int Contraste
{
get
{
return cont;
}
set
{
cont = value;
}
}
}

Para poder evaluar el comportamiento que realizan los objetos deberíamos programarlo
justo antes de la última llave.

97
[Link] con C#

3.2.4. Herencia
Éste es uno de los elementos más útiles a la hora de programar. Podemos definirlo
como una propiedad padre-hijo donde todas las propiedades que tenga el padre
también las va a tener automáticamente el hijo. La principal función de la herencia
es que la clase hija pueda tomar las propiedades del padre y además, añadirle las
suyas propias para especializarse. Supongamos que tenemos una clase reproductor
de música con las características volumen, avance, retroceso, stop y play. Ésta sería
la clase padre, y la clase hija pues podría ser Walkman, Discman, MP3, MP4 o IPod.
Cada una de estas clases hijas hereda todas las características de la clase padre,
pero además cada una de ellas puede adquirir ciertos comportamientos nuevos. Por
ejemplo, tomamos la clase hija Discman y aparte de las características que tiene le
podemos añadir la característica tipo de soporte, avance rápido, retroceso rápido, etc.

public class Discman : ReproductorMusica

{
//Todas las características de Reproductor de música
//más las características de Discman.
}

Ésta sería la forma de declararlo. Evidentemente, previamente habremos tenido que

definir la clase ReproductorMúsica.

Para la programación de páginas WEB las clases heredarían siempre de [Link].

[Link].

3.2.5. Hola mundo

Cuando se empieza a programar, el primer contacto con el lenguaje que se hace es la
aplicación “Hola Mundo”. En C# sería de esta forma:

public partial class HolaMundo : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
[Link](“Hola Mundo”);
}
}

Así de esta forma hemos escrito nuestro primer programa en C#. Explicando un poco
este programa vemos que se ha definido primero la clase, que como no, se llama
HolaMundo. Posteriormente se ha definido la clase principal del programa que es la
sección donde van las acciones que queremos que haga nuestro programa.

También podemos observar que se hace uso de llaves. Estas llaves sirven para delimitar
una zona de código, donde queremos que pasen ciertas cosas. Es muy importante
el uso de las llaves y tener controlado cuándo abren y cuándo cierran, porque de lo
contrario estaremos peleándonos continuamente con el código y el compilador nos
mostrará mensajes de error relacionados con una cantidad de llaves no balanceadas.

98
3: Introducción a C#

3.3. Elementos básicos en C#

Como en cada lenguaje de programación existen ciertos patrones que se deben de
cumplir. Podríamos decir que en casi el 100% de los lenguajes orientados a objetos
aparecen una serie de elementos básicos necesarios para la programación como la
existencia de palabras clave, bucles, sentencias condicionales o recorrido de listas.
C# no iba a ser menos y, por supuesto, también cuenta con esta serie de elementos.

3.3.1. Palabras clave

Las palabras clave son identificadores con un significado especial para el compilador y
cuentan con un valor predefinido. Estas palabras han de ser usadas en determinados
contextos y con especial cuidado.

abstract, as, base, bool, break, by, byte, case, catch, char, checked, class, const,
continue, decimal, default, delegate, do, double, descending, explicit, event, extern,
else, enum, false, finally, fixed, float, for, foreach, from, goto, group, if, implicit, in, int,
interface, internal, into, is, lock, long, new, null, namespace, object, operator, out,
override, orderby, params, private, protected, public, readonly, ref, return, switch,
struct, sbyte, sealed, short, sizeof, stackalloc, static, string, select, this, throw, true,
try, typeof, uint, ulong, unchecked, unsafe, ushort, using, var, virtual, volatile, void,
while, where, yield.

3.3.2. Tipos de datos

Los tipos de datos son la base de la mayoría de los lenguajes de programación. Este
término es más que importante a la hora de escribir un programa, puesto que todas las
variables y constantes se ajustan a un tipo. Pero, ¿qué es un tipo? Un tipo es el lugar
donde se guarda cierta información sobre los valores que puede tomar un objeto. Con
esto se quiere decir que cuando definimos un objeto con sus propiedades debemos
asociarle una serie de tipos a cada una de esas propiedades. Por ejemplo, si estamos
creando un objeto “coche” y queremos definir el número de ruedas lo haremos como
un entero, es decir, que los únicos valores que puede tomar la característica “ruedas”
serán números enteros.

Es muy importante el hecho de que existan los tipos para que la programación del
código sea clara y ordenada. De hecho, cada vez que estemos realizando cualquier
tipo de operación el compilador comprueba si se está utilizando el tipo correcto o no
para ser compiladas o en caso contrario mostrarnos un error.

Aquí vamos a explicar los tipos más importantes:

■■ Tipo entero.

■■ Tipo double.

■■ Tipo booleano.

■■ Tipo char.

99
[Link] con C#

■■ Tipo string.

■■ Tipo array.

■■ Conversión de tipos.

[Link]. Tipo entero

Un tipo entero es aquél que solo toma números enteros como era de esperar. Puede
tomar valores desde -2147483648 hasta 2147483647. En la plataforma .NET se
define como System.Int32 y cuando lo queramos declarar en el código se hará de la
siguiente manera:

class Coche
{
public static void Main()
{
int ruedas = 4;
int asientos = 5;
int puertas;
puertas = 3;
}
}

Existen otros tipos que se podrían englobar en los enteros, pero tienen otras
características. Los tipos byte y sbyte definen también tipos enteros, pero sólo puede
tomar valores entre 0 y 255 para byte y entre -128 y 127 para sbyte. En .NET se
definen como [Link] y [Link]. En el código se utilizarían de la misma
manera que int. Después tenemos los tipos short y ushort. Los valores que pueden
tomar son desde -32768 hasta 32767 para los short y desde 0 hasta 65535 para
ushort. En .NET vendrían dados por System.Int16 y System.UInt16 respectivamente.
Además, tenemos el tipo uint que es la versión de int, pero solo para números
positivos, pues puede tomar los valores que van desde 0 hasta 4294967295.
Finalmente, tenemos los tipos long y ulong que pueden tomar valores que van desde
-9223372036854775808 hasta 9223372036854.775807 para el caso de long y
desde 0 hasta 18446744073709551615 para ulong. Para .NET serían System.Int64
y System.Uint64.

A modo de resumen podemos decir que los tipos que van con la U delante quieren
decir que son tipos unsigned, es decir, sin signo y por eso solo toman valores positivos.
Los valores que toma cada tipo son la potencia de dos de cada uno de ellos. Por
ejemplo, sabemos que un byte son 8 bits, así que los valores que puede tomar son
hasta 2^8 -1, los que puede tomar short son como mucho 2^16 -1, y así con int y
long que pueden tomar hasta 2^32 -1 y 2^64 -1. Todos estos tipos se declaran de la
misma manera que el tipo int.

100
3: Introducción a C#

[Link]. Tipo double

Este tipo es de los más usados a la hora de hacer operaciones matemáticas con
decimales, y es denominado también tipo en coma flotante. Toma los valores
aproximadamente desde ±5.0E-324 hasta ±1.7E308 con 7 cifras significativas. Para
.NET se define como [Link] y en el código sería de la siguiente forma:

class Coche
{
public static void Main()
{
double deposito = 60.3234;
double velocidadMax;
velocidadMax = 190.275;
}
}

Además del tipo double, existen otros dos tipos muy similares que son el tipo float y
el tipo decimal, pero estos dos con mucha menos precisión que double. Para float
tendríamos en .NET lo siguiente: [Link] con valores que pueden estar entre
±1.5E-45 y ±3.4E38 aproximadamente con 7 cifras significativas y para decimal
tendríamos [Link] y con unos valores aproximados entre ±1.0E-28 y
±7.9E28 con 28 o 29 cifras significativas.

[Link]. Tipo booleano

Un tipo booleano es el que solo puede tomar dos valores: verdadero y falso. Se utiliza
normalmente en expresiones condicionales para ver si un elemento cumple ciertas
características o no. Para la plataforma .NET se define como [Link] y en el
código sería así:

class Coche
{
public static void Main()
{
bool todoterreno = false;
bool descapotable;
descapotable = true;
}
}

Los posibles valores que pueden tomar los booleanos son true y false.

101
[Link] con C#

[Link]. Tipo char

Con este tipo estamos definiendo el tipo carácter que sirve para almacenar un carácter
en formato simple. Puede tomar cualquier valor en formato “Unicode” y está definido
en la plataforma .NET como [Link] y se puede usar de la siguiente manera:

class Coche
{
public static void Main()
{
char tipoVehiculo = ‘A’;
}
}

[Link]. Tipo string

Éste es el tipo cadena y sirve para mostrar una secuencia de caracteres. Vienen
definidos por la palabra reservada string y su forma de uso sería la siguiente:

class Coche
{
public static void Main()
{
string marca = “Seat”;
string modelo = “Pandita”;
string motor;
motor = “diesel”;
}
}

[Link]. Tipo array

Un array es la sucesión de varios elementos del mismo tipo y puede mostrar el resultado
como un vector de manera unidimensional. Los arrays pueden ser de cualquier tipo.
Por ejemplo, podemos poner una serie de caracteres por separado que si los juntamos
en el array montamos una cadena.

using System;

class Vector
{
public static void Main()
{
string[] arr = new string[4];
arr[0] = “H”;
arr[1] = “o”;

102
3: Introducción a C#

arr[2] = “l”;
arr[3] = “a”;
[Link](arr[0] + arr[1] + arr[2] + arr[3]);
}
}

También podemos declarar los arrays de la siguiente manera.

string[] arr = { “H”, “o”, “l”, “a” };

[Link](arr[0] + arr[1] + arr[2] + arr[3]);

Además también podemos declarar los arrays en forma de vector bidimensional. Para
ello se puede hacer de la siguiente manera:

int[,] arr = new int[2, 2];

arr[0, 0] = 1;
arr[1, 0] = 2;
arr[0, 1] = 3;
arr[1, 1] = 4;

Tenemos que tener en cuenta que en C# los ínidices empiezan en 0, así que si estamos
formando una matriz, debemos estar atentos a este detalle.

[Link]. Conversión de tipos

A veces nos podemos encontrar en el caso de que queramos que cualquiera de
nuestros tipos en algún caso concreto actúe como otro tipo. Por ejemplo, si estamos
usando un tipo entero para saber cuál es la autonomía del coche y otro entero para
ver la capacidad del depósito y queremos ver la cantidad de litros que gasta cada
100 kilómetros de tipo double, tendremos que hacer una conversión de tipos. Así
tendremos que decir qué depósito o autonomía deben actuar como un double. De
esta forma nuestra solución sería 12,5 litros cada 100 kilómetros. Si no hubiéramos
hecho el casting a depósito, nos hubiera salido un mensaje de error.

class Coche
{
public static void Main()
{
int autonomia = 600;
int deposito = 75;
double litros100km = ((double) deposito /
autonomia) * 100;
[Link](“{0}!”, litros100km);
}
}

103
[Link] con C#

Tenemos que tener mucho cuidado con las conversiones que queramos realizar, pues
no todas están disponibles. Por ejemplo, no podemos convertir ningún tipo con signo
a alguno sin signo. Un ejemplo de una conversión de tipo podría ser el siguiente:

int var1 = (int) var2;

Para hacer la conversión de tipos también disponemos de Parse y TryParse. Con

estos métodos se consigue hacer una conversión de tipos a entero. La única diferencia
entre ellos es que Parse lanza una excepción y TryParse no la lanza. Para el Parse
podríamos tener el siguiente código:

int i;
try
{
i = [Link]([Link]);
}
catch (FormatException)
{
i = 0;
}
catch (OverflowException)
{
i = 0;
}

En el TryParse sería el siguiente:

int i;
if ([Link]([Link], out i) == false)
{
i = 0;
}

3.3.3. Variables, constantes y enumerados

Una variable es el nombre que le damos al espacio donde reservamos la información
de los tipos. Las variables pueden llevar cualquier nombre que queramos exceptuando
los nombres de las palabras reservadas. Existen variables locales y globales, pero
tenemos que tener mucho cuidado cuando se usan. Las variables locales son aquellas
que se declaran dentro de una función y solo pueden ser usadas dentro de la misma.
Las globales son las que se declaran fuera de todas las funciones y pueden ser usadas
en cualquiera de ellas. En este sentido es donde debemos tener cuidado. Si, por
ejemplo, tenemos 50 funciones distintas y declaramos una variable global que solo
va a ser usada en una función, no es eficiente y además, gasta muchísimos recursos,
sería mejor definirla como variable local en la función que se use. Distinto es el caso
si esta variable va a ser usada en 40 funciones distintas. Sería mucho más eficiente
declararla como variable global en vez de declararla en cada función donde vaya a ser
usada.

104
3: Introducción a C#

class Coche
{
//ZONA DE VARIABLES GLOBALES
private int capacidad;
private int autonomia;
private int velMax;

void Autopista()
{
velMax = 120;
}
void Ciudad()
{
velMax = 50;

public static void Main()

{
capacidad = 60;
autonomia = 1000;
[Link](capacidad);
[Link](autonomia);
double consumo = ((double)capacidad / autonomia)
* 100;
[Link](consumo);

}
}

En este ejemplo podemos ver que existen variables locales y variables globales. En
este caso solo tenemos una variable local que es “consumo” y se usa en el main, y
luego tenemos varias variables globales como capacidad, autonomía y velMax. Como
vemos, es posible declarar las variables de varias formas. Las más comunes son las
siguientes:

private int velMax;

velMax = 120;

private int velMax = 120;

Otro tipo de declaración de variables serían las de tipo NULL y se interpretarían de la

siguiente forma:

int? velMax = null;

105
[Link] con C#

Las declaraciones anteriores son exactamente iguales.

Otro de los términos que se usan son las constantes. Una constante es un atributo
que no va a cambiar de valor a lo largo de la ejecución del programa, por eso se le da
un valor al principio de éste y que va a llevar hasta el final.

Por ejemplo, si queremos usar el número PI en varias operaciones matemáticas,

probablemente la mejor elección será declarar una constante con su valor y usarlo
cuando lo necesitemos.

const double PI = 3.141592;

Finalmente, están los enumerados. Estos tipos sirven para darle un conjunto de
valores concretos a las variables. Si por ejemplo, estamos implementando un juego
“Parchís”, lo ideal es crear un tipo enum con los valores rojo, amarillo, verde y azul.

class Parchis
{
enum turno
{
rojo,
amarillo,
verde,
azul,
}

public static void Main()

{
turno jugador1 = [Link];
turno jugador2 = [Link];
turno jugador3 = [Link];
turno jugador4 = [Link];

}
}

A partir de este código se pueden empezar a implementar muchas más funciones y

operaciones.

3.3.4. Operadores
Los operadores son símbolos que llevan asignados una operación predefinida sobre
los operandos para que genere un resultado.

Los operadores pueden ser: de asignación, aritméticos, de comparación y lógicos.

106
3: Introducción a C#

[Link]. Operadores de asignación

Los operadores de asignación son aquellos que sirven para asignar valores a las
variables. Aquí tenemos varios ejemplos de asignación:

a = 2;
b = 3;
c = a + b;
d = c + 6;

Además, tenemos varios tipos más de asignación. Por ejemplo, si queremos usar la
misma variable expresamente para hallar otro valor, se puede hacer de las siguientes
formas:

var1 = 4;
var1 = var1 + 4;

var1 += 4;

var2 = 5;
var2 = var2 + 1;

var2++;

var3 = 5;
var3 = var3 - 3;

var3 -= 3;

var4 = 9;
var4 = var4 - 1;

var4--;

Aquí hemos visto varios ejemplos de cómo se pueden hacer las asignaciones. Por
ejemplo, en var1 se puede hacer la suma de esas dos formas y para var3 igual. Si lo
que queremos es ir sumando o restando de uno en uno, se pueden hacer de las dos
formas que aparecen para var2 y var4 respectivamente.

Además de las asignaciones para sumar y restar, existen también las asignaciones
con el operando * para multiplicar y / para dividir y se usan exactamente de la misma
manera que las anteriores, pero teniendo en cuenta que es absurdo tener un operador
var**, ya que no tiene sentido multiplicar esa variable por 1, al igual que tampoco
tendría sentido dividirla por 1. De esta forma solo tenemos para multiplicar y dividir:

var *= 10;
var /= 10;

107
[Link] con C#

[Link]. Operadores aritméticos

Los operadores aritméticos son aquellos que nos permiten realizar operaciones
matemáticas sencillas como sumar, restar, multiplicar, dividir, hacer el módulo y poner
a negativo. Aquí tenemos un ejemplo de cómo usarlos:

using System;

class OpAritmeticos
{
public static void Main()
{
int a = 10 + 5;
int b = 10 - 5;
int c = 10 * 5;
int d = 10 / 5;
int e = 10 % 5;
int f = -10 + 5;
[Link](“ a = {0}\n b = {1}\n c = {2}\n d
= {3}\n e = {4}\n f = {5}\n”, a, b, c, d, e, f);
}
}

El módulo nos devuelve el resto de una división.

Es muy importante saber que si no usamos paréntesis entre las operaciones que
hagamos, tendremos que conocer cuáles son las reglas de precedencia entre los
operadores. Por norma general se sigue el siguiente orden:

■■ ++, --, - (negativo);

■■ *, /, %

■■ +, -

■■ =, +=, -=, *=, /=;

[Link]. Operadores de comparación

Los operadores de comparación son aquellos que al comparar dos elementos nos
devuelve un tipo boolean. Aquí tenemos los siguientes ejemplos:

int a = 1;
int b = 2;

bool comp;
comp = (a == b); //IGUAL
comp = (a != b); //DISTINTO

108
3: Introducción a C#

comp = (a <= b); //A MENOR O IGUAL QUE B

comp = (a >= b); //A MAYOR O IGUAL QUE B
comp = (a < b); //A MENOR ESTRICTO QUE B
comp = (a > b); //A MAYOR ESTRICTO QUE B

La primera de ellas sirve para comparar si dos elementos son iguales. No confundir con
el operador de asignación que solo lleva un símbolo = y éste lleva dos. En el segundo
caso se compara si son distintos los dos elementos y el resto de comparaciones son
claras. En todas ellas, las respuestas van a ser o bien true o bien false.

[Link]. Operadores lógicos

Son los del tipo y, o, no y se utilizan para ver si se cumple una condición y otra, o para
ver si se cumple una condición u otra. Para ello se utilizan los siguientes símbolos:

using System;

class OpLogicos
{
public static void Main()
{
int a = 1;
int b = 2;
int c = 3;

if ((a >= b) && (b <= c))

{
[Link](“a es mayor que b y b es menor
que c\n”);
}
if ((a >= b) || (b <= c))
{
[Link](“a es mayor que b o b es menor
que c\n”);
}

if (!(a < b))

{
[Link](“a no es menor que b\n”);
}
}
}

Podemos ver que para ver si se cumplen las dos condiciones usamos &&, para ver si
se cumple una u otra ||, y para ver si una condición no se cumple usaremos !. Es decir,
podemos decir que && significa Y, || significa O, y ! significa NO.

109
[Link] con C#

Además, existen otros dos operadores lógicos que son muy parecidos a los anteriores
como son & y |, con la diferencia que estos últimos hacen las comparaciones a nivel
de bits.

110
3: Introducción a C#

3.4. Estructuras de control

Las estructuras de control son algo normal en los lenguajes de programación y su
función principal es dotar al código de un orden y ver qué funciones se ejecutan
primero y cuáles se ejecutan después. Es extremadamente importante el orden
en el que se van ejecutando las instrucciones porque de lo contrario obtendremos
resultados inesperados.

Dependiendo de lo que queramos ejecutar y cómo queramos hacerlo utilizaremos

un tipo de estructura u otro. Podemos enumerar dos tipos de estructuras de control:
estructuras de salto() y estructuras de bucles.

3.4.1. Estructuras de salto

Las estructuras de salto son aquellas en las que se puede pasar de una sentencia a
otra saltando el código. Por ejemplo, si estamos ejecutando una instrucción que nos
diga que si se cumple cierta condición se saltará a otra función o si sigue con su curso
normal. Existen dos tipos de salto, los condicionales y los incondicionales.

[Link]. Saltos incondicionales

Son aquellos que saltan a una instrucción sin necesidad de que cumplan ninguna
condición. Puede ocurrir cuando en la ejecución del código se encuentra con una
llamada a otro método o cuando se encuentra con alguna palabra reservada de llamada
como break, continue, return o throw. Un ejemplo de uso de saltos incondicionales
puede ser el siguiente:

class Saltos
{
static void Main()
{
[Link](“De momento voy por mi línea”);
SaltoIncondicional();
[Link](“Vuelvo del salto
incondicional”);
}

static void SaltoIncondicional()

{
[Link](“Aquí se está produciendo un
salto incondicional”);
}
}

111
[Link] con C#

[Link]. Saltos condicionales

Como se puede intuir, un salto condicional es el que se produce cuando se cumple
alguna condición. Dentro de estos saltos quizá el más interesante es la estructura if-
else.

if (condicion)
{
//Ejecución de las instrucciones si se cumplen
}
else
{
//Ejecución de las instrucciones si no se
cumplen
}

En esta estructura lo primero que se hace es comprobar si se cumplen las condiciones.

Si se cumplen, se ejecutan las primeras instrucciones y se sale del if. Si no se cumplen
las condiciones, se entra en el else y se ejecutan sus instrucciones. Puede darse el
caso de que tengamos más de una condición y más de un else. Es decir, que si no
entra en uno, busca en el siguiente y si no en el siguiente y así sucesivamente. Un
ejemplo puede ser el siguiente:

using System;

class SaltoCondicional
{
public static void Main()
{
double numero;

[Link](“¿Qué nota has sacado en ASP.

NET?”);
numero = [Link]([Link]());

if (numero < 5)
{
[Link](“SUSPENSO. Tienes que
mejorar”);
}
else if (numero >= 5 && numero < 7)
{
[Link](“APROBADO. Bueno, todavía se
puede mejorar más”);
}

112
3: Introducción a C#

else if (numero >= 7 && numero < 9)

{
[Link](“NOTABLE. La cosa marcha. Queda
poco para el Sobresaliente”);
}
else if (numero >= 9 && numero <= 10)
{
[Link](“SOBRESALIENTE. Perfecto, eres
mi ídolo”);
}
else (numero > 10)
{
[Link](“Creo que me estás engañando.
Esa nota no existe”);
}
}
}

El funcionamiento es exactamente el mismo en ambos casos con la salvedad de

que en este segundo ejemplo tenemos más casos de estudio. Tenemos que tener
en cuenta que en el segundo ejemplo, si estamos en el último caso no es necesario
poner if porque ya no hay más posibilidades donde se pueda entrar. Es decir, si ya ha
pasado por todas las anteriores y no ha entrado en ninguna, por obligación tiene que
entrar en la última.

En C# está permitida la anidación de bucles if. Esto quiere decir que si se cumple una
condición se entra en la ejecución y una vez aquí es posible que nos encontremos otra
instrucción if para que cumpla otra condición.

public static void Main()

{
if (condicion1)
{
//Ejecución de instrucciones
if (condicion2)
{
//Ejecución de instrucciones
}
}
}

113
[Link] con C#

También existe otra instrucción muy similar al else-if que es el switch. Con esta
instrucción se ejecuta solo la parte que nos interese. Se utiliza la palabra reservada
switch para leer lo que se escribe y luego las palabras case y break. Con case se
evalúa la opción y si coincide con la elegida pues se entra y cuando se ejecuten las
instrucciones necesarias se saldrá con break y no se ejecutará ninguna opción más.
Si no coincide con ninguna de las opciones, se usa la palabra reservada default, se
ejecutan sus instrucciones y se sale. Un ejemplo de uso de este tipo de estructuras
podría ser el que vemos a continuación:

using System;
class InstruccionSwitch
{
public static void Main()
{
string s;

[Link](“Pulse cualquiera de estos signos

y a ver qué pasa con el 10 y el 20”);
[Link](“ + - * /”);

s = [Link]();

switch (s)
{
case “+”:
[Link](“El resultado de sumar 10
y 20 es {0}”, 10 + 20);
break;
case “-”:
[Link](“El resultado de restar 10
y 20 es {0}”, 10 - 20);
break;
case “*”:
[Link](“El resultado de
multiplicar 10 y 20 es {0}”, 10 * 20);
break;
case “/”:
[Link](“El resultado de dividir 20
entre 10 es {0}”, 20 / 10);
break;
default:
[Link](“No te entiendo”);
break;
}
}
}

114
3: Introducción a C#

3.4.2. Estructuras de bucles

Los bucles son estructuras de control que hacen que una determinada operación se
repita un número de veces dependiendo de la condición. Existen principalmente estos
tipos de bucles, for, while, el do-while, break-continue y foreach.

[Link]. Bucle for

El bucle for es una estructura que hace que la operación se repita un número
predeterminado de veces. Su definición podría ser la siguiente:

for (valor inicio; expresión; iterador)

Esto quiere decir que el bucle for toma un valor de inicio, la expresión nos indica hasta
dónde se debe ejecutar empezando a contar desde el valor de inicio y, el iterador nos
indica qué es lo que se debe hacer después de ejecutar cada paso del bucle.

Vamos a ver un ejemplo:

using System;

class BucleFor
{
public static void Main()
{
for (int cont = 0; cont < 10; cont++)
{
[Link](“Esta es la línea número {0}”,
cont);
}
}
}

Como podemos observar el contador empieza en 0, queremos que se ejecute siempre

que el contador sea menor que 10 y que cada vez que haga una operación aumente
el contador en una unidad. La ejecución de este programa nos daría como resultado
“Esta es la línea número 0, esta es la línea número 1…”, y así hasta 9. Es interesante
el uso de este bucle cuando tengamos un número grande de iteraciones.

Aquí se ha podido ver otra forma de declarar una variable. En el bucle for, al inicializar
debemos también declararla. Además, otra opción es la posibilidad de anidación de
bucles for.

[Link]. Bucle while

El bucle while es aquél en el que el número de ejecuciones no depende
exactamente de las iteraciones que se haga, sino que su ejecución dependerá
de una condición. Veamos un ejemplo para entenderlo mejor:

115
[Link] con C#

class BucleWhile
{
public static void Main()
{
int cont = 1;
while (cont < 5)
{
[Link](“Esta es la línea número {0}”,
cont);
cont = cont + 1;
}
}
}

En este caso la instrucción while se va a ejecutar siempre que el contador sea menor
que 5. En el momento en el que el contador sea mayor ya no se entra más en el bucle.
Es importante saber que se debe poner alguna acción para que se realice dentro del
bucle y para que se vaya modificando el contador porque de lo contrario entraremos
en un bucle infinito y el programa nos dará un error.

[Link]. Bucle do-while

El bucle do-while es una estructura similar a la del while con la diferencia de que
primero se ejecutan las instrucciones y después las condiciones:

class DoWhile
{
public static void Main()
{
int cont = 0;
do
{
[Link](“Esta es la línea {0}”, cont);
cont++;
}
while (cont != 5);
}
}

Como vemos, primero se empiezan a realizar las acciones y se empiezan a escribir

las líneas que hemos declarado y, posteriormente, se comprueba si el contador ha
superado ya las 5 iteraciones.

116
3: Introducción a C#

[Link]. Bucle break-continue

A veces queremos que dentro del bucle haya ciertos valores que no queremos que
se ejecuten. Por ejemplo, tenemos un bucle for que queremos que itere durante 10
veces. Pero por ejemplo, hay valores que no queremos que aparezcan como el 2, el 4
y el 6, para ello se utiliza la siguiente estructura:

class ContinueBreak
{
public static void Main()
{
for (int cont = 0; cont < 10; cont++)
{
if (cont == 2)
continue;
if (cont == 4)
continue;
if (cont == 6)
continue;
if (cont == 9)
break;
[Link](“Se está ejecutando{0} \n”,
cont);
}
}
}

El resultado de la ejecución es: “Se está ejecutando 0, se está ejecutando 1, se está

ejecutando 3, se está ejecutando 5, se está ejecutando 7, se está ejecutando 8” , ya
en la ejecución del 9 decidimos que salga y esa instrucción no se ejecuta.

[Link]. Bucle foreach

El bucle foreach es un tipo de bucle cuya única función es repetir un bloque de código
para cada elemento de una colección:

foreach (int x in collection)

{
[Link](x);
}

117
[Link] con C#

3.5. Cadenas
Las cadenas no son más que el texto que queremos que se muestre. Como se ha
podido observar, hemos estado utilizando continuamente la siguiente sentencia:
“[Link] (“Texto a mostrar”)”. En realidad ésta es la instrucción que se
debe ejecutar cada vez que queramos que en nuestro programa aparezca un
texto. Otro tipo de sentencia que podríamos usar es la ya vista en la unidad anterior
“[Link]”, en la que “identificadorNuestro” es el nombre de la id
que le demos en la etiqueta label.

En puntos anteriores vimos algunos operadores de comparación. Para los textos

se pueden usar solo para comparar si dos cadenas son iguales o si dos cadenas
son distintas. En el caso de que queramos comparar si una cadena es más grande
que otra o más pequeña, no se pueden usar los operadores de comparación vistos
anteriormente.

También es posible la concatenación de cadenas. Para ello se debe utilizar la siguiente

estructura:

class Concatenacion
{
public static void Main()
{
string concat = “España” + “campeona” + “del” +
“mundo”;
[Link](concat);
}
}

Esto nos mostrará toda la cadena seguida “Españacampeonadelmundo”. Si queremos

que aparezcan espacios debemos escribir lo siguiente:

string concat = “España” +” “+ “campeona” +” “+ “del” +” “+

“mundo”;

118
3: Introducción a C#

3.6. Estándar de codificación de C#

Para desarrollar aplicaciones que sean fácilmente mantenibles, y con que tengan
código eficaz, existen directivas y estándares de programación.

En este punto se desarrollan los estándares para mjoers practicas de programación

en C#.

3.6.1. Reglas generales

Para la programación en C# usaremos unas reglas generales. Son las siguientes:

■■ Un tipo por archivo. Los archivos fuente contendrán un único tipo. El nombre del
archivo será el mismo que el usado en la declaración del tipo.

■■ Ordenación del código. El orden de código en cada archivo será el siguiente:

□□ Cláusulas using, sin indentación.

□□ Cláusula namespace, sin indentación.

□□ Declaración de clase, interfaz, enumeración u otro tipo.

■■ Indentación. Se debe usar indentación en el código, utilizando para ello el

tabulador, nunca la barra espaciadora. La tabulación debe ser de 4 caracteres.

■■ Tamaño de las líneas. Se procurará que el tamaño de las líneas se encuentre

entre 80 y 120 caracteres, con el objetivo de evitar el uso del scroll para visualizar
la totalidad.

■■ Densidad horizontal. Rodear los operadores de asignación con espacios en

blanco (para acentuar su presencia y facilitar su lectura). No colocar espacios en
blanco entre los nombres de funciones o métodos y la apertura de paréntesis.
Se deben poner espacios en blanco tras las comas de las listas de parámetros
tanto en la llamada como en la declaración de métodos y funciones.

■■ Ajuste de línea. Cuando una expresión no quepa en una sola línea, se procurará
dividir de acuerdo a los siguientes criterios:

□□ Nueva línea después de una coma.

□□ Nueva línea después de un operador aritmético.

□□ Buscar operadores con la prioridad más alta.

□□ Si es posible, procurar no “cortar” en medio de un paréntesis que englobe una

operación matemática. Esto hace menos legible el código.

■■ Densidad vertical. Implica asociación, ahí donde las líneas de código tienen
mucha relación entre ellas, deben mostrar un alto grado de densidad vertical. Se
debe rodear con una línea en blanco cada bloque de código. Bloques de código
pueden ser un bloque de declaraciones using, la declaración de un espacio de
nombres, un método, una función, etc.

119
[Link] con C#

3.6.2. Regiones
Visual [Link] ha introducido una forma de anidar y nombrar, un conjunto de
instrucciones, funciones o declaraciones. Esto se realiza usando el juego de directivas
#region y #endregion. Al anidar un conjunto de sentencias dentro de estas directivas,
el ide de .NET nos permite contraer y expandir estas sentencias mediante el uso del
ratón.

■■ Las etiquetas de regiones deben de indentarse al mismo nivel que el código que
engloban.

■■ Se deberá construir, como mínimo, la siguiente jerarquía básica de regiones en

una clase:

□□ Estado

●● Constantes

●● Variables miembro

●● Propiedades

□□ Comportamiento

●● Constructores

●● Métodos privados

●● Métodos públicos

●● Métodos estáticos (privados y públicos)

●● Eventos

■■ Si bien este recurso es útil para clarificar y hacer más manejable el código
fuente, el abuso puede generar un código poco práctico, en el que sea costoso
encontrar el código que se busca. Así pues, se aconseja no excederse en el uso
de regiones.

3.6.3. Declaraciones
Cuando se codifican clases, interfaces u otros tipos con C#, seguiremos las siguientes
reglas:

■■ La llave de apertura debe aparecer en la línea siguiente a la declaración.

■■ La llave de clausura debe aparecer en una nueva línea, a partir del último carácter
compilable de la definición de la clase o interfaz.

120
3: Introducción a C#

3.6.4. Encapsulación variable miembro–propiedades en clases

Todos los datos expuestos de una clase deben ser encapsulados en un par variable
miembro-propiedad de la siguiente forma:

01. public class Part

02. {
03. //Variable miembro
04. private string name;
05.
06. //Propiedad
07. public string Name
08. {
09. get
10. {
11. return name;
12. }
13. set
14. {
15. name = value;
16. }
17. }
18. }

La variable miembro siempre debe ser privada (o protegida), mientras que se puede
jugar con la visibilidad general de la propiedad y de sus cláusulas get y set para
exponer adecuadamente los datos.

3.6.5. Inicializaciones
Inicializar las variables locales lo antes posible, de ser posible en la propia declaración.

3.6.6. Sentencias
Las instrucciones condicionales son instrucciones que permiten ejecutar bloques de
instrucciones sólo si se da una determinada condición.

En los siguientes subapartados de este punto se describen cuáles son las instrucciones
condicionales y iterativas disponibles en C#.

■■ Sentencias simples: cada línea debe contener una sola sentencia.

01. id = customerList[i].ID;

■■ Sentencias if/then/else: el formato de las sentencias debe ser el siguiente:

01. //Ejemplo 1

121
[Link] con C#

02. if (condición)
03. {
04. //Acciones
05. }
06.
07. //Ejemplo 2
08. if (condición)
09. {
10. //Acciones
11. }
12. else
13. {
14. //Acciones
15. }
16.
17. //Ejemplo 3
18. if (condición)
19. {
20. //Acciones
21. }
22. else if (condición)
23. {
24. //Acciones
25. }
26. else
27. {
28. //Acciones
29. }

■■ Sentencias for/foreach: el formato de las sentencias debe ser el siguiente:

01. for (int i = 0; i < 10; i++)

02. {
03. //Acciones
04. }
05.
06. foreach (int i int ListaDeEnteros)
07. {
08. //Acciones
09. }

■■ Sentencias while/do-while: el formato de las sentencias debe ser el siguiente:

01. while (condición)

02. {

122
3: Introducción a C#

03. //Acciones
04. }
05.
06. do
07. {
08. //Acciones
09. }
10. while (condición)

■■ Sentencias switch: la sentencia switch debe seguir el siguiente patrón:

01. switch (condición)

02. {
03. case A:
04. //Acciones
05. break;
06. case B:
07. //Acciones
08. break;
09. default:
10. //Acciones
11. break;
12. }

■■ Sentencias try/catch: la sentencia try/catch, de captura de excepciones, debe

tener uno de estos dos formatos:

01. //Formato 1
02. try
03. {
04. //Acciones que pueden causar una excepción.
05. }
06. catch
07. {
08. //Acciones que se realizarán al capturar la
excepción.
09. }
10.
11.
12. //Formato 2
13. try
14. {
15. //Acciones que pueden causar una excepción.
16. }
17. catch

123
[Link] con C#

18. {
19. //Acciones que se realizarán al capturar la
excepción.
20. }
21. finally
22. {
23. //Acciones que se realizarán siempre, haya o no
excepción.
24. }

3.6.7. Estilos de mayúsculas

Utiliza las tres convenciones siguientes para poner en mayúsculas los identificadores.

■■ Mayúsculas y minúsculas Pascal: la primera letra del identificador y la primera

letra de las siguientes palabras concatenadas están en mayúsculas. El estilo de
mayúsculas y minúsculas Pascal se puede utilizar en identificadores de tres o
más caracteres. Por ejemplo: BackColor

■■ Mayúsculas y minúsculas Camel: la primera letra del identificador está en

minúscula y la primera letra de las siguientes palabras concatenadas en
mayúscula. Por ejemplo: backColor.

■■ Mayúsculas: todas las letras del identificador van en mayúsculas. Utilice esta
convención solo para identificadores que estén formados por dos o menos
letras. Por ejemplo:

01. [Link]
02. [Link]

Además, puede que sea necesario utilizar mayúsculas en los identificadores para
mantener la compatibilidad con esquemas existentes de símbolos no administrados,
donde los caracteres en mayúsculas se utilizan con frecuencia en valores de
constantes y enumeraciones. En general, estos símbolos no deben ser visibles fuera
del ensamblado en el que se utilizan.

3.6.8. Distinción de mayúsculas y minúsculas

Para evitar confusiones y garantizar la interoperación entre lenguajes, hay que seguir
estas reglas con respecto a la distinción entre mayúsculas y minúsculas.

■■ No utilices nombres que requieran distinción entre mayúsculas y minúsculas. Los

componentes se deben poder utilizar en los lenguajes que distinguen, y en los
que no distinguen, entre mayúsculas y minúsculas. Los lenguajes que no hacen
esta distinción no pueden diferenciar, dentro del mismo contexto, dos nombres
que difieren sólo en el uso de mayúsculas y minúsculas. Por consiguiente, se
debe evitar esta situación en los componentes o clases creados.

124
3: Introducción a C#

■■ No debes crear dos espacios de nombres con nombres que difieran solo en las
mayúsculas y minúsculas. Por ejemplo, un lenguaje que no haga distinción entre
mayúsculas y minúsculas no distingue entre las dos declaraciones siguientes de
espacio de nombres.

namespace [Link];
namespace [Link];

■■ No debes crear una función con nombres de parámetros que difieran solo en las
mayúsculas y minúsculas. El siguiente ejemplo es incorrecto.

void MyFunction(string a, string A)

■■ No crees un espacio de nombres con nombres de tipos que difieran solo en

las mayúsculas y minúsculas. En el siguiente ejemplo, Point p y POINT p son
nombres de tipo incorrectos, ya que difieren solo en el uso de las mayúsculas y
minúsculas.

[Link] p

■■ No debes crear un tipo con nombres de propiedades que difieran solo en las
mayúsculas y minúsculas. En el siguiente ejemplo, int Color y int COLOR son
nombres de propiedades incorrectos, ya que difieren solo en el uso de las
mayúsculas y minúsculas.

int Color {get, set}

int COLOR {get, set}

■■ No debes crear un tipo con nombres de métodos que difieran solo en las
mayúsculas y minúsculas. En el siguiente ejemplo, calculate y Calculate son
nombres de métodos incorrectos, ya que difieren solo en el uso de las mayúsculas
y minúsculas.

void calculate()
void Calculate()

3.6.9. Abreviaturas
Para evitar confusiones y garantizar la interoperación entre lenguajes, sigue estas
reglas con respecto a la utilización de abreviaturas.

■■ No utilices abreviaturas ni contracciones como parte de nombres de

identificadores. Por ejemplo, utiliza GetWindow en vez de GetWin.

■■ No utilices acrónimos que no estén aceptados en el campo de la informática.

■■ Si es necesario, utiliza acrónimos conocidos para reemplazar nombres en frases

largas. Por ejemplo, utiliza UI para interfaz de usuario y OLAP para procesamiento
analítico en línea.

125
[Link] con C#

■■ Cuando utilices acrónimos, utiliza el estilo de mayúsculas y minúsculas Pascal o

Camel en acrónimos de más de dos caracteres. Por ejemplo, usa HtmlButton o
htmlButton. Sin embargo, deberás utilizar mayúsculas en acrónimos que tengan
solo dos caracteres, por ejemplo [Link] en vez de [Link].

■■ No utilices abreviaturas en nombres de identificadores o parámetros. Si tienes que

utilizar abreviaturas, utiliza las mayúsculas y minúsculas Camel en abreviaturas
de dos o más caracteres, aunque esto contradiga la abreviatura estándar de la
palabra.

3.6.10. Elección de palabras

Sigue estas reglas para elegir palabras como nombres de los elementos de código
(variables, clases, métodos, funciones, etc.).

Todos los elementos de código serán nombrados en inglés.

Usa nombres de variables que revelen la intención o significado de las mismas.

01. //Nombre de variable incorrectamente seleccionado

02. int d; // elapsed time in days
03.
04. //Nombres de variable correctamente seccionados, no es
necesario poner un comentario que clarifique su significado
05. int elapsedTimeInDays;
06. int daysSinceCreation;
07. int daysSinceModification;
08. int fileAgeInDays;

■■ Evita usar nombres de clase que dupliquen a los namespaces del .NET
Framework usados comúnmente. Por ejemplo, no uses los siguientes nombres
de clase: System, Collections, Forms o UI. Visita el listado de namespaces del
BCL para comprobarlo.

■■ Evita nombres que provoquen desinformación: Por ejemplo, el uso de la L

minúscula o la O mayúscula, que se confunden con el 1 y el 0 respectivamente.

■■ Haz distinciones con sentido. Cuando se usa un mismo nombre para referirse
a dos cosas distintas en un mismo ámbito de variables, se puede estar tentado
de cambiar uno de ellos de una forma arbitraria, como por ejemplo, añadir un
número al final de la palabra:

01. //MAL!!
02. public static void CopyChars(char[] a1, char[] a2)
03. {
04. for (int i = 0; i < [Link]; i++)
05. {
06. a2[i] = a1[i];
07. }

126
3: Introducción a C#

08. }
09.
10. //BIEN!!
11. public static void CopyChars(char[] inputData,
char[] outputData)
12. {
13. for (int i = 0; i < [Link]; i++)
14. {
15. outputData[i] = inputData[i];
16. }
17. }

■■ Usa nombres pronunciables: El cerebro humano recuerda y maneja mejor

palabras que puede pronunciar vocalmente (sí, aunque sea en inglés, pueden
ser pronunciables).

01. //MAL!!
02. class DtaRcrd102
03. {
04. private Date genymdhms;
05. private Date modymdhms;
06. private String pszqint = “102”;
07. }
08.
09. //BIEN!!
10. class Customer
11. {
12. private Date generationTimestamp;
13. private Date modificationTimestamp;
14. private String recordId = “102”;
15. }

■■ Usa nombres fáciles de buscar. Los nombres de una sola letra y las constantes
numéricas son un problema a la hora de localizarlas en un código. Estos dos
elementos solo deberían ser utilizados en un contexto muy localizado de código,
por el contrario, si una variable se va a usar múltiples veces en el código, éstas
deben tener nombres fáciles de buscar.

01. //Ejemplo
02. int realDaysPerIdealDay = 4;
03. const int WORK_DAYS_PER_WEEK = 5;
04. int sum = 0;
05. for (int j = 0; j < NUMBER_OF_TASKS; j++)
06. {
07. int realTaskDays = taskEstimate[j] *
realDaysPerIdealDay;

127
[Link] con C#

08. int realTaskWeeks = (realdays / WORK_DAYS_PER_

WEEK);
09. sum += realTaskWeeks;
10. }

■■ No uses notación húngara que ya no tiene sentido con el uso de herramientas

de desarrollo actuales.

■■ No uses prefijos en las variables miembro para distinguirlas de sus

correspondientes propiedades:

01. //MAL!!
02. public class Part
03. {
04. private String m_Name; // Nombre del artículo
05.
06. public String Name
07. {
08. get { return m_Name; }
09. set { m_Name = value; }
10. }
11. }
12.
13. //BIEN!!
14. public class Part
15. {
16. private String name;
17.
18. /// <summary>
19. /// Nombre del artículo
20. /// </summary>
21. public String Name
22. {
23. get { return name; }
24. set { name = value; }
25. }
26. }

■■ Además, evita usar identificadores que entren en conflicto con las siguientes
keywords o palabras reservadas:

AddHandler AddressOf Alias And Ansi As Assembly Auto Base Boolean ByRef
Byte ByVal Call Case Catch CBool CByte CChar CDate CDec CDbl Char CInt
Class CLng CObj Const CShort CSng CStr CType Date Decimal Declare Default
Delegate Dim Do Double Each Else ElseIf End Enum Erase Error Event Exit
ExternalSource False Finalize Finally Float For Friend Function Get GetType Goto

128
3: Introducción a C#

Handles If Implements Imports In Inherits Integer Interface Is Let Lib Like Long
Loop Me Mod Module MustInherit MustOverride MyBase MyClass Namespace
New Next Not Nothing NotInheritable NotOverridable Object On Option Optional
Or Overloads Overridable Overrides ParamArray Preserve Private Property
Protected Public RaiseEvent ReadOnly ReDim Region REM RemoveHandler
Resume Return Select Set Shadows Shared Short Single Static Step Stop String
Structure Sub SyncLock Then Throw To True Try TypeOf Unicode Until volatile
When While With WithEvents WriteOnly Xor eval extends instanceof package var

3.6.11. Evitar confusión de nombres de tipos

Los distintos lenguajes de programación utilizan términos diferentes para identificar los
tipos administrados básicos. Los diseñadores de bibliotecas de clases deben evitar
utilizar terminología específica del lenguaje. Sigue las reglas que se describen en esta
sección para evitar la confusión de nombres de tipos.

■■ Utiliza nombres que describan el significado del tipo, en vez de nombres que
describan el tipo.

■■ En el caso poco frecuente de que un parámetro no tenga ningún otro significado

semántico aparte del significado del tipo, utiliza un nombre genérico. Por
ejemplo, una clase que admite la escritura de diversidad de tipos de datos en
una secuencia puede tener los métodos siguientes.

01. void Write(double value);

02. void Write(float value);
03. void Write(long value);
04. void Write(int value);
05. void Write(short value);

■■ No crees nombres de métodos con terminología específica del lenguaje, como

se muestra en el siguiente ejemplo.

void Write(double doubleValue);

void Write(float floatValue);
void Write(long longValue);
void Write(int intValue);
void Write(short shortValue);

■■ En el caso excepcional de que sea necesario crear un método con un nombre

único para cada tipo básico de datos, utiliza nombres de tipos universales

129
[Link] con C#

3.6.12. Instrucciones de nomenclatura de spacename

En las reglas siguientes se describen las instrucciones de nomenclatura de spacename:

■■ Por regla general, en los espacios de nombres se utiliza el nombre de la compañía

seguido del nombre de la tecnología y, opcionalmente, la característica y el
diseño como se muestra a continuación:

01. [Link][.Feature][.Design]
Por ejemplo:
01. [Link]
02. [Link]

■■ Al incluir un prefijo en los nombres de espacios de nombres que contengan el

nombre de una compañía o marca de reconocido prestigio, se evita la posibilidad
de publicar dos espacios de nombres que tengan el mismo nombre.

Por ejemplo, [Link] es un prefijo adecuado para las clases de

automatización de Office que proporciona Microsoft.

■■ Utiliza un nombre de tecnología reconocida y estable en el segundo nivel de un

nombre jerárquico.

■■ Utiliza una jerarquía organizativa como base para la jerarquía de espacios de

nombres. Asigna un nombre a un espacio de nombres que contenga los tipos
que proporcionan funcionalidades en tiempo de diseño para un espacio de
nombres base con el sufijo .Design.

Por ejemplo, el Espacio de nombres [Link] contiene

las clases de diseñador y clases relacionadas para diseñar aplicaciones basadas
en [Link].

■■ Un espacio de nombres anidado debe tener una dependencia en los tipos del
espacio de nombres contenedor.

Por ejemplo, las clases de [Link] dependen de las clases de

[Link]. No obstante, las clases de [Link] no dependen de las
clases en [Link].

■■ En los espacios de nombres, se debe utilizar el estilo de Mayúsculas y minúsculas

Pascal y separar los componentes lógicos con puntos, como en Microsoft.
[Link].

■■ Si la marca utilizada no emplea la regla de mayúsculas y minúsculas tradicional,

sigue el sistema que utiliza la marca, aunque no siga la regla Pascal.

Por ejemplo, los espacios de nombres [Link] y [Link]

muestran las variaciones correctas de utilización de mayúsculas y minúsculas
con respecto a la regla Pascal.

130
3: Introducción a C#

■■ No utilices el mismo nombre para un espacio de nombres y para una clase. Por
ejemplo, no proporciones un espacio de nombres Debug y una clase Debug.

■■ Por último, ten en cuenta que el nombre de un espacio de nombres no tiene que
ser análogo al nombre del ensamblado.

Por ejemplo, si asignas el nombre [Link] a un

ensamblado, no es necesario que contenga un espacio de nombres MyCompany.
MyTechnology.

3.6.13. Instrucciones de nomenclatura de clases

En las reglas siguientes se describen las instrucciones de nomenclatura de clases:

■■ Utiliza un sustantivo o un sintagma nominal para asignar un nombre a una clase.

■■ Utiliza el estilo de Mayúsculas y minúsculas Pascal.

■■ Utiliza las abreviaturas con moderación.

■■ No utiliza un prefijo de tipo, como C para clase, en un nombre de clase. Utiliza,

por ejemplo, el nombre de clase FileStream en vez de CFileStream.

■■ No utiliza el carácter de subrayado (_).

De vez en cuando, es necesario proporcionar un nombre de clase que comience con

la letra I, aunque la clase no sea una interfaz. Esto es correcto siempre que I sea la
primera letra de una palabra que forme parte del nombre de la clase. Por ejemplo,
IdentityStore es un nombre de clase correcto.

Cuando sea apropiado, utiliza una palabra compuesta en el nombre de una clase
derivada. La segunda parte del nombre de la clase derivada debe ser el nombre de la
clase base. Por ejemplo, ApplicationException es un nombre correcto para una clase
derivada de la clase Exception, pues ApplicationException es una clase de Exception.
En esta regla se debe utilizar la lógica. Por ejemplo, Button es un nombre adecuado
para una clase derivada de Control. Aunque un botón es una clase de control, si incluye
Control como parte del nombre de una clase alargaría el nombre innecesariamente.

A continuación, se incluyen algunos ejemplos de clases con nombres correctos:

01. public class FileStream

02. public class Button
03. public class String

131
[Link] con C#

3.6.14. Instrucciones de nomenclatura de interfaces

En las reglas siguientes se describen las pautas de nomenclatura de interfaces:

■■ Asigna nombres a interfaces utilizando sustantivos, sintagmas nominales o

adjetivos que describan su comportamiento. Por ejemplo, en el nombre de la
interfaz IComponent se utiliza un sustantivo descriptivo. En el nombre de la
interfaz ICustomAttributeProvider se utiliza un sintagma nominal. En el nombre
IPersistable se utiliza un adjetivo.

■■ Utiliza el estilo de mayúsculas y minúsculas Pascal.

■■ Utiliza las abreviaturas con moderación.

■■ Incluye un prefijo con la letra I en los nombres de interfaces para indicar que el
tipo es una interfaz.

■■ Utiliza nombres similares cuando definas un par clase/interfaz, donde la clase es

una implementación estándar de la interfaz.

■■ Los nombres deben ser distintos solo en el prefijo I del nombre de la interfaz.

■■ No utilices el carácter de subrayado (_).

A continuación, se incluyen algunos ejemplos de interfaces con nombres correctos:

01. public interface IServiceProvider

02. public interface IFormatable

En el siguiente ejemplo de código se muestra cómo definir la interfaz IComponent y su

implementación estándar, la clase Component.

01. public interface IComponent

02. {
03. // Aquí se escribe la implementación
04. }
05.
06. public class Component: IComponent
07. {
08. // Aquí se escribe la implementación
09. }

3.6.15. Instrucciones de nomenclatura de parámetros

Es importante seguir estas instrucciones de nomenclatura de parámetros, ya que las
herramientas de diseño visual que proporcionan ayuda contextual y funcionalidad de
exploración de clases, muestran en el diseñador los nombres de los parámetros de
métodos a los usuarios. En las reglas siguientes se describen las instrucciones de
nomenclatura de parámetros:

132
3: Introducción a C#

■■ Utiliza el estilo de mayúsculas y minúsculas Camel para los nombres de

parámetros.

■■ Utiliza nombres de parámetros descriptivos. Los nombres de parámetros

deben ser lo suficientemente descriptivos como para que el nombre y el tipo
del parámetro se puedan utilizar para determinar su significado en la mayoría de
los escenarios. Por ejemplo, las herramientas de diseño visual que proporcionan
ayuda contextual muestran los parámetros de los métodos a los programadores
mientras escriben.

■■ Por tanto, los nombres de los parámetros deberían ser lo suficientemente

descriptivos en este escenario como para permitir a los programadores
suministrar los parámetros adecuados.

■■ Utiliza nombres que describan el significado del parámetro, en vez de nombres

que describan el tipo de parámetro. Las herramientas de desarrollo deben
proporcionar información descriptiva sobre el tipo de parámetro. Por tanto, el
nombre del parámetro también sirve para describir su significado. Utilice los
nombres de parámetros basados en tipos con moderación y sólo cuando sea
correcto.

■■ No utilices parámetros reservados. Los parámetros reservados son parámetros

privados que se pueden exponer en futuras versiones, si así se precisa. En vez
de esto, si se necesitan más datos en una versión futura de la biblioteca de
clases, agrega una nueva sobrecarga para un método.

■■ No incluyas un prefijo en los nombres de parámetros con notación húngara de

tipo.

A continuación, se incluyen algunos ejemplos de parámetros con nombres correctos:

01. Type GetType(string typeName)

02. string Format(string format, object[] args).

3.6.16. Instrucciones de nomenclatura de métodos

En las reglas siguientes se describen las instrucciones de nomenclatura de métodos:

■■ Utiliza verbos o sintagmas verbales al asignar nombres a los métodos.

■■ Utiliza el estilo de mayúsculas y minúsculas Pascal.

A continuación, se incluyen algunos ejemplos de métodos con nombres correctos:

01. RemoveAll()
02. GetCharArray()
03. Invoke()

133
[Link] con C#

3.6.17. Instrucciones de nomenclatura de propiedades

En las reglas siguientes se describen las instrucciones de nomenclatura de propiedades:

■■ Utiliza un sustantivo o un sintagma nominal al asignar nombres a las propiedades.

■■ Utiliza el estilo de mayúsculas y minúsculas Pascal.

■■ No utilices la notación húngara.

■■ Es conveniente crear una propiedad con el mismo nombre que el tipo subyacente
correspondiente. Por ejemplo, si declaras una propiedad con el nombre Color, el
tipo de propiedad también deberá llamarse Color. Ve el ejemplo que se muestra
más adelante en este tema.

En el siguiente ejemplo de código se muestra cómo asignar nombres correctos a

propiedades.

01. public class SampleClass

02. {
03. public Color BackColor
04. {
05. // Code for Get and Set accessors goes here.
06. }
07. }

En el siguiente ejemplo de código se muestra cómo proporcionar una propiedad con

el mismo nombre que el tipo.

01. public enum Color

02. {
03. // Insert code for Enum here.
04. }
05.
06. public class Control
07. {
08. public Color Color
09. {
10. get {// Insert code here.}
11. set {// Insert code here.}
12. }
13. }

El siguiente ejemplo de código es incorrecto, ya que la propiedad Color es de tipo

Integer.

01. public enum Color {// Insert code for Enum here.}
02.

134
3: Introducción a C#

03. public class Control

04. {
05. public int Color
06. {
07. get {// Insert code here.}
08. set {// Insert code here.}
09. }
10. }

En el ejemplo incorrecto, no es posible hacer referencia a los miembros de la

enumeración Color. [Link] se interpretará como que tiene acceso a un miembro
que primero obtiene el valor de la propiedad Color (tipo Integer en Visual Basic o tipo
int en C#) y que, a continuación, tiene acceso a un miembro de ese valor (que tendrá
que ser un miembro de instancia de System.Int32).

3.6.18. Instrucciones de nomenclatura de eventos

En las reglas siguientes se describen las instrucciones de nomenclatura de eventos:

■■ Utiliza el estilo de mayúsculas y minúsculas Pascal.

■■ No utilices la notación húngara.

■■ Utiliza un sufijo EventHandler en nombres de controladores de eventos.

■■ Especifica dos parámetros denominados sender y e. El parámetro sender

representa al objeto que produjo el evento. El parámetro sender es siempre
de tipo object, aunque sea posible utilizar un tipo más específico. El estado
asociado con el evento está encapsulado en una instancia de una clase de
eventos denominada e. Usa una clase de eventos apropiada y específica para
el tipo de parámetro e.

■■ Asigna un nombre a la clase de argumentos del evento con el sufijo EventArgs.

■■ Es conveniente asignar los nombres de eventos con un verbo. Por ejemplo,

nombres de eventos correctos incluyen Clicked, Painting y DroppedDown.

■■ Utilice un verbo en gerundio para crear un nombre de evento que exprese el

concepto de evento anterior, y un tiempo en pasado para representar un evento
posterior. Por ejemplo, un evento Close que se puede cancelar, debe tener un
evento Closing y un evento Closed. No utilices el modelo de nomenclatura
BeforeXxx/AfterXxx.

■■ No utilices prefijo ni sufijo en la declaración de evento en el tipo. Por ejemplo,

utilicza Close en vez de OnClose.

■■ En general, se debe proporcionar un método protegido denominado OnXxx en

los tipos con eventos que se pueden reemplazar en una clase derivada. Este
método debe tener solo el parámetro de evento e, ya que el remitente es siempre
la instancia del tipo.

135
[Link] con C#

En el ejemplo siguiente se muestra un controlador de eventos con nombre y parámetros

correctos.

01. public delegate void MouseEventHandler(object sender,

MouseEventArgs e);

En el siguiente ejemplo se muestra una clase de argumentos de evento con nombre

correcto.

01. public class MouseEventArgs : EventArgs

02. {
03. int x;
04. int y;
05. public MouseEventArgs(int x, int y)
06. { this.x = x; this.y = y; }
07. public int X { get { return x; } }
08. public int Y { get { return y; } }
09. }

3.6.19. Comentarios
En C# se pueden insertar dos tipos de comentarios: implementación y documentación.

■■ Los comentarios de implementación están delimitados por /* */ ó //, y definen

información del propio código o de funcionalidades particulares.

■■ Los comentarios de documentación están delimitados por etiquetas XML

especiales, precedidos de ///, que pueden ser extraídos a ficheros internos, para
ser utilizados como documentación técnica. Describen funcionalidad y sirven
para proporcionar una visión general a desarrolladores que no tienen por qué
conocer el código fuente.

■■ Los comentarios sirven para proporcionar información adicional que no está

escrita en el propio código, y deben contener información relevante, condensada
y no repetitiva.

■■ No usaremos los símbolos /* */ para delimitar comentarios, solamente las

dos barras // para comentarios de implementación y las tres barras /// para
comentarios de documentación.

■■ Evita los comentarios al final de líneas de código, ya que dificultan la lectura.

Utilizalos solo en declaraciones de variables e indentándolos todos en la misma
tabulación, pero solo si es necesario, ya que el nombre de la variable debería ser
suficientemente explicativo.

■■ Evita incluir comentarios de separación, como por ejemplo una línea entera con
asteriscos. Para separar código de comentarios, usa una línea en blanco.

■■ Evita los bloques de comentarios con tipografías para englobar a los propios
comentarios. Esto puede parecer muy estético, pero resulta difícil de mantener.

136
3: Introducción a C#

■■ Antes de dar por terminado un desarrollo, elimina los comentarios temporales o

extraños, que hacen confuso el mantenimiento.

■■ No utilices abreviaturas en tus comentarios. Recuerda, se trata de clarificar el

código.

■■ Comenta tu código conforme lo desarrollas, ya que será mucho más costoso

documentar todo después.

■■ Mantén una visión global. Piensa que lo que ahora puede resultarte obvio, puede
no serlo dentro de un año.

■■ Usa comentarios para explicar el objetivo del código, no para traducirlo.

■■ Comenta todo lo que no sea obvio. Esto evitará interpretaciones subjetivas.

■■ Usa comentarios para avisar de problemas o bugs existentes, para evitar las
reincidencias en los mismos.

■■ Utiliza un estilo homogéneo.

■■ No utilices caracteres especiales.

3.6.20. Comentarios de implementación

Los comentarios adoptan por norma general un formato o bien de “bloque” o bien de
“fin de línea”. Hay gran variedad de formas de escribir comentarios pero en este punto
se citan las formas mas usadas.

■■ Comentarios de bloque: estos comentarios son utilizados para proporcionar

descripción de ficheros, métodos, estructuras de datos y algoritmos. Los
comentarios de bloque deben ser utilizados al principio de de cada archivo.
Evita en lo posible utilizarlos en otras partes del código, de todos modos, si los
utilizas, estos deberán ir en la misma indentación que el código que comentan.
Inserta una línea en blanco antes de cada comentario de bloque.

01. // Esto es
02. // un comentario
03. // de bloque

■■ Comentarios de línea: los comentarios de línea deberán tener el mismo nivel de

indentación que el código que describen. La longitud del comentario no debe
exceder, en líneas, a la del código que explica. Si esto ocurre, probablemente el
código es demasiado complejo, lo que puede ser un síntoma de un mal diseño.

01. private string CalcRiskClient(int id)

02. {
03. // Se obtienen los cobros pendientes
04. cashList = getPendingCashList();
05. }

137
[Link] con C#

■■ Comentarios en línea: como se ha comentado anteriormente, se deben evitar

estos tipos de comentarios, excepto en declaraciones de variables. De todos
modos: Si se inserta más de un comentario, de este tipo, en el mismo bloque de
código, se ubicarán en el mismo bloque de indentación.

01. if(HasChilds(idParent))
02. {
03. return true; // Caso especial
04. }
05. else
06. {
07. return Validate(idParent a); // Validación
08. }

■■ Comentarios buenos: comentarios informativos: Aquellos que proveen

información importante sobre el código, por ejemplo, el objeto de una expresión
regular:

01. //Expresión regular que permite validar que el

nombre de usuario no contenga carácteres no admitidos
02. Regex regex = new Regex(@”’/^[\w \- \. \ñ]+$/’;”);

■■ Explicación de intenciones: sirven para explicar los motivos que hay detrás de
una decisión en la implementación.

01. //No hemos encontrado una forma mejor de realizar

esto, más que creando un número muy alto de threads
02. for (int i = 0; i < 25000; i++)
03. {
04. WidgetBuilderThread widgetBuilderThread = new
WidgetBuilderThread(widgetBuilder, text, parent,
failFlag);
05. Thread thread = new Thread(widgetBuilderThread);
06. [Link]();
07. }

■■ Clarificación: hay ocasiones en las que el código resulta demasiado oscuro

para el ojo humano, y un comentario que clarifique el contenido ayuda a su
entendimiento.

01. public void TestCompareTo()

02. {
03. WikiPagePath a = [Link](“PageA”);
04. WikiPagePath ab = [Link](“[Link]”);
05. WikiPagePath b = [Link](“PageB”);
06. WikiPagePath aa = [Link](“[Link]”);
07. WikiPagePath bb = [Link](“[Link]”);

138
3: Introducción a C#

08. WikiPagePath ba = [Link](“[Link]”);

09. assertTrue([Link](a) == 0); // a == a
10. assertTrue([Link](b) != 0); // a != b
11. assertTrue([Link](ab) == 0); // ab == ab
12. assertTrue([Link](b) == -1); // a < b
13. assertTrue([Link](ab) == -1); // aa < ab
14. assertTrue([Link](bb) == -1); // ba < bb
15. assertTrue([Link](a) == 1); // b > a
16. assertTrue([Link](aa) == 1); // ab > aa
17. assertTrue([Link](ba) == 1); // bb > ba
18. }

■■ Advertencias sobre consecuencias: es útil advertir a otros programadores

que vayan a modificar el código posteriormente sobre ciertas consecuencias
que podrían ocasionar el uso o modificación de algo sin tomar las debidas
precauciones.

01. public static SimpleDateFormat

MakeStandardHttpDateFormat()
02. {
03. //SimpleDateFormat no es threadsafe
04. //por eso es necesario crear cada instancia
independientemente.
05. SimpleDateFormat df = new SimpleDateFormat(“EEE,
dd MMM yyyy HH:mm:ss z”);
06. [Link]([Link]);
07. return df;
08. }

■■ Comentarios TODO, HACK, UNDONE, etc. (Lista de tareas): Visual Studio

implementa una funcionalidad mediante la que se pueden incluir en comentarios
de código ciertos tokens que permiten confeccionar la lista de tareas para
consultarla y navegar desde ella a esas zonas de código.

□□ TODO: señala un lugar donde quedan tareas pendientes.

□□ HACK: señala un lugar donde se ha implementado algo que puede ser

controvertido por su eficiencia u otros motivos, pero no se ha encontrado en
ese momento una mejor forma de hacerlo, y es conveniente tenerlo en cuenta
para solucionarlo posteriormente si se puede.

□□ UNDONE: señala un lugar donde falta código por implementar para alcanzar
la funcionalidad requerida.

■■ Los comentarios de la lista de tareas se utilizan para indicar el trabajo que

queda por hacer en la ubicación marcada, incluido lo siguiente:

□□ Características que se van a agregar.

139
[Link] con C#

□□ Problemas que se van a corregir.

□□ Clases que se van a implementar.

□□ Ubicación de marcadores para el código de control de errores.

□□ Avisos para proteger el archivo.

01. // Ejemplos
02.
03. public virtual String AssemblyCodeBase
04. {
05. get { return m_AssemblyCodeBase; }
06. private set
07. {
08. if (m_AssemblyCodeBase != value)
09. {
10. m_AssemblyCodeBase = value;
11. //HACK: Lo pongo aquí para forzar provisionalmente
la carga del ensamblado
12. [Link]();
13. }
14. }
15. }
16.
17. private void cmdAdd_Click(object sender, EventArgs
e)
18. {
19. foreach (ListViewItem item in ListGAC.
SelectedItems)
20. //TODO: Falta código para controlar versiones de
ensamblado
21. //SharpDevelop lo hace con el check de última
versión y
22. //luego filtra la lista que muestra en el ListView
23. [Link]([Link],
[Link], (String)[Link]);
24. [Link]();
25. }
26.
27. void ModelService_ModelSaved(object sender,
ModelEventArgs e)
28. {
29. //UNDONE: No implementado
30. }

140
3: Introducción a C#

■■ Amplificación: comentarios con el único propósito de remarcar la importancia

de una porción de código.

01. // El Trim es muy importante, ya que si hay

espacios en blanco, puede ocurrir que el elemento no
sea reconocido
02. // en otra lista
03. String listItemContent = [Link](3).Trim();

■■ Comentarios malos: comentarios superfluos. Que no aporten ninguna

información relevante.

■■ Comentarios redundantes: si el código es suficientemente explicativo, no hace

falta poner un comentario.

01. //El evento de soporte para el ciclo de vida de

este componente
02. protected LifecycleSupport lifecycle = new
LifecycleSupport(this);

■■ Comentarios erróneos o no precisos: entrarían en este grupo los comentarios

que ya no tienen sentido y no han sido eliminados tras la modificación de código,
o comentarios en los que el programador está dando información falsa o no del
todo cierta sobre lo que pasa en la implementación.

■■ Comentarios diarios: comentarios al principio del fichero o junto al código que

se está modificando con el nombre del desarrollador y la fecha en la que se ha
editado tenían razón de ser cuando no existían sistemas de control de código
fuente, ahora con la información que nos da SourceSafe o Subversion, no hacen
más que ensuciar los ficheros de código.

■■ Ruido: comentarios como éstos solo pueden considerarse de este tipo, ruidosos:

01. //Constructor por defecto

02. protected AnnualDateRule() {}
03.
04.
05.
06.
07. //El día del mes
08. private int dayOfMonth;
09.
10.
11.
12.
13. private void StartSending()
14. {
15. try

141
[Link] con C#

16. {
17. DoSending();
18. }
19. catch (SocketException e)
20. {
21. // Normal. Alguien ha parado el request.
22. }
23. catch (Exception e)
24. {
25. try
26. {
27. [Link](ErrorResponder.
MakeExceptionString(e));
28. [Link]();
29. }
30. catch (Exception e1)
31. {
32. //Give me a break!!
33. }
34. }
35. }

142
3: Introducción a C#

3.7. Ejemplo
Hasta ahora hemos visto cómo funciona C# por separado, pero vamos a realizar un
ejemplo en el que incluyamos código [Link] y código C#.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{

int pasajeros;
int contador;
//También se puede así: int pasajeros,
contador;

if ([Link][“Origen”] != null)
{
switch ([Link][“Origen”])
{
case “Nueva York”:
[Link] = “Salida desde Nueva
York, Nueva York”;
break;
case “Chicago”:
[Link] = “Salida desde
Chicago, Illinois”;
break;
case “Miami”:
[Link] = “Salida desde
Miami, Florida”;
break;

143
[Link] con C#

default:
[Link] = “Tiene que elegir
entre una de las ciudades”;
break;
}
}
if ([Link][“Destino”] != null)
{
switch ([Link][“Destino”])
{
case “Nueva York”:
[Link] = “Llegada a Nueva
York, Nueva York <hr/>”;
break;
case “Chicago”:
[Link] = “Llegada a
Chicago, Illinois <hr/>”;
break;
case “Miami”:
[Link] = “Llegada a Miami,
Florida <hr />”;
break;
default:
[Link] = “Tiene que elegir
entre una de las ciudades”;
break;
}
}

if ([Link][“numPasaj”] != null)
{
pasajeros = Convert.ToInt32(Request.
Form[“numPasaj”]);
[Link] = “”;
for (contador = 0; contador < pasajeros;
contador++)
{
[Link] += “Nombre
Pasajero:...............<br />” + “Nacionalidad
pasajero:............... <br /> <hr />”;
}
if (pasajeros <= 0)
{
[Link] = “Me parece que van

144
3: Introducción a C#

pocos pasajeros”;
}
else if (pasajeros >= 1 && pasajeros <= 5)
{
[Link] = “Que tengan un buen
viaje”;
}
else
{
[Link] = “Tanta gente no puede
ir”;
}
}
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Compra del Billete de avión </title>
</head>
<body>
<form id = “Form1” runat = “server”>
Elija su ciudad de origen:
<br />
<asp:RadioButtonlist ID = “Origen” runat = “server”>
<asp:listitem>Nueva York</asp:listitem>
<asp:listitem>Chicago</asp:listitem>
<asp:listitem>Miami</asp:listitem>
</asp:radioButtonlist>
<br />
Elija su ciudad destino:
<br />
<asp:RadioButtonlist ID = “Destino” runat = “server”>
<asp:listitem>Nueva York</asp:listitem>
<asp:listitem>Chicago</asp:listitem>
<asp:listitem>Miami</asp:listitem>

145
[Link] con C#

</asp:radioButtonlist>
Elija el tipo de viaje
<br />
<asp:RadioButtonlist ID = “IdaVuelta” runat =
“server”>
<asp:listitem>Ida</asp:listitem>
<asp:listitem>Ida y Vuelta</asp:listitem>
</asp:radioButtonlist>
Introduzca el número de pasajeros:
<br />
<asp:DropDownList ID = “numPasaj” runat = “server”>
<asp:ListItem> 0 </asp:ListItem>
<asp:ListItem> 1 </asp:ListItem>
<asp:ListItem> 2 </asp:ListItem>
<asp:ListItem> 3 </asp:ListItem>
<asp:ListItem> 4 </asp:ListItem>
<asp:ListItem> 5 </asp:ListItem>
<asp:ListItem> +6 </asp:ListItem>
</asp:DropDownList>
<br />
<input type = “submit” value = “Aceptar”>
<br />
<asp:Label ID = “mensaje” runat = “server” />
<br />
<asp:Label ID = “mensaje1” runat = “server”/>
<br />
<asp:Label ID = “mensaje2” runat = “server”/>
<br />
<asp:Label ID = “mensaje3” runat = “server”/>
</form>
</body>
</html>

En este ejemplo se pueden ver varias de las estructuras que hemos visto durante
el tema. En un primer lugar tenemos dos estructuras switch-case para elegir la
ciudad origen y destino, después tenemos una estructura for para elegir el número
de pasajeros y dependiendo de ello se imprimirán por pantalla tantos textos como
pasajeros hayamos elegido, y dentro de este bucle tenemos una estructura if-else-if
para indicar si el número de pasajeros elegidos es correcto o no. El resultado obtenido
puede ser el siguiente:

146
3: Introducción a C#

147
3: Introducción a C#

RESUMEN
■ C# es un lenguaje de programación orientado a objetos.

■
La programación orientada a objetos se cimienta sobre los términos clase, interfaz,
herencia y objetos.

■
C# dispone de varias palabras clave que no pueden ser usadas libremente. Hay que
tener un control exhaustivo de qué palabras estamos usando.

■
Un tipo es el lugar donde se guarda cierta información sobre los valores que puede
tomar un objeto. En C# los tipos generales son entero, double, booleano, char, string
y array.

■
En la programación en C# existen otros elementos como las variables, las constantes
y los enumerados, que nos sirven para dar valores a los tipos que hayamos creado.

■
Los símbolos que llevan asignados una operación predefinida sobre los operandos
para que generen un resultado son los operadores y sirven para dar más consistencia
a nuestro código. Los operadores en C# se pueden clasificar en operadores de
asignación, aritméticos, comparación y lógicos.

■
Las estructuras de control sirven para dar un orden a nuestro código y saber qué se
debe ejecutar primero y qué se debe ejecutar después. En C# las estructuras pueden
ser de salto condicional, de salto incondicional y de bucles. En las de salto condicional
encontramos las if-else y las switch-case y entre las de bucle for, foreach, while, do-
while, break-continue.

■ Las cadenas no pueden compararse como se hace con los números.

149
4
[Link] con C#
4
DIDÁCTICA
UNIDAD

4. Elementos de [Link]
4: Elementos de [Link]

153
4: Elementos de [Link]

OBJETIVOS
■ Reconocer los eventos.

■ Aprender la programación basada en eventos.

■ Saber qué es postback y cómo funciona.

■ Aprender a fondo la programación orientada a objetos, en especial de los propios objetos.

■ Conocer el funcionamiento de los objetos y saber usarlos con [Link].

■ Aprender varios objetos de [Link] como la redirección a otras páginas o namespaces.

■ Diferenciar entre los distintos tipos de relación entre clases: herencia, uso y contenido.

■
Saber usar otras estructuras nuevas de datos como son las colecciones, desde listas
hasta Hashtables.

155
[Link] con C#

INTRODUCCIÓN

En la anterior unidad estuvimos hablando sobre Ya en la unidad anterior estuvimos hablando de objetos
algunos elementos de la programación orientada a a rasgos generales, pero vamos a intentar conocer
objetos y sobre ciertos aspectos de la programación más a fondo los objetos. En la programación Web
en C#. En esta unidad vamos a hablar de aspectos el uso de los objetos es fundamental, ya que gracias
sobre programación basada en eventos y postback, a ellos nos podemos ahorrar mucho tiempo. Un
que no tiene una traducción literal, pero podemos programador tiene que aprender a sacar rendimiento
averiguar intuitivamente su significado. Podemos de lo que ya está hecho, es decir, no debe ponerse
definirlo como el proceso que existe cuando enviamos a programar cosas que ya existen, sino que debe
una página al servidor y éste nos devuelve otra página usarlas o si no modificarlas para poderlas usar a su
con la respuesta. Además, vamos a hacer un estudio antojo. Esta posibilidad nos la dan los objetos, ya
más exhaustivo sobre los elementos estudiados en que con la creación de un objeto podemos usar ese
la unidad anterior como son los objetos, herencia código para poder crearnos otros objetos parecidos.
y haremos más ejemplos incluidos dentro de la Además, para poder aumentar la eficiencia del código y
tecnología [Link]. aumentar la claridad y elegancia de este es importante
Muchas veces estamos interactuando con el servidor agrupar los objetos que sean parecidos para poder
sin darnos cuenta a través de eventos. Todas las acceder a ellos de una manera transparente. El uso de
acciones que realicemos que hagan modificar al las colecciones va a ser fundamental en este sentido,
servidor pueden ser consideradas como eventos. El ya que nos proporciona una manera fácil de acceder
simple hecho de pinchar sobre un botón es realizar a los objetos.
una acción y que se provoque un evento.

156
4: Elementos de [Link]

4.1. Programación basada en eventos

La programación basada en eventos es uno de los rasgos más importantes en la
tecnología [Link]. Podemos definir como modelo de programación basado en
eventos a aquel que no hace nada a menos que nosotros lo pidamos, es decir, que
únicamente trabaja cuando el usuario es el que decide qué hacer y cuándo hacerlo.
Como ejemplo tenemos los sistemas operativos que disponemos hoy en día que
funcionan con un modelo basado en eventos. Por ejemplo, en Windows o en un SO
Mac un evento puede ser hacer un clic sobre un icono y éste como respuesta a ese
evento se abre.

Una de las propiedades más importantes de la programación basada en eventos

es que la forma de programación secuencial desaparece. En vez de ello tenemos
programas que reaccionan ante nuestras acciones y que interrumpen su ejecución
secuencial del código para saltar al evento seleccionado. Este principio es usado en
[Link] y utilizado comúnmente en la programación de sus páginas Web.

4.1.1. Eventos
Podemos decir que un evento es una situación que ocurre en un determinado momento
y que puede ser respondida de diferentes formas. Así que cuando un evento ocurre,
el sistema (o usuario) lo detecta y éste responde a él. Como ejemplo hemos hablado
sobre cuando un usuario hace click en un botón, el sistema se da cuenta de la acción
y empieza a ejecutar ésta.

En [Link] podemos decir que los eventos ocurren mientras nosotros estamos
navegando por nuestra página Web. Éstos ocurren en el servidor como la inicialización,
el procesamiento y la forma en que se muestra la información. Todo esto ocurre
cuando se llama al servidor.

Los eventos más importantes que tenemos en [Link] son:

■■ Page_Init(): que es un evento que ocurre cuando nosotros inicializamos una

página. Se utiliza cuando queramos que se ejecute esa parte del código antes
de que ocurra nada en la página.

void Page_Init()
{
// Código
}

■■ Page_Load(): es el evento que sucede cuando podemos visualizar la página

entera. Esta parte del código se ejecutará después de que la página se haya
descargado, pero antes de que el usuario pueda enviar algún control.

void Page_Load()
{
// Código
}

157
[Link] con C#

■■ Eventos de control: cuando los controles del servidor han sido descargados,
éstos pueden responder a eventos como clics o algún cambio en cualquier parte
de la página.

■■ Page_Unload(): este evento viene a pasar cuando se trata con los eventos de
control. En esta ocasión los eventos ocurren una vez el código [Link] ha sido
ejecutado completamente.

■■ En [Link] el código únicamente se ejecuta cuando la página se ha cargado

completamente. Puede ocurrir que una función vaya dentro de otra de manera
anidada, y ésta no se ejecutará hasta que hayamos utilizado el evento Page_
Load(). Por ejemplo, con este código tendríamos lo siguiente:

void FuncionAnidada()
{
// Código de la función anidada
}

void Page_Load()
{
FuncionAnidada();
}
void FuncionAnidada();
{
// Código de la función anidada
}

Veamos ahora un ejemplo en el que incluyamos varios de los eventos vistos

anteriormente.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public class prueba :[Link]

{
private int numero;

158
4: Elementos de [Link]

public int Numero

{
get
{
return numero;
}

set
{
numero = value;
}
}

public partial class _Default : prueba

{
protected void Page_Init()
{
Numero++;
[Link] += “<br> Se ha inicializado la página “
+ Numero + “ Page_Init<br />”;
}
}

public partial class _Default : prueba

{
protected void Page_Load(object sender, EventArgs e)
{

Numero++;
[Link] += “<br> Se ha cargado la página “ +
Numero + “ Page_Load()<br />”;

Numero++;
[Link] += “<br> Otra vez se ha cargado la
página “ + Numero + “ Page_Load()<br />”;
}
}
__________________________________________________________

159
[Link] con C#

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Eventooooooooos </title>
</head>
<body>
<form id = “Form1” runat = “server”>
<asp:Label ID = “init” runat = “server”> </asp:Label>
<asp:Label ID = “load” runat = “server”> </asp:Label>
<asp:Label ID = “load2” runat = “server”> </asp:Label>
<br />
<br />
<input type = “submit” value = “Prueba” />
<br />
</form>
</body>
</html>

El resultado de la página es el que se muestra en la captura de imagen que hay a

continuación. Lo que realmente ocurre es que mostramos un mensaje cuando se ha
inicializado la página y una vez que ya hemos inicializado dicha página podemos ir
cargando nuestro resultado tantas veces como queramos gracias a la función Page_
Load(). El resultado se muestra en la segunda imagen.

160
4: Elementos de [Link]

Después de pulsar el botón dos veces:

4.1.2. Otros tipos de eventos

Tanto para HTML, como para [Link] podemos encontrar muchos tipos de eventos.
Muchas veces habremos observado que existen controles en los navegadores que
nos permiten ver ciertos elementos gracias a alguna acción que hagamos nosotros.
Muchas veces sin darnos cuenta estamos realizando acciones, por ejemplo, si
tenemos activado el traductor de un navegador, al pasar el ratón por encima de una
palabra en el navegador aparece una pestaña con su traducción. Esta técnica también
es muy usada cuando navegamos por la red y pasamos el ratón por encima de un
anuncio y se abre una nueva pestaña. Todos éstos son eventos y para ello existen
una serie de controles para poder activarlos. Por ejemplo, para HTML algunos de sus
controles son:

■■ Onclick: dispara el evento al pulsar sobre un botón.

■■ Onmouseover: dispara el evento al pasar el ratón por encima.

■■ Ondblclick: cuando se hace doble clic sobre un elemento.

■■ Onkeypress: cuando pulsamos una tecla.

Existen varios elementos más como onmouseup, onmousedown, onkeyup y

onkeydown, realizando acciones que dependiendo de la posición del ratón o del
teclado, ejecutan una acción u otra, es decir, se activa o desactiva el evento si
tenemos una tecla pulsada o la soltamos. En el código HTML para poder realizar estas
acciones tenemos que declararnos la etiqueta <input type=”button” value=”leyenda
que aparece sobre el botón”, control=”alert (‘Texto que queremos que aparezca’)”>.

Este comando lo debemos situar en nuestro código entre las etiquetas <form> y </
form>.

161
[Link] con C#

Estos controles pueden ser usados también para la tecnología [Link], pero además,
ésta puede implementar varios controles más para ampliar nuestra gama de controles.

La diferencia que radica entre la forma de programar con HTML y con [Link] es que
en este último cuando hagamos la llamada a la acción no la hacemos directamente,
sino que tenemos que crearnos dicha función a la que se acude desde una etiqueta
asp de la siguiente manera:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

162
4: Elementos de [Link]

<html xmlns=”[Link]
<head>
<title> Eventos </title>
</head>
<body>
<form id = “Form1” runat = “server”>
<asp:CheckBox ID = “Regalo” Text = “Eres el visitante
1.999.999. Pulsa para ver tu regalo” runat=”server” />
<br />
<br />
<asp:Button ID = “Botoncito” Text = “Aceptar” runat =
“server” />
<asp:Label ID = “mensaje” runat = “server” />
<br />
</form>
</body>
</html>

Como se puede observar, hemos creado una función denominada Eventos a la cual se
accede desde la etiqueta <asp:Button ID= “Botoncito” Text=”Aceptar”
onclick=”Eventos” runat =”server” />.

Además, vemos que cuando creamos la función hay dos atributos: uno que es para
comunicar que vamos a enviar al servidor un objeto (el sender) y otro es para decir que
vamos a enviar eventos.

Éstos son los controles que añade [Link]:

■■ Onload: cuando el control ha sido cargado en la ventana.

■■ Onunload: cuando un control se ha eliminado de la ventana.

■■ Onclick: cuando se pincha sobre el control.

■■ Oninit: cuando se inicializa la página.

■■ Onprerender: antes de renderizar (volver) el control.

163
[Link] con C#

4.2. Postback
Postback es el proceso a través del cual el navegador manda la información al servidor
diciéndole a éste que procese el evento y que cuando lo haga mande la información
resultante al navegador. Postback solo sucede cuando estamos programando
formularios Web y en su mayoría cuando estamos programando con ASP o [Link].
Este componente se utiliza sobre todo en casos de comprobación de contraseñas,
cambios de datos de usuario de algún registro de alguna página Web.

En varias ocasiones de este curso hemos visto cómo puede actuar una aplicación con
postback.

<html>
<head>
<title> Eventos </title>
</head>
<body>
<form runat = “server”>
¿Qué canal de TV le gusta más?. Vote por favor.
<asp:RadioButtonList ID = “RadioButtonList1” runat =
“server”>
<asp:ListItem id = “uno” Value = “TVE1” runat =
“server” />
<asp:ListItem id = “dos” Value = “TVE2” runat =
“server” />
<asp:ListItem id = “tres” Value = “Antena 3” runat
= “server” />
<asp:ListItem id = “cuatro” Value = “Cuatro” runat
= “server” />
<asp:ListItem id = “cinco” Value = “Telecinco”
runat = “server” />
<asp:ListItem id = “seis” Value = “La Sexta” runat
= “server” />
</asp:RadioButtonList>
<br />
<br />

<input type = “submit” value = “Aceptar” onclick

= “alert(‘Hemos registrado su voto. Gracias por su
votación’)” />

</form>
</body>
</html>

164
4: Elementos de [Link]

En este ejemplo se puede ver que si seleccionamos una opción y le damos a aceptar
nos aparece esta ventana modal (que aparece gracias a la palabra alert). Si en esta
ventana le damos al botón que aparece por defecto de aceptar volvemos a nuestra
página inicial.

Vamos a realizar otro ejemplo antes de seguir con el temario. En este caso vamos a
ver una nueva estructura y algunas palabras que nos pueden ser útiles a la hora de
programar.

Este ejemplo puede ser el principio de cómo programar una calculadora. Nosotros
vamos a hacer solo una pequeña parte de lo que podría ser una calculadora real, para
ello hemos utilizado el siguiente código que vamos a explicar a continuación.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Suma(object sender, EventArgs args)
{
try
{
double num = [Link] ([Link]) +
[Link] ([Link]);

165
[Link] con C#

[Link] = [Link]();
}
catch
{
[Link] = “Error”;
}
}
protected void Resta(object sender, EventArgs args)
{
try
{
double num = [Link] ([Link]) -
[Link] ([Link]);
[Link] = [Link]();
}
catch
{
[Link] = “Error”;
}
}
protected void Raiz(object sender, EventArgs args)
{
try
{

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

166
4: Elementos de [Link]

<html xmlns=”[Link]
<head>
<title> Calculadora </title>
</head>
<body>
<form id=”Form1” runat=”server”>
Si quiere sumar o restar, introduzca un número en las
dos siguientes cajas.
<br />
<asp:TextBox ID=”caja1” runat=”server”> </asp:TextBox>
<asp:Button ID=”suma” runat=”server” Text=”+”
OnClick=”Suma” />
<br />
<asp:TextBox ID=”caja2” runat=”server”> </asp:TextBox>
<asp:Button ID=”resta” runat=”server” Text=”-”
OnClick=”Resta” />
<br />

Si lo que quiere es hacer la raíz cuadrada de un

número, hágalo en esta caja.
<br />
<asp:TextBox ID=”caja3” runat=”server”> </asp:TextBox>
<asp:Button ID=”raiz” runat=”server” Text=”Raiz”
OnClick=”Raiz” />

<br />
<b>Resultado =
<asp:Label ID=”respuesta” runat=”server”> </
asp:Label></b>
</form>
</body>
</html>

Aunque pueda parecer un código algo extenso es bastante sencillo y de hecho se

puede copiar y pegar varias veces tan solo cambiando la identificación de cada uno.

167
[Link] con C#

Para empezar, lo primero que puede llamar la atención es la estructura try{…} o

catch{…}. Con esta estructura se intenta perseguir la detección de errores y su uso es
que en la parte del try habría que poner lo que queremos que salga como resultado y el
catch intenta atrapar aquel error que no concuerde con el try, como por ejemplo, dejar
una caja vacía o poner una letra en vez de un número. Además, se puede observar
que hemos utilizado también una sentencia [Link], que lo que hace es
asegurarse de que si, por ejemplo, hubiésemos colocado una operación para dividir y
dividimos 4 / 3 nos dé como resultado un número real. Para esto último también existe
la opción de usar la sentencia [Link]

La parte de HTML apenas muestra nada nuevo respecto a lo que ya conocemos.

Es un claro ejemplo en el que vemos cómo actúa la programación por eventos y
postback. Al servidor se le mandan una serie de elementos por parte del usuario
y el primero tiene que evaluarlos y devolver el resultado al segundo mostrando su
resultado por pantalla.

Es importante resaltar que la programación Web carece de estados y en cada postback

que realicemos vamos a perder los valores, a no ser que utilicemos el siguiente control:
[Link], el cual obtiene un diccionario con información de estado que le
permite guardar y restaurar el estado de vista de un control de servidor en las distintas
solicitudes de la misma página.

Como ejercicio para el alumno puede intentar ejecutar una calculadora que contenga
el resto de botones con las operaciones sumar, restar, multiplicar y dividir, además de
contener un botón de igual y los correspondientes botones con los números desde el
0 hasta el 9. Es un ejercicio no más complicado que lo que acabamos de hacer.

A modo de observación vamos a repetir un ejercicio anterior realizado anteriormente,

pero incluyendo la condición IsPostBack. Si no queremos que se carguen todos los
loads tenemos la posibilidad de hacerlo así:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public class prueba : [Link]

{
private int numero;

168
4: Elementos de [Link]

public int Numero

{
get
{
return numero;
}

set
{
numero = value;
}
}

public partial class _Default : prueba

{
protected void Page_Init()
{
Numero++;
[Link] += “<br> Se ha inicializado la página “
+ Numero + “ Page_Init<br />”;
}
}

public partial class _Default : prueba

{
protected void Page_Load(object sender, EventArgs e)
{
if (IsPostBack)
{
Numero++;
[Link] += “<br> Se ha cargado la página “
+ Numero + “ Page_Load()<br />”;

Numero++;
[Link] += “<br> Otra vez se ha cargado la
página “ + Numero + “ Page_Load()<br />”;
}
}
}

169
[Link] con C#

La única diferencia con el ejemplo anterior es la inclusión de la condición ya mencionada

arriba sin ser necesario modificar el código .aspx.

Después de darle a Prueba:

170
4: Elementos de [Link]

4.3. Objetos
En el tema anterior hicimos una breve introducción a los principales elementos de
la programación orientada a objetos y en esta unidad profundizaremos sobre ellos y
haremos algunos ejemplos que nos ayuden a entender estos conceptos.

El uso de objetos en la programación nos ayuda a ser mucho más eficientes a la hora
de programar y tener nuestro código más ordenado. Además, tiene la ventaja de que
se puede reusar el código sin necesidad de tener que reescribir código.

Así que como dijimos en la unidad 3, un objeto es un trozo de código que realiza
las tareas de un programa y que tiene la información y capacidades necesarias para
poder realizarlas.

Para entender lo que es un objeto en la programación se usa normalmente el ejemplo

de un coche con una serie de propiedades como son el color, la capacidad del motor,
la velocidad máxima, el número de asientos o simplemente el número de ruedas.

Éste es un caso de lo que podría ser un objeto, aunque si nos fijamos el mundo real está
lleno de objetos y cada uno tiene una serie de propiedades. Desde el punto de vista
de la programación las personas mismas somos objetos con nuestras propiedades
como son el nombre, los apellidos, la edad, el NIF o el domicilio. Esto nos ayuda a
modelar el mundo real y que cada objeto tenga unas características que los distinga
unos de otros.

Como vimos en la unidad 3 para crear un objeto tenemos que definir una clase donde
vamos a describir las características y el comportamiento de los objetos dependiendo
de su estado, que eran las características que tenía un objeto en un determinado
momento. Dentro de una clase podemos considerar las propiedades de cada objeto
y los métodos, que son aquellos trozos de código, donde se realizan las acciones que
deben realizar.

Así que antes de realizar cualquier tipo de código debemos saber exactamente cuáles
van a ser las propiedades que tenga cada objeto y cuáles son las acciones que va a
realizar (métodos). Así que vamos a crear un objeto que sea coche con las siguientes
características: color, número de asientos, velocidad máxima y número de marchas.
Como métodos va a tener el cambio de marchas y cambio de velocidad.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

171
[Link] con C#

using [Link];

public string Color

{
get
{
return color;
}
set
{
color = value;
}
}
public int NumeroAsientos
{
get
{
return numeroAsientos;
}
set
{
numeroAsientos = value;
}
}
public int VelMax
{
get
{
return velMax;
}
}

public void CambioVelocidad(int velocidad)

{

172
4: Elementos de [Link]

if (velocidad < 0)
velMax -= 10;
if (velocidad > 0)
velMax += 10;
if (velMax > 130)
velMax = 130;
if (velMax < 0)
velMax = -1;
}
public int Marchas
{
get
{
return marchas;
}
}

public void CambioMarchas(int marchaActual)

{
if (marchaActual < 0)
marchas--;
if (marchaActual > 0)
marchas++;
if (marchas > 6)
marchas = 6;
if (marchas < 0)
marchas = -1;
}
}
void Page_Load()
{
MiCoche SuperFerrari = new MiCoche();
[Link](“Existe un nuevo coche
<b>SuperFerrari</b>.”);
[Link](“<br /> El SuperFerrari es de color
“ + [Link]);
[Link](“<br /> El SuperFerrari tiene <b>”
+ [Link] + “</b>” + “ plazas.”);
[Link](“<br /> El SuperFerrari va a <b>”
+ [Link] + “</b>” + “ km/hora.”);
[Link](“<br /> El SuperFerrari va en <b>”
+ [Link] + “</b>” + “º velocidad.”);
[Link] = “Rojo”;
[Link] = 5;

173
[Link] con C#

[Link](+10);
[Link](+1);
[Link](“<br /> <br /> <b> El SuperFerrari
ha cambiado sus propiedades </ b> <br /> <br />”);
[Link](“<br /> El SuperFerrari es de color
<b>” + [Link] + “</b>”);
[Link](“<br /> El SuperFerrari tiene <b>”
+ [Link] + “</b>” + “ plazas.”);
[Link](“<br /> El SuperFerrari va a <b>”
+ [Link] + “</b>” + “ km/hora.”);
[Link](“<br /> El SuperFerrari va en <b>”
+ [Link] + “</b>” + “º velocidad.”);
[Link] = “Rojo”;
[Link] = 5;
[Link](+10);
[Link](+1);
[Link](“<br /> <br /> <b> El SuperFerrari
ha cambiado sus propiedades </ b> <br /> <br />”);
[Link](“<br /> El SuperFerrari es de color
<b>” + [Link] + “</b>”);
[Link](“<br /> El SuperFerrari tiene <b>”
+ [Link] + “</b>” + “ plazas.”);
[Link](“<br /> El SuperFerrari va a <b>”
+ [Link] + “</b>” + “ km/hora.”);
[Link](“<br /> El SuperFerrari va en <b>”
+ [Link] + “</b>” + “º velocidad.”);
}

}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Mi Cochazo </title>
</head>
<body>

174
4: Elementos de [Link]

</body>
</html>

Como vemos, hemos creado un objeto nuevo llamado MiCoche con una serie de
propiedades que podemos ir modificando en nuestro código simplemente copiando y
pegando. Como vemos, lo primero que hacemos es declarar la clase, posteriormente
definimos los atributos que va a tener el objeto y creamos un método get y set para
cada uno de ellos excepto cuando tenemos un método que afecte a los atributos. Se
puede ver que cuando exponemos las propiedades las creamos públicas para que
puedan ser usadas desde cualquier lugar del código y además, debe llevar un tipo,
que es aquél que vaya a devolver nuestro código, por ejemplo, para velocidad será
un entero y para color, un string o cadena. El tipo void no devuelve ningún tipo en
concreto.

Posteriormente se ha escrito la sentencia void Page_Load() y justo después es donde

hemos creado los objetos. Podemos declarar más de un objeto a la vez de la forma
NombreClase nombreObjeto = new NombreClase(); en la zona de código donde los
necesitemos.

La siguiente parte del código está dedicada a escribir lo que se debe mostrar en el
navegador y posteriormente es donde podemos modificar los atributos. Los atributos
pueden ser modificados cada vez que queramos, así como las veces que queramos
que se muestre en la pantalla. Hemos de decir que cada vez que queramos modificar
un objeto lo tendremos que hacer a través de una llamada, así mismo como hemos
hecho nosotros llamando a [Link].

175
[Link] con C#

En este ejemplo no hemos visto el caso en el que los objetos se inicializan directamente.
Imaginemos que queremos que nuestro coche tenga un precio inicial, obviamente
tendríamos que declarar una variable llamada “precio” de tipo entero, sus métodos
get y set y la única diferencia respecto al código anterior sería la de crear el siguiente
trozo de código:

private int precio;

public MiCoche ()
{
precio = 300000;
}

Otra forma de crear constructores sería de la siguiente forma, denominada creación

con sobrecarga del constructor con parámetros:

public MiCoche (int precio)

{
[Link] = precio;
}

Si tuviésemos que crear más constructores, se haría en esa zona de código con los
valores inicializados.

176
4: Elementos de [Link]

4.4. Más objetos en [Link]

[Link] es una tecnología bastante amplia y con mucha capacidad. Es por ello que
tiene sus propios objetos y sus propias formas de declararlos. Uno de los elementos
más importantes de [Link] quizás sean los Namespaces, los cuales ya vimos en
unidades anteriores, que es una forma de agrupar clases del mismo tipo.

4.4.1. Namespaces
A modo de recordatorio podemos decir que los namespaces son un conjunto de
clases similares que se agrupaban para poder ser usadas por el programador en
cualquier momento. Si, por ejemplo, necesitamos clases que nos puedan ayudar a
conectarnos a una base de datos, usaremos el namespace [Link], el cual
agrupa todas las clases necesarias para ello.

A nosotros nos viene especialmente bien el uso del namespace relacionado para
la creación de páginas Web y para ello usaremos [Link]. Es muy importante
recordar que los namespaces se importan al principio del código, es decir, lo primero.
En posteriores unidades veremos cómo el propio usuario puede ser capaz de crear
sus propios namespaces.

4.4.2. Links a otras páginas

Otro objeto que podemos usar en [Link] es el link a otras páginas. Éste es un
aspecto muy común en la programación Web, de hecho podemos observar cómo se
hace esto continuamente en páginas tipo buscadores, noticias en los periódicos que
nos ponen algún link a otra página o el uso en foros.

Vamos a ver un ejemplo:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs

177
[Link] con C#

args)
{
if (!(IsPostBack))
{
[Link] = “Acceder”;
[Link](“[Link]
[Link](“[Link]
com”);
[Link](“[Link]
[Link](“[Link]
}
}

public void Ir(object sender, EventArgs args)

{
//Esta es la línea importante
[Link]([Link]);
}

}
___________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head id = “Head1” runat = “server”>
<title> Redirección </title>
</head>
<body>
<form id = “form1” method = “post” runat = “server”>
<div>
<asp:DropDownList ID = pg runat = “server”> </
asp:DropDownList>
<asp:Button ID = “msg” runat = “server” Onclick = “Ir”
Text = “ “ />

</div>
</form>

178
4: Elementos de [Link]

</body>
</html>

Como podemos observar, el sitio donde se redirige a la página es en un método

creado para tal situación, a través de la directiva [Link].

También podemos redirigirnos a una página a través de la siguiente línea de código:

<asp:LinkButton ID=”LinkButton1” runat=”server”

OnClick=”Ir”>[Link]

4.4.3. Estados de sesión

Otro de los objetos más usados es el del estado de una sesión. Imaginemos que
estamos haciendo un examen tipo test a través de una página Web y durante el examen
cada vez que contestemos una pregunta le damos a un botón de confirmación. Ahí
existirá un contador que cada vez que enviemos una respuesta aumentará.

Esta propiedad se puede usar también para contar el número de visitantes que tiene
una página o el número de elementos descargados de una página.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{

protected void Respuesta(object sender, EventArgs

args)

179
[Link] con C#

{
if (Session[“Examen”] != null)
{
int i = (int)Session[“Examen”];
i++;
Session[“Examen”] = (object)i;
}
else
{
Session[“Examen”] = 1;
}
}

}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head id = “Head1” runat = “server”>
<title> Sesion </title>
</head>
<body>
<form id = “form1” method = “post” runat = “server”>
<div>
<asp:Button ID = “msg” runat = “server” Onclick =
“Respuesta” Text = “Enviar” />
<br />
Respuestas enviadas: <%=Session[“Examen”] %>
</div>
</form>
</body>
</html>

En este tipo de objetos se hace uso de una propiedad llamada session que sirve para
devolvernos un objeto, en nuestro caso una nueva respuesta.

180
4: Elementos de [Link]

Esto también se puede usar cuando hemos iniciado alguna sesión de alguna
página en la que estemos registrados. Por ejemplo, estamos viendo nuestro correo
electrónico. Si queremos desconectarnos o que pasado un tiempo se desconecte
automáticamente se hará gracias a este tipo de directivas. Por ejemplo, abandon()
servirá para desconectarnos manualmente, isnewsession() servirá para iniciar una
nueva sesión y timeout servirá para que el servidor finalice automáticamente la sesión
una vez haya pasado un tiempo sin ser usada.

Todas las anteriores directivas serán usadas del mismo modo que la directiva session
y todas ellas son del tipo Httpsessionstate.

A veces es recomendable usar otra directiva denominada application con la misma

funcionalidad que session, pero con la salvedad de que es compartida por todos los
usuarios, siendo esta forma más eficiente, ya que no sobrecargaría al servidor.

181
[Link] con C#

4.5. Relaciones entre clases

En la POO podemos tener relaciones entre clases y habrá que inventarse algo para
intentar evitar en la medida de lo posible reescribir código una y otra vez. En general,
las relaciones entre clases pueden ser varias, como usar una clase, contener una
clase o heredar de una clase. En nuestro ejemplo anterior podemos decir, por ejemplo,
que una clase persona usa una clase coche, una clase coche contiene una clase
cuentakilómetros y también podemos pensar que una clase coche hereda de una
clase vehículo.

4.5.1. Relación “Usa”

Este tipo de relación se da normalmente entre un objeto de una clase X que usa una
clase Y.

Aquí vamos a ver un ejemplo en el que creamos una clase conductor que va a usar
una clase coche, ya creada anteriormente aunque con muchas modificaciones.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{

public class Conductor

{
private int nombre;

public Conductor(int nombreActual)

{
nombre = nombreActual;
}
public int Nombre
{
get

182
4: Elementos de [Link]

{
return nombre;
}
}
}

public class MiCoche

{
//Zona de atributos
private bool arrancado;
private int competidor;

public MiCoche(int Corredor)

{
competidor = Corredor;
}

public string ACorrer

{
get
{
if (arrancado)
return (“Puede correr”);
else
return (“Trata de arrancarlo”);
}
}

public void Competidor(Conductor c1)

{
if ([Link] == competidor)
{
arrancado = true;
}
}

public void Apagado()

{
arrancado = false;
}
}

void Page_Load()

183
[Link] con C#

Conductor alonso = new Conductor(1);

Conductor hamilton = new Conductor(2);
Conductor vettel = new Conductor(3);
Conductor webber = new Conductor(4);
MiCoche superFerrari = new MiCoche(1);

}
___________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head id = “Head1” runat = “server”>
<title> Fórmula 1 </title>
</head>
<body>

184
4: Elementos de [Link]

</body>
</html>

Como podemos observar, tenemos esas dos clases y el objeto conductor puede usar
cualquiera de los métodos creados en la clase coche. En la clase persona no se
ha hecho algo mucho más distinto que lo que se hace en otras clases. En la clase
MiCoche se han creado dos nuevos atributos y un nuevo constructor. Luego dispone
de varios métodos nuevos y es en el Page_Load donde la clase persona hace uso de
los métodos de la clase coche.

4.5.2. Relación “Contiene”

Supongamos ahora que nuestro objeto coche tiene una clase llamada cuentakilómetros.
Se dice que una clase contiene a otra cuando la primera puede definir los datos de la
otra.

public class CuentaKm

{
private int maxVel;

public int MaxVel

{
get
{
return maxVel;
}
}

public CuentaKm(int velocidad)

{
maxVel = velocidad;
}
public bool EstaParado()
{
return (“Arranque el coche y acelere”);
}
}

public class MiCoche

{
private CuentaKm cuentaKiloms;

public CuentaKm contVelocidad

{
get

185
[Link] con C#

{
return cuentaKiloms;
}
set
{
cuentaKiloms = value;
}
}
…
MiCoche superMercedes = new MiCoche();
[Link] = new CuentaKm(200);
…

Como vemos, hemos declarado la clase cuentakilómetros dentro de la clase coche

y como clase más importante puede usar cualquiera de los métodos de la clase
Cuentakilómetros.

4.5.3. Relación “Es-un(a)”

Es una de las partes más importantes en la POO. Gracias a esta propiedad tenemos la
posibilidad de tener un código mucho más eficiente y más corto. Como ya explicamos,
la principal característica es que tenemos una clase más general y luego otra más
especializada que tiene los mismos atributos y métodos que la clase más general,
pero que además dispone de una serie de nuevos métodos que la especializan y la
diferencian de la clase padre.

Así que vamos a crear una clase vehículo que tenga unas propiedades más generales
y que la clase coche pueda usarse sin ningún problema.

public class Vehiculo

{
private int numRuedas;

public void Freno()

{
int maxVel = 0;
}
public int NumRuedas
{
get
{
return numRuedas;
}
set
{
value = numRuedas;

186
4: Elementos de [Link]

}
}

}
public class MiCoche : Vehiculo
{
…
}

void Page_Load()
{
MiCoche superFerrari = new MiCoche();
MiCoche superMercedes = new MiCoche();
[Link] = new CuentaKm(200);
[Link] = 4;
[Link] (“<br /> El SuperFerrari tiene “ +
[Link] + “ ruedas”);
…
…
}

Una vez tenemos la clase padre y la clase hija, ésta última en su declaración debe
indicar que es hija de la clase padre y lo hace a través de:

public class MiCoche : Vehiculo

Por lo tanto, ya podemos usar desde la clase hija cada una de las propiedades de la
clase padre siempre que la necesitemos.

187
[Link] con C#

4.6. Estructuras de datos

Las estructuras de datos nos ayudan a organizar los objetos para poder acceder a
ellos de una forma fácil y eficiente. Una de las estructuras más importantes y que
nos puede ayudar mucho son las colecciones, que son un tipo de objetos que los
podemos agrupar en una colección.

4.6.1. Listas
Las colecciones normalmente se agrupan por tipo, aunque sin necesidad de estar
ordenadas. En otro caso:

■■ Listas: es un tipo de colección en el que los elementos están ordenados. Sobre

una lista se pueden hacer varios tipos de operaciones como añadir o eliminar
elementos de la misma. Cuando se añada un elemento se hará al final de la lista.
No es necesario que todos los elementos sean distintos.

■■ Map: un map es una lista en la que cada elemento está identificado por un valor
y una clave, ésta identifica al elemento para que sea único. Por ejemplo, una
persona tiene un valor que es su nombre y, una clave que es su DNI, el cual es
único para cada persona.

■■ Pilas: es una lista en la que los elementos se añaden al final y solo pueden ser
eliminados del final.

■■ Colas: es una lista en la que los elementos se añaden al final de la lista y se

eliminan del principio de la lista.

■■ Diccionarios: la clase genérica Dictionary nos da una asociación de un conjunto

de claves a un conjunto de valores. Cada elemento que se agrega al diccionario
está compuesto de un valor y su clave asociada. Cada clave de un diccionario
debe ser única respecto al comparador de igualdad del diccionario.

Veamos el siguiente ejemplo:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

188
4: Elementos de [Link]

public partial class _Default : [Link]

{

protected void Page_Load()

{
List<string> tenistas = new List<string>();

[Link](“Nadal”);
[Link](“Federer”);
[Link](“Djokovic”);
[Link](“Murray”);
[Link](“Soderling”);

foreach (string tenista in tenistas)

{
[Link](tenista);
}
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

En este ejemplo podemos ver cómo hemos declarado una lista de tipo String

List<string> tenistas = new List<string>();

a la que posteriormente vamos insertando nuevos elementos y luego con la sentencia

foreach van siendo asignados a un control de tipo Radio.

189
[Link] con C#

4.6.2. Arrays
Un array es un conjunto de elementos con un valor cada uno de ellos y todos
pertenecientes al mismo tipo. Los arrays pueden ser de una o varias dimensiones.
Para definir un array se hace de la siguiente manera:

<tipo> [ ] nombreArray = new <tipo> [ ]

Por ejemplo, si se quiere crear un array de varios elementos se puede hacer de la

siguiente manera:

string [] ArrayVehiculos = new string [5]

{
“Coche”, “Moto”, “Camión”, “Furgoneta”, “Sidecar”
};

Si quiero obtener la información que aparece en una posición en concreto se hace de

la siguiente forma:

[Link] = [Link](0).ToString();

Estas dos estructuras vistas se podrían crear dentro de la sección de Page_Load. Si lo

que deseamos es buscar la posición en la que se encuentra un determinado elemento
se hace así:

int n = -1;
string[] ArrayVehiculos = new string[5]
{
“Coche”, “Moto”, “Camión”, “Furgoneta”, “Sidecar”
};
do
{
n = [Link](ArrayVehiculos, “Moto”, n++);
}
while (n != [Link](ArrayVehiculos,
“Moto”));

Como podemos observar, lo primero que hacemos es declarar un entero que nos
va a servir de contador para ir recorriendo el array entero para así poder devolver el
resultado de la posición en la que se encuentra el elemento. La sentencia IndexOf
nos devuelve la posición en la que se encuentra el elemento objeto de la búsqueda,
y como puede haber más de un elemento, continuamos la búsqueda hasta el último
elemento, el cual se puede hacer a través de la llamada a LastIndexOf.

Existen varias llamadas que nos pueden ser útiles como [Link] que nos ordenará
los elementos, [Link] que nos borrará el array entero, [Link] para buscar el
elemento dentro de un array o [Link], que nos servirá para encontrar el último
elemento de los que estamos buscando.

190
4: Elementos de [Link]

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{

protected void Page_Load()

{

string[] ArrayVehiculos = new string[5]

{
“Coche”, “Moto”, “Camión”, “Furgoneta”, “Sidecar”
};
[Link](ArrayVehiculos);

foreach (string veh in ArrayVehiculos)

{
[Link](veh);
}
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<body>
<form runat=”server”>
<asp:radiobuttonlist id=”Radio” runat=”server”> </

191
[Link] con C#

asp:radiobuttonlist>
</form>
</body>
</html>

Con este código pretendemos mostrar cómo se podría hacer, por ejemplo, una lista
de botones de radio con los elementos del array de vehículos ordenados. Por defecto,
la ordenación que se realiza es alfabética.

Hay que recordar que los arrays, listas, colecciones y demás elementos de este tipo
empiezan a contar desde 0. Así para el ejemplo anterior el resultado para la búsqueda
de la moto nos debe dar 1.

4.6.3. Arraylist
Un arraylist es una mejora del array, puesto que nos permite interactuar con la lista
dinámicamente, como añadiendo elementos a una lista y borrarlos de manera sencilla.
Tiene una serie de métodos asociados como:

■■ [Link]: añadir un elemento.

■■ [Link]: eliminar el elemento que le pasemos como parámetro.

■■ [Link]: ordenar el arraylist.

■■ [Link]: limpiar el array.

■■ [Link]: devuelve la posición del elemento que le pasemos como

parámetro.

■■ [Link]: inserta en la posición n, el elemento que deseemos.

Aquí vemos un ejemplo de cómo se pueden ir añadiendo elementos a un arraylist.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

192
4: Elementos de [Link]

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{

protected void Page_Load()

{
ArrayList CiudadesPrefes = new ArrayList();
[Link](“Nueva York”);
[Link](“Chicago”);
[Link](“Miami”);
[Link](“París”);
[Link](“Londres”);
[Link](“Praga”);
[Link] = CiudadesPrefes;
[Link]();

}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link] <body>

Con DataSource y DataBind conseguimos que se muestren los resultados en el

navegador. DataSource es de donde se cogen los elementos y DataBind es a quien
van unidos esos elementos. Este proceso de denomina bindeo de datos.

193
[Link] con C#

Si alteramos nuestro código de la siguiente manera:

ArrayList CiudadesPrefes = new ArrayList();

[Link] (“Nueva York”);
[Link] (“Chicago”);
[Link] (“Miami”);
[Link] (“París”);
[Link] (“Londres”);
[Link] (“Praga”);
[Link] (“Miami”);
[Link] (“París”);
[Link]();
[Link] (4, “Estambul”);

[Link] = CiudadesPrefes;
[Link]();
Tendremos como resultado lo siguiente:

Vemos que hemos eliminado de la lista a Miami y París y la hemos ordenado por orden
alfabético, y posteriormente hemos insertado en la posición 5, el elemento Estambul.

4.6.4. Sortedlist
Es otro tipo de colecciones donde se almacenan los datos con un valor y una clave
donde los elementos son ordenados por su clave. Este tipo de listas es útil cuando
tengamos que ordenar por clave, como por ejemplo, la clasificación de una liga.

using System;
using [Link];

194
4: Elementos de [Link]

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

if (!([Link]))
{
foreach (DictionaryEntry Item in Atp)
{
ListItem raqueto = new ListItem();
[Link] = [Link]();
[Link] = [Link]();
[Link](raqueto);
}
}
}

protected void Evento(object sender, EventArgs args)

{
[Link] = [Link];
}
}

__________________________________________________________

195
[Link] con C#

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<body>
<form id = “Form1” runat = “server”>
Seleccione la posición en el ranking:
<br />
<asp:radiobuttonlist id = “Radio” runat =
“server”> </asp:radiobuttonlist>
<asp:Button ID = “Tenista” runat = “server”
Text = “Ver” Onclick = “Evento” />
<br />
Tenista: <asp:Label ID = “sel” runat =
“server” Text = “ “ />
</form>
</body>
</html>

Como vemos, primero definimos la clasificación de los tenistas, luego ponemos la

sentencia

if (!([Link]))
{

que nos evitará la repetición de los elementos una vez hayamos seleccionado uno de
ellos. Después iremos añadiendo cada uno de los elementos a nuestros botones de
radio y asociaremos a cada uno su clave y su valor.

196
4: Elementos de [Link]

4.6.5. Hashtable
Es un tipo de colecciones muy similar al SortedList con la salvedad de que no es
necesario que los objetos estén ordenados. Cada elemento tiene asociado un par
clave–valor. Como ejemplo podemos tomar el mismo que antes, pero desordenando
a los tenistas y cambiando SortedList por HashTable:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

if (!([Link]))
{
foreach (DictionaryEntry Item in Atp)
{
ListItem raqueto = new ListItem();
[Link] = [Link]();
[Link] = [Link]();
[Link](raqueto);
}
}

197
[Link] con C#

}
protected void Evento(object sender, EventArgs args)
{
[Link] = [Link];
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

198
4: Elementos de [Link]

4.6.6. Dictionary
Este tipo de colecciones es similar a las HashTables en las que se nos muestra una
lista de elementos con una clave y un valor y al igual que antes solo puede existir
una clave diferente para cada valor. Los valores sí se pueden repetir. A continuación
tenemos un ejemplo:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{

protected void Page_Load()

{
Dictionary<string, string> tenistas =
new Dictionary<string, string>();

[Link](“Rafa”, “Rafa Nadal”);

[Link](“Roger”, “Roger Federer”);
[Link](“Nole”, “Novak Djokovic”);
[Link](“Andy”, “Andy Murray”);

foreach ( KeyValuePair<string, string> tenista in

tenistas)
{
[Link]([Link]);
}
try
{
[Link](“Andy”, “Andy Roddick”);
}
catch (ArgumentException)

199
[Link] con C#

{
[Link](“Ya existe un tenista con la
clave Andy”);
}

}
}

__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

Como podemos observar, hemos ido creando una serie de objetos con una clave y un
valor, pero en el momento en el que hemos intentado introducir otro elemento con la
misma clave que uno de los que ya había aparece un error.

200
4: Elementos de [Link]

RESUMEN
■
Las acciones en las que se vea envuelto el usuario y el servidor serán consideradas
como eventos. Un evento es la acción que realiza un usuario, el cual recibe una
respuesta a la misma.

■
En [Link] tenemos varios tipos de eventos con los que se puede interactuar, como
es pinchar un botón o pinchar dos veces sobre un botón.

■
Postback es el proceso a través del cual el navegador manda la información al servidor
diciéndole a éste que procese el evento y que cuando lo haga mande la información
resultante al navegador.

■
Un objeto es un trozo de código que realiza las tareas de un programa y que tiene la
información y capacidades necesarias para poder realizarlas. El uso de objetos en la
programación [Link] es básico.

■
Con [Link] podemos programar nuestros propios objetos como la redirección a
páginas a través de la directiva Redirect o el ciclo de vida de una sesión de usuario.

■
Existen tres tipos de relación de clases: la relación de herencia, la relación en la que una
clase usa otra clase y la relación en la que una clase contiene a la otra.

■
Las colecciones son agrupaciones de objetos del mismo tipo. Las listas, listas
ordenadas, arrays, listas de arrays, hashtables, listas ordenadas, diccionarios, etc. son
colecciones de objetos.

201
5 5
[Link] con C#
DIDÁCTICA
UNIDAD

5. [Link]
5: [Link]

205
5: [Link]

OBJETIVOS
■ Conocer los principios básicos de las bases de datos.

■ Conocer los principios básicos sobre [Link].

■ Conocer los tipos de proveedores.

■ Aprender a usar los objetos [Link].

■ Conocer el servidor SQL.

■
Aprender a trabajar con bases de datos y manipular los datos a través de comandos de
[Link].

207
[Link] con C#

INTRODUCCIÓN

El uso de recursos externos es uno de los grandes De esta forma podemos entender que el uso de
fundamentos de la programación Web. Los lenguajes elementos externos a nuestro código es prácticamente
nos ofrecen una serie de funcionalidades con las que necesario para hacer de nuestra página una Web
podemos hacer casi todo lo que nos propongamos, dinámica y a la vez visual.
pero hay veces en las que la programación no lo es En este tema vamos a hacer especial hincapié en una
todo. Esto ocurre cuando tenemos que usar recursos colección de accesos a datos llamada [Link] que
situados en otro emplazamiento, como pueden ser proporciona al programador una serie de herramientas
fotografías, vídeos o simplemente el uso de elementos necesarias para el acceso, manipulación y uso de
de una base de datos. Uno de los casos más claros datos.
es cuando nos registramos en cualquier página o
nos damos de alta en una cuenta de correo nueva.
Cuando nos piden nuestros datos, no estamos más
que introduciéndolos en una base de datos. Es muy
importante este hecho, ya que a la hora de acceder
a nuestra cuenta de correo, por ejemplo, al introducir
nuestro usuario y contraseña, el servidor comprueba
en la base de datos si esos datos son coincidentes
con los que hemos metido.

208
5: [Link]

5.1. Bases de datos

Todo el mundo puede hacerse una idea de lo que es una base de datos. Probablemente
si preguntásemos en la calle a gente de mediana edad sobre una base de datos todos
darían una respuesta que se acerca a la realidad.

Existen muchos tipos de bases de datos, como son las bases de datos jerárquicas,
transaccionales u orientadas a objetos. Sin embargo, el tipo de base de datos más
utilizado en la actualidad son las relacionales. De forma general podemos definir
que una base de datos es una colección de datos relacionados entre ellos dentro
de un mismo contexto. Es muy importante el concepto “relacionados entre ellos”.
Cuando hablamos de esto queremos decir que en una base de datos podemos
encontrar datos primarios y datos secundarios, denominados clave. Por ejemplo,
supongamos una muestra de población de 50000 personas. Si ponemos a comparar
los nombres de las personas probablemente obtengamos nombres repetidos, así
como si comparamos ciertos datos de las personas, pero para distinguir lógicamente
hablando a dos personas, la única forma puede ser a través del DNI. No pueden existir
dos personas con un mismo DNI, así que podemos hablar de que este dato es una
clave primaria. En otras palabras, podemos decir que una clave primaria es aquella
que identifica de manera única a un elemento de una base de datos. El resto de datos
que identifiquen a una persona estarán relacionados con su clave primaria.

Actualmente y con más fuerza, aparecen nuevos sistemas intermediarios entre el

usuario y las bases de datos. En este capítulo nos centraremos en [Link], un
sistema muy potente que nos permite acceder a muchas fuentes de datos como por
ejemplo ficheros XML, bases de datos, etc.

209
[Link] con C#

5.2. [Link]
[Link] (ActiveX Data Object) es el nombre que se le da a un grupo de componentes
software proporcionados por el Framework de .NET usados por los programadores
para acceder a datos y a servicios de datos en sistemas gestores de bases de datos
relacionales.

[Link] puede interactuar con muchos tipos de datos y proporciona acceso a

orígenes de datos tales como Microsoft SQL Server, XML, OLE DB, ODBC o IBM
DB2. Las aplicaciones de usuario que existen para compartir datos pueden utilizar
[Link] para conectarse a esos mismos orígenes de datos y así poder manipular,
recuperar o actualizar los datos existentes en ellos.

Además, gracias a [Link] podemos conectarnos a otros tipos de sistemas de

almacenamiento como Access, sistemas de ficheros y directorios como puede ser
Windows FAT32, hojas de datos de Excel, e-mails o bases de datos de XML.

[Link] es capaz de distinguir lo que es el acceso al sistema para comprobar datos

y lo que es la modificación y manipulación de datos, además de tener la capacidad de
crear componentes que realicen ambas funciones a la vez.

Para poder acceder a los datos de una base de datos necesitamos una interfaz que
haga de intermediaria entre ésta y el usuario. En [Link] se incluyen una serie de
proveedores y la que usa [Link] es OLE DB y los drivers ODBC que son mecanismos
genéricos para interactuar con las bases de datos.

De esta forma vamos a nombrar los Proveedores de Datos Administrados en el

Framework .NET.

■■ El proveedor para el servidor SQL

■■ El proveedor para OLE DB.

5.2.1. SQL server

SQL Server (Structured Query Language o lenguaje de consultas estructurado) es un
sistema para la gestión de bases de datos desarrollado por Microsoft para su modelo
relacional. En este caso la información se almacena en el servidor y el usuario solo
tiene la opción de acceder a ella.

Como se puede observar en el gráfico de más adelante, al servidor SQL se puede

acceder tanto desde el propio proveedor para el servidor SQL, así como desde los
proveedores OLE DB genéricos, en este caso que estudiamos para SQL.

5.2.2. OLE DB
OLE DB son las siglas para Object Linking and Embedding for Databases que viene
a significar “Enlaces de datos e inserción de datos en las bases de datos”, la cual ha
sido creada por Microsoft para tener acceso a los datos de manera regular.

210
5: [Link]

OLE DB pertenece a los componentes para accesos a datos creado por Microsoft
para interactuar con los programadores y ofrece una ayuda casi indispensable a la
hora de poder acceder a los datos. Gracias al namespace “[Link]” que
es el proveedor de datos de .NET para OLE DB podemos acceder a un origen de
datos en el espacio administrado. Existen una gran variedad de clases cada una con
una funcionalidad distinta a la hora de interactuar con datos y así facilitar la labor del
programador.

Volviendo al punto 5.2 de la unidad y volviendo a generalizar para ambos métodos de

proveedores de datos, vamos a ver un gráfico de cómo interactuarían estos sistemas
con nuestras aplicaciones [Link].

211
[Link] con C#

5.3. Objetos [Link]

El proceso que se sigue en [Link] para acceder a los datos consta de varios pasos
elementales para el correcto funcionamiento de nuestro código. Para ello se deben
utilizar una serie de objetos, cada uno con su funcionalidad y un uso específico.

Cuando estamos accediendo a una base de datos a través de los proveedores

anteriores, los resultados obtenidos o se procesan directamente, o bien se colocan
en un objeto DataSet perteneciente a [Link] para que el usuario pueda usarlos,
aunque para ello deben seguir un proceso hasta este último paso.

Para empezar, cuando se ha accedido a la base de datos tenemos un objeto

denominado connection, que es a través del que se puede acceder al proveedor
de datos. Una vez que hemos accedido al connection, el siguiente paso es el objeto
command que nos dice sobre qué datos estamos actuando o queremos manipular
dentro de una base de datos. Posteriormente, estos datos son insertados en el
nombrado DataSet o en DataReader que están en el mismo nivel y, finalmente desde
nuestra aplicación [Link] se pueden acceder a dichos datos.

Vamos a entrar en detalle en cada uno de los objetos nombrados y ver cuál es su uso.

5.3.1. Objeto Connection

Gracias a este objeto podemos acceder a un repositorio desde el cual podemos
obtener aquellos datos que necesitemos para nuestras consultas. El objeto [Link]
connection tiene un método que nos permite abrir la base de datos. Dicho método
es el Open () y a través de éste se especifica la cadena de conexión, la cual contiene
la información necesaria para conectarnos a la base de datos. En esta cadena se
especifica el proveedor que queremos usar, la base de datos de la cuál coger los
datos y los datos de usuario.

Dependiendo del proveedor que usemos, tendremos que usar una directiva u otra.
Evidentemente no podemos nombrar todos los proveedores existentes, pero sí
podemos nombrar las directivas más usuales.

Entre ellas encontramos la directiva para Access, que tendríamos la siguiente:

provider = [Link].4.0; data source =

MiWeb:MiRuta/[Link]

Para OLEDB cuando se llama a una base de datos SQL Server tendríamos la siguiente
directiva:

“provider = SQLOLEDB.1 ; server = Servidor; database =

MiBaseDatos; uid = Usuario; pwd = contraseña”

Vamos a realizar un ejemplo en el que hagamos uso de estas directivas. Para empezar
vamos a buscar dentro de la siguiente ruta:

C:\Program Files\Microsoft SQL Server Compact Edition\v3.5\Samples

212
5: [Link]

En esa ubicación podemos encontrar el fichero “[Link]”, que es una base

de datos de ejemplo que aparece al instalar el SQL Server. A modo de recordatorio
podemos decir que el SQL Server fue instalado en el paquete inicial en la unidad 1 (hay
que tener en cuenta que los datos están en inglés, aunque es sencillo).

También podemos encontrar este mismo fichero en la siguiente ruta, ya que en el

paquete office también aparece:

C:\Program Files\Microsoft Office\Office\samples

En el caso de no encontrarlo porque no lo tengamos instalado se puede bajar de la

página de Microsoft:

[Link]

Podemos observar en Microsoft Access (un uso más sencillo, ya que sólo con el ratón
vamos a poder movernos por dentro de la tabla) las tablas que contiene dicho ejemplo,
aunque posteriormente vayamos a utilizar Microsoft Visual Studio para cualquier tipo
de gestión con la base de datos.

Al abrir el documento nos encontraríamos con la siguiente tabla:

Ahora pinchamos sobre cualquiera de las siguientes tablas. Vamos a elegir por ejemplo
la de clientes (customers) y obtendremos una tabla con el resultado de los clientes.
Aquí presentamos una pequeña muestra de la tabla.

213
[Link] con C#

Si quisiéramos hacer esto en el SQL Server, deberíamos poner lo siguiente:

“Select * from Customers” que nos indica que queremos seleccionar todas las entradas
existentes para “customers”.

Además, para la conexión con la base de datos necesitamos configurar el fichero

[Link] de la siguiente forma:

<[Link]>
<compilation debug=”true” targetFramework=”4.0” />

...
</configuration>

Observamos que tenemos un trozo de código que nos permite configurar los
parámetros necesarios para poder realizar la conexión correctamente, en el bloque
de connectionStrings, en el cual tenemos que indicar un nombre y la ruta a la que
queremos acceder. Estos parámetros de configuración van a variar según el origen de
la base de datos y bajo la tecnología en la que se ha construido la misma.

214
5: [Link]

5.3.2. Objeto Command y DataReader

Hasta el momento lo único que hemos hecho ha sido saber cómo debemos
conectarnos a la base de datos, pero necesitamos algo más. Para ello tenemos que
conocer ciertos aspectos sobre SQL y sobre todo saber usar las funciones necesarias
para seleccionar, modificar, insertar o borrar datos.

■■ Select: para coger datos de una tabla.

■■ Insert: para insertar nuevos datos en la tabla.

■■ Delete: para borrar datos de una tabla.

■■ Update: para modificar datos de una tabla.

No nos basta solo con estas cuatro palabras para hacer consultas en la tabla. También
vamos a usar From para elegir dónde queremos que se actúe con los datos y Where
para explicar la condición.

Como ejemplo de los anteriores valores podemos intentar seleccionar el nombre de

las personas que hayan nacido en Sevilla de la tabla Personas. La solución a este
problema sería:

SELECT Nombre FROM Personas WHERE ciudad = ‘Sevilla’.

Vamos a aprender a gestionar las bases de datos desde Microsoft Visual Studio. Para
ello vamos a usar los ficheros descargados por el alumno. A continuación, vamos a
acceder a la carpeta contenedora del nuevo proyecto, para lo cual podemos llegar
copiando la ruta. Posteriormente, vamos a entrar en la carpeta descargada y copiamos
el fichero NORTHWND de tipo .MDF. Copiaremos estos ficheros y las pegaremos en
nuestro proyecto en la carpeta APP_DATA. Una vez realizado este paso, vamos a
volver a Visual Studio y actualizamos el proyecto, que se realizará en el explorador de
soluciones, pulsando sobre el botón de mostrar todos los archivos. También podemos
hacer este paso pulsando con el botón derecho sobre App_Data y darle a añadir un
elemento existente y buscar la ubicación de la base de datos. Podemos observar
como aparecen las nuevas carpetas añadidas, por lo tanto, ya podemos acceder a la
base de datos y realizar operaciones con ellas.

215
[Link] con C#

Si pinchamos sobre la base de datos empleada, nos aparecerá en Microsoft Visual

Studio la siguiente ventana:

A través de esta ventana podemos manejar la base de datos, es decir, añadiendo

registros, eliminándolos, modificándolos o creando nuevas tablas.

Vamos a realizar nuestro primer ejemplo para el cual (y todos los siguientes en la
unidad) vamos a tener que usar dos namespaces nuevos:

using [Link];
using [Link];

Así ya vamos a poder realizar las conexiones con la base de datos a través de
instrucciones SQL.

using System;
using [Link];
using [Link];
using [Link];
using [Link];

216
5: [Link]

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{

string consulta = “SELECT FirstName from

Employees”;
string resultado = “ “;
SqlConnection connection = new SqlConnection(Con
[Link][“ConnectionString”].
ToString());
SqlCommand comando = new SqlCommand(consulta,
connection);
SqlDataReader lector = null;
try
{
[Link]();
[Link] = “Hemos realizado bien la
conexión. <br />”;
lector = [Link]();
while ([Link]() == true)
{
resultado += lector[“FirstName”];
resultado += “&nbsp”;
resultado += “<br />”;
}

[Link] = resultado;
}
catch (Exception exc)
{
[Link] = “Algo hemos hecho mal. Error en
la conexion. <br />”;
[Link] = [Link]();
}

217
[Link] con C#

finally
{
[Link]();
[Link]();
[Link] = “Ya se ha cerrado la conexión
tras haberla abierto bien. <br />”;
}

}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>
</head>
<body>

Comprobando la conexión con

<asp:Label ID=”abrir” runat=”server”> </asp:Label>

Además vamos a tener que realizar una serie de modificaciones sobre el fichero Web.
config. Es en este fichero donde vamos a tener que realizar la conexión con la base de
datos a través del siguiente bloque:

218
5: [Link]

En dicho bloque vemos que tenemos un nombre (ConnectionString en nuestro caso,

aunque puede denominarse como el programador desee) que es el que utilizamos en
el fichero .[Link] en la línea de código para declarar la conexión.

SqlConnection objeto = new SqlConnection(ConfigurationMana

[Link][“ConnectionString”].ToString());

Además tenemos otro parámetro denominado “ConnectionString” en el que indicamos

la ruta donde está la base de datos. Nos quedaría, por lo tanto, ese trozo de código
de [Link] de la siguiente manera:

...

</configuration>

Como se puede observar, hemos tomado el código del primer ejemplo y hemos
añadido ciertas líneas. Las líneas principales serían en las que se hace la consulta, en
las que primero definimos la consulta y luego desde SQLCommand se hace la llamada
a esa consulta.

Posteriormente, hacemos un bucle while en el que mientras haya elementos que

consultar, vamos imprimiendo cada uno de los nombres de los empleados.

El resto del código es similar al anterior y como conclusión a nuestra consulta debemos
obtener los siguientes resultados:

219
[Link] con C#

Esto que hemos hecho anteriormente también es posible adaptarlo a un formato

más llamativo con tablas, con colores, etc. Simplemente hay que tener en cuenta la
etiqueta dataGrid.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{

string consulta = “SELECT PostalCode, City FROM

Customers”;

SqlConnection objeto = new SqlConnection(Confi

220
5: [Link]

[Link][“ConnectionString”].
ToString());
SqlCommand comando = new SqlCommand(consulta,
objeto);

try
{
[Link]();
[Link] = “Hemos realizado bien la
conexión. <br />”;

[Link] = comando.
ExecuteReader([Link]);
[Link]();

}
catch (Exception exc)
{
[Link] = “Algo hemos hecho mal. Error en
la conexion. <br />”;
[Link] = [Link]();
}

finally
{
[Link]();
[Link] = “Ya se ha cerrado la conexión
tras haberla abierto bien. <br />”;

}
}

________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]

221
[Link] con C#

[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>
</head>
<body>
Comprobando la conexión
<b> <asp:Label ID = “datos” runat = “server”> </
asp:Label></b> <br />
<br />
<asp:Label ID = “abrir” runat = “server”> </asp:Label>
<asp:datagrid ID = “tablita”
runat = “server” CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white” />
<asp:Label ID = “cerrar” runat = “server”> </
asp:Label>
</body>

</html>

Aquí hemos incluido los datos dentro de una tabla para una mayor atracción visual.
El código apenas cambia, puesto que en vez de recorrer todos los datos uno a uno
hemos decidido abrir la conexión e ir recogiéndolos a través de DataSource y DataBind.
Como conclusión hemos obtenido una tabla con los resultados de las ciudades y sus
códigos postales de la tabla de clientes:

222
5: [Link]

5.3.3. Objetos DataSet y DataTable

Gracias a DataSet vamos a poder representar datos de una base de datos
independientemente del origen de datos que contenga. [Link] trabaja con datos
aparentemente sin la necesidad de conectarse a la base de datos, es decir, sin ninguna
llamada al open ni al close, sino que se hace una copia de los datos y luego pueden ser
subidos. Tanto las directivas open como close van encapsuladas en el control. Para
ello se crea una DataTable y se rellenan las tablas con datos mediante DataAdapter (a
través del método Fill). Con DataView podemos ver una representación de los datos
en la tabla.

Aquí tenemos un ejemplo del código que hay que utilizar para obtener el mismo
resultado que anteriormente:

223
[Link] con C#

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
string consulta = “SELECT PostalCode, City FROM
Customers”;
DataSet objset = new DataSet();
SqlConnection objeto = new SqlConnection(Config
[Link][“ConnectionString”].
ToString());
SqlDataAdapter comando = new
SqlDataAdapter(consulta, objeto);
[Link](objset, “Customers”);
DataView objdat = new DataView(objset.
Tables[“Customers”]);
[Link] = objdat;
[Link]();
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

224
5: [Link]

<title> Control de errores </title>

</head>
<body>
Comprobando la conexión
<b> <asp:Label ID = “datos” runat = “server”> </
asp:Label></b> <br />
<br />
<asp:Label ID = “abrir” runat = “server”> </asp:Label>
<asp:datagrid ID = “lista”
runat = “server” CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white” />
<asp:Label ID = “cerrar” runat = “server”> </
asp:Label>
</body>

</html>

225
[Link] con C#

5.4. Trabajando con datos

Como hemos visto en el punto 5.3.3, tenemos la posibilidad de ir incluyendo los datos
o bien de forma conectada a través de open (), o bien de forma desconectada. Si
tenemos en cuenta el último apartado de los objetos [Link], podemos observar
cómo se trabajaba con DataSet y DataReader. Como pudimos ver en el ejemplo,
con DataSet obteníamos una tabla con los datos necesarios y la rellenábamos con el
comando Fill.

DataGrid es más llamativo visualmente hablando, pero DataSet tiene la ventaja de que
puede trabajar con varias tablas a la vez.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
string consulta = “SELECT PostalCode, City FROM
Customers”;
string consulta2 = “SELECT LastName, City FROM
Employees”;
DataSet objset = new DataSet();

SqlConnection objeto = new SqlConnection(Config

[Link][“ConnectionString”].
ToString());
SqlDataAdapter comando = new
SqlDataAdapter(consulta, objeto);
SqlDataAdapter comando2 = new
SqlDataAdapter(consulta2, objeto);
[Link](objset, “Customers”);
[Link](objset, “Employees”);

226
5: [Link]

DataView objdat = new DataView(objset.

Tables[“Customers”]);
DataView objdat2 = new DataView(objset.
Tables[“Employees”]);

[Link] = objdat;
[Link]();
[Link] = objdat2;
[Link]();
DataTable tabla = [Link][“Customers”];
DataTable tabla2 = [Link][“Employees”];
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>
</head>
<body>
Comprobando la conexión
<b> <asp:Label ID = “datos” runat = “server”> </
asp:Label></b> <br />
<br />
<asp:Label ID = “abrir” runat = “server”> </asp:Label>
<asp:datagrid ID = “lista”
runat = “server” CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white” />
<asp:datagrid ID = “lista2”
runat = “server” CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white” />
<asp:Label ID = “cerrar” runat = “server”> </
asp:Label>
</body>
</html>

227
[Link] con C#

5.4.1. Inclusión de nuevos datos con DataSet

Con [Link] tenemos acceso a bases de datos, pero también podemos manipularlas
como ya venimos diciendo a lo largo de esta unidad. Vamos a empezar con la inclusión,
que se puede realizar gracias a la opción DataRow. Row significa fila, así que con esta
opción vamos a añadir una nueva fila a la tabla. Veamos un ejemplo:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

228
5: [Link]

using [Link];

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>
</head>
<body>
<asp:Label ID = “datos” runat = “server”> </asp:Label>
<asp:Label ID = “abrir” runat = “server”> </asp:Label>

229
[Link] con C#

<table>
<tr>
<td> Tabla Inicial</td>
<td> Tabla Nueva </td>
</tr>
<tr>
<td valign = “top”>
<asp:DataGrid ID = “lista” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
<td valign = “top”>
<asp:DataGrid ID = “nuevafila” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
</tr>
</table>
<asp:Label ID = “cerrar” runat = “server”> </
asp:Label>
</body>

</html>

230
5: [Link]

Como podemos ver, hemos añadido un nuevo registro de la siguiente forma. Nos
hemos declarado una nueva variable fila de tipo DataRow, que llama a un elemento
DataTable y se crea un nuevo elemento. Posteriormente, hemos creado un nuevo
registro con los datos nuevos y añadimos a nuestra tabla la fila nueva:

[Link](fila);
[Link] = [Link];
[Link]();
}

5.4.2. Edición de datos con DataSet

Lógicamente también es posible modificar los datos que ya teníamos en la tabla. Para
ello accedemos al elemento que queramos modificar y posteriormente introducimos
los nuevos datos. De esta manera el código quedaría así:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

231
[Link] con C#

using [Link];

[Link] = [Link];
[Link]();
// Fin de la parte nueva del código
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

232
5: [Link]

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<table>
<tr>
<td> Tabla Inicial</td>
<td> Tabla Nueva </td>
<td> Tabla Modificada </td>
</tr>
<tr>
<td valign = “top”>
<asp:DataGrid ID = “lista” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
<td valign = “top”>
<asp:DataGrid ID = “nuevafila” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
<td valign = “top”>
<asp:DataGrid ID = “nuevafilamod” runat =
“server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
</tr>
</table>

233
[Link] con C#

<asp:Label ID = “cerrar” runat = “server”> </

asp:Label>
</body>

</html>

5.4.3. Eliminación de datos con DataSet

También es posible eliminar datos de una base de datos. Para ello utilizamos la directiva
delete. Aquí tenemos un ejemplo de una eliminación de un elemento:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

234
5: [Link]

[Link] = [Link];
[Link]();
// Parte nueva del código.
[Link][9].Delete();
[Link] = [Link];
[Link]();

// Fin de la parte nueva del código

}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

235
[Link] con C#

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<table>
<tr>
<td> Tabla Inicial</td>
<td> Tabla Nueva </td>
<td> Tabla Modificada </td>
<td> Fila eliminada </td>
</tr>
<tr>
<td valign = “top”>
<asp:DataGrid ID = “lista” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
<td valign = “top”>
<asp:DataGrid ID = “nuevafila” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
<td valign = “top”>
<asp:DataGrid ID = “nuevafilamod” runat =
“server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>

236
5: [Link]

</td>
<td valign = “top”>
<asp:DataGrid ID = “filaelim” runat = “server”
CellPadding=”2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
</tr>
</table>
<asp:Label ID = “cerrar” runat = “server”> </
asp:Label>
</body>
</html>

5.4.4. Tabla original con DataSet y Command

Recordamos que con DataSet trabajamos de forma desconectada, así que cualquiera
de las modificaciones que hemos hecho antes solo puede ser visible para nosotros
que las hemos hecho. Para el resto de personas que tengan acceso a esa tabla
tendremos que hacer algo, y para poder realizar dicha operación tenemos que definir
un constructor y sobre ese constructor especificar los cambios realizados.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

237
[Link] con C#

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

[Link] = [Link];
[Link]();
[Link][9].Delete();
[Link] = [Link];
[Link]();

//Parte nueva del Código

238
5: [Link]

SqlCommandBuilder constructor = new

SqlCommandBuilder(comando);
[Link] = constructor.
GetUpdateCommand();
[Link] = constructor.
GetInsertCommand();
[Link] = constructor.
GetDeleteCommand();
[Link](objset, “Employees”);
consulta = “SELECT EmployeeID, LastName, City FROM
Employees”;
[Link]();
SqlCommand apertura = new SqlCommand(consulta,
objeto);
[Link] = apertura.
ExecuteReader([Link]);
[Link]();
//Fin de la parte nueva del código
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<table>
<tr>
<td> Tabla Inicial</td>
<td> Tabla Nueva </td>
<td> Tabla Modificada </td>
<td> Fila eliminada </td>

239
[Link] con C#

</tr>
<tr>
<td valign = “top”>
<asp:DataGrid ID = “lista” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
<td valign = “top”>
<asp:DataGrid ID = “nuevafila” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
<td valign = “top”>
<asp:DataGrid ID = “nuevafilamod” runat =
“server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
<td valign = “top”>
<asp:DataGrid ID = “filaelim” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
</td>
</tr>
</table>
<asp:DataGrid id = “original” runat = “server”
CellPadding = “2”
HeaderStyle-BackColor = “black”
HeaderStyle-ForeColor = “white”>
</asp:DataGrid>
<asp:Label ID = “cerrar” runat = “server”> </
asp:Label>
</body>

</html>

240
5: [Link]

Como vemos, hemos utilizado cuatro comandos para actualizar nuestra tabla:
UpdateCommand, InsertCommand, DeleteCommand y Update. Posteriormente,
hemos realizado la conexión con la base de datos y luego la hemos cerrado.

5.4.5. Otros métodos

Aparte de los métodos que hemos visto hasta ahora, existen una serie de ellos que
son también muy importantes para el manejo de las bases de datos, como son
ExecuteReader (sí se ha visto), ExecuteNonQuery y ExecuteScalar.

ExecuteNonQuery se usa para realizar operaciones de consulta de la estructura de

la base de datos o para modificar los datos sin necesidad de hacer uso del DataSet
cuando se ejecutan las instrucciones de inserción, modificación o actualización. El
valor devuelto se corresponde al número de filas afectadas por el comando. Para el
resto de instrucciones el valor devuelto es -1. Aquí vemos un ejemplo de cómo usar
el comando:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

241
[Link] con C#

Con ExecuteReader se envía la propiedad CommandText al objeto Connection y se

crea un objeto de tipo SqlDataReader.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{

string consulta = “SELECT FirstName from

Employees”;
string resultado = “ “;
SqlConnection connection = new SqlConnection(Con
[Link][“ConnectionString”].

242
5: [Link]

ToString());
SqlCommand comando = new SqlCommand(consulta,
connection);
SqlDataReader lector = null;
try
{
[Link]();
[Link] = “Hemos realizado bien la
conexión. <br />”;
lector = [Link]();
while ([Link]() == true)
{
resultado += lector[“FirstName”];
resultado += “&nbsp”;
resultado += “<br />”;
}

[Link] = resultado;
}
catch (Exception exc)
{
[Link] = “Algo hemos hecho mal. Error en
la conexion. <br />”;
[Link] = [Link]();
}
finally
{
[Link]();
[Link]();
[Link] = “Ya se ha cerrado la conexión
tras haberla abierto bien. <br />”;
}

}
}

Con ExecuteScalar se ejecuta la consulta de forma que como resultado se devuelva

un dato de un registro concreto o de una consulta del tipo “SELECT COUNT…”.

using System;
using [Link];
using [Link];
using [Link];
using [Link];

243
[Link] con C#

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{

string consulta = “SELECT COUNT (FirstName) from

Employees”;
SqlConnection connection = new SqlConnection(Con
[Link][“ConnectionString”].
ToString());

SqlCommand comando = new SqlCommand(consulta,

connection);

try
{
[Link]();
[Link] = “Hemos realizado bien la
conexión. <br />”;

int id;
if ([Link]([Link]().
ToString(), out id))
{
[Link] = “El numero de empleados es “
+ id + “<br />”;
}
}
catch (SqlException ex)
{
[Link] = [Link]();
}
finally
{
[Link]();

244
5: [Link]

[Link] = “Connection Closed.”;

}
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>
</head>
<body>

Comprobando la conexión...
<br />

<asp:Label ID=”abrir” runat=”server”> </asp:Label>

Tanto para un método como para el otro es necesario que la conexión con la base de
datos esté abierta.

Además, también disponemos del método NextResult, proporcionado por el

DataReader, el cual sirve para recorrer el conjunto de resultados en orden en caso de
que se devuelvan varios resultados. Por ejemplo:

245
[Link] con C#

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{

string consulta = “SELECT FirstName from

Employees; SELECT City From Employees”;
string resultado = “ “;
SqlConnection connection = new SqlConnection(Con
[Link][“ConnectionString”].
ToString());
SqlCommand comando = new SqlCommand(consulta,
connection);
SqlDataReader lector = null;
try
{
[Link]();
[Link] = “Hemos realizado bien la
conexión. <br />”;
lector = [Link]();

while ([Link]() == true)

{
resultado += lector[“FirstName”];
resultado += “&nbsp”;
resultado += “<br />”;
}
[Link]();

while ([Link]() == true)

246
5: [Link]

{
resultado += lector[“City”];
resultado += “&nbsp”;
resultado += “<br />”;
}
[Link]();

}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>
</head>
<body>

Comprobando la conexión...
<br />

<asp:Label ID=”abrir” runat=”server”> </asp:Label>

247
[Link] con C#

<div id = “clientes” runat = “server”> </div>

<asp:Label ID=”cerrar” runat=”server”> </asp:Label>
</body>
</html>

248
5: [Link]

RESUMEN
■
Las bases de datos son colecciones de datos en las que podemos insertar datos,
eliminarlos, modificarlos o simplemente acceder a ellos para consultarlos.

■
Tenemos varios tipos de proveedores de datos, como proveedores para SQL o
proveedores para OLE DB.

■
Tenemos varios objetos [Link] para poder realizar una conexión y manipular datos
de una base de datos. Dichos objetos son Connection, Command, DataReader,
DataSet y DataTable.

■
Se puede trabajar con datos de forma conectada y desconectada. En ambos casos
se pueden manipular datos a través de cualquiera de las cuatro acciones nombradas.
La diferencia de hacerlo de forma conectada a forma desconectada, es que mientras
estamos conectados los demás usuarios que accedan a la tabla pueden ver los
cambios en tiempo de ejecución, mientras que si lo hacemos de forma desconectada
hay que subir los datos a través de una conexión.

249
6
[Link] con C#
6
DIDÁCTICA
UNIDAD

6. Controles Web con [Link]

6: Controles Web con [Link]

253
6: Controles Web con [Link]

OBJETIVOS
■ Aprender los tipos de controles que existen para programar.

■
Conocer y saber usar los distintos tipos de controles que existen. Vamos a ver los controles
HTML, los controles de usuario y los propios de la tecnología [Link].

■ Saber cuáles son las ventajas y propiedades del uso de los controles [Link].

■ Saber cuál es el proceso que sigue una página [Link].

■
Aprender los distintos tipos de controles que existen en [Link], cómo usarlos, cuándo
usarlos y cuáles son sus propiedades.

■
Aprender algunas técnicas de programación que mejoren nuestras prestaciones y que
aumenten en eficiencia. En esta ocasión aprenderemos a usar la técnica Code-Behind.

■
Aprender a programar usando la mayoría de los tipos de controles de usuario y ampliar
conocimientos en HTML.

■ Aprender a usar los Web parts.

■ Saber cuándo usar cada tipo de Web parts.

■
Profundizar en la personalización de las páginas Web y saber utilizar los controles de Visual
Studio para su implementación.

255
[Link] con C#

INTRODUCCIÓN

Ya en la unidad 2 empezamos a familiarizarnos con los Además de todo esto, debemos conocer distintas
controles Web [Link], que como podemos recordar, técnicas de programación para mejorar nuestro
nos ayudan a darle mayor dinamismo a nuestra página. código, nuestra eficiencia y la elegancia del código.
Vimos, entre otros, controles para formularios y durante Dentro de este marco incluimos la técnica Code-
esta unidad ampliaremos nuestros conocimientos Behind que veremos al final del tema, que es una
sobre los controles Web. Además de los controles técnica que separa lo que es código HTML y ASP.
Web [Link], también podemos encontrarnos con NET y lo que es código C#.
controles HTML y controles de usuario.
El uso de controles es una gran ventaja a la hora de
programar con [Link], ya que obtenemos gran
abstracción del código y conseguimos muchas
funcionalidades que nos van a ser útiles. Hay
varios tipos de controles y cada uno de ellos nos
proporcionará un uso distinto y nos permitirá tener una
página dinámica, sin errores y limpia. Es importante
saber cuándo se van a usar los controles.

256
6: Controles Web con [Link]

6.1. Controles HTML y de usuario

Como hemos dicho ya, aparte de los controles [Link], tenemos controles HTML
y controles de usuario. Los controles HTML son necesarios, tanto que los controles
[Link] los usan. Además, hay veces que [Link] no puede por sí mismo realizar
ciertos aspectos, sino que necesita de la ayuda del usuario para realizarlos. En este
marco se encuadran los controles de usuario.

6.1.1. Controles HTML

Los controles de servidor HTML son etiquetas HTML entendidas por el servidor. Esto
quiere decir que podemos convertir una etiqueta HTML en un objeto HtmlInputText.
Para poder hacer esto necesitamos primero importar un nuevo namespace que
es [Link], que hereda de la clase base [Link].
[Link]. Con la siguiente declaración tenemos un control de
servidor HTML que puede ser accedido en el servidor dentro del código del formulario
Web:

<INPUT id = ”ParteHtml” type = ”text” name = “ParteHtml” runat

= “server”>

El hecho de que esto sea programable es que gracias a la referencia que hacemos
en runat = ”server”, nos aseguramos que el Framework .NET convertirá una etiqueta
HTML en un objeto. Una condición básica es que las etiquetas estén correctamente
cerradas y dentro de su estructura.

HTML tiene sus propios controles para definir sus características. Dentro de ellas
podemos encontrarnos con las siguientes:

■■ Podemos acceder a los controles de servidor HTML de manera programática,

usando las técnicas de programación orientada a objetos. Como objetos que
son cada control de servidor HTML podemos acceder a ellos y modificarlos.

■■ Los controles HTML proporcionan un mecanismo que nos permita escribir

eventos.

■■ Los valores que un usuario puede dar en un formulario, cuando son enviados al
servidor, se mantienen.

■■ Podemos asociar datos a una o más propiedades de un control de servidor

HTML.

■■ Podemos asociar cualquier atributo que necesitemos a un control HTML.

■■ Podemos asignar una validación de control [Link] para hacer el trabajo de

validación de HTML.

A modo de resumen podemos decir, que para pasar una página de control de HTML a
un control de servidor HTML, nos basta con añadir a la etiqueta la característica runat
=”server” y que el identificador que le demos sea único.

257
[Link] con C#

Es importante decir que podemos usar controles HTML o [Link] a nuestro gusto,
incluso mezclarlos cuando nos convenga.

6.1.2. Controles de usuario

Este tipo de controles son desarrollados por el usuario con texto, controles HTML o
controles [Link]. El propósito de la creación de controles de usuario es proveer
de la capacidad de reusar funcionalidades de la interfaz de usuario. Los controles de
usuario se guardan como ficheros .ascx.

Veamos un ejemplo de un control de usuario. Primero tenemos que crearnos un

fichero de tipo Control de Usuario y guardarlo, además de saber su ruta porque luego
lo vamos a usar. Al igual que con los ficheros .aspx, vamos a necesitar usar tanto el
fichero .ascx, como el .[Link]. Observemos como debemos codificar estos ficheros:

Fichero .[Link]:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class control : [Link]

{
private string backColor = “blue”;

public string BackColor

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

258
6: Controles Web con [Link]

protected void Page_Load(object sender, EventArgs e)

{

}
}

Fichero .ascx:

<%@ Control Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”control” %>

<table style = “background-color: <% =BackColor %>” width

= “40%” cellpadding = “10” cellspacing = “0” >
<tr>
<td width = “50%”>
Curso [Link] usando C#
</td>
</tr>
</table>

Con este control hemos definido un control de usuario en el que hemos definido un
propio estilo, el cual tiene ciertos aspectos que nosotros hemos creado. Podemos
definir que hemos inventado un patrón, el cual puede ser usado por los usuarios.

A continuación vamos a crear un fichero .aspx, con su respectivo fichero .[Link] para
poder usar nuestro control de usuario.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load()
{

259
[Link] con C#

if (!([Link]))
{

ArrayList colores = new ArrayList();

[Link](“Yellow”);
[Link](“Red”);
[Link](“Green”);
[Link](“Blue”);
[Link](“Black”);
[Link] = colores;
[Link]();
}

}
public void click(Object o, EventArgs args)
{
string col = [Link];
[Link] = col;
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>
<%@ Register TagPrefix = “control” TagName = “entrada” Src
= “~/[Link]” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head runat=”server”>
<title>Control de Usuario</title>
</head>
<body>
<form id=”Form1” runat = “server” method = “post”>
<control:entrada ID = “usuario” runat = “server” />
Elija un color
<br />
<asp:DropDownList ID = “lista” runat = “server”>
</asp:DropDownList>
<asp:Button ID=”Button1” Text = “Cambie la cabecera”
OnClick = “click” runat = “server” />

260
6: Controles Web con [Link]

<br /> <br />

<asp:Label ID = “color” runat = “server”> </asp:Label>
</form>
</body>
</html>

Con la primera línea estamos definiendo una nueva etiqueta, la cual usa el
control de usuario que hemos creado. Esta etiqueta será de la siguiente forma:
<TagPrefix:TagName …> el resto del código nos resulta familiar y los aspectos de
diseño se resolverán más adelante. El resultado como era de esperar es una página
en la que podemos cambiar de color nuestra cabecera de la página al elegir un color
de la lista.

Esta característica se puede apreciar en muchas páginas en las que uno puede definir
su fondo de pantalla, por ejemplo, en la cuenta de usuario de Gmail cada uno puede
definir el tema de su fondo de pantalla.

261
[Link] con C#

6.2. Controles de servidor [Link]

Como vimos en la unidad 3, los controles [Link] nos proporcionan los elementos
necesarios para poder diseñar y construir páginas Web. Entre estos controles podemos
recordar aquellos que usábamos para los Web forms, por ejemplo, los botones, los
radio buttons, las casillas para elegir varias opciones, etcétera. [Link] nos puede
proporcionar algunos controles más un poco más avanzados, entre ellos el DataGrid
que hemos visto justo en la unidad anterior. Vamos a ver algunas características
sobre los controles [Link], que hacen que podamos elegir mejor entre [Link]
que HTML. A continuación, describiremos estas ventajas: detección automática
del navegador, anulación automática de la elección del navegador, modelado de
objetos, eventos o propiedades.

6.2.1. Detección automática del navegador

Los controles de servidos de [Link] son capaces de detectar las capacidades del
navegador del cliente, simplemente leyendo la información del agente de usuario a
través del navegador al servidor durante la solicitud de conexión. En el momento en
el que la página encuentra alguna coincidencia entre la información que ha pasado el
usuario y las encontradas en el archivo ya se pueden leer las funciones pertenecientes
al navegador. Dependiendo del tipo de navegador que estemos utilizando, cada uno
interpretará los controles [Link] de distintas formas. Por ejemplo, si [Link] está
representando un código HTML, se puede determinar si usamos una versión u otra.

Hay que decir que evidentemente en páginas simples, la diferencia apenas se nota.
Si representamos un Web form simple, no vamos a notar diferencias, sin embargo, si
representamos una página compleja sí se puede notar alguna diferencia entre distintos
exploradores. Esta característica también se puede anular.

6.2.2. Eliminación automática de la detección del navegador

Como hemos visto en el apartado anterior, se puede detectar automáticamente el
navegador, aunque también podemos eliminar esa característica. Para ello debemos
establecer la propiedad ClientTarget de nuestra página. Esta propiedad la podemos
establecer a través de la declaración como atributo de la directiva @Page para la
página. Para configurar dicha propiedad debemos utilizar el siguiente código:

262
6: Controles Web con [Link]

El namespace al que pertenece esta característica es el [Link].

ClientTargetSection.

6.2.3. Eventos y modelado de objetos

En el caso del modelado de objetos vimos, en la unidad 3 y 4, al instanciar un servidor
[Link] que estábamos creando una instancia de un objeto. Por parte de los eventos
sabemos que [Link] es capaz de asignar eventos. Un evento se conseguía al
mandar una acción al servidor:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
public void Hora(object o, EventArgs args)
{
[Link] = [Link]();
}

}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>
<%@ Register TagPrefix = “control” TagName = “entrada” Src
= “~/[Link]” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]

263
[Link] con C#

<head runat=”server”>
<title>Control de Usuario</title>
</head>
<body>
<form id = “horita” method = “post” runat = “server”>
<asp:button id = “BotonHora” runat = “server” text =
“¿Qué hora es?” onclick = “Hora” />
</form>
</html>

6.2.4. Propiedades
Algunas de las propiedades [Link] son las siguientes:

■■ BackColor: para asignar un color de fondo a la sección que deseemos.

Podemos asignar un color en forma de cadena, tipo “blue” o en forma de cadena
hexadecimal, por ejemplo: #C00C34.

■■ ForeColor: para asignar un color de letra.

■■ BorderWidth: para asignar el ancho del borde de la sección que estamos

usando.

■■ Visible: esta característica sirve para darle visibilidad o la capacidad de ocultar

un control.

■■ Enabled: esta capacidad, aunque parecida a la anterior, nos muestra el control

siempre, aunque podemos modificarlo para que esté habilitado o no.

■■ Height y Width: sirven para darle anchura y altura en píxeles a los controles.

■■ Font-Size: sirve para dar formato y tamaño a las letras.

Hay muchas más características que pueden tomar los controles, pero solo hemos
nombrado las más importantes. También podemos darle anchura a las letras,
ponerlas en negrita, darle formato a los bordes de los botones, etcétera. Para ampliar
conocimientos sobre estas características es recomendable visitar la documentación
de SDK.

264
6: Controles Web con [Link]

6.3. Ciclo de vida de una página [Link]

Cuando nos referimos al ciclo de vida de una página estamos hablando del proceso
que existe desde que se abre la página hasta que se cierra, es decir, desde que se
hace el Page_Load() hasta que se cierra.

6.3.1. Page_Load
Es un método de la clase Page. Este método es invocado cuando la página se carga
por primera vez o cuando es actualizada. Ya sabemos perfectamente cómo se usa
este método:

void Page_Load (object o, EventArgs args).

6.3.2. Manejo de eventos

Después de que una página sea cargada, el siguiente paso es el manejo de los
eventos. Una vez cargada la página, los eventos son invocados cuando se llaman,
como ocurre con los botones cuando son pulsados.

6.3.3. Page_Unload
Este método es el contrario a Page_Load. Con Page_Unload lo que intentamos es
cerrar elementos abiertos antes de cerrar la página, como por ejemplo cerrar ficheros,
desconectarnos de una base de datos. Este método se usa de la siguiente forma:

void Page_Unload (object o, EventArgs args)

Es cierto que el uso de este método puede provocar problemas de rendimiento, por
lo que conviene cerrar las bases de datos en el mismo método en las que se esté
usando.

Vamos a ver un ejemplo donde utilicemos algunas de las aplicaciones anteriores:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

265
[Link] con C#

using [Link];

public partial class _Default : [Link]

{
protected void Validacionpista(object o, [Link].
[Link] args)
{
[Link] = true;

}
protected void ConfirmarPista(object o, EventArgs args)
{
if (!([Link]))
{
return;
}
String horapartido, pistapartido;
horapartido = [Link];
pistapartido = [Link];
[Link] = [Link];
[Link] = “Ya tiene reservada su pista a
las “ + horapartido
+ “ en la pista “ + pistapartido;
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>
<%@ Register TagPrefix = “control” TagName = “entrada” Src
= “~/[Link]” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Unidad 6 </title>
</head>
<body>
<h3> Alquiler pista Pádel </h3>
<form id=”padel” method =”post” runat=”server”>

266
6: Controles Web con [Link]

<asp:Panel ID = “panel” runat = “server” Width =

“400px” Height = “60px” BackColor = “Gray”>
Número de pista: <asp:Dropdownlist ID =
“pista” runat = “server” Width = “80px” Height = “25px”>
<asp:listitem> Pista 1 </asp:listitem>
<asp:listitem> Pista 2 </asp:listitem>
<asp:listitem> Pista 3 </asp:listitem>
<asp:listitem> Pista 4 </asp:listitem>
</asp:dropdownlist>
Hora de alquiler: <asp:DropDownList ID =
“hora” runat = “server” Width = “60px” Height = “25px”>
<asp:listitem> 10:00 </asp:listitem>
<asp:listitem> 12:00 </asp:listitem>
<asp:listitem> 16:00 </asp:listitem>
<asp:listitem> 18:00 </asp:listitem>
<asp:listitem> 20:00 </asp:listitem>
</asp:DropDownList>
<asp:RequiredFieldValidator ID = “pistarequerida”
runat = “server”
ErrorMessage = “Indique qué pista desea
seleccionar por favor. “
ControlToValidate = “pista”
/>
<asp:RequiredFieldValidator ID = “horarequerida”
runat = “server”
ErrorMessage = “Indique a qué hora desea
jugar. “
ControlToValidate = “hora”
/>
<asp:CustomValidator ID = “validacion” runat =
“server”
ControlToValidate = “pista”
OnServerValidate = “validacionpista” />

</asp:Panel>

<p>
<asp:Button ID = “botonaceptar” runat =
“server” Text = “Confirmar” OnClick = “confirmarPista” />
</p>
<p>
<asp:Label ID = “mensajeconf” runat = “server”
BackColor = “Gray” Font-Bold = “true”
Text = “Escoja una pista, una hora y

267
[Link] con C#

confirme” />
</p>

</form>
</body>
</html>

268
6: Controles Web con [Link]

Después de elegir una pista y una hora, le damos al botón de confirmar y nos debería
salir algo parecido a lo siguiente:

Como podemos observar, es un código que es asequible a estas alturas del curso. Ya
hemos visto la mayoría de los elementos que aparecen en este código, aunque sí es
verdad que hay algunos nuevos. Vamos a empezar por los comandos nuevos que hay
en la parte del HTML. Por primera vez aparecen algunas propiedades de las que hemos
visto antes como son Width y Height o BackColor. También aparece en este ejemplo
la opción para obligar a rellenar un campo. Esta etiqueta es la RequiredFieldValidator,
que aunque en este ejemplo no nos sirva de mucho porque tenemos una lista en la que
por defecto ya tenemos una opción seleccionada, sí nos va a servir para el próximo
ejemplo. En esta etiqueta tenemos que indicar qué error se debe mostrar a través
del comando ErrorMessage y cuál es el campo que queremos que sea obligatorio
a través del comando ControlToValidate. Para hacer la comprobación tenemos que
usar la etiqueta CustomValidator y dentro de ésta se usa el OnServerValidate, que
nos sirve para ver en qué método se debe hacer esta comprobación. Como ya hemos
visto antes, en estos momentos no hace falta.

Si pasamos a la parte de los métodos, tenemos uno que sirve para validar la pista, el
cual usaremos en el siguiente ejemplo, en el que hemos puesto que los argumentos
estén a true para que los cambios que hagamos puedan hacerse correctamente y
después, tenemos un nuevo método que hará posible que modifiquemos la etiqueta
que tenemos en la parte inferior de nuestro navegador.

Veamos ahora un ejemplo en el que en vez de tener una lista desplegable tengamos
que rellenar nosotros mismos esos campos. En esta ocasión sí vamos a hacer uso de
los campos requeridos:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

269
[Link] con C#

using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void validacioncoche(object o, [Link].
[Link] args)
{
[Link] = false;
DateTime fecharec, fechadev;
[Link] = [Link];

try
{
fecharec = [Link]([Link]);
}
catch (Exception e1)
{
[Link] = “Introduzca la fecha con el
siguiente formato: DD/MM/YYYY “ +
“ en el campo fecha de recogida.”;
return;
}
try
{
fechadev = [Link](fechadevolucion.
Text);
}
catch (Exception e2)
{
[Link] = “Introduzca la fecha con el
siguiente formato: DD/MM/YYYY “ +
“ en el campo fecha de devolución.”;
return;
}

if (fecharec >= fechadev)

{
[Link] = “La fecha de devolución
debe ser posterior a la fecha de recogida”;
return;
}

270
6: Controles Web con [Link]

if (fecharec <= [Link])

{
[Link] = “La fecha de recogida debe
ser posterior a la fecha actual.”;
return;
}

[Link] = true;

}
protected void confirmarCoche(object o, EventArgs args)
{
if (!([Link]))
{
return;
}
DateTime fecharec, fechadev;
String cocherec, lugarrec;
cocherec = [Link];
lugarrec = [Link];
fecharec = [Link]([Link]);
fechadev = [Link]([Link]);
[Link] = [Link];
[Link] = “Ya tiene reservada su coche
del modelo: “ + cocherec
+ “ y lo debe recoger en: “ + lugarrec + “<br
/>” + “ Su alquiler va desde el “
+ [Link]() + “ hasta el “
+ [Link]();
}

}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

271
[Link] con C#

<title> Unidad 6 </title>

</head>
<body>
<h3> Alquiler de un Coche </h3>
<form id=”padel” method =”post” runat=”server”>

<asp:Panel ID = “panel” runat = “server” Width =

“500px” Height = “130px” BackColor = “#D8D8D8” >
Marca: <asp:Dropdownlist ID = “coche” runat =
“server” Width = “120px” Height = “25px”>
<asp:listitem> Ferrari </asp:listitem>
<asp:listitem> Lamborghini </asp:listitem>
<asp:listitem> Rolls Royce </asp:listitem>
<asp:listitem> Maseratti </asp:listitem>
</asp:dropdownlist>
Lugar de alquiler: <asp:DropDownList ID =
“lugar” runat = “server” Width = “120px” Height = “25px”>
<asp:listitem> Madrid </asp:listitem>
<asp:listitem> Barcelona </asp:listitem>
<asp:listitem> Sevilla </asp:listitem>
<asp:listitem> Valencia </asp:listitem>
<asp:listitem> Zaragoza </asp:listitem>
</asp:DropDownList>
<br />
<br />
Fecha de recogida: <asp:TextBox ID =
“fecharecogida” runat = “server” Width = “120px” Height =
“25px” />
Fecha de devolución: <asp:TextBox ID =
“fechadevolucion” runat = “server” Width = “120px” Height
= “25px” />
<asp:RequiredFieldValidator ID = “fecharecreq”
runat = “server”
ErrorMessage = “Indique el día de recogida por
favor. “
foreColor = “Blue”
ControlToValidate = “fecharecogida”
/>
<br />
<asp:RequiredFieldValidator ID = “fechadevreq”
runat = “server”
ErrorMessage = “Indique qué día va a devolver
el coche. “
foreColor = “Blue”

272
6: Controles Web con [Link]

ControlToValidate = “fechadevolucion”
/>
<br />
<asp:CustomValidator ID = “validacion” runat =
“server”
ControlToValidate = “fecharecogida”
OnServerValidate = “validacioncoche” />

</asp:Panel>

</form>
</body>
</html>

Como podemos ver aquí, hemos hecho uso de los campos requeridos en los de fecha
de recogida y en los de fecha de devolución. Veamos una imagen del resultado que
obtendríamos una vez le damos al botón aceptar con esos campos vacíos:

Además, tenemos que hacer algunas comprobaciones respecto a la fecha. [Link]

nos proporciona un tipo que es el DateTime, el cual tiene un formato para la fecha
y podemos realizar estas comprobaciones de manera fácil a través de operadores

273
[Link] con C#

de comparación. Como es lógico y se suele hacer en todas las páginas de este

tipo, debemos comprobar que la fecha de recogida debe ser previa a la fecha de
devolución, así como que la fecha de recogida no sea previa a la actual. Para hacer
este último chequeo utilizamos el .Now que nos devuelve la hora actual. También
debemos comprobar que el formato que le demos a la fecha debe ser tal y como se
indica. Hay que decir que [Link] soporta varios formatos de fecha. Por ejemplo, “30
diciembre 2010” lo soporta y 30-12-2010 también lo soporta. Este error también se
producirá si introducimos una fecha errónea, por ejemplo, 32/20/2010.

En primer lugar es que la fecha de recogida debe ser posterior a la fecha actual:

Ahora veamos que la fecha de devolución sea posterior a la fecha de recogida del
coche:

274
6: Controles Web con [Link]

Vamos a ver que en el campo fecha no ponemos ninguno de los formatos soportados
por [Link]:

Finalmente, si hemos hecho todo correctamente, obtendremos el siguiente resultado:

275
[Link] con C#

6.4. Tipos de controles en [Link]

Los controles en [Link] pueden ser de varios tipos. Nosotros vamos a hacer un
repaso a los cuatro diferentes grupos de controles: intrínsecos, de validación, rich y de
interpretación. Expliquemos un poco más estos controles.

6.4.1. Controles intrínsecos

La mayoría de estos controles ya los hemos visto, pero vamos a hacer un pequeño
repaso. Algunos de estos controles se refieren a comandos HTML. Por ejemplo,
tenemos Button, CheckBox, ListBox, RadioButton, Table, TableRow, TableCell o
Label. Hay algunos que no hemos visto como Image que sirve para mostrar una
imagen GIF, JPG o cualquier otro tipo de imagen soportado por [Link]. También
podemos usar el HyperLink que nos muestra el hipervínculo a otra página.

6.4.2. Controles rich

Estos controles son la composición de más de dos componentes intrínsecos y nos
proporcionan una mayor funcionalidad y podemos programarlos de una manera
extremadamente sencilla. Como ejemplo tenemos los siguientes controles:

■■ AdRotator: nos muestran elementos como anuncios de manera aleatoria que

van cambiando cada vez que accedemos a la página.

■■ Calendar: nos muestra el calendario en forma de una tabla de un mes. Un poco

más adelante veremos cómo se hace.

■■ CheckBoxList: con este control podemos hacer una selección de varios

elementos entre varias opciones.

■■ ImageButton: nos muestra una imagen sobre la que se puede pulsar y acceder
a ella.

■■ LinkButton: al pulsar sobre ella nos devuelve a la página de origen.

■■ RadioButtonList: nos da la posibilidad de elegir una única opción de entre varios

elementos.

En Microsoft Visual Studio cuando estamos creando un nuevo sitio Web tenemos
la posibilidad de incluir los controles anteriores y los intrínsecos de manera manual
gracias a la pestaña que aparece a la derecha de la pantalla:

276
6: Controles Web con [Link]

Aquí simplemente tenemos que pulsar sobre el control que queramos incluir y
arrastrarlo hasta la zona de código donde queramos que aparezca.

Veamos ahora algunos ejemplos sencillos de uso de los controles Rich:

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

<html>
<head runat=”server”>
<title>Página sin título</title>
</head>
<body>
<form id=”form1” runat=”server”>
<asp:Calendar ID=”Calendar1” runat=”server”> </
asp:Calendar>
</form>
</body>
</html>

277
[Link] con C#

Se pueden hacer algunas mejoras sobre el calendario, como elegir el día en el que
se empieza, ya que por ejemplo, en algunos países se empieza a contar desde el
domingo y en otros como España desde el lunes.

Otro ejemplo puede ser para ir a un hipervínculo:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void click(object o, EventArgs args)
{
[Link](“[Link]
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

278
6: Controles Web con [Link]

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Unidad 6 </title>
</head>
<body>
<form id=”form1” runat=”server”>
Para hacer nuestro curso en [Link] visite nuestra
página Web:
<asp:LinkButton ID=”LinkButton1” runat=”server”
OnClick = “click” > Seas, estudios superiores abiertos
</asp:LinkButton>

</form>
</body>
</html>

6.4.3. Controles de validación

Los controles de validación son aquellos que nos permiten que los datos que
introduzcamos en los campos cumplan con una serie de condiciones necesarias. Ya
hemos visto que existe una validación para campos requeridos o una validación para
evitar desbordamientos o valores fuera de rango. Veamos algunos controles:

■■ CompareValidator: compara el valor que ha dado un usuario con un valor fijo.

■■ CustomValidator: comprueba el dato introducido por el usuario con un método

desarrollado por nosotros.

■■ RangeValidator: comprueba que los datos no se salgan de un rango especificado

(no puede haber más de 12 meses, ni más de 31 días).

■■ RegularExpressionValidator: comprueba que el valor que introducimos cumple

un cierto patrón. Por ejemplo, queremos que el NIF sea introducido de la siguiente
manera: 12345678-X. Si no se cumple cierto patrón, nos saldrá un error.

■■ RequiredFieldValidator: comprueba que no haya un campo obligatorio vacío.

279
[Link] con C#

6.4.4. Controles de interpretación

Quizá sea el tipo de control más complejo, aunque no por ello sean más difíciles
de usar. Con estos controles podemos mostrar gran variedad de datos, aunque
especialmente en los de una base de datos. Entre los controles de datos existentes
tenemos los siguientes:

■■ DataGrid: sirve para dibujar varias columnas e introducir datos dentro de sus
celdas.

■■ DataList: muestran los elementos de una fuente de datos.

■■ Repeater: con este control podemos hacer repetir el valor de una fila en el resto
de filas correspondientes.

Vamos a realizar un ejemplo en el que intentemos incluir la mayoría de los elementos

vistos hasta ahora.

Gracias a un magnífico sorteo que se ha realizado entre los estudiantes del curso ASP.
NET, al ganador le ha tocado un viaje “Round the World” para dar la vuelta al mundo.
Como es un tanto complejo y con todas las escalas que hacemos, nos resulta casi
imposible acordarnos cuando tenemos los vuelos, así que para ello nos creamos un
calendario.

Para usar el calendario hemos tenido que incluir los datos del viaje en un fichero .xml
con el siguiente código:

<?xml version=”1.0” encoding=”utf-8” ?>

<Ruta>
<Event>
<ShortDesc> 1º vuelo: Madrid - Dubai </ShortDesc>
<DetailDesc> Vuelo directo Round the World. 6 días en
destino </DetailDesc>
<EventDate> 01/01/2011 </EventDate>
<StartTime> 08.00 </StartTime>
<EndTime> 11.00 </EndTime>
</Event>
<Event>
<ShortDesc> 2º vuelo: Dubai - Katmandú </ShortDesc>
<DetailDesc> Vuelo directo Round the World. 5 días en
destino </DetailDesc>
<EventDate> 01/07/2011 </EventDate>
<StartTime> 09.00 </StartTime>
<EndTime> 13.00 </EndTime>
</Event>
<Event>

280
6: Controles Web con [Link]

<ShortDesc> 3º vuelo: Katmandú - Pekín </ShortDesc>

<DetailDesc> Vuelo directo Round the World. 7 días en
destino </DetailDesc>
<EventDate> 01/12/2011 </EventDate>
<StartTime> 13.00 </StartTime>
<EndTime> 19.00 </EndTime>
</Event>
<Event>
<ShortDesc> 4º vuelo: Pekín - Shanghai </ShortDesc>
<DetailDesc> Vuelo directo Round the World. 3 días en
destino </DetailDesc>
<EventDate> 01/19/2011 </EventDate>
<StartTime> 18.00 </StartTime>
<EndTime> 19.30 </EndTime>
</Event>
<Event>
<ShortDesc> 5º vuelo: Shanghai - Tokyo </ShortDesc>
<DetailDesc> Vuelo directo Round the World. 7 días en
destino </DetailDesc>
<EventDate> 01/22/2011 </EventDate>
<StartTime> 09.00 </StartTime>
<EndTime> 11.00 </EndTime>
</Event>
<Event>
<ShortDesc> 6º vuelo: Tokyo - Sydney </ShortDesc>
<DetailDesc> Vuelo directo Round the World. 6 días en
destino </DetailDesc>
<EventDate> 01/29/2011 </EventDate>
<StartTime> 08.00 </StartTime>
<EndTime> 16.00 </EndTime>
</Event>
<Event>
<ShortDesc> 7º vuelo: Sydney - Auckland </ShortDesc>
<DetailDesc> Vuelo directo Round the World. 5 días en
destino </DetailDesc>
<EventDate> 02/04/2011 </EventDate>
<StartTime> 13.00 </StartTime>
<EndTime> 14.00 </EndTime>
</Event>
<Event>
<ShortDesc> 8º vuelo: Auckland - Buenos Aires </
ShortDesc>
<DetailDesc> Vuelo con escala en Santiago de Chile. 8
días en destino </DetailDesc>

281
[Link] con C#

<EventDate> 02/09/2011 </EventDate>

<StartTime> 08.00 </StartTime>
<EndTime> 20.00 </EndTime>
</Event>
<Event>
<ShortDesc> 9º vuelo: Buenos Aires - Rio de Janeiro
</ShortDesc>
<DetailDesc> Vuelo directo Round the World. 6 días en
destino </DetailDesc>
<EventDate> 02/17/2011 </EventDate>
<StartTime> 08.00 </StartTime>
<EndTime> 10.00 </EndTime>
</Event>
<Event>
<ShortDesc> 10º vuelo: Rio de Janeiro - Los Ángeles
</ShortDesc>
<DetailDesc> Vuelo con escala en Miami. 10 días en
destino </DetailDesc>
<EventDate> 02/23/2011 </EventDate>
<StartTime> 06.00 </StartTime>
<EndTime> 16.00 </EndTime>
</Event>
<Event>
<ShortDesc> 11º vuelo: Los Ángeles - Nueva York </
ShortDesc>
<DetailDesc> Vuelo directo Round the World. 10 días en
destino </DetailDesc>
<EventDate> 03/05/2011 </EventDate>
<StartTime> 08.00 </StartTime>
<EndTime> 10.00 </EndTime>
</Event>
<Event>
<ShortDesc> 12º vuelo: Nueva York - Johannesburgo </
ShortDesc>
<DetailDesc> Vuelo directo Round the World. 6 días en
destino </DetailDesc>
<EventDate> 03/15/2011 </EventDate>
<StartTime> 07.00 </StartTime>
<EndTime> 12.00 </EndTime>
</Event>
<Event>
<ShortDesc> 13º vuelo: Johannesburgo - Marrakech </
ShortDesc>
<DetailDesc> Vuelo directo Round the World. 6 días en

282
6: Controles Web con [Link]

destino </DetailDesc>
<EventDate> 03/21/2011 </EventDate>
<StartTime> 01.00 </StartTime>
<EndTime> 10.00 </EndTime>
</Event>
<Event>
<ShortDesc> 14º vuelo: Marrakech - Madrid </ShortDesc>
<DetailDesc> Vuelo directo Round the World. Fin de
trayecto </DetailDesc>
<EventDate> 03/27/2011 </EventDate>
<StartTime> 09.00 </StartTime>
<EndTime> 11.00 </EndTime>
</Event>
</Ruta>

Como se puede observar, es un código donde se repite constantemente un bloque.

No es necesario que sepamos programar en XML, aunque sí sería recomendable
tener ciertos conocimientos. Simplemente nos tenemos que fijar en el nombre de las
etiquetas, puesto que van a ser utilizados posteriormente en nuestro código [Link].
Este fichero lo debemos guardar en la misma carpeta donde tengamos el fichero .aspx
o saber la ruta exactamente.

Es muy importante el detalle de las fechas. Las fechas deben usarse como se hace en
el sistema sajón: MM/DD/YYYY.

283
[Link] con C#

protected void RutaRender(object o, DayRenderEventArgs

args)
{
if ([Link])
{

284
6: Controles Web con [Link]

[Link] = [Link].
FromName(“Gray”);
}
else
{
if ([Link])
{
[Link] = [Link].
[Link](“#F2F5A9”);
}
else
{
[Link] = [Link].
[Link](“White”);
}
}
DataSet calendario = VerRuta();
if (calendario == null)
{
return;
}
foreach (DataRow zRow in [Link][0].
Rows)
{
DateTime compareDate =
GetFecha(zRow[“EventDate”].ToString());
if (compareDate == [Link])
{
MuestraCalendario obj = new
MuestraCalendario();
[Link] = zRow[“ShortDesc”].
ToString();
[Link] = zRow[“DetailDesc”].
ToString();
[Link] = zRow[“StartTime”].
ToString();
[Link] = zRow[“EndTime”].ToString();
Label lab = new Label();
[Link] = “<br />” + [Link];
[Link](lab);
}
}
}
protected void VerDetalle()

285
[Link] con C#

{
DateTime dt = [Link];
DataSet ds = VerRuta();
if (ds == null)
{
return;
}
ArrayList obj = new ArrayList();
foreach (DataRow zRow in [Link][0].Rows)
{
DateTime compareDate =
GetFecha(zRow[“EventDate”].ToString());
if (compareDate == dt)
{
MuestraCalendario mc = new
MuestraCalendario();
[Link] = dt;
[Link] = zRow[“ShortDesc”].
ToString();
[Link] = zRow[“DetailDesc”].
ToString();
[Link] = zRow[“StartTime”].
ToString();
[Link] = zRow[“EndTime”].ToString();
[Link](mc);
}
}
[Link] = obj;
[Link]();
if ([Link] > 0)
{
[Link] = true;
[Link] = “Viajes en esta fecha: “
+ [Link]();
}
else
{
[Link] = false;
[Link] = “Sin viajes este día: “ +
[Link]();
}
}

protected DateTime GetFecha(string s)

286
6: Controles Web con [Link]

{
DateTime obj;
try
{
obj = [Link](s, DateTimeFormatInfo.
InvariantInfo);
}
catch (Exception exc)
{
[Link](“Error al mostrar la fecha” +
[Link] + “.”);
obj = [Link];
}
return obj;
}

public class MuestraCalendario

{
private string shortdesc;
private string detaildesc;
private DateTime eventdate;
private string starttime;
private string endtime;

public string ShortDesc

{
get
{
return shortdesc;
}
set
{
shortdesc = value;
}
}
public string DetailDesc
{
get
{
return detaildesc;
}
set
{
detaildesc = value;

287
[Link] con C#

}
}
public DateTime EventDate
{
get
{
return eventdate;
}
set
{
eventdate = value;
}
}
public string StartTime
{
get
{
return starttime;
}
set
{
starttime = value;
}
}
public string EndTime
{
get
{
return endtime;
}
set
{
endtime = value;
}
}
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]

288
6: Controles Web con [Link]

[Link]”>

<html xmlns=”[Link]
<head>
<title> Round the world </title>
</head>
<body>
<h4> Round the world trip </h4>
<form id = “ruta2” method = “post” runat = “server”>
<p align = “center”>
<asp:Calendar ID = “world” runat = “server”
SelectedDate = “01/01/2011”
VisibleDate = “01/01/2011”
FirstDayOfWeek = “Monday”
ShowDayHeader = “true”
DayHeaderStyle-BackColor = “#D8D8D8”
DayHeaderStyle-ForeColor = “Black”
DayHeaderStyle-BorderStyle = “Solid”
ShowGridLines = “true”
ShowNextPrevMonth = “true”
NextPrevStyle-BackColor = “#D8D8D8”
NextPrevStyle-ForeColor = “Black”
NextPrevStyle-Font-Bold = “true”
ShowTitle = “true”
TitleFormat = “MonthYear”
TitleStyle-BackColor = “#D8D8D8”
TitleStyle-ForeColor = “Black”
TitleStyle-BorderStyle = “Double”
TitleStyle-Font-Size = “Medium”
DayNameFormat = “FirstTwoLetters”
DayStyle-HorizontalAlign = “Right”
DayStyle-VerticalAlign = “Top”
SelectedDayStyle-BackColor = “#6E6E6E”
SelectedDayStyle-ForeColor = “Red”
SelectedDayStyle-Font-Bold = “true”
TodayDayStyle-BackColor = “#F3F781”
TodayDayStyle-VerticalAlign = “Top”
TodayDayStyle-HorizontalAlign = “Center”
OnDayRender = “rutaRender”
OnSelectionChanged = “rutaCambiar” />
</p>
<p align = “center”>

289
[Link] con C#

<asp:Label ID=”SelectedDate” runat=”server”>

</asp:Label>
</p>
<asp:Panel ID = “rutacompleta” runat = “server”>
<asp:Repeater ID = “repe” runat = “server”>
<HeaderTemplate>
<p align = “center”>
<table border = “2” width =
“100%” />
<table style = “color: Black;
border-collapse: collapse;”>
<tr style = “color: Black;
background-color: #D8D8D8;”>
<td> Viaje </td>
<td> Detalle </td>
<td> Hora Salida </td>
<td> Hora Llegada </td>
</tr>
</HeaderTemplate>
<ItemTemplate>
<tr style = “background-color: Blue;”>
<td> <%# [Link]
([Link], “ ShortDesc”) %> </td>
<td> <%# [Link]
([Link], “ DetailDesc”) %> </td>
<td> <%# [Link]
([Link], “ StartTime”) %> </td>
<td> <%# [Link]
([Link], “ EndTime”) %> </td>
</tr>
</ItemTemplate>
<AlternatingItemTemplate>
<tr style = “background-color:Gray;”>
<td> <%# [Link]
([Link], “ShortDesc”) %> </td>
<td> <%# [Link]
([Link], “DetailDesc”) %> </td>
<td> <%# [Link]
([Link], “StartTime”) %> </td>
<td> <%# [Link]
([Link], “EndTime”) %> </td>
</tr>
</AlternatingItemTemplate>
<FooterTemplate>

290
6: Controles Web con [Link]

</table>
</p>
</FooterTemplate>
</asp:Repeater>
</asp:Panel>
</form>
</body>
</html>

Estamos ante uno de los códigos más extensos del curso, aunque no debe
preocuparnos mucho. Vamos a explicar de forma sencilla qué es lo que hace este
código.

Empecemos por el método VerRuta. Aquí hacemos la llamada al fichero XML y

hacemos las comprobaciones necesarias para ver si existe la ruta donde se supone
que se debe encontrar el fichero que buscamos. Luego hacemos una comprobación,
la cual es muy útil y sobre todo ganamos muchísimo en eficiencia. Ahora ya hemos
definido un DataSet … Session, el cual lo que hace es comprobar si ya tenemos
abierto el calendario, para no tener que cargarlo más veces, es decir, si el calendario
es distinto de nulo, lo tenemos ya y no se carga, en otro caso, tenemos que leer de
nuevo el fichero XML para poder cargar otra vez nuestro calendario.

En el siguiente método rutaRender lo primero que hacemos es dibujar nuestro

calendario con los colores que queramos, tanto si es fin de semana, como si es del mes
actual o como si son días de los meses previos o posteriores al mes actual. Para ello
usamos algunas de las funciones intrínsecas del DayRenderEventArgs. A continuación
vamos construyendo nuestro calendario y rellenándolo con los elementos creados
en el documento XML. Como ya dijimos antes, era importante saber cuál iba a ser
el nombre que tenían las etiquetas, puesto que ahora sí las necesitamos y debemos
crear un objeto por cada elemento que vayamos a insertar.

En el método VerDetalle obtenemos un cuadro en la parte inferior que nos da el detalle

de los elementos creados en XML. El código es muy similar al de rutaRender, con la
salvedad de que se nos muestran dos cosas distintas en el caso de que tengamos esa
fecha del calendario con algún evento o la tengamos sin ningún evento.

291
[Link] con C#

En el método GetFecha hacemos la comprobación para que la fecha sea correcta.

Como dijimos anteriormente, es importante saber el formato de fecha utilizado, porque
de lo contrario los eventos no serán incluidos de forma correcta dentro del calendario.
Probablemente obtengamos algunas fechas erróneas y otras se colocarán en el sitio
incorrecto, es decir, si ponemos 02/04/2011 automáticamente se nos colocará un
evento el día 4 de febrero de 2011 en vez del 2 de abril de 2011. Y si por ejemplo,
introducimos una fecha 14/05/2011 el compilador detectará un fallo en la fecha porque
no existe el mes 14.

El resto del código ya nos es familiar y apenas hay cosas que reseñar, puesto que en
el HTML hemos incluido elementos de tipo tabla y les hemos dado un estilo propio y
apenas encontramos más elementos nuevos.

A la hora de programar, si estamos usando Visual Studio, nos podemos dar cuenta
de la cantidad de combinaciones posibles que nos ofrecen a la hora de elegir el estilo
de los objetos usados. Si pulsamos a la vez Shift + Espacio, se nos desplegará una
pestaña con todas las posibilidades que tenemos para una función o para un atributo.

El propio alumno puede crear su propio calendario e incluir los elementos que considere
necesarios.

Como resultado del código diseñado obtenemos el siguiente calendario:

292
6: Controles Web con [Link]

6.5. Code-Behind
Code-Behind es una técnica, quizá la más recomendable a la hora de programar con
[Link], en la que el programador tiene distintos ficheros. En un fichero tenemos
todos los métodos que se incluyen en los scripts y lo guardamos como un fichero C#,
es decir, con una extensión .cs. El resto de ficheros los podemos guardar como .aspx
y desde ellos hacer llamadas a los ficheros .cs. Veamos un ejemplo donde creemos un
fichero con los scripts y otro donde incluyamos el código HTML con [Link].

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public class CodeBehind : Page

{
private DropDownList lista;
private Label aceptar;

public DropDownList Lista

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

public Label Aceptar

{
get

293
[Link] con C#

{
return aceptar;
}
set
{
aceptar = value;
}
}

public void click(object o, EventArgs args)

{
string cadena = [Link];
[Link] = “ Has seleccionado el color “ +
[Link];
}
}

Este fichero lo guardamos como [Link]. En Visual Studio al crear un fichero .cs
(tipo clase cuando le damos a agregar nuevo elemento) por defecto nos salen los
namespaces. Después simplemente tenemos que definir una clase que determine las
acciones que queremos realizar. Como siempre decimos, es importante recordar los
nombres que vamos a utilizar, ya que luego los vamos a necesitar.

Una vez ya hemos definido nuestro código .cs procedemos a crear un fichero .aspx:

294
6: Controles Web con [Link]

<asp:Label ID = “aceptar” runat = “server” ></

asp:Label>
</form>
</body>
</html>

En la primera línea de código debemos indicar de qué clase heredamos y cuál es su

ruta. El resto del código es simple, solo que en el form debemos indicar sobre qué
página estamos haciendo las acciones. En nuestro caso, es sobre la propia página
nuestra.

295
[Link] con C#

6.6. Ciclo de vida de una página [Link]

Los Web parts o elementos Web en [Link] se refieren a un conjunto integrado de
controles para crear páginas Web que permitan al usuario modificar el contenido,
la apariencia y el comportamiento de las mismas. Cuando un usuario realiza
modificaciones lo puede hacer tanto para la navegación en ese momento o para
futuras conexiones. Gracias a los Web parts los usuarios pueden realizar sus propias
personalizaciones sin la necesidad de un programador. Las opciones que tiene
un usuario son personalizar la apariencia y la visualización de la página, como por
ejemplo, utilizar un fondo de pantalla de un color u otro, personalizar el contenido de la
misma como agregar controles Web, crear conexiones, exportar o importar controles
para utilizarlas en la propia página o en otra página remota o incluso administrar y
personalizar la configuración de todo el sitio. Dentro de esta última opción podemos
englobar las típicas redes sociales en las que cada usuario es el que administra sus
propios contenidos, subiendo fotos, escribiendo posts o incluyendo su música.

Para crear controles de elementos Web o Web parts tenemos tres bloques distintos
de creación como son la personalización, los componentes estructurales de la interfaz
de usuario y los controles de la interfaz de usuario de elementos web reales.

Como venimos avanzando, podemos trabajar de distintas formas con los Web parts:
crear páginas que utilicen Web parts, crear Web parts individuales o crear aplicaciones
completas para personalizarlas a nuestro gusto.

6.6.1. Páginas que utilizan Web parts

Para crear páginas que utilicen Web parts podemos utilizar herramientas como el
Visual Studio, que como sabemos nos permite agregar controles arrastrando los
elementos desde el cuadro de herramientas. Gracias a ello, el hecho de crear páginas
que posean Web parts es sumamente sencillo, puesto que tenemos dos opciones
para ello, o bien arrastrarlos a la zona del código que nos interese, o bien desde
la vista de diseño en la que podemos ver mientras programamos una especie de
visualización previa de la página.

6.6.2. Creación de Web parts individuales

Para el desarrollo de Web parts individuales, normalmente crearemos un control de
usuario y lo utilizaremos como un control de elementos Web o desarrollaremos un
Web part personalizado.

Un ejemplo de un Web part puede ser la creación de cualquier control que ya

proporcione [Link] como puede ser el calendario, el cual vimos en unidades
anteriores o una calculadora.

296
6: Controles Web con [Link]

6.6.3. Creación de aplicaciones completas

Gracias a este tipo de desarrollos podemos crear páginas Web que permitan la
personalización completa por parte del usuario. De esta forma podemos proporcionar
al usuario una solución final para que éstos administren y personalicen sus aplicaciones.
En este sentido podemos imaginar una página en la que el usuario pueda modificar el
estilo, lo que desea que aparezca, su contenido, etcétera. Por ejemplo, Google nos da
la posibilidad de que al abrir su página nos aparezcan noticias, el tiempo o cualquier
tema que nos parezca.

Vamos a realizar un ejemplo en el que veamos el funcionamiento de los Web Parts y

cómo implementarlos con Visual Studio.

Como siempre nos creamos un nuevo proyecto Web [Link] y esta vez vamos a
hacer algo nuevo. Al proyecto nuestro vamos a agregarle un nuevo elemento que será
una formulario Web nuevo, es decir, un archivo .aspx y nos vamos a la pestaña de
diseño y en el cuadro de herramientas cogemos un elemento WebPartManager de la
sección de elementos Web. Una vez arrastrado nos aparecerá lo siguiente:

Ahora podemos añadirle, por ejemplo, una tabla a través del menú Tabla > Insertar
Tabla y podemos poner, por ejemplo, una tabla con dos filas y dos columnas.

En cada una de las celdas creadas podemos poner un Web part distinto. Para ello
basta con arrastrar desde la barra de herramientas en la zona de elementos Web el
componente WebPartZone, quedando de la siguiente forma:

297
[Link] con C#

Si pinchamos sobre cualquiera de los Web parts, a la derecha nos aparecen todas las
propiedades que pueden adquirir cada uno de ellos. Esto mismo es lo que hacemos
dentro de las etiquetas. Por ejemplo, podemos darle un título al Web part a través de
la propiedad HeaderText que aparece a la derecha:

Si nos vamos a la parte del código, observaremos cómo se ha creado el código que
nosotros hemos ido “dibujando” a través de los controles:

<%@ Page Language = “C#” %>

<script runat = “server”>

</script>

<html>
<head runat = “server”>
<title> Ejemplo de un Web Part </title>
<style type = “text/css”>
.style1
{
width: 100%;
}
</style>

298
6: Controles Web con [Link]

</head>
<body>
<form id = “form1” runat = “server”>
<div>

<asp:WebPartManager ID = “WebPartManager1” runat

= “server”>
</asp:WebPartManager>
<br />
<br />
<table class = “style1”>
<tr>
<td>
<asp:WebPartZone ID = “WebPartZone1”
runat = “server” HeaderText= “Zona 1”>
</asp:WebPartZone>
</td>
<td>
<asp:WebPartZone ID = “WebPartZone2”
runat = “server” HeaderText = “Zona 2”>
</asp:WebPartZone>
</td>
</tr>
<tr>
<td>
<asp:WebPartZone ID = “WebPartZone3”
runat = “server” HeaderText = “Zona 3”>
</asp:WebPartZone>
</td>
<td>
<asp:WebPartZone ID = “WebPartZone4”
runat = “server” HeaderText = “Zona 4”>
</asp:WebPartZone>
</td>
</tr>
</table>

</div>
</form>
</body>
</html>

299
[Link] con C#

Ahora lo que tendremos que hacer es incluir algo dentro de los Web parts. Por
ejemplo, vamos a incluir algo de texto, por lo que si nos vamos a la pestaña de diseño
podemos arrastrar una etiqueta Label hacia cualquiera de las zonas y dentro de ellas
escribir lo que nos parezca:

Además, podemos crearnos nuestros propios controles de usuario por lo que para
ello nos crearemos controles nuevos, es decir, tendremos que agregar un nuevo
elemento y seleccionar Control de Usuario Web y le damos cualquier nombre. Vamos
a crearnos, por ejemplo, una zona de conexión a la cuenta de correo imaginaria,
pudiéndolo hacer directamente desde la zona de diseño incluyendo dos cajas de texto
y un botón y darle el diseño deseado. Si por ejemplo, queremos que aparezca un salto
de línea entre el nombre de usuario y la contraseña, simplemente le damos a intro
donde queremos que aparezca, es decir, podemos usarlo como si de un procesador
de textos se tratara. El código quedaría así:

<%@ Control Language = “C#” ClassName = “Control1” %>

<p>
Mi cuenta de correo</p>
Nombre de Usuario:  <asp:TextBox runat = “server” ID
= “TextBox1”>
</asp:TextBox>
 <br />
Contraseña:       &nbs
p;       <asp:TextBox runat
= “server” ID = “TextBox2”>
</asp:TextBox>
 <p> </p>
<asp:Button runat = “server” ID = “Button1” text =
“Conectar” />

En la imagen podemos observar cómo es el diseño en el Visual Studio:

300
6: Controles Web con [Link]

Una vez creado este Web part podemos agregarlo a cualquiera de las zonas que
creamos antes específicas para los Web parts. Para poder realizar esto nos vamos a
nuestro archivo .aspx y desde el explorador de soluciones arrastramos el control de
usuario a cualquier zona, por ejemplo, la zona 2.

En cualquiera de las zonas podemos crearnos un Web part, por ejemplo, podemos
escribir lo siguiente:

301
[Link] con C#

En el código queda de la siguiente forma:

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

<%@ Register src=”[Link]” tagname=”Control1”

tagprefix=”uc1” %>

</script>

<html>
<head runat = “server”>
<title> Ejemplo de un Web Part </title>
<style type = “text/css”>
.style1
{
width: 100%;
}
</style>
</head>
<body>
<form id = “form1” runat = “server”>
<div>

<asp:WebPartManager ID = “WebPartManager1” runat

= “server”>
</asp:WebPartManager>
<br />

302
6: Controles Web con [Link]

<br />
<table class = “style1”>
<tr>
<td>
<asp:WebPartZone ID = “WebPartZone1”
runat = “server” HeaderText= “Zona 1”>
<ZoneTemplate>
<asp:Label ID=”Label1”
runat=”server” Title=”Titulo Parte 1”>
<h3> Esta es la zona del
primer Web Part </h3>
</asp:Label>
</ZoneTemplate>
</asp:WebPartZone>
</td>
<td>
<asp:WebPartZone ID = “WebPartZone2”
runat = “server” HeaderText = “Zona 2”>
<ZoneTemplate>
<uc1:Control1 ID=”Control11”
runat=”server” />
</ZoneTemplate>

</asp:WebPartZone>
</td>
</tr>
<tr>
<td>
<asp:WebPartZone ID = “WebPartZone3”
runat = “server” HeaderText = “Zona 3”>
<ZoneTemplate>
<asp:Label runat = “server” id
= “paginas” title = “Favoritos” BackColor = “Yellow”
ForeColor = “Blue”>
<a href = “[Link] >
Seas Estudios Abiertos </a>
<br />
<a href = “[Link]
Página de [Link] </a>
<br />
<a href = “[Link]
com”> Página de Microsoft </a>
<br />

303
[Link] con C#

<a href = “[Link]

Página de Google </a>
<br />
</asp:Label>

</ZoneTemplate>
</asp:WebPartZone>
</td>
<td>
<asp:WebPartZone ID = “WebPartZone4”
runat = “server” HeaderText = “Zona 4”>
</asp:WebPartZone>
</td>
</tr>
</table>

</div>
</form>
</body>
</html>

En la zona 4 podemos incluir, por ejemplo, el control de usuario que propusimos en

el apartado 6.1.2, así que debemos crearnos un nuevo control de usuario e incluir el
siguiente código:

<script language = “c#” runat = “server”>

public string BackColor = “blue”;
</script>

<table style = “background-color: <% =BackColor %>” width

= 40%” cellpadding = “10” cellspacing = “0” >
<tr>
<td width = “50%”>
Curso [Link] usando C#
</td>
</tr>
</table>

Y el archivo .aspx debe quedar de la siguiente manera si incluimos el código necesario

para que el usuario pueda modificar los colores de la cabecera:

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

<%@ Register src=”[Link]” tagname=”Control1”

tagprefix=”uc1” %>

304
6: Controles Web con [Link]

<%@ Register src=”[Link]” tagname=”control2”

tagprefix=”uc2” %>

public void click(Object o, EventArgs args)

{
string col = [Link];
[Link] = col;
}

</script>

<asp:WebPartManager ID = “WebPartManager1” runat

= “server”>

305
[Link] con C#

</asp:WebPartManager>
<br />
<br />
<table class = “style1”>
<tr>
<td>
<asp:WebPartZone ID = “WebPartZone1”
runat = “server” HeaderText= “Zona 1”>
<ZoneTemplate>
<asp:Label ID=”Label1”
runat=”server” Title=”Titulo Parte 1”>
<h3> Esta es la zona del
primer Web Part </h3>
</asp:Label>
</ZoneTemplate>
</asp:WebPartZone>
</td>
<td>
<asp:WebPartZone ID = “WebPartZone2”
runat = “server” HeaderText = “Zona 2”>
<ZoneTemplate>
<uc1:Control1 ID=”Control11”
runat=”server” />
</ZoneTemplate>

306
6: Controles Web con [Link]

com”> Página de Microsoft </a>

</ZoneTemplate>
</asp:WebPartZone>
</td>
<td>
<asp:WebPartZone ID = “WebPartZone4”
runat = “server” HeaderText = “Zona 4”>
<ZoneTemplate>
<uc2:control2 ID = “usuario”
runat = “server” />
<asp:DropDownList ID = “lista”
runat = “server”>
</asp:DropDownList>
<asp:Button ID = “Button1”
Text = “Cambie la cabecera” OnClick = “click” runat =
“server” />
<asp:Label ID = “color” runat
= “server”> </asp:Label>

</ZoneTemplate>
</asp:WebPartZone>
</td>
</tr>
</table>

</div>
</form>
</body>
</html>

Con la consiguiente imagen en el modo diseño de Visual Studio:

307
[Link] con C#

Si queremos que el usuario pueda ir incluyendo nuevos elementos en tiempo de

ejecución, podemos hacerlo de la siguiente forma:

Nos vamos a la vista diseño y desde ahí podremos verlo bastante más claro. Primero
elegimos la zona donde incluir los elementos que van a poder ser modificados por
el usuario, hasta ahí arrastramos el elemento CatalogZone de la parte de elementos
Web de la barra de herramientas, y dentro del CatalogZone incluimos un elemento
DeclarativeCatalogPart. En el menú de tareas de las mismas seleccionaremos editar
plantillas, por lo que nos saldrá una plantilla (“Template”) en la cual incluiremos de la
sección estándar del cuadro de herramientas los elementos UploadFile y Calendar.

<asp:WebPartManager ID = “WebPartManager1” runat =

“server”>
</asp:WebPartManager>

308
6: Controles Web con [Link]

<br />
<br />
<table class = “style1”>
<tr>
<td>
<asp:WebPartZone ID = “WebPartZone1”
runat = “server” HeaderText= “Zona 1”>
<ZoneTemplate>
<asp:Label ID=”Label1”
runat=”server” Title=”Titulo Parte 1”>
<h3> Esta es la zona del
primer Web Part </h3>
</asp:Label>
</ZoneTemplate>
</asp:WebPartZone>
<asp:CatalogZone ID=”CatalogZone1”
runat=”server” HeaderText=”Elementos Web”>
<ZoneTemplate>
<asp:DeclarativeCatalogPart
ID=”DeclarativeCatalogPart1” runat=”server”>
<WebPartsTemplate>
<asp:FileUpload
ID=”FileUpload1” runat=”server” />
<asp:Calendar
ID=”Calendar1” runat=”server”></asp:Calendar>
</WebPartsTemplate>
</asp:DeclarativeCatalogPart>
</ZoneTemplate>
</asp:CatalogZone>
</td>
<td>
<asp:WebPartZone ID = “WebPartZone2”
runat = “server” HeaderText = “Zona 2”>
<ZoneTemplate>
<uc1:Control1 ID=”Control11”
runat=”server” />
</ZoneTemplate>

</asp:WebPartZone>
</td>
</tr>
<tr>
<td>

309
[Link] con C#

<asp:WebPartZone ID = “WebPartZone3”
runat = “server” HeaderText = “Zona 3”>
<ZoneTemplate>
<asp:Label runat = “server” id
= “paginas” title = “Favoritos” BackColor = “Yellow”
ForeColor = “Blue”>
<a href = “[Link] >
Seas Estudios Abiertos </a>
<br />
<a href = “[Link]
Página de [Link] </a>
<br />
<a href = “[Link]
com”> Página de Microsoft </a>
<br />
<a href = “[Link]
Página de Google </a>
<br />
</asp:Label>

Ya desde el navegador podremos utilizar estos controles.

310
6: Controles Web con [Link]

RESUMEN
■
Aparte de los controles de servidor de [Link] tenemos los controles de usuario y
los controles HTML. Los controles HTML son los propios del lenguaje HTML y que son
entendidos por el servidor y los de usuario son los diseñados y desarrollados por el
usuario.

■
Algunas de las características más importantes sobre los controles de servidor ASP.
NET es que es capaz de detectar automáticamente sobre qué navegador estamos
actuando, eliminar esa detección de navegador para poder usar nuestro código en
cualquier creación de objetos y eventos, y las propiedades que nos permitan dar un
diseño más llamativo.

■
El ciclo de vida de una página [Link] no es más que el proceso que realiza una
página desde que la llamamos hasta que la cerramos. El proceso consta de tres pasos:
Page_Load, Manejo de eventos y Page_Unload.

■
Existen varios tipos de controles de servidor [Link], controles intrínsecos, controles
Rich, controles de validación y controles de interpretación.

■
Code-Behind es una técnica de programación en la que separamos lo que es código
HTML de lo que es código C#. Para ello deberemos crear distintos ficheros.

■
Los Web parts son controles integrados que permiten al usuario modificar, manipular y
administrar la apariencia y contenido de las páginas Web a su gusto.

■
Los Web parts se pueden incluir en páginas Web, los podemos crear nosotros
individualmente e incluso podemos crear páginas únicamente con Web parts.

311
7
[Link] con C#
7
DIDÁCTICA
UNIDAD

7. Manejo de errores
7: Manejo de errores

315
7: Manejo de errores

OBJETIVOS
■ Conocer los distintos tipos de errores que puedan afectar a nuestra página.

■ Conocer técnicas que sean capaces de prevenir los errores, más vale prevenir que curar.

■ Aprender a hacer las pruebas necesarias para detectar errores.

■ Saber localizar errores una vez se hayan producido.

■ Aprender a atrapar errores de manera automática y de forma manual.

317
[Link] con C#

INTRODUCCIÓN

Cuando estamos programando es más que evidente Hay muchos tipos de errores, a veces estará en nuestras
que mientras estamos escribiendo el código nos manos el atraparlos y otras veces se nos escaparán o
equivoquemos. Es casi imposible escribir un código bien por despiste, o bien porque no podemos hacer
medianamente complejo sin tener errores, ya sean de nada al respecto como la caída de un servidor. Pues
compilación o de ejecución. Nos podemos equivocar bien, nuestro objetivo como programador es hacer
a la hora de escribir un nombre, de llamar a un método tantas pruebas como sea necesario para atrapar
equivocado o simplemente que estemos intentando errores y poder tener una página robusta, que haga lo
hacer algo prohibido por nuestro lenguaje o tecnologí[Link] tiene que hacer y que no provoque el cabreo de
Es por todo esto que es más que importante saber los usuarios.
buscar errores, encontrarlos y por encima de todas Hay muchas formas de atrapar errores de manera
las cosas, solucionarlos. Normalmente cuando sencilla y que no nos va a llevar mucho tiempo
tenemos un error es el propio compilador el que nos codificar dichas formas de caza de errores. Nosotros
avisa dónde puede existir un error. Es verdad que no mismos vamos a ser capaces de atrapar errores que
siempre el error está en la línea indicada, sino en la no queremos que aparezcan en nuestra página o de
referencia que se hace de esta línea. usos indebidos en ella.
Para encontrar errores existen muchas técnicas, como
debuggear por la zona donde creemos que está el
error, o incluyendo trozos de código para ver dónde se
encuentra el error que estamos buscando.

318
7: Manejo de errores

7.1. ¿Qué hacer para evitar errores?

Muchos estudios sobre el software dicen que la parte más compleja y más trabajosa
es la de buscar errores. Cuando estamos buscando un error y lo solucionamos es
probable que la corrección del mismo provoque el error en otra parte del código, así
que es importante que vayamos tratando los errores desde el principio del código
hasta el final del mismo, por lo tanto, nuestro objetivo es ir atrapando esos errores en
tiempo de ejecución.

Hoy en día gracias a los editores y compiladores que existen es mucho más asequible
encontrar un error que hace unos años. A modo de curiosidad, se piensa que el primer
caso de búsqueda y solución de un error se produjo en 1947 cuando un insecto se
coló dentro de uno de los relés de la máquina, provocando su fallo. De aquí viene la
palabra debug (bug significa insecto en inglés) que significa en la actualidad depurar.

Para empezar a tratar errores, incluso si no los tenemos, es importante que entendamos
a la perfección nuestro código para poder averiguar dónde estamos fallando y en qué
zona del código está cada cosa. Una vez hayamos localizado dónde puede estar
nuestro posible error, lo mejor es asegurarse que las condiciones bajo las que nuestro
error puede ocurrir son estables. Por este motivo siempre es un acierto comentar
el código. Cuando un programador trabaja en un equipo, el código que uno realice
pasará por varias manos y es importante que éstos sepan qué es lo que hace el
código. Por lo tanto, ante líneas de código que puedan causar dudas lo mejor es
comentarlas.

Gracias a sentencias como el if, else if o else vamos a ser capaces de buscar errores
y encontrar el posible fallo de nuestro código. Cuando estemos programando también
es importante saber los nombres que estamos asignando a las variables o a los
métodos y tenemos que intentar dar nombres que se asemejen a lo que estamos
haciendo. El hecho de usar mayúsculas y minúsculas también nos puede ayudar. Si
realmente no sabemos qué nombre darle a un método, lo mejor es hacer un breve
comentario explicando lo que hace dicho método.

Como se puede pensar, existen distintos tipos de errores, entre los que se encuentran
los errores de sintaxis, errores lógicos o errores de sistema. En el siguiente apartado
haremos un repaso sobre todos ellos y explicaremos en qué consisten cada uno de
ellos.

319
[Link] con C#

7.2. Tipos de errores

Como hemos comentado anteriormente, tenemos varios tipos de errores que nos
pueden surgir a lo largo del código, como son errores de sintaxis, errores lógicos y
errores de sistema.

7.2.1. Errores de sintaxis

Los errores de sintaxis se producen, como su propio nombre indica, cuando hay
un error de sintaxis. Normalmente los errores de sintaxis se producen cuando
hemos escrito algún tipo mal, es decir, en vez de escribir <asp:Label…/> escribimos
<asp:Labl … />, cuando escribimos algún código incorrectamente, por ejemplo, en
vez de escribir <asp:Label … /> escribimos <asp:Label … > sin la barra de cierre de
etiqueta. Otro fallo muy común es cuando convertimos de un código a otro en el que
es tremendamente usual olvidarnos de un punto y coma, de cerrar una llave o de usar
una, o incluso confundir mayúsculas con minúsculas.

<html>
<head>
<title> Error de sintaxis </title>
</head>
<body>
<form method = “post” action = “[Link]”
runat = “server”>
<asp:Labl id = “error” runat = “server”> </
asp:Labl>
</form>
</body>
</html>

Al escribir este código de manera errónea, véase que la etiqueta la hemos escrito de
forma errónea intencionadamente, en el navegador obtendremos un error del siguiente
tipo:

320
7: Manejo de errores

Como podemos observar, el navegador ha lanzado un mensaje avisándonos de que

existe un error en la codificación. Se nos informa de la línea donde se ha producido y
el tipo de error que se ha producido:

En concreto se nos avisa de que hay una “Etiqueta de servidor ‘asp:Labl’ desconocida”.

Al escribir correctamente el código:

<html>
<head>
<title> Error de sintaxis </title>
</head>
<body>
<form method = “post” action = “[Link]”
runat = “server”>
<asp:Label id = “error” runat = “server” Text
= “Error corregido” > </asp:Label>
</form>
</body>
</html>

Ahora nos encontramos con que ya no existen errores y en el navegador aparece la

información correcta.

7.2.2. Errores lógicos

Son errores difíciles de encontrar y corregir y ocurren cuando el resultado está fuera de
los límites o un resultado es incorrecto. Los más comunes son los siguientes:

■■ División por 0.

■■ Incompatibilidad de tipos.

■■ Error en la devolución.

■■ Uso de objetos inexistentes.

■■ Datos inválidos.

321
[Link] con C#

[Link]. División por 0

Este error es de los más comunes y difíciles de corregir. Ocurre cuando el programa
divide un número entre un entero, el cual contiene un 0. Imaginemos que tenemos un
código que lo que hace es que el usuario elige un número de personas entre las que
dividir una cantidad de dinero y el usuario elige 0. Al hacer esto obtendremos un error.
Una forma de solucionarlo es incluyendo, por ejemplo, un if o atrapando el error:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{

double num = Convert.ToInt32 ([Link]) /

Convert.ToInt32 ([Link]);
[Link] = [Link]();
}
}

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]

<head>

322
7: Manejo de errores

<title> Calculadora </title>

</head>
<body>
<form id=”Form1” runat=”server”>
Introduzca los números:
<br />
<asp:TextBox ID=”caja1” runat=”server”> </asp:TextBox>
<asp:Button ID=”div” runat=”server” Text=”/”
OnClick=”Page_Load” />
<br />
<asp:TextBox ID=”caja2” runat=”server”> </asp:TextBox>
<br />
<b>Resultado =
<asp:Label ID=”respuesta” runat=”server”> </
asp:Label></b>
</form>
</body>
</html>

Al compilar este código obtendremos la siguiente página e introduciremos una división

de un número entre 0:

Y como resultado en el navegador obtendremos lo siguiente:

323
[Link] con C#

Un resultado que intenta dividir por 0, lo que provoca que el navegador lance un
mensaje de error. Para solucionarlo podemos hacer lo siguiente:

void Page_Load(object sender, EventArgs args)

{
if (Convert.ToInt32([Link]) == 0)
{
[Link] = “No se puede dividir por 0”;
}
else
{
double num = Convert.ToInt32([Link]) /
Convert.ToInt32([Link]);
[Link] = [Link]();
}
}

También se puede solucionar con bloques try-catch:

void Page_Load(object sender, EventArgs args)

{
try
{
double num = Convert.ToInt32 ([Link]) /
Convert.ToInt32 ([Link]);

324
7: Manejo de errores

[Link] = [Link]();
}
catch
{
[Link] = “Se ha producido un error”;
}
}

[Link]. Incompatibilidad de tipos

Este tipo de errores ocurre cuando estamos utilizando tipos incompatibles de datos,
es decir, cuando estamos usando un string en vez de un entero o asignamos un entero
a un string. Para resolver este tipo de errores tenemos los convertidores de tipo. Si
usamos el mismo ejemplo que antes y modificamos un poco el código veremos qué
ocurre:

void Page_Load(object sender, EventArgs args)

{
try
{
double num = [Link] / [Link];
[Link] = [Link]();
}
catch
{
[Link] = “Se ha producido un error”;
}
}
Como se puede apreciar, hemos modificado una línea de código y simplemente
hemos dejado de usar el convertidor de tipos. Evidentemente nos sale un error del
siguiente tipo:

Para solucionarlo usamos lo visto en el ejemplo anterior, es decir, un convertidor de

tipo, en nuestro caso Convert.ToInt32.

325
[Link] con C#

[Link]. Error en la devolución

Este tipo de errores ocurre cuando usamos una función que nos devuelve un tipo de
error distinto al esperado en nuestro programa.

[Link]. Uso de objetos inexistentes

Este tipo de error ocurre cuando intentamos usar un objeto que no ha sido creado aún
o se creó erróneamente.

[Link]. Datos inválidos

Este error suele ocurrir cuando introducimos datos erróneos o que están fuera de
rango, como por ejemplo, poner 30 de febrero o poner el día 8º de la semana.

7.2.3. Errores de sistema

Son errores generados por la propia tecnología, en nuestro caso [Link], ya que
es capaz de generar sus propios errores. Este tipo de errores puede ser debido a un
código que funcione mal, un error en tiempo de ejecución o cualquiera que no esté
englobado en los anteriores.

326
7: Manejo de errores

7.3. Pruebas para detectar errores

Hay veces en las que tenemos que hacer pruebas para detectar errores, ya que el
compilador no nos avisa de ello. En este caso podemos ver el ejemplo que vimos en la
división por 0. En un principio el código nos funcionaba y de hecho salía la página, de
modo que para encontrar el error tuvimos que introducir un valor erróneo. Esto también
forma parte del trabajo de un programador. Hay muchas técnicas para encontrar
errores en un código correcto, por ejemplo, si estamos probando con un objeto de
un tipo, es importante que probemos con el mayor valor posible, el menor posible,
con 0, con 1 y con -1. Si estamos probando que un objeto solo puede ser de tipo
entero, probemos a introducir un string. Este tipo de pruebas hay que ir haciéndolas
continuamente y no escatimar en tiempo, puesto que es mucho más importante hacer
pruebas y encontrar los errores y que quede con un aspecto poco llamativo hacer una
página espectacularmente llamativa y luego no sea nada robusta en lo que respecta a
la codificación. De nada sirve tener una página en la que podamos introducir errores
de datos.

Este trabajo es complejo, de hecho en las empresas que se dedican al desarrollo de

webs o de software en general tienen a gente especializada para tratar de buscar
errores haciendo pruebas.

De hecho, Microsoft Visual Studio proporciona los proyectos de pruebas unitarias,

los cuales no vamos a tratar, puesto que solo existen para versiones mucho más
especializadas y más avanzadas que la que estamos usando.

Hagamos un ejemplo en el que intentemos atrapar todos los posibles errores que nos
puedan ir surgiendo cuando tenemos que introducir un entero:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
if ([Link] != “”)

327
[Link] con C#

{
if (!([Link]([Link], 0)))
{
if ([Link](0, 1) != “-”)
{
[Link] = “Este campo es numérico,
así que por favor, no molestes más al código. “;
}
else
{
[Link] = “A ver, no puedes comprar
menos de 0 productos. “;
}
}
else if (Convert.ToInt32([Link]) == 0)
{
[Link] = “Ya que has entrado cómprame
algo no. Me siento ofendido si no compras nada. “;
}
else if (Convert.ToInt32([Link]) > 0)
{
[Link] = “Gracias por comprarme algo.
“;
}
}
else
{
[Link] = “Por favor, introduzca una
cantidad válida. “;
}
}
}
__________________________________________________________

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]

<head>

328
7: Manejo de errores

<title> Control de errores </title>

</head>
<body>
<form id=”Form1” method = “post” action = “Default.
aspx” runat = “server”>
Introduzca el número de productos que se va a llevar.
Cuantos más, mejor.
<br />
<asp:TextBox ID=”texto” runat=”server”> </asp:TextBox>
<br />
<asp:Button ID=”boton” runat=”server” Text=”Aceptar”
OnClick=”Page_Load” />
<br />
<b>
<asp:Label ID=”fallo” runat=”server”> </
asp:Label></b>
</form>
</body>
</html>

Como resultado obtenemos los siguientes fallos:

329
[Link] con C#

Como se puede observar, hemos comprobado que el campo no esté vacío, que sea
mayor o igual que 0 y que sea un valor numérico. Al haber hecho un Convert.ToInt32, si
metemos un valor decimal nos sale un error diciéndonos que es un campo numérico.

También es posible que tengamos que usar controles de validación en la corrección

de errores. Veamos un pequeño ejemplo:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{

if ([Link] != “”)
{
if (!([Link]([Link], 0)))
{
if ([Link](0, 1) != “-”)

330
7: Manejo de errores

{
[Link] = “Este campo es numérico,
así que por favor, no molestes más al código. “;
}
else
{
[Link] = “A ver, no puedes comprar
menos de 0 productos. “;
}
}
else if (Convert.ToInt32([Link]) == 0)
{
[Link] = “Ya que has entrado cómprame
algo no. Me siento ofendido si no compras nada. “;
}
else if (Convert.ToInt32([Link]) > 0)
{
[Link] = “Gracias por comprarme algo.
“;
}
}
else
{
[Link] = “Por favor, introduzca una
cantidad válida. “;
}
if ([Link](“”))
{
[Link] = “Introduzca un nombre de usuario.
“;
}
}
}

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>

331
[Link] con C#

</head>
<body>
<form id=”Form1” method = “post” action = “Default.
aspx” runat = “server”>
Introduzca el número de productos que se va a llevar.
Cuantos más, mejor.
<br />
Cantidad:
<asp:TextBox ID=”texto” runat=”server”> </asp:TextBox>
<br />
<asp:RequiredFieldValidator
ID=”RequiredFieldValidator1” ControlToValidate = “usuario”
runat = “server”
ErrorMessage = “Debe rellenar el campo usuario”>
</asp:RequiredFieldValidator>
<br />
Usuario:
<asp:TextBox ID=”usuario” runat=”server”> </
asp:TextBox>
<br />
<asp:Button ID=”boton” runat=”server” Text=”Aceptar”
OnClick=”Page_Load” />
<br />
<b>
<asp:Label ID=”fallo” runat=”server”> </
asp:Label></b>
</form>
</body>
</html>

Como se puede observar en el ejemplo, hemos incluido un campo que debe ser
obligatorio. Para ello hemos usado el control RequiredFieldValidator que vimos en la
unidad anterior. Como resultado debemos obtener lo siguiente:

Si lo rellenamos correctamente, debemos obtener el siguiente resultado:

332
7: Manejo de errores

333
[Link] con C#

7.4. Localizar errores

Es posible que aún habiendo hecho todo lo dicho en el apartado anterior sigan
apareciéndonos errores. Puede ser que o no hayamos hecho todas las pruebas
necesarias, o por ejemplo, que la página no suba correctamente al servidor.

En [Link] pueden ocurrir varios tipos de errores, como por ejemplo, errores de
configuración, errores en el párser, errores de compilación o errores en tiempo de
ejecución. A continuación vamos a detallar cada uno de estos tipos de errores:

■■ Errores de configuración.

■■ Errores de párser.

■■ Errores de compilación.

■■ Errores en tiempo de ejecución.

7.4.1. Errores de configuración

Estos errores pueden ocurrir porque esté mal configurado el fichero porque haya
errores de sintaxis en el código. El hecho de hablar de un error de configuración en
el fichero es porque la configuración se trata en ficheros de tipo XML, el cual nos
proporciona cada uno de los elementos que debe cumplir el fichero. Estos ficheros de
configuración se llaman [Link].

7.4.2. Errores de párser

Son errores que ocurren por una mala gramática o simplemente por errores de sintaxis.
Engloba los mismos errores que vimos en el apartado de errores de sintaxis.

7.4.3. Errores de compilación

Estos errores, siendo errores de sintaxis, no los podemos agrupar en los anteriores,
puesto que en este caso estamos haciendo uso de comandos o palabras, que no
son reconocidas por el compilador. La diferencia entre este tipo de errores en ASP.
NET y los de párser es que éstos últimos ocurren cuando hay un error de sintaxis en
la parte de [Link] y, los errores de compilación ocurren dentro de la sección de C#
que hayamos escrito. Esto es porque hay comandos que se pueden usar en ciertos
lenguajes y en otros no.

Como recordarás, C# tiene una serie de palabras reservadas, que puede ser que
no coincidan con las de otro lenguaje. Como [Link] puede trabajar con varios
lenguajes, es posible que con el lenguaje que estemos usando tengamos un error,
pero con otro lenguaje y el mismo código no. Por lo que podemos decir que son
errores que afectan a nuestro código en [Link], pero que no son provocados por
éste. Por ejemplo, si usamos el código de apartados anteriores haciendo una pequeña
modificación en el segundo if:

334
7: Manejo de errores

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
private int numero;

public int Numero

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

protected void Page_Load(object sender, EventArgs e)

{
if ([Link] != “”)
{
if ([Link] == numero)
{
if ([Link](0, 1) != “-”)
{
[Link] = “Este campo es numérico,
así que por favor, no molestes más al código. “;
}
else
{
[Link] = “A ver, no puedes comprar

335
[Link] con C#

menos de 0 productos. “;
}
}
else if (Convert.ToInt32([Link]) == 0)
{
[Link] = “Ya que has entrado cómprame
algo no. Me siento ofendido si no compras nada. “;
}
else if (Convert.ToInt32([Link]) > 0)
{
[Link] = “Gracias por comprarme algo.
“;
}
}
else
{
[Link] = “Por favor, introduzca una
cantidad válida. “;
}
if ([Link](“”))
{
[Link] = “Introduzca un nombre de usuario.
“;
}
}
}

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>
</head>
<body>
<form id=”Form1” method = “post” action = “Default.
aspx” runat = “server”>
Introduzca el número de productos que se va a llevar.
Cuantos más, mejor.
<br />

336
7: Manejo de errores

Cantidad:
<asp:TextBox ID=”texto” runat=”server”> </asp:TextBox>
<br />
<asp:RequiredFieldValidator
ID=”RequiredFieldValidator1” ControlToValidate = “usuario”
runat = “server”
ErrorMessage = “Debe rellenar el campo usuario”>
</asp:RequiredFieldValidator>
<br />
Usuario:
<asp:TextBox ID=”usuario” runat=”server”> </
asp:TextBox>
<br />
<asp:Button ID=”boton” runat=”server” Text=”Aceptar”
OnClick=”Page_Load” />
<br />
<b>
<asp:Label ID=”fallo” runat=”server”> </
asp:Label></b>
</form>
</body>
</html>

Obtendremos el siguiente resultado:

Como se puede observar, es un error que se produce en la parte de código escrita en

C#. Aquí lo que ocurre es que estamos intentando comparar un tipo string con un tipo
booleano. Una solución posible es incluir el comando equals, que sirve para comparar
dos elementos de tipos distintos.

void Page_Load(object sender, EventArgs args)

337
[Link] con C#

if ([Link] != “”)
{
if ([Link](“”))
{
if ([Link](0, 1) != “-”)
{
[Link] = “Este campo es numérico,
así que por favor, no molestes más al código. “;
}
else
{
[Link] = “A ver, no puedes comprar
menos de 0 productos. “;
}
}
else if (Convert.ToInt32([Link]) == 0)
{
[Link] = “Ya que has entrado cómprame
algo no. Me siento ofendido si no compras nada. “;
}
else if (Convert.ToInt32([Link]) > 0)
{
[Link] = “Gracias por comprarme algo.
“;
}
}
else
{
[Link] = “Por favor, introduzca una
cantidad válida. “;
}
if ([Link](“”))
{
[Link] = “Introduzca un nombre de usuario.
“;
}
}

Con este código habremos solucionado el fallo que se produce anteriormente.

7.4.4. Errores en tiempo de ejecución

338
7: Manejo de errores

Como su propio nombre indica son errores que se producen durante la ejecución y no
durante la compilación o haciendo el párser. Son errores que se producen cuando el
usuario introduce elementos no válidos en algunos campos.

Supongamos que un usuario intenta darse de alta en una nueva cuenta de correo;
si el usuario se registrase con el nombre usuario@[Link], no tendría ningún
tipo de error, pero si en cambio intenta registrarse con el nombre de usuario@correo,
el compilador detectará un error en tiempo de ejecución. Este tipo de errores ya lo
hemos visto en apartados anteriores.

Veamos un ejemplo en el que se produce el error en la ejecución cuando introducimos

un valor erróneo. Para ello vamos a utilizar el código de antes, pero quitando la primera
comprobación:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

339
[Link] con C#

“;
}
}
else
{
[Link] = “Por favor, introduzca una
cantidad válida. “;
}
if ([Link](“”))
{
[Link] = “Introduzca un nombre de usuario.
“;
}
}
}

<html>
<head>
<title> Control de errores </title>
</head>
<body>
<form id=”Form1” method = “post” action = “Default.
aspx” runat = “server”>
Introduzca el número de productos que se va a llevar.
Cuantos más, mejor.
<br />
Cantidad:
<asp:TextBox ID=”texto” runat=”server”> </asp:TextBox>
<br />
<asp:RequiredFieldValidator ControlToValidate =
“usuario” runat = “server”
ErrorMessage = “Debe rellenar el campo usuario”>
</asp:RequiredFieldValidator>
<br />
Usuario:
<asp:TextBox ID=”usuario” runat=”server”> </
asp:TextBox>
<br />
<asp:Button ID=”boton” runat=”server” Text=”Aceptar”
OnClick=”pruebas” />
<br />
<b>
<asp:Label ID=”fallo” runat=”server”> </

340
7: Manejo de errores

asp:Label></b>
</form>
</body>
</html>

En un principio aparece la página, pero al introducir un valor no válido obtendremos el

siguiente pantallazo:

En el que se nos avisa de un error en tiempo de ejecución porque la cadena de

entrada que hemos utilizado no contiene un dato correcto.

Aparte de los errores aquí comentados, pueden existir muchos tipos de errores como
no encontrar el recurso externo que estamos usando, por ejemplo, que una base de
datos a la que estamos accediendo no esté disponible o que se encuentre en otra
ruta. Nosotros mismos podemos lanzar el error configurando el fichero [Link].

Hemos nombrado algunas veces ya el fichero [Link]. Pues bien, cuando nos
creamos una nueva página Web en Visual Studio estamos generando una serie de
ficheros que hasta ahora no hemos tocado. Si nos vamos a la parte izquierda del
editor en la pestaña de explorador de soluciones, tenemos un fichero denominado
[Link]:

Sobre este fichero podemos hacer ciertas modificaciones que permitirán atrapar
errores. Si abrimos dicho fichero, nos encontraremos con un código de configuración
y justo hay una parte que está comentada que es la que nos interesa a nosotros.
Vamos a habilitarla y obtendremos ya un código de este tipo:

<authentication mode=”Windows” />

<!--

341
[Link] con C#

La sección <customErrors> habilita la

configuración de
las acciones que se deben realizar si un error
no controlado tiene lugar
durante la ejecución de una solicitud.
Específicamente,
permite a los desarrolladores configurar
páginas de error html
que se mostrarán en lugar de un seguimiento
de pila de errores.
-->
<customErrors mode=”RemoteOnly”
defaultRedirect=”[Link]”>
<error statusCode=”403” redirect=”NoAccess.
htm” />
<error statusCode=”404” redirect=”default2.
aspx” />
</customErrors>

Como podemos ver, la etiqueta se denomina customErrors, es decir, errores de

cliente. Supongamos que estamos intentando acceder a una página, la cual es la que
aparece en el defaultRedirect y esa página no existe. Vamos a crearnos cada una de
las páginas .aspx necesarias para comprobar el funcionamiento del [Link]:

<html>
<head>
<title> Errores </title>
</head>
<body>
<h2> MANTENIMIENTO </h2>
<br />
<h4> Estamos trabajando para mejorar la página para usted
<br />
Disculpen las molestias, pronto estaremos a su servicio.
</h4>

</body>
</html>

Si intentamos acceder a una página que no está disponible, obtendremos el siguiente

error:

342
7: Manejo de errores

Otro tipo de errores es el que obtenemos cuando intentamos acceder a un elemento

fuera de rango. Si por ejemplo, tenemos una cadena de 5 elementos y nosotros le
damos a acceder al sexto, obtendremos un error de aplicación:

<% fueraderango(); %>

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

343
[Link] con C#

7.4.5. Modo debug

El modo debug es una opción que podemos poner al definir el lenguaje de la página:
<%@ Page Language = “c#” Debug = “true”>. Con esta opción está
disponible la sección Fuente del Error, que aparece cuando hemos provocado un
error y nos aparecerá un mensaje diciéndonos en qué página y en qué línea aparece
dicho error. En caso de que tengamos puesto el debug a false nos aparecerá una
información en la que nos recomienda habilitar el debug para localizar el error.

7.4.6. Modo traza

A lo largo de la ejecución de un programa, una variable puede tomar distintos valores,
por ejemplo, al recorrer un bucle for desde 0 hasta 10, la variable que recorra ese
bucle en algún momento de la ejecución valdrá 3 y en otro 7, por ejemplo. El modo
traza nos permite ir sabiendo el valor de cada una de las variables en cada momento
de la ejecución del programa. Para ello, al igual que hicimos en el modo debug, en
este modo, y en el mismo sitio que el anterior podemos incluir esta opción. De esta
forma hay que escribirlo así: <%@ Page Trace = “true” %> o también a false si
no estamos interesados en ello.

Veamos el siguiente ejemplo:

<%@ Page Trace = “true” %>

<html>

344
7: Manejo de errores

<head>
<title> Lista Desplegable </title>
</head>
<body>
<br />
<form id=”Form1” runat=”server”>
Elija una opcion
<br />
<br />
<asp:DropDownList forecolor=”red” ID=”list1”
runat=”server”>
<asp:ListItem>1</asp:ListItem>
<asp:ListItem>2</asp:ListItem>
<asp:ListItem>3</asp:ListItem>
<asp:ListItem>4</asp:ListItem>
</asp:DropDownList>
<br />
<br />
<input type=”submit” />
</form>
</body>
</html>

Al ejecutar este código en el navegador obtendremos una página con el siguiente

aspecto:

Estos son los campos que aparecen en la traza:

345
[Link] con C#

En los detalles de solicitud obtenemos información sobre la petición de ejecución de

la página. En el tipo de petición al principio aparece get, aunque si le damos a enviar
consulta, el tipo de petición pasará a ser post.

Además, aparece una información de seguimiento que es donde se pueden ir

observando todas las informaciones relativas a nuestra página:

Luego observamos otra sección denominada árbol de control que nos informa de los
distintos controles usados.

Después aparece una serie de secciones que no nos importan demasiado, excepto la
última donde se muestran los distintos encabezados enviados por el cliente al servidor:

Finalmente nos quedan las siguientes secciones:

346
7: Manejo de errores

Solo reseñar que en la última sección podemos visualizar todos los elementos de las
variables del servidor.

Veamos qué es lo que ocurre en estas secciones cuando introducimos cambios:

<% traza(); %>

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

347
[Link] con C#

{
[Link](“Error error error”, “El contador
no sube”);
}
}
}

Con el consiguiente resultado en la información de seguimiento:

El error es evidente, puesto que si estamos inicializando el contador a 1 y no lo

incrementamos a menos que sea 5, es imposible que ocurra algo.

348
7: Manejo de errores

7.5. Control de errores manualmente

Ya conocemos algo acerca de este tipo de controles. El ejemplo más evidente es el
del uso de excepciones. Como todos sabemos, una excepción es un error controlado
que salta cuando se produce un comportamiento inesperado durante la ejecución de
un programa.

7.5.1. Excepciones
Como hemos visto, una excepción es un error controlado y lo podemos usar gracias a
la importación de la clase [Link]. Para capturar las excepciones se puede
operar de muchas formas desde usando un bloque try-catch-finally, hasta un catch
múltiple.

[Link]. Try-catch-finally
Ya hemos visto algunos ejemplos donde aparecen este tipo de bloques, pero que por
lo general tendrán la siguiente estructura:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

349
[Link] con C#

{
//En esta zona es donde se tratan los posibles
errores producidos
//en la zona del try.
}
finally
{
//En esta zona de código se debe ejecutar el
código pase lo que pase
//en las zonas de arriba.
}
}
}

Es conveniente saber que un uso abusivo de los try-catch puede producir un consumo
elevado de los recursos. Vamos a estudiar el siguiente ejemplo:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

350
7: Manejo de errores

public void metodo2()

{
metodo3();
}

public void metodo3()

{
//Aquí se produce el error sin
//ser capturado por el try-catch.
}

En este ejemplo el método 3 lanza un error, el cual va al método 2, el cual no captura

la excepción por no ser suya, así que el error vuelve a ser enviado esta vez al método
1, el cual va a capturar el error producido en el método 3, por lo que vemos que no
siempre es necesario poner bloques try-catch a lo largo de todos los métodos, ya que
el método contenedor de los demás es el que va a capturarlo. Este tipo de procesos
se denominan de patata caliente.

[Link]. Catch múltiple

Un try puede llevar más de un bloque catch detrás de él. Las excepciones que son
lanzadas en el try empiezan a recorrer los bloques catch hasta que alguno de ellos
atrapa la excepción. En el caso de que la excepción no sea atrapada por ningún
bloque catch, la excepción pasa al .NET, por lo que no podemos manejar por nosotros
mismos la excepción. El bloque quedaría de la siguiente manera:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)

351
[Link] con C#

{
try
{
//En esta zona de código va la parte que
queremos que ocurra.
//Es el sitio donde puede ser que se produzcan
los fallos
}
catch (SystemException exc)
{
//En esta zona es donde se tratan los posibles
errores producidos
//en la zona del try. Si es capaz de tratar la
excepción se hace aquí.
//Si no es capaz de tratarla pasa al siguiente
bloque.
}
catch (Exception exc)
{
//En esta zona es donde se tratan los posibles
errores producidos
//en la zona del try. Solo se ejecuta esta
zona de código si no se ha podido
//tratar la excepción en los bucles anteriores
y si esta excepción puede
//ser tratada aquí
}
//Aquí solo se llega si la excepción no ha
podido ser tratada por ninguno
//de los bloques catch anteriores. En el caso
de que se llegue aquí entonces
//tenemos que abortar el código, con el
consiguiente error
}
}
}

[Link]. Throw
Las excepciones cazadas anteriormente son lanzadas por .NET, pero tenemos la
opción de crear nosotros mismos nuestras propias excepciones. Esto lo podemos
hacer manualmente, si por ejemplo, no se cumple alguna de las condiciones que
propongamos al usuario. Un caso sería si hemos creado una página para que los
usuarios se den de alta y les proponemos un formulario que tienen que rellenar para tal
propósito. Aquí, podemos crearnos una serie de excepciones inventadas por nosotros

352
7: Manejo de errores

que, por ejemplo, lance un error si ya hay un usuario con ese nombre, o si por ejemplo,
introducen una contraseña de menos de 6 caracteres. La estructura de un catch sería
la siguiente:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

Como se puede observar, para que se lance una excepción se tiene que cumplir una
condición que en el caso de que se cumpla se entra en el bucle y se trata la excepción
que hemos creado. Para crear una excepción se hace de esa manera:

Throw new exception (“Mensaje de error”);

Existen muchas excepciones predefinidas propias del lenguaje que estemos usando.
Por ejemplo, como todos sabemos, si intentamos dividir en una calculadora un
número entre 0, en la calculadora podemos ver math error o algo parecido. Pues bien,
esto podría ser un tipo de excepción propio del lenguaje en el que está programada
la calculadora. Esto mismo puede ocurrir cuando estamos usando C#, que tiene
excepciones que son lanzadas automáticamente con su error. Entre estas excepciones
las más comunes son:

■■ ArgumentException: que se lanza cuando introducimos un valor no válido.

■■ ArgumentNullException: se lanza cuando el argumento pasado es nulo.

353
[Link] con C#

■■ ArgumentOutOfRangeException: esta excepción se lanza cuando el argumento

pasado como valor se sale de los límites del rango.

■■ DivideByZeroException: esta excepción se lanza cuando estamos intentando

dividir por 0.

■■ IndexOutOfRangeException: se lanza la excepción cuando el índice que le

pasamos está fuera de los valores de la tabla o del array.

■■ NullReferenceException: se lanza cuando estamos intentando acceder a un

objeto nulo.

■■ OutOfMemoryException: esta excepción se lanza en el caso de que la memoria

sea insuficiente como para crear un nuevo elemento.

Existen muchas más excepciones, siendo las más comunes las vistas arriba. Veamos
un ejemplo de cómo usar las excepciones:

int division(int x, int y)

{
try
{
return (x / y);
}
catch ([Link] dbz)
{
[Link](“Division by zero
attempted!”);
return 0;
}
}

También podemos usarlo de la siguiente forma:

int division(int x, int y)

{
if (y == 0)
{
throw new DivideByZeroException ();
}
return x / y;
}

Un ejemplo más donde se pueda ver cómo actuaría el compilador en el caso de que
no se cumpla alguna de las restricciones propuestas:

<% excepciones(); [Link](“Proceso finalizado “ +

“<br />”); %>

354
7: Manejo de errores

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

355
[Link] con C#

Empiece de nuevo “ + “<br />”);

}
}
}

Como podemos observar, en este caso hemos lanzado una excepción fuera de rango
en el caso de que se supere el límite del array. Durante el proceso se va incrementando
la i y como hemos puesto i <= 10 en el momento que se llega al 10, entonces se llega
a la excepción en la que se ha accedido a un elemento fuera de rango.

Como resultado obtenemos lo siguiente:

■■ Programa descargado al 0%.

■■ Programa descargado al 10%.

■■ Programa descargado al 20%.

■■ Programa descargado al 30%.

■■ Programa descargado al 40%.

■■ Programa descargado al 50%.

■■ Programa descargado al 60%.

■■ Programa descargado al 70%.

■■ Programa descargado al 80%.

■■ Programa descargado al 90%.

La descarga se ha quedado al 90% [Link]: Índice fuera

de los límites de la matriz. En ASP.default_aspx.excepciones().

Ha fallado la descarga, de modo que empiece de nuevo.

Proceso finalizado.

[Link]. Bloques try anidados

Los bloques try anidados son otra manera de capturar errores. Normalmente existe
un try principal y otros try secundarios, y lo usual es que en el try principal o externo
se capturen los errores más graves y en los try internos o secundarios, los errores
menos complejos. Con este tipo de captura de errores se nos permite manejar de
diferentes formas distintos tipos de errores. El proceso habitual de un try anidado es
que si ninguno de los try internos es capaz de atrapar la excepción, ésta se propaga
hacia el try externo. Veamos un nuevo ejemplo:

<% excepciones(); [Link](“Proceso finalizado“ +

“<br />”); %>
using System;

356
7: Manejo de errores

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

357
[Link] con C#

//capturado en el try interno.

}
finally
{
//Ejecución del resto del código
}
}
}

Éste es un ejemplo sencillo, pero en realidad podemos anidar muchos más bloques
unos dentro de otros. Supongamos que en vez de anidar bucles if lo hacemos con
bucles try. El funcionamiento es muy similar.

7.5.2. Page_error ()
Este tipo de errores son capturados en el caso de que se nos haya escapado alguna
condición, o que no nos hayamos acordado de controlar algún error. El método Page_
Error es un tipo de error perteneciente a la clase Page y que sirve para manejar errores
a nivel de la página.

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
excepciones();
}

void excepciones ()
{

int [] array = new int [10];

358
7: Manejo de errores

for (int i = 0; i <= 10; i++)

{
array[i] = i;
[Link](“Programa descargado al “ + i
* 10 + “%.<br />”);
}
}
void Page_Error(object o, EventArgs args)
{
[Link] (“<b>” + “Vaya vaya vaya, un error
por aquí “ + [Link]().ToString());
[Link]();
}
}

Como podemos ver, hemos usado un ejemplo anterior cambiando un par de bloques.
Hemos incluido el método Page_Error() y hemos eliminado los bucles, donde
atrapábamos la excepción en la que se accedía a un índice fuera de rango.

En esta ocasión es el método Page_Error el que trata la excepción y con ella enviamos
un mensaje que se lanza a través del control GetLastError, que nos muestra el error
atrapado con un mensaje enviado por el propio [Link]. Después debemos liberar el
servidor a través del control ClearError. Éste debe ser el resultado del código anterior:

■■ Programa descargado al 0%.

■■ Programa descargado al 10%.

■■ Programa descargado al 20%.

■■ Programa descargado al 30%.

■■ Programa descargado al 40%.

■■ Programa descargado al 50%.

■■ Programa descargado al 60%.

■■ Programa descargado al 70%.

■■ Programa descargado al 80%.

■■ Programa descargado al 90%.

Error:

[Link]: Índice fuera de los límites de la matriz. en

ASP.default_aspx.excepciones() en ASP.default_aspx.Page_Load() en System.
[Link](IntPtr fp, Object o) en [Link].
[Link](Object sender, EventArgs e) en System.

359
[Link] con C#

[Link](EventArgs e) en [Link]() en
[Link](Boolean includeStagesBeforeAsyncPoint,
Boolean includeStagesAfterAsyncPoint)

Para finalizar con la unidad, vamos a llegar al peor de los casos. Supongamos que
hemos hecho todas las pruebas posibles y decidimos subir la página. Pues bien, una
vez subida la página existe la posibilidad de que aparezca algún error más, y para ello
[Link] nos permite avisar al administrador del sitio de que ha ocurrido un error.

Veamos un ejemplo de uso de este tipo de detección de errores:

<% excepciones(); %>

<%@ Import Namespace = “[Link]” %>

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public partial class _Default : [Link]

{
protected void Page_Load(object sender, EventArgs e)
{
excepciones();
}

void excepciones ()
{

int [] array = new int [10];

for (int i = 0; i <= 10; i++)
{
array[i] = i;
[Link](“Programa descargado al “ + i
* 10 + “%.<br />”);
}

360
7: Manejo de errores

}
void Page_Error(object o, EventArgs args)
{
[Link] (“<b>” + “Vaya vaya vaya, un error
por aquí “ + [Link]().ToString());
[Link]();

MailMessage email = new MailMessage();

[Link] = “direccion@[Link]”;
[Link] = “administrador@[Link]”;
[Link] = “Ha ocurrido un error, cuidado “;
[Link](email);
}
}

Debemos incluir las líneas de código dentro del Page_Error y en ellas debemos
especificar quién manda, quién recibe y el motivo. Hay otras muchas opciones que
podemos incluir en el email que se envíe, como el cuerpo del mensaje o la url de
donde procede, siendo estos campos opcionales.

No podemos mostrar una imagen de este error porque no tenemos una dirección
exacta desde la que enviar ni a la que enviar.

361
7: Manejo de errores

RESUMEN
■ En esta unidad hemos aprendido a usar técnicas que puedan evitar errores.

■
Existen muchos tipos de errores, errores de sintaxis, errores de sistema y errores
lógicos, siendo estos últimos los más comunes, como por ejemplo la división por 0, el
uso de datos inválidos o el acceso a objetos inexistentes.

■
Hemos aprendido a realizar pruebas para detectar los errores. Este paso es complejo,
pero necesario antes de subir una página. Hay que hacer las pruebas necesarias para
asegurarnos de que no se van a producir errores.

■
Existen otros tipos de errores que se puedan producir como son los errores de
configuración, los errores de párser, los errores de compilación o los errores en tiempo
de ejecución.

■
Para saber dónde se han producido los errores podemos usar varias técnicas, como
usar el modo debug o el modo traza para encontrarlos.

■
También podemos controlar los errores manualmente, normalmente a través de
excepciones. Para ello hay varias técnicas como usar bloques try-catch o catch
múltiples.

■
Existen errores mucho más complejos que se nos pueden escapar de las manos y
para ello podemos usar el método Page_Error, o el envío de un email al administrador
de la página para detectarlos.

363
8
[Link] con C#
8
DIDÁCTICA
UNIDAD

8. Protección y seguridad para

[Link]. Personalización
8: Protección y seguridad para [Link]. Personalización

367
8: Protección y seguridad para [Link]. Personalización

OBJETIVOS
■ Conocer algunos principios sobre la seguridad en las páginas Web.

■ Conocer los tipos de servicios de seguridad que hay.

■ Aprender a implementar una página para acceder a otra página.

■ Crear una aplicación relacionada con bases de datos.

■
Conocer el proveedor Membership de Microsoft para el almacenamiento y manipulación
de los datos de usuario.

■ Saber los distintos tipos de métodos y atributos de la clase Membership.

369
[Link] con C#

INTRODUCCIÓN

La seguridad en Internet es uno de los mayores Por otro lado, echaremos un vistazo a los Web parts,
problemas que se puede encontrar tanto a nivel de que son elementos que permiten la personalización
usuario como a nivel de administrador. Tener una de las páginas Web a través de controles Web de
página segura es un hecho prioritario, puesto que usuarios.
de lo contrario nuestra página sería muy vulnerable a Gracias a este tipo de controles el administrador o
ataques. desarrollador de una página le ofrece al usuario la
Desde el punto de vista del administrador de la posibilidad de visualizar la página de una manera u
página lo importante es evitar tanto ataques a la otra, o permitir modificar el contenido de la misma
página como ataques al usuario, por lo que para ello según sus prioridades y preferencias.
no debe escatimar en esfuerzos para conseguir una
página segura. Desde el punto de vista del usuario
lo importante es que éste no sea atacado y que su
navegación por la Web sea segura y, que los datos que
vaya incluyendo en la Web no puedan ser transmitidos
ni sean visibles a los hackers.
Para ello crearemos el típico caso de introducir un
nombre de usuario y contraseña para poder acceder
a una página en concreto. Éste es un ejemplo que
parece sencillo, pero pongámonos en situación. El
administrador debe tener en cuenta que para acceder
a ciertos contenidos de la página los usuarios necesitan
registrarse. Para hacerlo, el desarrollador debe ir
incluyendo todos los registros de usuario en una base
de datos a través de la cual se deben comprobar los
datos cada vez que uno de ellos se conecte.

370
8: Protección y seguridad para [Link]. Personalización

8.1. Principios de seguridad

Como ya hemos comentado previamente, los niveles de seguridad se pueden
contemplar desde el punto de vista de un usuario o de un administrador. Podemos
configurar una clasificación en niveles para llevar a cabo la seguridad en nuestras
páginas atendiendo a una arquitectura lógica, ya que con ella podemos identificar
los tipos genéricos de servicios que siempre están disponibles en cualquier sistema.
Vamos a definir esta clasificación en tres niveles: los servicios de usuario, servicios
empresariales y servicios de datos.

8.1.1. Servicios de usuarios

Los servicios de usuario se encargan de la interacción de clientes con el sistema
y proporcionan la conexión necesaria con la lógica empresarial básica. La primera
imagen que se nos viene a la cabeza sobre la seguridad a nivel de usuario es la de la
identificación de un usuario y su contraseña. Este proceso normalmente se denomina
autenticación y autorización y como es lógico se suele realizar en el nivel de servicios
de usuario.

La autenticación es el proceso a través del cual se pueden verificar las credenciales de

usuario en una lista denominada referencial. En [Link] se pueden reconocer varios
referenciales, como por ejemplo, Windows, ASPNetDB, así como también es capaz
de crear los suyos propios. Cada referencial puede implementar una técnica distinta
de verificación, aunque como ya hemos comentado antes, la más usual y la que casi
todos usan es la de usuario y contraseña, aunque no tiene por qué ser así siempre,
como por ejemplo en muchas ocasiones, normalmente en ámbito privado, nos pueden
pedir un dominio de red o que estemos conectados a un servidor concreto. Una vez
que el usuario ha sido identificado y validado, las credenciales son constantes entre
todos los referenciales.

En el caso que nos interesa, que no es otro que en [Link], éste puede tomar como
modo de autenticación entre varias opciones, como son Windows, Forms o Passport.
Como ya sabemos de la primera unidad con el modo Windows, el encargado de
identificar al usuario es el Internet Information Service, es decir, IIS. Si nos atenemos al
modo Forms, lo más usual es tener una página de conexión para reconocer al usuario,
cuya identidad se comprueba a través de una base de datos, en la que se compara
el nombre de usuario y la contraseña introducidos con los que existe en la base de
datos. El modo passport no difiere apenas en nada en del tipo forms, excepto que nos
proporciona una autenticación centralizada con los servicios de Microsoft.

[Link] para identificar a un usuario entrante.

-->
<authentication mode=”Forms” />

Los modos en los que puede actuar una Web se pueden configurar en el [Link],
donde tenemos la opción de manipular las autorizaciones, permitiendo o no el acceso
a ciertos contenidos para los usuarios. La forma de modificar estos permisos se puede
definir de la siguiente forma:

<location path = “[Link]”>

<[Link]>
<authorization>
<allow roles = “conocidos” />
<deny users = “*”/>
</authorization>
</[Link]>
</location>

La parte de autorización debe ir dentro de las etiquetas de configuration, mientras que

el bloque de location tiene que ir fuera.

Vamos a ver un ejemplo de cómo podemos conectarnos a una página Web que
requiera un nombre de usuario y una contraseña. Para ello vamos a necesitar crearnos
una nueva página dentro de alguno de los proyectos que hayamos realizado, por
ejemplo, vamos a usar el del calendario del plan de vuelos.

Así que como hemos dicho, nos creamos una nueva página (botón derecho sobre el
proyecto, agregar nuevo elemento, formulario web) y la denominamos autenticacion.
aspx, por ejemplo, y dentro de ella vamos a incluir el siguiente código:

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

372
8: Protección y seguridad para [Link]. Personalización

private bool Comprobar(string usuario, string passwd,

bool rememberUserName)
{
string usuariointro = “usuario”;
string contraintro = “[Link]”;
if ([Link](usuariointro) && passwd.
Equals(contraintro))
{
return true;
}
else
{
return false;
}
}
}

<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”[Link]” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0

Transitional//EN” “[Link]
[Link]”>

<html xmlns=”[Link]
<head>
<title> Control de errores </title>

373
[Link] con C#

</head>
<body>
<form id = “form1” runat = “server”>

<asp:Login ID = “Login1” runat = “server”

BackColor = “#F7F6F3”
BorderColor = “#E6E2D8”
BorderStyle = “Solid”
ForeColor = “#333333”
Onauthenticate = “Page_Load”>

<InstructionTextStyle Font-Italic = “True” ForeColor =

“Black” />

<TitleTextStyle BackColor = “blue” Font-Bold = “True”

ForeColor = “White” />

</asp:Login>
</form>
</body>
</html>

Como podemos ver, nos hemos creado dos métodos para poder autenticar a los
usuarios. El primer método lo que hace es que una vez introducidos el nombre de
usuario y contraseña, siendo éstos correctos, nos redirecciona a la página que
queremos y el segundo método lo que hace es comprobar que el nombre de usuario
y contraseña introducidos son correctos. Para ello toma tres parámetros, 2 de ellos
los que ha introducido el usuario (usuario y contraseña) y un tercer parámetro que
sirve para recordarlos. En nuestro caso hemos usado como usuario = usuario y
como contraseña = [Link]. En un caso real esto serviría quizá en el caso de que el
administrador tenga puesto un nombre de usuario y contraseña únicos para poder
entrar él mismo. Normalmente lo que ocurre es que cada vez que un usuario se da
de alta, sus datos de usuario y contraseña son almacenados en una base de datos
y la página tendrá que leer de esa base de datos el nombre de usuario y contraseña.

En la parte del HTML hemos usado una nueva pestaña que es la pestaña Login que
nos permite crearnos un formulario para comprobar el usuario y la contraseña. Esta
etiqueta por defecto nos muestra el botón de conexión que al pulsarlo implementa
onauthenticate, que es muy parecido al onClick y también muestra la pestaña de
recordar la próxima vez que visite la página.

374
8: Protección y seguridad para [Link]. Personalización

Esto aún no funciona, pues todavía nos queda comunicar a qué página tiene que
redirigirse una vez hayamos introducido nuestros nombres de usuario y contraseña.
Para ello tenemos que abrir el [Link] y en él introducir el siguiente bloque:

<authentication mode = “Forms”>

<forms defaultUrl = “[Link]” loginUrl = “~/

[Link]” slidingExpiration = “true” timeout =
“20”>

</forms>
</authentication>

Como podemos observar, antes que nada hemos definido el modo de autenticación a
Forms. Tenemos que crear después un bloque con etiquetas forms y dentro de éste
especificar la ruta a la que se dirige una vez comprobado los datos en defaultUrl y
desde donde se autentica, que es en loginUrl. También se puede definir el timeout,
que es el tiempo que puede permanecer una página inactiva hasta que se desconecte
automáticamente y haya que volver a introducir los datos.

Después tenemos un bloque de autorización que nos permite prohibir el paso a

usuarios desconocidos. Para ello se usa la etiqueta <deny users = “?” />. Una vez
hechos todos estos pasos procedemos a ejecutar la página “[Link]” y
obtenemos el siguiente resultado:

Si introducimos un nombre de usuario y contraseña correctos, accederemos a la

página que tengamos definida por defecto. Así que si hemos hecho el ejemplo del
plan de vuelos, obtendremos esa página.

En el caso de que introduzcamos un nombre de usuario o contraseña incorrectos

obtendremos lo siguiente:

375
[Link] con C#

8.1.2. Servicios empresariales

Los servicios empresariales son capaces de proporcionarnos lo que es la funcionalidad
básica de nuestro sistema y encapsular la lógica empresarial. En este tipo de servicios
el canal de comunicación, el servidor y el origen de los datos no importa, puesto que
va a funcionar del mismo modo. Gracias a estas características podemos tener la
estabilidad necesaria para que en un futuro se puedan incorporar y agregar nuevos
elementos en forma de servidores o canales de comunicación. Lo más usual de
este tipo de servicios es que cuando estemos procesando una petición empresarial
concreta, estemos usando varios componentes en colaboración con el nivel de
servicios empresariales.

La aplicación de este tipo de servicios proporciona los servicios de infraestructura

necesarios para las aplicaciones. Entre ellos, figuran las transacciones distribuidas y
servicios de administración de recursos, como por ejemplo, la agrupación de objetos
para componentes de .NET.

8.1.3. Servicios de datos

Este tipo de servicios son los que nos permiten acceder a los datos y a otros sistemas a
través de interfaces genéricas que resulten sencillas de usar desde el nivel de servicios
empresariales. Gracias a los servicios de datos, los cuales comprenden los orígenes
de datos y los sistemas de servidor, se pueden abstraer las reglas de acceso y los
formatos de datos específicos.

376
8: Protección y seguridad para [Link]. Personalización

8.2. Seguridad
Este apartado lo vamos a dedicar a hacer una aplicación, a través de la cual
conoceremos nuevos aspectos relacionados con la autenticación y bases de datos.

Para ello vamos a crearnos un nuevo proyecto al que vamos a llamar, por ejemplo,
seguridad. A continuación, vamos a acceder a la carpeta contenedora del nuevo
proyecto, para lo cual podemos acceder copiando la ruta. Posteriormente, vamos
a entrar en la carpeta de “Recursos de Seguridad” proporcionada al alumno. Al
descomprimir este archivo obtendremos tres carpetas: “Configuración”, “Formularios
e imágenes” y “Mapa”. En este caso vamos a abrir la de Formularios e imágenes, la
cual tiene otras dos carpetas: “Admin” e “Images”. Procedemos a copiar estas dos
carpetas y las pegamos en nuestro proyecto. Una vez realizado este paso vamos a
volver a Visual Studio y actualizamos el proyecto, que se realizaría en el explorador
de soluciones, pulsando sobre el botón de mostrar todos los archivos. Podemos
observar como aparecen las nuevas carpetas copiadas, pero salen de color blanco,
lo cual implica que para que formen parte del proyecto debemos pinchar con el botón
derecho sobre cada una de ellas y pinchar sobre “Incluir en el proyecto”.

Al realizar este paso podemos ver el contenido de las carpetas. Si accedemos a la

carpeta Admin > Security, se desplegará un árbol con una serie de ficheros .aspx.
Pinchamos sobre “[Link]” y le damos a Debug. Vamos a ver como en el
explorador nos aparece la siguiente ventana:

377
[Link] con C#

Es importante recordar que para que esto que hemos hecho funcione debemos tener
activado SQL Server. En el caso de que nos salga este error “Error relacionado con la
red o específico de la instancia mientras se establecía una conexión con el servidor
SQL Server. No se encontró el servidor o éste no estaba accesible. Compruebe
que el nombre de la instancia es correcto y que SQL Server está configurado para
admitir conexiones remotas. (provider: SQL Network Interfaces, error: 26 - Error al
buscar el servidor o instancia especificado)” debemos hacer lo siguiente:

Inicio > Programas > Microsoft SQL Server 2008 > Configuration Tools >
Sql Server Configuration Manager > SQL Server Network Configuration > Protocols
for SQLEXPRESS > TCP/IP. Posteriormente pulsamos sobre el botón derecho,
propiedades y cambiar: Protocols > Enabled = true y además IP Address > IP ALL >
TCP Dynamic Ports = 1433.

Finalmente tendríamos que reiniciar SQL Server:

SQL Server Services > SQL Server (EXPRESS) > Botón derecho, reiniciar.

Una vez hayamos podido abrir la página anterior volvemos de nuevo a Visual Studio.
Pinchamos sobre la carpeta App Data y en el mismo explorador de soluciones le
damos a ver todos los ficheros. Aparecerá un nuevo fichero “[Link]”. Si
ahora abrimos el fichero “[Link]”, observamos que aparece la siguiente cadena:

Podemos observar que en la cadena de conexión aparece el fichero nombrado

anteriormente [Link]. Pues en el explorador de soluciones vamos a eliminar
este fichero con el botón derecho y posteriormente vamos a modificar el [Link]. En
este fichero tenemos que cambiar el nombre de la cadena de conexión. Anteriormente se
llamaba ApplicationServices y lo vamos a renombrar como SecurityConnectionString y
lo que antes se denominaba como [Link] va a pasar a llamarse [Link].

378
8: Protección y seguridad para [Link]. Personalización

Así de esta forma vamos a cambiar todas las etiquetas que se llamen ApplicationString
por SecurityConnectionString, y en la etiqueta que pone RoleManager cambiamos
“false” por “true”, quedándonos el código de la siguiente forma:

<?xml version=”1.0”?>

<[Link]>
<compilation debug=”true” targetFramework=”4.0” />

379
[Link] con C#

</membership>

</[Link]>

<[Link]>
<modules runAllManagedModulesForAllRequests=”true”/>
</[Link]>
</configuration>

Guardamos el código y a continuación procedemos a copiar el código proporcionado

al alumno en la carpeta “Configuración”:

<siteMap defaultProvider=”XmlSiteMapProvider”
enabled=”true”>
<providers>
<add name=”XmlSiteMapProvider”

380
8: Protección y seguridad para [Link]. Personalización

description=”Default SiteMap provider.”

type=”[Link] “
siteMapFile=”[Link]”
securityTrimmingEnabled=”true” />
</providers>
</siteMap>

y lo situamos justo después del bloque <roleManager> … </roleManager> y por

delante de </[Link]> y volvemos a guardar.

El siguiente paso es abrir la carpeta dada al alumno “Mapa” y copiamos el único

fichero que aparece “Web” y lo pegamos en la carpeta de nuestro proyecto y volvemos
a actualizar como ya hicimos anteriormente y lo incluimos en nuestro proyecto.

Si abrimos podemos observar el siguiente código:

<?xml version=”1.0” encoding=”utf-8” ?>

<siteMap xmlns=”[Link]
SiteMap-File-1.0” >
<siteMapNode url=”~\[Link]” title=”Página
principal” description=”” >
<siteMapNode url=”~\[Link]” title=”Acerca de”
description=”” />
<siteMapNode title=”Seguridad”

381
[Link] con C#

roles=”Administrador”>
<siteMapNode url=”~/Admin/Security/
[Link]” title=”Reglas de acceso”/>
<siteMapNode url=”~/Admin/Security/
[Link]” title=”Resumen de acceso de
seguridad”/>
<siteMapNode title=”Lista de usuarios”
roles=”Administrador”>
<siteMapNode url=”~/Admin/Security/Users.
aspx” title=”Usuarios por Nombre”/>
<siteMapNode url=”~/Admin/Security/
[Link]” title=”Usuarios por Rol”/>
<siteMapNode url=”~/Admin/Security/
[Link]” title=”Usuarios Activos/Inactivos”/>
<siteMapNode url=”~/Admin/Security/
[Link]” title=”Usuarios Online”/>
<siteMapNode url=”~/Admin/Security/
[Link]” title=”Usuarios Bloqueados”/>
</siteMapNode>
<siteMapNode url=”~/Admin/Security/AddUser.
aspx” title=”Añadir Usuario”/>
<siteMapNode url=”~/Admin/Security/[Link]”
title=”Mantenimiento de roles”/>
</siteMapNode>
</siteMapNode>
</siteMap>

Podemos observar que cada una de las url de “siteMapNode” coincide con cada
uno de los ficheros proporcionados en la carpeta de Admin/Security, donde también
podemos apreciar que en algunas etiquetas aparece roles al cual se le proporciona el
nombre de Administrador.

Si ahora abrimos la carpeta [Link], obtenemos el código de la vista de la página

que hemos abierto en el explorador y Visual Studio nos da la posibilidad de ver el
diseño que tendría nuestro código pulsando sobre la pestaña “Diseño” que aparece
debajo de la ventana del código:

382
8: Protección y seguridad para [Link]. Personalización

Para cada código podemos ver su diseño. En este caso vemos el siguiente:

Como podemos observar, podemos pulsar sobre cualquiera de los componentes

diseñados. Si pulsamos sobre el que pone “Página Principal” y “acerca de”, accedemos
a un menú en el que vamos a elegir el origen de los datos. Si pulsamos sobre “Elegir
Origen de los Datos”, se nos despliega una lista con las posibles fuentes. Debemos
escoger la segunda opción “<Nuevo origen de datos…>” y nos aparece la siguiente
ventana:

383
[Link] con C#

En este caso debemos seleccionar como origen de los datos “Mapa del sitio” y dejar
el nombre que se nos proporciona automáticamente y aceptamos. Seguidamente
pinchamos sobre el elemento “Ventana principal”. Además, tenemos que tener abierta
la vista de propiedades:

En la ventana de propiedades aparecen una serie de características que nos pueden

servir para el diseño de nuestra página. En este caso vamos a usar la función
StaticDisplayLevels, el cual obtiene o establece el número de niveles de menú que
se van a mostrar en un menú estático. En un principio aparece un solo nivel, pero
vamos a cambiarlo por dos niveles:

384
8: Protección y seguridad para [Link]. Personalización

Si seguimos recorriendo el menú de propiedades, vemos que existe una denominada

“Items”. Si pinchamos sobre ella, se nos abre la siguiente ventana:

Al seleccionar un ítem podemos eliminarlo pinchando sobre la cruz. Procedemos a

eliminar los dos ítems que nos aparecen, le damos a OK y guardamos. A continuación
ejecutamos dándole a Debug, apareciendo en el navegador la siguiente pantalla:

385
[Link] con C#

Esta página es la página que nos aparecería. Vemos que si pinchamos en cada una
de las pestañas nos aparecen URL diferentes ([Link], [Link]). Si ahora
accedemos a la siguiente URL [Link]
(el número que acompaña a localhost en la dirección URL variará según el usuario),
veremos que nos aparece la siguiente ventana:

Podemos añadir el rol que nos parezca, por ejemplo, Administrador y aceptamos.
Nos damos cuenta de que se ha creado un nuevo rol. Este rol puede ser también
eliminado. Cada uno de los ficheros proporcionados al alumno de la carpeta Security
tiene una función, algunas de las cuales podemos usar ahora en esta página:

386
8: Protección y seguridad para [Link]. Personalización

En esta página podemos añadir tantos usuarios como queramos, así como eliminarlos
si creemos conveniente. Así que nosotros vamos a crear un nuevo usuario denominado
Usuario.

Para ver cómo se han creado los nuevos roles podemos acceder a la siguiente URL:
[Link] .

Ahora podemos dar de alta a los usuarios rellenando los campos que aparecen en la
pantalla:

387
[Link] con C#

Al rellenar todos los campos y darle al botón “Añadir Usuario” somos redireccionados
a la siguiente ventana:

Como se puede observar, hemos sido dados de alta y ya aparecemos en la lista de

usuarios de la aplicación. Una vez registrados podemos acceder con nuestro nombre
de usuario y contraseña pulsando en la esquina superior derecha sobre Log In.

388
8: Protección y seguridad para [Link]. Personalización

Como podemos observar, ya aparecen menús desplegables con las diferentes

funciones que se pueden realizar. Dentro de estas funciones aparecen reglas de acceso,
resumen de acceso de seguridad, lista de usuarios… A través de ellos podemos, en
definitiva, realizar una gestión de los usuarios. Desde aquí también podemos añadir
nuevos usuarios.

Además, podemos acceder al mantenimiento de roles y ver los usuarios:

389
[Link] con C#

Toda vez que tenemos algún usuario registrado podemos darle a la función reglas
de acceso. Como se puede comprobar, aparece una descripción detallada sobre la
gestión de los niveles de seguridad y en el lateral un árbol con las diferentes páginas.
Si pinchamos sobre admin, podemos crear nuevas reglas sobre el rol de cada uno de
los usuarios. Por ejemplo, en la siguiente imagen se puede ver cómo hemos creado
una regla sobre el rol “Administrador” que le permita realizar el acceso a la aplicación
como administrador. Por lo tanto, el caso contrario sería denegar el acceso a todo
el resto de usuarios de la aplicación. Para ello seleccionamos la acción Denegar y
aplicamos la regla a todos los usuarios.

Como se puede apreciar en la imagen, al lado de cada regla aparecen dos botones,
subir y bajar. Estos dos botones se usan para subir una regla o bajarla. Esto quiere
decir que según el orden en el que estén colocadas las reglas se aplican de una
manera u otra, puesto que éstas se aplican en orden y es por eso por lo que primero

390
8: Protección y seguridad para [Link]. Personalización

hemos creado los permisos para el administrador y luego para todos los usuarios
(entre los que también se encuentra el administrador), lo que implica que al estar ya
creada la regla para el administrador, todas aquellas que se creen después no le van
a afectar.

Para ver el funcionamiento más concretamente vamos a cerrar la sesión que tenemos
abierta y volvemos a Visual Studio y agregamos una nueva carpeta al proyecto
(recordamos que con el botón derecho pulsamos sobre el nombre del proyecto y le
damos a añadir nuevo elemento). Llamemos a esta carpeta Users.y vamos a iniciar la
depuración, lo cual nos lleva a abrir de nuevo la aplicación en el navegador e iniciamos
sesión con el nombre al cual le dimos los mayores privilegios anteriormente, es decir,
como administrador. Si le damos a Reglas de Acceso, se observa como aparece en
el árbol de la izquierda la carpeta que nos acabamos de crear. Si pinchamos sobre
ella, podemos crear nuevas reglas y vamos a crearnos una para el rol Usuario que le
permita acceder al directorio que aparece y otra regla que deniegue el acceso a los
demás. Si cerramos la sesión e intentamos entrar ahora con el segundo perfil que
nos creamos anteriormente como Usuario, vemos que la pantalla es distinta a la del
administrador, puesto que ésta carece de los permisos que sí tiene la otra.

Para ver más funcionalidades de la aplicación procedemos a cerrar la sesión y entramos

de nuevo como administrador y nos fijamos en el menú “Usuarios bloqueados” y
vemos que no aparecen elementos.

Vamos a cerrar la sesión y parar la aplicación y vamos de nuevo a Visual Studio.

Guardamos todo por si acaso, cerramos las pestañas que tengamos y actualizamos
el explorador de soluciones. Como podemos ver en la carpeta AppData aparece el
nuevo fichero que nos creamos denominado [Link] y si pinchamos
sobre él, nos aparece una nueva ventana:

391
[Link] con C#

Al pinchar sobre Tablas vemos que se despliega un menú con diferentes tablas, a las
cuales le podemos agregar las que queramos pinchando sobre el botón derecho y
agregar nueva tabla apareciendo lo siguiente:

En esta nueva tabla declaramos el nombre de cada columna, el tipo de datos que
usa y si permite valores nulos. Procedemos a rellenar los campos con el nombre
UserId, de tipo int y que no permita valores nulos. Podemos observar como en la fila
de abajo aparecen una serie de propiedades de la columna creada. Hay que cambiar
una propiedad en “Especificación de la Identidad” y donde pone (Identidad) debemos
poner que Sí en vez de No.

392
8: Protección y seguridad para [Link]. Personalización

A continuación, a esta columna se le aplica la condición de clave primaria, señalando

la columna y pulsando sobre el ícono en el que aparece una llave:

Luego podemos crear todas las columnas que queramos. Nosotros, además, vamos
a usar una tabla que ya está hecha, que es la de aspnet_Users y vamos a crear una
serie de columnas tal y como aparece en la imagen:

Vemos que aparecen una serie de tipos de datos que por su nombre podemos deducir
qué valores permite. Uniqueidentifier nos permite darle un identificador único, Int solo
valores enteros y varchar nos permite campos alfanuméricos y el número que aparece
entre paréntesis es el tamaño máximo que puede alcanzar ese campo.

Ahora vamos a proceder a administrar los índices y claves pulsando sobre el siguiente
botón:

393
[Link] con C#

Vamos a añadir una nueva tabla, la cual tiene un nombre y una serie de columnas que
casualmente son las que hemos creado.

Vamos a seleccionar la columna aspnet_Users y le damos a OK y ponemos

Uniqueidentifier como aparece en la imagen y cerramos:

394
8: Protección y seguridad para [Link]. Personalización

Posteriormente tenemos la posibilidad de establecer relaciones entre tablas a través

del siguiente botón:

Las relaciones entre tablas nos dan la opción de vincular ciertas características
comunes a varias tablas para mantener una integridad relacional entre ellas. Vamos
a proceder a crear relaciones entre tablas dándole al botón agregar, apareciendo la
siguiente ventana:

395
[Link] con C#

Pinchamos sobre la pestaña de “Especificación de tablas y columnas” del menú

“General” y la configuramos de la siguiente manera:

Donde hemos seleccionado como tabla de clave principal la tabla “aspnet_Users” y su

columna UserId y como tabla de clave ajena Table1 con su columna “aspnet_Users.
Pulsamos sobre OK y sobre la pantalla que nos aparece en la “Especificación de
INSERT y UPDATES” seleccionamos como regla de actualización y de eliminación
la opción “Cascada”. La política de actualización en cascada consiste en permitir la
operación de actualización de la tupla, y en efectuar operaciones compensatorias
que propaguen en cascada la actualización a las tuplas que la referenciaban para así
mantener la integridad referencial.

Después de todo esto guardamos y le damos un nuevo nombre a la tabla, por ejemplo,
Users y decimos que sí queremos continuar.

Al pulsar con el botón derecho sobre la tabla aspnet_Users que aparece en el menú
seleccionamos la opción “Mostrar datos de tabla”. Los datos que aparecen son los
que hemos registrado a través de la aplicación con los campos que hemos incluido,
apareciendo el UserId y applicationId encriptados.

Al abrir la tabla Users que nos creamos anteriormente, vemos que aparece vacía,
pero está relacionada a través de su columna UserId con la tabla aspnet_Users. Para
poder apreciar la relación entre tablas vamos a copiar el campo UserId de cualquier
entrada de la tabla aspnet_Users y lo vamos a pegar en la tabla Users en la columna
aspnet_Users pues es ésta la que está relacionada. Podemos rellenar el resto de
campos con los datos que creamos conveniente siempre que cumplan los criterios
impuestos sobre el tipo de datos.

396
8: Protección y seguridad para [Link]. Personalización

Además, podemos crearnos tantos registros como creamos.

Si se intenta copiar el mismo UserId para distintos registros, Visual Studio nos va
a lanzar un mensaje de error, puesto que previamente habíamos declarado que el
campo UserId iba a tener un identificador único:

Por lo tanto, debemos cambiar el UserId del segundo registro. Podemos cerrar las
tablas e iniciamos la depuración y ya en el navegador aparece la aplicación, en la cual
vamos a iniciar sesión como Administrador.

Vamos a ver la lista de usuarios por nombre. Al pinchar sobre cualquiera de ellos nos
aparece la siguiente página con la información relativa al usuario seleccionado:

397
[Link] con C#

En esta parte de la aplicación podemos desbloquear a un usuario si lo estuviese o

directamente eliminarlo. Si decidimos que queremos eliminarlo, vamos a ver reflejados
los cambios en Visual Studio en la tabla que corresponda, en este caso en la tabla
aspnet_Users y al estar relacionada a través de un campo con la tabla Users, en ésta
también podemos apreciar los cambios realizados en la aplicación debido a que antes
habíamos procedido a la eliminación en cascada.

En definitiva, para manejar una aplicación el programador es el que decide los

privilegios de los usuarios, mostrando a cada uno de ellos una página diferente
según su función, siendo capaz de bloquear usuarios, eliminarlos, modificar sus
datos, etcétera. Aparte puede hacerlo tanto desde la aplicación, así como desde la
herramienta de programación.

A la hora de crear una aplicación de este tipo es muy importante saber manejar algunos
conceptos de bases de datos y tener muy claro qué es lo que se necesita, qué juego
de datos va en cada tabla y cómo se relacionan entre ellas.

Existe un video correspondiente a este apartado disponible en la sección de

videos del curso.

398
8: Protección y seguridad para [Link]. Personalización

8.3. Proveedor Membership

Como hemos podido observar en el ejemplo anterior es bastante, asequible la
construcción de un modo de conexión a una página con el modo forms. En cambio
con este modo también se tenía problemas desde el punto de vista en el que no había
ninguna herramienta disponible para construir su propio referencial de usuarios.

Con [Link] se soluciona este problema, ya que en las primeras versiones de la

tecnología se introduce el Membership Provider que es un proveedor de pertenencia
en el que se instaura la autenticación y gestión de usuarios.

Al implementar un proveedor de pertenencia personalizado, es necesario heredar

la clase abstracta MembershipProvider. La clase abstracta MembershipProvider
se hereda de la clase abstracta ProviderBase. Las implementaciones
MembershipProvider deben implementar a su vez los miembros necesarios de
ProviderBase.

public abstract class MembershipProvider : ProviderBase

Con la API de Membership poseemos un conjunto de clases a través de las cuales

seremos capaces de crear, suprimir, autenticar y mantener una base de datos con las
cuentas de usuarios. Normalmente la lista de los usuarios está constituida por una
base de datos SQL.

Para poder crearnos nuestro propio proveedor de suscripciones hay que implementar
los siguientes métodos y propiedades:

8.3.1. Método Initialize

Gracias a este método se pueden establecer los valores de las propiedades del
proveedor, como por ejemplo, los valores de la implementación y las opciones
especificadas en el [Link]. Para ello se debe de escribir el siguiente código:

public virtual void Initialize (string nombre,

NameValueCollection configuracion)

8.3.2. Propiedad EnablePasswordReset

Con esta propiedad se le permite al usuario modificar su contraseña a través del
método ResetPassword, por una nueva contraseña generada aleatoriamente.

public abstract string ResetPassword(string username,

string answer)
{
}

399
[Link] con C#

8.3.3. Propiedad EnablePasswordRetrieval

A través de esta propiedad se le da al usuario la posibilidad de recuperar su contraseña
mediante el método GetPassword.

public abstract string GetPassword(string username, string

answer)
{
}

8.3.4. Propiedad Requiresquestionandanswer

Con esta propiedad se le indica al usuario si deben proporcionar una respuesta de
contraseña a una pregunta previa para poder recuperar su contraseña o restablecerla.

8.3.5. Propiedad RequiresUniqueMail

Gracias a esta propiedad estamos indicándole al usuario si debe introducir un valor
de correo electrónico único al crear el usuario. Se devolvería un error controlado en el
caso de que ya existiera. Para ello tenemos el método CreateUser.

public abstract MembershipUser CreateUser(string username,

string password, string email,
string passwordQuestion, string passwordAnswer,
bool isApproved, Object providerUserKey,
out MembershipCreateStatus status)
{
}

8.3.6. Propiedad PasswordFormat

Mediante esta propiedad se indica el formato en el que se guardan las contraseñas.
En formato clear se guardan tal cual están escritas con la consiguiente desventaja de
que es infinitamente más fácil de desencriptar. Con el formato Encrypted se cifran
al almacenar y se descifran al comparar o recuperar la contraseña. Es mucho más
seguro que el anterior, aunque requiere la implementación del cifrado y descifrado.
Con el formato hash las contraseñas se fragmentan utilizando un algoritmo hash y un
valor asociado que se genera aleatoriamente. Cuando se valida una contraseña se
fragmenta con el valor asociado en la base de datos para su comprobación. Es el más
seguro aunque no se pueden recuperar.

Se pueden utilizar tanto un método para encriptar como para desencriptar, para los
cuales tenemos respectivamente EncryptPassword y DecryptPassword.

protected virtual byte[] EncryptPassword(byte[] password)

{
}

400
8: Protección y seguridad para [Link]. Personalización

protected virtual byte[] DecryptPassword(byte[]

encodedPassword)
{
}

8.3.7. Propiedad MaxInvalidPasswordAttempts

Debido a esta propiedad tenemos la posibilidad de limitar el número máximo de
intentos fallidos a la hora de introducir una contraseña antes de bloquear la cuenta.
Esta medida sirve como protección si un usuario no deseado intenta atacar una
cuenta.

Vamos a ver cómo habría que incluir todas estas propiedades dentro del método
Initialize:

public override void Initialize(string name,

NameValueCollection config)
{

if (config == null)
throw new ArgumentNullException(“config”);

if (name == null || [Link] == 0)

name = “OdbcMembershipProvider”;

if ([Link](config[“description”]))
{
[Link](“description”);
[Link](“description”, “Sample ODBC
Membership provider”);
}

[Link](name, config);

pApplicationName = GetConfigValue(config[“applicati
onName”],
[Link].
[Link]);
pMaxInvalidPasswordAttempts = Convert.ToInt32(Get
ConfigValue(config[“maxInvalidPasswordAttempts”], “5”));
pPasswordAttemptWindow = Convert.ToInt32(GetConfig
Value(config[“passwordAttemptWindow”], “10”));
pMinRequiredNonAlphanumericCharacters = Convert.
ToInt32(GetConfigValue(config[“minRequiredNonAlphanumericCh

401
[Link] con C#

aracters”], “1”));
pMinRequiredPasswordLength = Convert.ToInt32(GetC
onfigValue(config[“minRequiredPasswordLength”], “7”));
pPasswordStrengthRegularExpression = [Link]
ring(GetConfigValue(config[“passwordStrengthRegularExpressi
on”], “”));
pEnablePasswordReset = [Link](GetConfig
Value(config[“enablePasswordReset”], “true”));
pEnablePasswordRetrieval = [Link](GetC
onfigValue(config[“enablePasswordRetrieval”], “true”));
pRequiresQuestionAndAnswer = [Link](Ge
tConfigValue(config[“requiresQuestionAndAnswer”], “false”));
pRequiresUniqueEmail = [Link](GetConfig
Value(config[“requiresUniqueEmail”], “true”));
pWriteExceptionsToEventLog = [Link](Ge
tConfigValue(config[“writeExceptionsToEventLog”], “true”));

string formato = config[“passwordFormat”];

if (formato == null)
{
formato = “Hashed”;
}

switch (formato)
{
case “Hashed”:
pPasswordFormat = MembershipPasswordForma
[Link];
break;
case “Encrypted”:
pPasswordFormat = MembershipPasswordForma
[Link];
break;
case “Clear”:
pPasswordFormat = MembershipPasswordForma
[Link];
break;
default:
throw new ProviderException(“Password for
mat not supported.”);
}
}

private string GetConfigValue(string configValue, string

402
8: Protección y seguridad para [Link]. Personalización

defaultValue)
{
if ([Link](configValue))
return defaultValue;

return configValue;
}

private string pApplicationName;

private bool pEnablePasswordReset;
private bool pEnablePasswordRetrieval;
private bool pRequiresQuestionAndAnswer;
private bool pRequiresUniqueEmail;
private int pMaxInvalidPasswordAttempts;
private int pPasswordAttemptWindow;
private MembershipPasswordFormat pPasswordFormat;

public override string ApplicationName

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

public override bool EnablePasswordReset

{
get
{
return pEnablePasswordReset;
}
}

public override bool EnablePasswordRetrieval

{
get
{

403
[Link] con C#

return pEnablePasswordRetrieval;
}
}

public override bool RequiresQuestionAndAnswer

{
get
{
return pRequiresQuestionAndAnswer;
}
}

public override bool RequiresUniqueEmail

{
get
{
return pRequiresUniqueEmail;
}
}

public override int MaxInvalidPasswordAttempts

{
get
{
return pMaxInvalidPasswordAttempts;
}
}

public override int PasswordAttemptWindow

{
get
{
return pPasswordAttemptWindow;
}
}

public override int PasswordAttemptWindow

{
get { return pPasswordAttemptWindow; }

404
8: Protección y seguridad para [Link]. Personalización

}
public override MembershipPasswordFormat
PasswordFormat
{
get
{
return pPasswordFormat;
}
}

private int pMinRequiredNonAlphanumericCharacters;

public override int

MinRequiredNonAlphanumericCharacters
{
get
{
return pMinRequiredNonAlphanumericCharacters;
}
}

private int pMinRequiredPasswordLength;

public override int MinRequiredPasswordLength

{
get
{
return pMinRequiredPasswordLength;
}
}

private string pPasswordStrengthRegularExpression;

public override string

PasswordStrengthRegularExpression
{
get
{
return pPasswordStrengthRegularExpression;
}
}

405
[Link] con C#

Como podemos observar, tenemos las propiedades vistas arriba más algunas
propiedades que sirven para perfeccionar la forma en la que debemos introducir la
contraseña. Al principio tenemos que definir las propiedades y asignarles el valor
predeterminado que queremos, como por ejemplo, asignar un número máximo de
intentos o el modo en el que guardamos las contraseñas. Después tenemos que
generar los get y set para cada una de las propiedades. Hemos obviado algunos
elementos correspondientes a la configuración.

8.3.8. Método CreateUser

Este método toma como parámetros de entrada el nombre y contraseña de un
usuario, su email e inserta un nuevo usuario en la base de datos. Se crea un objeto
MembershipUser que se rellena con la información que el usuario acaba de introducir.
Además, se puede indicar si el usuario se ha creado o no correctamente.

8.3.9. Métodos UpdateUser, DeleteUser, GetUser y ValidateUser

Con estos métodos tenemos la posibilidad de modificar los datos de un usuario,
borrarlos o comprobar si un usuario está conectado respectivamente para los métodos
UpdateUser, DeleteUser y GetUser. Con ValidateUser comprobamos que el usuario
y contraseña introducidos son correctos.

8.3.10. Método GetAllUsers

Con este método podemos obtener el conjunto de todos los objetos MembershipUser
de todos los usuarios en la base de datos. Tenemos dos parámetros: pageIndex
que identifica la página de resultados que se va a devolver y pageSize que indica el
tamaño de la página que se devuelve. Si tuviésemos pageIndex = 1 y pageSize = 5
tendríamos los usuarios del 1 al 5.

8.3.11. Método GetNumberOfUsersOnline

A través de la implementación de este método podemos obtener el número de usuarios
registrados en la base de datos que están conectados actualmente. No es un valor
exacto, sino que se hace de forma que vemos los usuarios que están conectados, por
ejemplo, en los últimos 5 minutos. Es decir, se establece un valor de minutos mínimos
desde el momento actual en los que hay usuarios conectados, de esta forma tenemos
un valor aproximado.

8.3.12. Método ResetPassword y GetPassword

Como vimos en las propiedades, el método ResetPassword es el encargado de generar
una nueva contraseña aleatoria al usuario, mientras que el método GetPassword nos
devuelve la contraseña de un usuario cuando éste, por ejemplo, la ha olvidado y se
le reenvía a través del email o de una pregunta y respuesta previamente dadas por el
usuario.

406
8: Protección y seguridad para [Link]. Personalización

8.3.13. Método ChangePassword

Con este método, tomando como parámetros el nombre de usuario y la contraseña
actual, si damos una nueva contraseña, actualiza la antigua por la nueva dada en la
base de datos.

8.3.14. Método ChangePasswordQuestionAndAnswer

Mediante este método tenemos la posibilidad de cambiar la pregunta y respuesta de
contraseña dados un nombre de usuario y una contraseña, para así poder actualizarlas.

Existen otros métodos como encontrar a los usuarios por nombre o por email o
simplemente para desbloquear una cuenta previamente bloqueada por algún ataque
a una de las cuentas. Las combinaciones de todos estos métodos son muchísimas,
pero es verdad que cuantos más métodos y propiedades usemos, más completa y
variada será nuestra página.

Todos los métodos vistos arriba son más complejos de codificar puesto que utilizan
estructuras que no hemos visto durante el curso. Eso sí, gracias a estos métodos
implementados por [Link] no es necesario implementarlos más ya que una vez
hechos pueden ser reutilizados constantemente para distintas páginas, aunque como
hemos dicho antes, podemos crear nuestro propio proveedor de usuarios de manera
personalizada añadiendo o eliminando métodos. La solución propuesta por la propia
tecnología [Link] y Microsoft es la siguiente y puede ser encontrada en la siguiente
página:

[Link]

Como ya hemos comentado, es un código muy extenso, pero muy útil. Es muy
recomendable echar un vistazo y entender bien los métodos, puesto que muchos de
ellos los podemos reutilizar y modificar para crear nuestras propias reglas a la hora de
dar de alta a los usuarios o de mantener la seguridad de los mismos. Como se puede
observar, hay muchos métodos muy similares y que utilizan las mismas estructuras
para atrapar excepciones.

Es algo notorio que cada empresa o página tiene unas credenciales de usuario distintas
e incluso tecnologías distintas para implementar la creación de cuentas de usuario. Por
ejemplo, hay páginas que solicitan muchos de nuestros datos personales, algunos de
ellos incluso hay que ponerlos de forma obligatoria y otros de forma opcional y otras
páginas que solo se bastan de un nombre de usuario, una contraseña y una cuenta
de correo. Si queremos registrarnos, por ejemplo, en una cuenta de alguna tecnología
perteneciente a Microsoft, estaremos utilizando todas las propiedades vistas arriba y si
estamos dándonos de alta en alguna cuenta perteneciente a otra página, tendremos
otras opciones, como por ejemplo a la cuenta de usuario de un banco, donde el
número de intentos para acceder a una cuenta es mucho menor que en cualquier otro
tipo de cuentas.

407
8: Protección y seguridad para [Link]. Personalización

RESUMEN
■ En esta unidad hemos visto los tres tipos de servicios de seguridad.

■
Los servicios de usuario son los que más nos interesan y en ellos se encuadra la
utilización de autenticación y validación de usuarios. Para ello hemos aprendido una
nueva etiqueta, asp:login.

■ Los otros tipos de servicios son los de empresa y los de datos.

■
Para manejar una aplicación el programador es el que decide los privilegios de cada
uno de los usuarios, permitiendo o denegando acceder a ciertos contenidos de la
misma.

■
A la hora de crear una aplicación de este tipo es muy importante saber manejar algunos
conceptos de bases de datos y tener muy claro qué es lo que se necesita, qué juego
de datos va en cada tabla y cómo se relacionan entre ellas.

409

3
Material
ÍNDICE GENERAL
1. Introducción..................................................................................

4
ASP.NET C#
3.5. Cadenas..................................................................................................

5
Material
INTRODUCCIÓN.....................................................................................................

1
ASP.NET con C#
1. Introducción
1
UNIDAD
DIDÁCTICA

9
1: Introducción
ÍNDICE
ÍNDICE............................................................................................

También podría gustarte

Asp Net
100% (2)
Asp Net
456 páginas
Manual para Programador Jr. ASP.NET MVC
80% (5)
Manual para Programador Jr. ASP.NET MVC
282 páginas
Programación en ASP
100% (1)
Programación en ASP
83 páginas
Guía para Aplicaciones Web Dinámicas ASP.NET
Aún no hay calificaciones
Guía para Aplicaciones Web Dinámicas ASP.NET
73 páginas
ASP .NET Orientado Web
Aún no hay calificaciones
ASP .NET Orientado Web
217 páginas
Desarrollo de Aplicaciones Web Con ASP .NET 2.0. Aspectos Avanzados (Ejemplo)
Aún no hay calificaciones
Desarrollo de Aplicaciones Web Con ASP .NET 2.0. Aspectos Avanzados (Ejemplo)
36 páginas
ASp. NET 4.5 en C#
0% (1)
ASp. NET 4.5 en C#
481 páginas
C# Core
100% (5)
C# Core
137 páginas
mvc5 Spanish
50% (2)
mvc5 Spanish
100 páginas
Aprender ASP.NET MVC en 7 Pasos
Aún no hay calificaciones
Aprender ASP.NET MVC en 7 Pasos
134 páginas
Proyecto ASP.NET MVC5: ListBoxFor
100% (1)
Proyecto ASP.NET MVC5: ListBoxFor
212 páginas
Introducción a Clean Architecture .NET
100% (3)
Introducción a Clean Architecture .NET
261 páginas
Guía Completa de ASP.NET 4.5 y C#
Aún no hay calificaciones
Guía Completa de ASP.NET 4.5 y C#
199 páginas
Desarrollo de Aplicaciones ASP.NET Core MVC
Aún no hay calificaciones
Desarrollo de Aplicaciones ASP.NET Core MVC
42 páginas
Azure For Architects es-ES PDF
Aún no hay calificaciones
Azure For Architects es-ES PDF
335 páginas
Introducción a Visual Basic .NET y ASP.NET
Aún no hay calificaciones
Introducción a Visual Basic .NET y ASP.NET
273 páginas
Dot Net Framework Es PDF
Aún no hay calificaciones
Dot Net Framework Es PDF
244 páginas
La Biblia de C#
100% (4)
La Biblia de C#
835 páginas
C# 10 en Pocas Palabras: Guía Esencial
100% (1)
C# 10 en Pocas Palabras: Guía Esencial
1022 páginas
Asp Net MVC Es PDF
Aún no hay calificaciones
Asp Net MVC Es PDF
134 páginas
Programacion PHP Con Slim, Paris y Twig
100% (1)
Programacion PHP Con Slim, Paris y Twig
284 páginas
ES Guia Practica Del Desarrollo Aplicaciones Windows en Net Free
100% (2)
ES Guia Practica Del Desarrollo Aplicaciones Windows en Net Free
412 páginas
Manual Implementando Clean Architecture en Aplicaciones
Aún no hay calificaciones
Manual Implementando Clean Architecture en Aplicaciones
72 páginas
Aprende Laravel 6: Guía Práctica
100% (2)
Aprende Laravel 6: Guía Práctica
45 páginas
Acceso A Datos Con ADO .NET 3.5 (Ejemplo)
Aún no hay calificaciones
Acceso A Datos Con ADO .NET 3.5 (Ejemplo)
26 páginas
Introducción a AJAX para principiantes
Aún no hay calificaciones
Introducción a AJAX para principiantes
96 páginas
Java y MySQL: Guía Práctica de Desarrollo
100% (2)
Java y MySQL: Guía Práctica de Desarrollo
49 páginas
(Arrioja Landa Cosio Nicolás) C# Avanzado (2011)
Aún no hay calificaciones
(Arrioja Landa Cosio Nicolás) C# Avanzado (2011)
324 páginas
C# Desde Cero Aprende C# Desde Las Bases Hasta La Programacion Orientada
Aún no hay calificaciones
C# Desde Cero Aprende C# Desde Las Bases Hasta La Programacion Orientada
223 páginas
ACFrOgA0be1I69CIh0LQRNMzk8GPCAT37o7mrAdY65ba52CsvMSDaqJFl3uKUSgz-NDj8Cmthz 8le6DQcaYty5CJf8Q7M4mHRw0VFMphVfgUkqq9ufohwwnrzxMCI6fD8fw2fiNwYGFA63aGgcz
100% (1)
ACFrOgA0be1I69CIh0LQRNMzk8GPCAT37o7mrAdY65ba52CsvMSDaqJFl3uKUSgz-NDj8Cmthz 8le6DQcaYty5CJf8Q7M4mHRw0VFMphVfgUkqq9ufohwwnrzxMCI6fD8fw2fiNwYGFA63aGgcz
38 páginas
C# Avanzado
100% (6)
C# Avanzado
324 páginas
Programador .NET - Desarrollo de Aplicaciones Eficientes Con C# & ASP - Users
Aún no hay calificaciones
Programador .NET - Desarrollo de Aplicaciones Eficientes Con C# & ASP - Users
356 páginas
Fundamentos de C# 3.0
100% (10)
Fundamentos de C# 3.0
650 páginas
Introducción al Lenguaje C#
Aún no hay calificaciones
Introducción al Lenguaje C#
251 páginas
Aplicaciones Desarrolladas Con ASP - AJAX y JQUERY - Cristian Sánchez
Aún no hay calificaciones
Aplicaciones Desarrolladas Con ASP - AJAX y JQUERY - Cristian Sánchez
538 páginas
Sistema MVC para Recaudación Tributaria Puno
Aún no hay calificaciones
Sistema MVC para Recaudación Tributaria Puno
114 páginas
Visual Studio 2015 PDF - En.es
100% (2)
Visual Studio 2015 PDF - En.es
122 páginas
Desarrollo y Reutilización de Componentes Software y Multimedia Mediante Lenguajes de Guion - UF1842
100% (1)
Desarrollo y Reutilización de Componentes Software y Multimedia Mediante Lenguajes de Guion - UF1842
140 páginas
Metodología O.O. por Rosa Menéndez Mueras
Aún no hay calificaciones
Metodología O.O. por Rosa Menéndez Mueras
121 páginas
Migrate-Classic-Appserver en Es
Aún no hay calificaciones
Migrate-Classic-Appserver en Es
78 páginas
Microservicios NET Arquitectura para Aplicaciones NET Contenerizadas (Microsoft Ebook) Es ES PDF
100% (4)
Microservicios NET Arquitectura para Aplicaciones NET Contenerizadas (Microsoft Ebook) Es ES PDF
343 páginas
Crear tu primera app con ASP.NET Core
Aún no hay calificaciones
Crear tu primera app con ASP.NET Core
80 páginas
Dominando C# 8 para .NET y Visual Studio
Aún no hay calificaciones
Dominando C# 8 para .NET y Visual Studio
506 páginas
Curso de Facturación Electrónica en C#
Aún no hay calificaciones
Curso de Facturación Electrónica en C#
3 páginas
Asp Net Core Es PDF
100% (1)
Asp Net Core Es PDF
146 páginas
C# 3.0 y LINQ: Guía Completa
Aún no hay calificaciones
C# 3.0 y LINQ: Guía Completa
302 páginas
Azure For Architects es-ES PDF
100% (1)
Azure For Architects es-ES PDF
493 páginas
Desarrollo de Aplicaciones Web Con JSP y XML PDF
Aún no hay calificaciones
Desarrollo de Aplicaciones Web Con JSP y XML PDF
49 páginas
C# 7 y V1sual Studi0 2o17
100% (2)
C# 7 y V1sual Studi0 2o17
409 páginas
UML 2: Guía y Ejercicios Prácticos
100% (4)
UML 2: Guía y Ejercicios Prácticos
201 páginas
Guía de Historias de Usuario en Agile
Aún no hay calificaciones
Guía de Historias de Usuario en Agile
45 páginas
Ingeniería del Software: Enfoque Práctico
100% (2)
Ingeniería del Software: Enfoque Práctico
614 páginas
Introducción a Visual Basic .NET
100% (2)
Introducción a Visual Basic .NET
438 páginas
Sintaxis de C# en .NET
100% (78)
Sintaxis de C# en .NET
31 páginas
Backend con JavaScript: Proyecto E-commerce
Aún no hay calificaciones
Backend con JavaScript: Proyecto E-commerce
117 páginas
ES-ES-Containerize Your Apps With Docker and Kubernetes PDF
100% (4)
ES-ES-Containerize Your Apps With Docker and Kubernetes PDF
325 páginas
Java 2. Curso de Programación - Javier Ceballos-BN
Aún no hay calificaciones
Java 2. Curso de Programación - Javier Ceballos-BN
704 páginas
Una Nueva Forma de Desarrollo Visual Studio 2010 - Cristian Sánchez Flores
100% (1)
Una Nueva Forma de Desarrollo Visual Studio 2010 - Cristian Sánchez Flores
368 páginas
Introducción a C# para Educadores
100% (4)
Introducción a C# para Educadores
199 páginas
Programación Web Avanzada - Módulo 5 - Introducción A
Aún no hay calificaciones
Programación Web Avanzada - Módulo 5 - Introducción A
96 páginas
Tipos de Datos y Variables en Java
Aún no hay calificaciones
Tipos de Datos y Variables en Java
7 páginas
GDA Electiva II - Programacion de Sitios Web
Aún no hay calificaciones
GDA Electiva II - Programacion de Sitios Web
37 páginas
Características de JavaScript
Aún no hay calificaciones
Características de JavaScript
20 páginas
Calendario de Cursos LG HVAC 2022
Aún no hay calificaciones
Calendario de Cursos LG HVAC 2022
2 páginas
Introducción a Dart: Sintaxis y Funciones
Aún no hay calificaciones
Introducción a Dart: Sintaxis y Funciones
7 páginas
Análisis de Malware: Herramientas y Métodos
Aún no hay calificaciones
Análisis de Malware: Herramientas y Métodos
32 páginas
Qué es GLPI y sus funciones clave
Aún no hay calificaciones
Qué es GLPI y sus funciones clave
2 páginas
Diseño y Programación Orientada a Objetos
Aún no hay calificaciones
Diseño y Programación Orientada a Objetos
3 páginas
Modificadores y Sobrecarga en Java
Aún no hay calificaciones
Modificadores y Sobrecarga en Java
34 páginas
Generador de tabla de multiplicar
Aún no hay calificaciones
Generador de tabla de multiplicar
2 páginas
Punteros y Memoria Dinámica en C++
Aún no hay calificaciones
Punteros y Memoria Dinámica en C++
91 páginas
Traducción Semántica en Compiladores
Aún no hay calificaciones
Traducción Semántica en Compiladores
39 páginas
Comunicación entre Procesos con Tuberías
Aún no hay calificaciones
Comunicación entre Procesos con Tuberías
19 páginas
Diseno Patrones
Aún no hay calificaciones
Diseno Patrones
26 páginas
Desarrollo de Interfaces de Usuario
0% (1)
Desarrollo de Interfaces de Usuario
105 páginas
Software y Servicios de Internet: Guía Completa
Aún no hay calificaciones
Software y Servicios de Internet: Guía Completa
2 páginas
Traducción Sintáctica en Compiladores
Aún no hay calificaciones
Traducción Sintáctica en Compiladores
12 páginas
Partes de la Pantalla en Visual Basic
60% (5)
Partes de la Pantalla en Visual Basic
4 páginas
Programación Orientada a Objetos en Java
Aún no hay calificaciones
Programación Orientada a Objetos en Java
114 páginas
Mapa mental de software e Internet
Aún no hay calificaciones
Mapa mental de software e Internet
7 páginas
Desarrollador Java con Proyectos Destacados
Aún no hay calificaciones
Desarrollador Java con Proyectos Destacados
2 páginas
Programas y Cursos para Windows 7
Aún no hay calificaciones
Programas y Cursos para Windows 7
75 páginas
Evaluación del Curso de Negocios Digitales
Aún no hay calificaciones
Evaluación del Curso de Negocios Digitales
20 páginas
Ventajas de Azure sobre Amazon VPC
Aún no hay calificaciones
Ventajas de Azure sobre Amazon VPC
158 páginas
Algoritmos para Evaluar Estudiantes y Cálculos Matemáticos
Aún no hay calificaciones
Algoritmos para Evaluar Estudiantes y Cálculos Matemáticos
17 páginas
Proyecto de Software a Medida para Empresas
100% (1)
Proyecto de Software a Medida para Empresas
33 páginas
Articulos de Microservicios
Aún no hay calificaciones
Articulos de Microservicios
5 páginas
Diagrama de Clases UML y Persistencia
Aún no hay calificaciones
Diagrama de Clases UML y Persistencia
28 páginas
Evaluación de Riesgos en Sistemas Informáticos
Aún no hay calificaciones
Evaluación de Riesgos en Sistemas Informáticos
4 páginas
Habilidades del Pensamiento en Software
Aún no hay calificaciones
Habilidades del Pensamiento en Software
11 páginas