Material Digital 3075 Fundamentos de Programacion Web

UNED
Fundamentos de Programación Web
Material Digital
Autor: Prof. Enrique Gómez Jiménez

Fecha de Creación: Febrero-2008.
Fecha Versión Descripción de Cambios Modificó
Documento digital oficial del curso.

Universidad Estatal a Distancia (UNED) – Fundamentos de Programación Web
Material Digital. Profesor Enrique Gómez Jiménez. 2008.
Contenido
TEMA 1: Introducción a ASP .NET ........................................... 4
Visual Studio .NET. El paradigma. ............................................................................................ 4
Introducción a NET Framework ................................................................................................ 5
Componentes del NET Framework ........................................................................................... 5
Introducción a ASP .NET ......................................................................................................... 6
Autoevaluación ....................................................................................................................... 7
TEMA 2: Creación de Web Forms ........................................... 8

IDE (Intregrated Development Environment) ............................................................................ 8
Directorio Virtual y Físico en aplicaciones Web (http://localhost – c:\inetpub\wwwroot) .............. 9
Ubicación de Proyectos ASP .NET (archivos, http://, ftp://) ........................................................ 9
IIS Local y de servidor........................................................................................................... 11
Navegación entre Web Form (response.redirect) ..................................................................... 12
Autoevaluación ..................................................................................................................... 16
TEMA 3: Agregando código a un Web Form ............................. 18

Definición de entradas de usuario .......................................................................................... 20
Uso de eventos del lado del cliente o del servidor ................................................................... 20
Controles de validación de ASP .............................................................................................. 21
Variables de aplicación y de sesión ......................................................................................... 26
Cookies ................................................................................................................................ 33
Utilización de controles (textbox, label, dropdownlist, etc) ....................................................... 35
Autoevaluación ..................................................................................................................... 39
Caso de Aplicación. ............................................................................................................... 39
TEMA 4: Fundamentos de Web Services ................................. 40

Definición de Servicio Web XML ............................................................................................. 40
Características de los Servicios Web XML ................................................................................ 40
Creando el primer servicio Web (aplicación calculadora científica) ............................................ 41
Caso de Aplicación: calculadora científica mediante Web services (servicios Web) ..................... 45
Autoevaluación ..................................................................................................................... 49
TEMA 5: Uso de datos XML ................................................. 50

Definición de XML ................................................................................................................. 50
Componentes de un documento XML ..................................................................................... 50
Tecnologías XML ................................................................................................................... 51
Caso de Aplicación ................................................................................................................ 53
Autoevaluación ..................................................................................................................... 56
TEMA 6: Depuración y corrección de errores .......................... 58

Información en tiempo de ejecución ....................................................................................... 58
Habilitar el seguimiento ......................................................................................................... 58
Uso del objeto Trace ............................................................................................................. 60
Visualización de resultados de seguimiento ............................................................................. 60
Uso de seguimiento a nivel de aplicación ................................................................................ 61
Elaboró Revisó Autorizó Versión Clave Página

Lic. Enrique Gómez Jiménez 1.0 2/105
Autoevaluación ..................................................................................................................... 61
TEMA 7: Administración del Estado ...................................... 62

Introducción a la administración del estado ............................................................................ 62
Cookies y sesiones que no utilizan cookies .............................................................................. 63
Autoevaluación ..................................................................................................................... 63
Caso de Aplicación ................................................................................................................ 64
TEMA 8: Acceso a datos mediante ADO .NET ........................... 65

ADO .NET en sitios Web ........................................................................................................ 65
Utilización de Dataset ...................................................................................................... 66
Utilización de DataReader ................................................................................................ 69
Autenticación en SQL Server .................................................................................................. 70
Autenticación en modo mixto: ................................................................................... 71
Autenticación en modo Windows: .............................................................................. 71
Cómo cambiar el modo de autenticación de SQL Server .............................................. 71
Creación de la base de datos de la aplicación de ejemplo ........................................................ 72
Conectividad WebConfig y System.ConfigurationManager ........................................................ 73
Utilización de DataSet y DataReader en la aplicación ejemplo: ................................................. 74
Autoevaluación ..................................................................................................................... 82
Casos de Aplicación ............................................................................................................... 82
TEMA 9: Procedimientos almacenados SQL ............................. 83

Definición de procedimiento almacenado ................................................................................ 83
Usos de procedimientos almacenados .................................................................................... 83
Creación de Procedimientos Almacenados. ............................................................................. 84
Creación de los procedimientos almacenados de la aplicación ejemplo ..................................... 84
Funciones en SQL Server ....................................................................................................... 86
TEMA 10: Procedimientos almacenados y Web Services ............. 88

Creación de Web Services para la utilización en los procedimientos almacenados ...................... 88
Prueba de los Web Services generados .................................................................................. 92
TEMA 11: Seguridad en aplicaciones Web ASP .NET ................. 102

Descripción de la seguridad para aplicaciones Web ............................................................... 102
Autenticación basada en Windows ....................................................................................... 102
Habilitando la autenticación basada en Windows ............................................................. 103
Autenticación basada en formularios .................................................................................... 104
Habilitando la autenticación basada en formularios ......................................................... 104
Autenticación de Microsoft® Passport .................................................................................. 105
Habilitando la autenticación basada en Microsoft® Passport® ......................................... 106
TEMA 1: Introducción a ASP .NET
Antes de introducirnos al paradigma de ASP .NET, debemos conocer un poco la historia de esta
novedosa herramienta de programación Web, desarrollada por Microsoft® Hace muchos años
Microsoft® introdujo ASP con su servidor Windows NT, bajo la convicción de manejar aplicaciones
Web dinámicas a través de un servidor Web integrado a ese sistema operativo y que se denominó IIS
(Internet Information Server) ASP fue conocido como Active Server Page (Páginas Activas de
Servidor)
ASP utiliza VBScript, que es básicamente una variación del lenguaje Visual Basic de Microsoft® Con
esa virtud, ASP es adoptado rápidamente por la comunidad de programadores de Basic, dada su
familiaridad con el IDE de Microsoft® Visual Studio® Sin embargo, la evolución del “scripting” de
Visual Basic en ASP no fue consonante con los cambios que se presentaron en otros lenguajes
competidores como Java o PHP.
La principal ventaja de ASP es que los servidores de Microsoft® manifestaron siempre su

omnipresencia por todos lados (usuarios comunes y corporaciones) así como su navegador Internet y
otras muchas facilidades. Asimismo, Microsoft® SQL Server® es cada vez más popular y apoya
consistentemente los sitios construidos con ASP.
Actualmente, existen muchos seguidores de ASP y otros de PHP y ha crecido el debate si utilizar una
u otra herramienta. El argumento será finalmente una cuestión de familiaridad con cada herramienta
y lo que la evolución que vayan presentando cada una. En tanto, la posibilidad de utilizar Java o
.NET (o ambos) es actualmente, la coyuntura.
Visual Studio .NET. El paradigma.

Visual Studio .NET es un conjunto de herramientas que permiten crear aplicaciones orientadas a
Windows, Webs, dispositivos móviles o a bases de datos. Estas herramientas, que en realidad son
lenguajes de programación muy poderosos, agrupan una rica colección de objetos ya desarrollados,
los cuales pueden ser utilizados para crear aplicaciones muy sofisticadas. Asimismo, cuentan con
asistentes de programación, depuradores de código, soporte de aplicaciones multilenguaje, entre
otras cualidades, lo que agilizan el desarrollo de potentes soluciones informáticas.
El IDE (que es el entorno de programación) es único para todas las herramientas de Visual Studio
.NET. Esto permite tener un aspecto coherente e independiente del leguaje de programación que se
utilice. Los desarrolladores agradecen esto por cuanto pueden crear aplicaciones utilizando el
lenguaje que más dominan, a sabiendas que posteriormente podrán integrar su solución al resto del
proyecto.
Algunas características de Visual Studio .NET son las siguientes:
 Un IDE para múltiples lenguajes y múltiples tipos de proyectos.

 Se pueden utilizar varios lenguajes de la herramienta en un mismo proyecto.
 Pueden existir varios tipos de proyectos en una misma solución.
 Posee un navegador integrado.
 Posee soporte de depuración integrado.
 La interfaz es personalizable al gusto del desarrollador (a nivel de ventanas o herramientas)
Introducción a NET Framework

El NET Framework es la base sobre la cual se desarrollan y ejecutan las aplicaciones (Windows, Web,
Smart Devices, etc.) y servicios (Windows, Web) desarrollados con Visual Studio .NET. Esto es,
mediante un conjunto de herramientas y códigos comunes, se desarrolla cualquier aplicación sea
Windows o Webs, servicios Web o para dispositivos móviles, utilizando el NET Framework.
En fin, el NET Framework constituye una infraestructura de lenguajes y servicios que simplifican
importantemente el desarrollo rápido de aplicaciones.
Componentes del NET Framework

El NET Framework está conformado por:
 Common Language Runtime (CLR) Este motor gestiona los servicios requeridos por una
aplicación en tiempo de ejecución, incluyendo la integración de lenguajes, seguridad y la
gestión de memoria. En realidad el CLR es el fundamento de la tecnología convirtiéndose en
el motor de tiempo de ejecución de una aplicación .NET Se puede asociar con un agente que
administra el código mientras se está ejecutando y además brinda servicios tales como
administración de la memoria, de los subprocesos, la interacción remota de componentes y la
seguridad estricta de tipos.
 Class Base Library (BCL) Son un conjunto de librerías que proporcionan al desarrollador
código reutilizable para tareas tan habituales como el acceso a datos, creación de formularios
Windows o Webs, entre otras.
Entre los objetivos principales del .NET Framework podemos citar los siguientes:
 Proveer un entorno de programación orientada a objetos que permita el almacenamiento y

ejecución de código en forma local, distribuida a través de Internet o remota.
 Proveer un entorno de ejecución de código que minimice la implementación y el conflicto de
versiones de software.
 Proporcionar un entorno de ejecución de código que garantice la seguridad del mismo.
 Ofrecer al desarrollar un IDE integrado, que no diferencie un entorno orientado a desarrollo
Windows de uno orientado a Web.
Microsoft® define los componentes del Framework, considerando herramientas (tales como Visual
Basic .NET, Visual C#, Visual J#, Visual C++), metodologías (tales como ASP .NET, ADO .NET y
Smart Devices) Esta visión de Visual Studio .NET se muestra en la ilustración 1. En esta ilustración
podrás observar como nivel superior todos los lenguajes soportados por la herramienta. Más abajo
observarás algunos otros elementos como servicios Web, gestión de datos a través de ADO .NET,
diseñadores de sitios Web como ASP .NET, entre otros productos.
Ilustración 1
Referencias Webs:
http://msdn.microsoft.com/library/spa/default.asp?url=/library/SPA/cpguide/html/cpovrIntroductionToNETFrameworkSDK.asp
Introducción a ASP .NET

ASP .NET es la herramienta Microsoft® orientada a la creación de Páginas Activas de Servidor
(Active Server Pages) Esta tecnología es utilizada para crear y generar páginas dinámicas en un
servidor Web y enviarlas para su ejecución en el lado del cliente a través de un navegador Web. En
este sentido, el servidor Web espera peticiones del cliente para enviarle, automáticamente, una
respuesta (generalmente en HTML o XML)
ASP .NET es un marco de programación que se basa en el .NET Framework que no solamente se
utiliza para generar aplicaciones Web sino que también permite la creación de servicios Web XML,
muy útiles para la construcción de aplicaciones distribuidas basadas en la Web.
Entre las características más importantes de ASP .NET tenemos:
 Permite la creación de páginas Web dinámicas que pueden acceder a recursos del servidor
Web.
 Permite el procesamiento de formularios Webs (Web Forms) en el lado del servidor.
 Las aplicaciones Webs distribuidas se pueden construir mediante servicios Web XML.
Las aplicaciones Webs creadas con ASP .NET son independientes del navegador y del lenguaje de
implementación.
El componente fundamental de ASP .NET es el formulario Web, el cual es una pantalla de usuario
donde se implementa una determinada funcionalidad. Por ejemplo, algo tan sencillo como ingresar a
un sitio en Internet, las páginas que presentan son formularios Web. Es decir, es la página Web que
visualiza un usuario cuando ingresa a Internet mediante un navegador. Una aplicación Web es un
conjunto de formularios Webs creados para crear una solución específica. Un formulario Web ASP
.NET es una página dinámica que puede acceder a recursos de un servidor de Internet.
Referencias Webs:
http://www.es-asp.net/
http://www.asp.net/es/
http://www.es-asp.net/tutoriales-asp-net/tutorial-61-76/introduccion-a-paginas-asp-net.aspx
Autoevaluación
1. Cite tres características esenciales de Visual Studio .NET.
2. Explique la funcionalidad del framework de Visual Studio .NET
3. ¿Qué es y cuáles funcionalidades ofrece CLR en el framework de Visual Studio .NET?
4. Determine la funcionalidad que tiene BCL en el framework de Visual Studio .NET.
5. Refiérase brevemente a la operatividad de MSIL en el CLR del framework de Visual Studio
.NET.
6. Cite al menos tres objetivos del framework de Visual Studio .NET.
7. ¿Qué son páginas activas de servidor (ASP)?
8. Cite al menos tres características principales de ASP .NET.
TEMA 2: Creación de Web Forms
Un formulario constituye la interface con la cual los usuarios interactúan con la lógica de negocios de
una aplicación y probablemente con una base de datos. En aplicaciones Web se denominan Web
Forms y tienen la función de permitir las entradas de datos del usuario y la salida de información. A
través de formularios Web (Web Forms) podemos implementar la lógica de negocios necesaria para
automatizar procesos de usuario mediante un sitio Web.
IDE (Intregrated Development Environment)

El IDE de Microsoft® Visual Studio constituye un ambiente o entorno de trabajo simplificado y que
conserva la interface habitual de los desarrolladores que desde hace mucho tiempo vienen
trabajando con Visual Studio. Así, desarrolladores de Visual Basic 5.0 por ejemplo, o Visual C++,
estarán muy familiarizados con las barras de controles, los menús contextuales, la ventana de
propiedades, el F5 de ejecución, entre tantas funcionalidades heredadas.
En la ilustración 2 podemos observar el IDE genérico de una aplicación de Visual Studio .NET.
Independientemente del lenguaje que escojamos ese entorno va a conservar esa misma interface.
Vamos identificar claramente las mismas opciones: Menús horizontales e icónicos (rápidos),
explorador de la solución, ventana de propiedades de cada objeto, barra de controles reutilizables,
área de trabajo, etc.
Ilustración 2
Directorio Virtual y Físico en aplicaciones Web
(http://localhost – c:\inetpub\wwwroot)
En aplicaciones Web que desarrollemos con ASP .NET, es importante que conozcamos donde se
deben almacenar y cómo ejecutar. Cuando se instala Windows XP, por ejemplo, automáticamente
podemos instalar el IIS (si no se instala se puede hacer posteriormente) que no es más que nuestro
servidor Web. Mediante este servidor Web es que podemos configurar y administrar nuestros sitios
Web.
Físicamente la dirección donde se deben instalar nuestros sitios Web (asumiendo sitios http, que más
adelante explicaré) está ubicada en nuestro disco duro (generalmente en c:\inetpub\wwwroot) Esa
dirección física es virtualmente direccionada por el servidor a través de http://localhost En realidad,
localhost es un nombre reservado que tienen las computadoras equipadas con una tarjeta de red
Ethernet y que sirve para autoreferenciarse (referirse a sí mismo)
Ubicación de Proyectos ASP .NET (archivos, http://,

ftp://)
En ASP .NET existen tres tipos de ubicación de proyectos Web. Estos son:
 Sistema de archivos.
 Sistema HTTP.
 Sistema FTP.
Ilustración 3
Como puede observarse en la ilustración 3, cuando creamos un sitio Web ASP .NET se nos hablita la
opción de seleccionar el tipo de ubicación que le vamos a dar a nuestro sitio. Las ubicaciones son
mediante sistema de archivos (en carpetas), HTTP y FTP.
Sistema de Archivos:
Una aplicación Web ASP .NET permite mantener los archivos que la conforman en una carpeta de
disco local o en una ubicación compartida de la red de área local. En este caso, el sitio Web no debe
crearse como una aplicación IIS para desarrollarlo o probarlo.
En un sitio Web creado mediante un sistema de archivos se pueden crear y modificar archivos que se
encuentren en las carpetas donde se encuentran, sea localmente o en un entorno de red local. No
se exige la presencia de IIS en dicho equipo para su ejecución y prueba de las páginas desarrolladas
con ASP .NET.
1. Cuando no es posible o no desea instalarse el IIS en el equipo de desarrollo.

2. Cuando existen archivos Web en una determinada carpeta y se deben utilizar con Visual
Studio .NET
3. En una configuración de equipo donde los miembros del mismo puedan acceder un sitio Web
común que se ubique en un servidor central.
Referencias Webs:
http://msdn2.microsoft.com/es-es/library/e5x4xz73(VS.80).aspx
HTTP:
Las aplicaciones Web que desarrollemos mediante HTTP utilizará los servicios de IIS para su
implementación. Es decir, las páginas (Web Forms) que diseñemos, así como las carpetas del
proyecto, se situarán en el directorio físico del servidor o de la microcomputadora, cuya ubicación es
[Drive]:\Inetpub\wwwroot, que virtualmente se constituiría en http://localhost
Debe crear un sitio Web tipo HTTP cuando deba ser accesible por otros equipos, utiliza autenticación
basada en HTTP, grupos de aplicaciones y filtros ISAPI.
FTP:
FTP es un protocolo estándar que se utiliza para copiar o descargar archivos de un equipo a otro
mediante Internet. Un servidor FTP establece comunicaciones a través de Internet pero no ejecuta
páginas Web, se utiliza para transferencia de archivos entre equipos.
Estos sitios se utilizan básicamente para conectarse a un sitio Web que está instalado en un servidor
FTP. Mediante permisos de lectura/escritura se pueden crear y editar páginas Web en dicho sitio y
administrarse remotamente.
Referencias Webs:
http://msdn2.microsoft.com/es-es/library/bfx5as36.aspx
IIS Local y de servidor
Un sitio IIS local es aquel que está configurado a nivel de equipo del usuario. Es decir, el IIS se
instala en el equipo del usuario una vez que se instala Windows como sistema operativo. Si no se
instaló inicialmente puede hacerlo posteriormente. El proceso es el siguiente:
1. Pulse con el puntero del mouse sobre el botón Inicio de Windows XP o Vista.
2. Seleccione Panel de Control, luego la opción Agregar y Quitar Programas y finalmente
Agregar o quitar componentes de Windows.
3. Una vez ahí se cargará una ventana emergente donde se mostrarán aquellos componentes
instalados y no instalados en su sistema operativo. Ubique la descripción de IIS y si la casilla
de verificación no está habilitada proceda a marcarla e inmediatamente pulsar el botón
siguiente. Es probable que le solicite el disco de instalación de Windows.
Observe la figura 4 para ubicar el servidor IIS.
Ilustración 4
La habilitación de IIS local puede ser útil en los siguientes casos:
1. Querer probar la funcionalidad del IIS con un sitio Web que estemos desarrollando en el
equipo del programador, simulando hacerlo en un servidor IIS establecido.
2. El equipo local es a la vez el servidor Web.
3. Se tienen archivos del sitio en una carpeta (a modo archivo) y se desea probar su
funcionalidad mediante un IIS.
Referencias Webs:
http://msdn2.microsoft.com/es-es/library/ckk1e6z4.aspx
http://docentes.uacj.mx/jpaz/WebAppsWeb/dv_VWDcon_web/html/afd8f418-d465-4ee5-
ab7d-92277f584ae7.htm
El IIS es un programa que se ejecuta en un equipo servidor y que se encarga de proporcionar

páginas Web a quienes lo solicitan. Los que solicitan estas páginas son los navegadores Web tales
como Internet Explorer, Mozzilla, Netscape entre otros. El IIS que se encuentra instalado en el
servidor es el que proporciona accesibilidad a los navegadores, controla la seguridad y sirve de
intermediario entre nuestro sitio Web y aquellos usuarios que lo solicitan a través de un explorador.
En la referencia Webs que te indicamos a continuación podrás pormenorizar los conceptos de IIS, así
como debes instalarlo, especificaciones de requerimientos entre otros datos de importancia.
Referencias Webs:
http://www.adrformacion.com/curso/intranet/leccion1/InternetInformationServer.htm
Navegación entre Web Form (response.redirect)

La navegación de una página Web a otra se realiza a través de response.redirect. A través de esta
invocación podemos ir a una página de nuestro sitio o una de otro sitio. Por ejemplo podría llamar a
otra página de mi sitio mediante response.redirect(“miPagina.aspx”) o a otro sitio tal como
response.redirect(“http://www.microsoft.com”)
Para iniciar con la creación de un sitio Web vamos a crear el inicio de nuestra aplicación Web que
denominaremos miUniversidad. Para ello siga las siguientes instrucciones:
1. Ingrese a Visual Studio .NET, pulsando sobre el botón de Inicio de Windows. Podrá ubicarlo
generalmente en las opciones de Todos los programas y Microsoft Visual Studio 200x y
nuevamente Microsoft Visual Studio 200x. Lo de la x en 200x significa la versión. En mi caso
sería 2005 pero ya está disponible la versión 2008 o puedes utilizar la versión 2003 o
anterior.
2. Una vez que hayas ingresado a la herramienta, debes seleccionar la opción Archivo del menú
principal de Visual Basic y luego Nuevo sitio Web… tal y como muestra la ilustración 5.
Ilustración 5
3. Una vez que has seleccionado la opción del punto 2 se habilitarán las opciones de desarrollo
de un sitio Web. Deberás seleccionar Sitio Web ASP .NET en la ventana que aparece,
ubicación HTTP, lenguaje Visual Basic y el direccionamiento http://localhost/miUniversidad.
Pulse el botón Aceptar.
Ilustración 6
4. Una vez que aceptaste los valores iniciaste del sitio Web, se mostrará algo similar a lo que se
muestra en la ilustración 7.
Ilustración 7
Observa que existen varias “secciones” del entorno. El AREA DE TRABAJO (que no es más
que una página Web o Web Form) es donde colocamos los controles que vamos a utilizar en
nuestra página. Estos controles (Cajas de Texto, Etiquetas, Botones, etc) son arrastrados
desde la Barra de Controles, la cual puede ser invocada mediante el botón señalado por la
flecha Barra de Controles
El Área de componentes del proyecto lo constituyen todos los formularios (páginas Web),
archivos de configuración (como el web.config), referencias y otros objetos. Puede ser
habilitada pulsando el botón que señala la flecha Explorador de Proyectos
La Ventana de Propiedades es donde se configuran los valores iniciales de cada objeto. Por
ejemplo se le puede poner el nombre a una etiqueta o el color de letra a una caja de texto.
Se puede habilitar utilizando el botón que señala la flecha Ventana de Propiedades.
Finalmente, tenemos las opciones de Habilitar ventana de diseño que es básicamente para
mostrar la interface del formulario y la de Habilitar ventana de código que nos permite
visualizar el código que estamos creando en nuestro formulario Web.
5. A continuación busca en la barra de controles los componentes Label y Button y arrástralos

hasta la página Web. Observa la ilustración 8 para que veas donde están esos controles.
Ilustración 8
6. Ya colocados en el formulario Web, pulsa sobre cada objeto (la etiqueta o Label y el botón
Button) y habilita las propiedades (puedes pulsar botón derecho del mouse y seleccionar
Propiedades, estando encima del objeto) de cada uno con las siguientes propiedades
iniciales:
Objeto Propiedad Valor Inicial

ID lblTitulo
Label Text “PAGINA No. 1”
Font y Size XX-Large
ID btnEjecutar
Button Text Ejecutar
Font y Size Medium
Tabla No. 1
7. Pulse con el botón derecho del mouse sobre el identificador del proyecto
(http://localhost/miUniversidad/) y seleccione Agregar nuevo elemento. Se mostrará una
ventana de opciones para seleccionar el elemento que agregará al proyecto Web. Escoja
Formulario Web. El sistema le asignará un nombre por defecto (default2.aspx) Dejémoslo así.
La ilustración 9 muestra esta interface de creación de un nuevo formulario Web.

Ilustración 9
8. La configuración de este nuevo formulario será similar al primero (default.aspx) con la

diferencia que mostrará los siguientes valores:
9. Repita el paso 6 indicado en este ejercicio para configurar las propiedades de este nuevo
formulario (default2.aspx)

ID lblTitulo
Label Text “PAGINA No. 2”
ID btnVolver
Button Text Volver
Font y Size Medium
Tabla No. 2
10. Activa el primer formulario Web (default.aspx) y pulsa dos veces con el puntero del mouse
sobre el botón Ejecutar. Aparecerá el editor de código de ASP .NET. Es ahí donde
procederemos a programar nuestro primer formulario Web.
En realidad, el editor de código viene acompañado de una herramienta denominada

intellisense que básicamente te ayuda a autocompletar el código que deseas implementar en
la solución. Una vez escrito el nombre de un objeto, se desplegarán (después de escribir un
punto) todas las propiedades y métodos que posee el objeto. Basta con pulsar la tecla TAB y
se escribirá automáticamente. La ilustración 10 muestra este concepto.
Ilustración 10
Una vez aquí digital el siguiente código:
Response.Redirect (“default2.aspx”)
11. Ahora tienes un sitio (que aunque no es nada funcional ya es obra tuya) Falta probarlo y
para ello debes pulsar al mismo tiempo las teclas CTRL y F5. Verás como se ejecuta tu sitio
Web en el navegador que tenga instalado tu máquina.
12. Ahora cambia la línea Response.Redirect(“default2.aspx”) por
Response.Redirect(http://www.asp.net) Observarás que cuando lo ejecutes lo que se
desplegará es el sitio de www.asp.net.
13. En el segundo formulario (default2.aspx) solo resta agregarle en el botón volver el código
Response.Redirect(“default.aspx”) para que retorne a la primera página.
14. La ejecución inicial de nuestro primer sitio Web se asemejaría a lo mostrado en la ilustración
11.
Ilustración 11
Autoevaluación
1. Determine la funcionalidad del IDE de Visual Studio .NET.
2. ¿Para qué es importante mantener un mismo entorno visual de desarrollo (el mismo entorno
que ve el desarrollador de Visual Basic .NET lo ve el desarrollador de C#) para diferentes
lenguajes incluidos en Visual Studio .NET?
3. Explique la operatividad del directorio virtual y el físico utilizado por las aplicaciones ASP .NET
utilizando IIS.
4. Determine la diferencia entre sitios Web implementados en carpetas de archivos, tipo HTTP y
FTP. ¿En qué circunstancias podríamos aplicar uno u otro tipo de proyectos?
5. ¿Qué es y para que se utiliza IIS?
6. ¿Para qué es importante la existencia de un servidor IIS?
TEMA 3: Agregando código a un Web Form
En el tema 2 vimos como podemos crear nuestro primer sitio Web. Aunque no es funcional para
nada por lo menos hemos incursionado en la lógica de diseño y de programación de sitios ASP .NET.
De la forma en que agregamos código a los formularios Web (Web Form) default.aspx y
default2.aspx así podemos agregar más funcionalidad a nuestro sitio Web.
Podemos utilizar muchos componentes y toda la funcionalidad implícita en ellos. Acceso a datos,
transacciones, cálculos complejos, interfaces, todo eso podemos implementar en nuestros sitios. El
código que agreguemos lo podemos hacer en los propios formularios Web o invocarlos desde un
servicio Web (Web Service)
En realidad existen tres métodos para agregar código a un Web Form:
1. Ubicando el código en el mismo archivo de contenido. Básicamente, el código se encuentra

mezclado con el contenido Web. Es un formato HTML donde convergen el código y el diseño
de la interfaz en el mismo archivo. (Código Mezclado)
2. Ubicando el código en una sección distinta del archivo de contenido (código en línea) En
este caso aunque el código se encuentra en un mismo archivo, este se aísla en una sección
SCRIPT distinta al igual que el contenido HTML. (Código en Línea)
3. Ubicando el código en un archivo distinto (páginas de código subyacente) Este es el método
predeterminado de Visual Studio .NET El archivo que contiene el sitio Web se denomina
código subyacente. (Código Subyacente)
El siguiente código es un ejemplo de código en línea.
<HTML>
<asp:Button id="btn" runat="server"/>
...
</HTML>
<SCRIPT Language="vb" runat="server">
Sub btnCalcular_Click(s As Object, e As EventArgs) Handles btn.Click
...
End Sub
</SCRIPT>
En este caso se está utilizando código en línea en una página Web donde el HTML y el mismo código
se encuentran en distintas secciones de un único archivo .aspx. La razonabilidad es justa: ofrecer
claridad en la lectura de la página; la funcionalidad, el código y el HTML, los cuales pueden coexistir
en cualquier lugar de la página.
En cuanto el código subyacente es clara la separación de los <tags> y el código. Por ejemplo, en la
creación del primer formulario del tema 2 “default.aspx” se generaron los Tags y el código
subyacente del formulario. El <tags> lo conforma el archivo default.aspx que se creó y que generó
el siguiente código:
<%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-
transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Página sin título</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Label ID="lblTitulo" runat="server" Font-Size="XX-Large" Text="PAGINA No. 1"
Width="320px"></asp:Label>
<asp:Button ID="btnEjecutar" runat="server" Font-Size="Medium" Style="z-index: 100;
left: 104px; position: absolute; top: 96px" Text="Button" Width="160px" />
</div>
</form>
</body>
</html>
Por su parte, el código subyacente (que se encuentra en el archivo default.aspx.vb) generó el

siguiente código:
Partial Class _Default

Inherits System.Web.UI.Page
Protected Sub btnEjecutar_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles _

btnEjecutar.Click
Response.Redirect("default2.aspx")
End Sub
End Class
Una de las ventajas de utilizar código subyacente es que la lógica de programación puede ser
trabajada aparte de la de la parte visual de la misma. Por ende, un desarrollador puede estar
desarrollando la lógica de programación, mientras otro se ocupa de la interfaz gráfica.
¿Cómo trabajan estos dos archivos (aspx y aspx.vb)?
Default.aspx

Wireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" %>
Default.aspx.vb
Protected Sub btnEjecutar_Click(ByVal …
End Sub
End Class
Como podrás observar tanto el archivo ASPX (interface gráfica y código) mantienen su relación a
través del encabezado que radica en el código subyacente (ASPX.VB)
Definición de entradas de usuario
La validación de entradas de usuario es un proceso mediante el cual ser verifica, en una página Web,
que los datos digitados por el usuario cumplan con un formato o intervalo de valores, previamente
definidos. Este proceso permite mejorar la experiencia de usuario y coadyuvar a la reducción de
tiempo de espera del usuario (por procesamientos de validación) Se pueden utilizar, por ejemplo, un
control que valide el formato de una dirección electrónica, de un apartado postal o de un número
telefónico. Visual Studio .NET incluye varios objetos para realizar la validación de entradas del
usuario.
Uso de eventos del lado del cliente o del servidor

Del lado del cliente:
La idea principal de este apartado es demostrar cómo se ejecutan los procedimientos de eventos en
el lado del cliente en una aplicación Web ASP .NET.
Básicamente, los procedimientos de eventos que se ejecutan en el lado del cliente en una aplicación
Web ASP .NET se gestionan directamente en el equipo que solicita un formulario Web. En este
caso, el navegador del cliente interpreta el código y realiza la ejecución. No se envía ninguna
información al servidor.
Los procedimientos de eventos que se ejecutan del lado del cliente solo pueden utilizar controles
HTML y nunca tienen acceso a los recursos del servidor. Un ejemplo es tener un SCRIPT de conexión
a una base de datos en el servidor. Esto no es posible.
Los procedimientos de eventos en el lado del cliente son útiles para cuando se requiere de algún
procesamiento pueda realizarse localmente (en el cliente) y no tenga que invocar al servidor para
que lo resuelva. Por ejemplo, podría implementarse en el cliente una validación de un textBox
incluyendo código en el SCRIPT de la propia página del usuario (puede ser que lo digitado cumpla
con un formato preestablecido) La ejecución del código se realiza como un evento del lado del
cliente. Una vez validada puede enviarse al servidor Web para que proceda a otra validación (por
ejemplo puede ser que se verifique en una base de datos.
Del lado del servidor:
Contrario al procesamiento de eventos en el lado del cliente, cuando se procesan en el lado del
servidor éste es el responsable de su ejecución. Estos procedimientos son sumamente potentes y
significan costos de tiempo de procesamiento, por lo que se requiere ser muy cuidadoso para cuando
se deben desarrollar.
Los procedimientos que se ejecutan del lado del servidor incluyen código compilado en el servidor
Web. Utilizan controles de servidor Web y HTML para sus operaciones. Se utilizan cuando la
operación a realizar requiere utilizar recursos que radican en el servidor tal como la conectividad a
una base de datos.
Para su creación de un procedimiento de evento en el lado del servidor implica dos situaciones:
1. Creación del control que genera el evento en el formulario Web.

2. Proporcionar el código en la página de código subyacente para procesar el evento.
En la ilustración 12 se puede observar la forma en cómo se ejecuta una página Web en un cliente.
Inicialmente, el cliente solicita una página a un servidor Web quien se la envía y se carga en la
máquina del mismo. Se ejecuta algún tipo de validación en el lado del cliente y una vez validada se
remite de regreso al servidor, quien, a su vez, puede realizar otra validación, pero esta vez a nivel de
servidor.
Solicitud de página Web

INTERNET
Página Web validada

Validación a
Validación a nivel de
nivel de cliente servidor
Ilustración 12
Controles de validación de ASP

Es casi una necesidad que muchas entradas de anuncio sean controladas en algunos controles web.
Por ejemplo, una entrada en un objeto textbox que requerimos que cumpla con un determinado
formato.
Afortunadamente, ASP. NET incluye varios controles comunes de validación, tales como:
A. REQUIREDFIELVALIDATOR: Se utiliza para comprobar que un control tenga contenido (algún

valor) Como su nombre lo indica es un validador de campo requerido.
B. COMPAREVALIDATOR: Facilita la comparación de valores contenidos en dos controles. Por
ejemplo, se puede utilizar en una aplicación donde se implemente el cambio de contraseña
de un usuario. Se requerirán dos objetos TextBox para que el usuario escriba la nueva
contraseña en uno y la reescriba en otra para validar que son iguales.
C. RANGEVALIDATOR: Permite validar que el contenido de un objeto, por ejemplo en un
TextBox se digite un valor numérico que está en un rango de valores previamente
determinados.
D. REGULAREXPRESIONVALIDATOR: Las expresiones regulares tales como un número
telefónico, dirección de email, código postal etc. tienen generalmente un formato
predefinido. Con este control es fácil configurar, en tiempo de diseño, la entrada que
deseamos en el mismo.
E. CUSTOMVALIDATOR: Permite personalizar la validación de una operación. Con este control
se pueden programar validaciones que con los controles anteriores no es posible.
A continuación vamos a desarrollar un nuevo Sitio Web. Lo denominaremos CustomValidatorVb dado

que utilizaremos un control CustomValidator para validar del lado del cliente y una función en
JavaScript para validar del lado del cliente.
Este proyecto o sitio Web solo tendrá un formulario, el cual se denominará webForm1 (en realidad
puede dejarlo como default.aspx o ponerle algún otro nombre que sea distintivo para usted)
El formulario Web en este sitio, será similar a la ilustración 13 que se muestra a continuación:
Ilustración 13
La tabla de configuración de los objetos en este formulario Web se especifican en la tabla siguiente:

ID Label1
Label
Text Digite un número:
ID Label2
Label
Text Digite un nombre:
ID TextBox1
TextBox
Text
ID TextBox2
TextBox
Text
ID Button1
Button
Text
ID CustomValidator1
ClientValidationFunction Validar
CustomValidator
ControlToValidate TextBox1
ErrorMessage Digite un valor numérico
Tabla No. 3
Una vez que haz colocado los objetos indicados en la tabla anterior, procederemos inicialmente a
programar una función que se ejecutará en la página del cliente. Observa que en la tabla los objetos
Label, TextBox1 y Button no tienen nada en especial. Simplemente, se les puso el nombre y las
etiquetas un título inicial. Sin embargo, el control CustomValidator1 se especifica que existe una
función llamada Validar la cual se ejecutará del lado del cliente. El CustomValidator1 basará su
validación inicial (cliente) de acuerdo al contenido configurado del TextBox1.Text y posteriormente
procederá a ejecutar el código a nivel del servidor (una vez superada la validación del cliente)
Ya que hemos configurado los objetos del formulario Web ahora debemos ingresar a la programación
el SCRIPT del cliente que nos servirá para validar el TextBox1.Text en el formulario. Para ello pulse
sobre el botón Código que se encuentra al pie de nuestro formulario Web. Observa la ilustración 14
(la flecha lo señala) para que sepas donde debes pulsar con el puntero del mouse.
Ilustración 14
Una vez ahí vamos a programar una función en un script Java (similar a C#) la cual validará que la
información digitada por el usuario en el TextBox1.Text del formulario contenga un formato
numérico. Para ello observe el Script de esta página y proceda a escribir (lo que se resalta) a
continuación lo siguiente:
<%@ Page Language="vb" AutoEventWireup="false" Inherits="CustomValidatorVb.WebForm1"

CodeFile="WebForm1.aspx.vb" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-
transitional.dtd">
<HTML>
<HEAD>
<title>CusVal</title>
<meta nombre="GENERATOR" Content="Microsoft Visual Studio .NET 7.1">
<meta nombre="CODE_LANGUAGE" Content="C#">
<meta nombre="vs_defaultClientScript" content="JavaScript">
<meta nombre="vs_targetSchema"
content="http://schemas.microsoft.com/intellisense/ie5">
<script language="javascript">

</script>
</HEAD>
<body>
<form id="Form1" method="post" runat="server">
<asp:CustomValidator id="CustomValidator1" style="Z-INDEX: 100; LEFT: 432px; POSITION: absolute; TOP: 64px"
runat="server" ClientValidationFunction="Validar" Width="184px"
ControlToValidate="TextBox1" ErrorMessage="Digite un valor numerico"></asp:CustomValidator>
<asp:TextBox id="TextBox1" style="Z-INDEX: 101; LEFT: 264px; POSITION: absolute; TOP: 64px" runat="server" Font-
Size="Smaller"></asp:TextBox>
<asp:Label id="Label1" style="Z-INDEX: 102; LEFT: 88px; POSITION: absolute; TOP: 64px" runat="server"
Width="120px" Height="24px">Digite un número:</asp:Label>
<asp:Button id="Button1" style="Z-INDEX: 103; LEFT: 264px; POSITION: absolute; TOP: 128px" runat="server"
Text="Validar" Width="160px"></asp:Button>
<asp:Label ID="Label2" runat="server" Height="24px" Style="z-index: 104; left: 88px;
position: absolute; top: 96px" Width="120px">Digite un nombre:</asp:Label>
<asp:TextBox ID="TextBox2" runat="server" Style="z-index: 106; left: 264px; position: absolute;
top: 88px"></asp:TextBox>
</form>
</body>
</HTML>
No vamos por ahora a tratar de explicar toda esta codificación. Basta con que observes que hay una
función denominada Validar que recibe dos parámetros: source y arguments. Source lo que permite
es determinar el objeto que hace el llamado a la función, mientras arguments lo que determina es si
la validación en el Script es o no verdadera. Guardemos este archivo y con esto tenemos lista ya la
validación del lado del cliente.
Ahora pulsemos sobre el botón Diseño (observa la ilustración 14) y procedamos ahora a escribir la
validación que realizaremos en el lado del servidor. Para ello pulsaremos sobre el objeto
CustomValidator1 y habilitaremos el evento ServerValidate y escribamos lo siguiente (no escribas lo
que está entre Sub y End Sub):
Private Sub CustomValidator1_ServerValidate(ByVal source As System.Object, _

ByVal args As System.Web.UI.WebControls.ServerValidateEventArgs) Handles _
CustomValidator1.ServerValidate
Dim Numero As Integer = -1 'Define un valor inicial
Try
Numero = Val(TextBox1.Text) 'Convierte el valor de TextBox1.Text a numérico
args.IsValid = True 'El resultado es verdadero
Response.Write("PASO la validación del Servidor!!!!")
Catch
args.IsValid = False 'El resultado es falso
Response.Write("NO paso la validación del Servidor!!!!")
End Try
End Sub
Ya con este último código hemos validado del lado del servidor a través de un componente Web
(CustomValidator) En la ilustración 15 vemos como la prueba falla (en el campo numérico intento
incluir un valor alfabético)
Ilustración 15
Ahora veamos qué pasa si realmente digitamos un valor numérico (observa la ilustración 16)
Ilustración 16
Observa como indica el mensaje que muestra la ilustración 16 y que escribimos en el Script del
cliente (alert(“PASO la validación en la página del cliente!!!!!) Con esto se ha validado a nivel de
cliente la entrada del usuario en el TextBox1.Text. Ahora falta la ultima prueba que es cuando se
ejecuta la validación a nivel de servidor a través del objeto CustomValidator1. Observa la ilustración
17.
Ilustración 17
En esta se ejecuta el código que está en el control CustomValidator1, evento ServerValidate, el cuál
da verdadero. Con esto damos por concluido este tema.
Variables de aplicación y de sesión
Variables de Aplicación.
Muchas veces es necesario (sino todo el tiempo) que el servidor de Internet “recuerde” algunos
valores existentes entre la navegación de páginas Web. Por ejemplo, puede que un sitio sea accedido
por varios usuarios y queramos ir guardando el valor de visitas. En realidad, es necesario contar con
una variable global que sirva para todas las sesiones de usuario que se establezcan.
ASP .NET para resolver el problema de no poder utilizar variables globales, tal y como se manejan en
aplicaciones Windows, recurre al objeto Application. Este objeto permite (entre otras cosas)
mantener información asignada al objeto, mientras IIS no se reinicie. Esto es persistencia de
valores.
Las variables de aplicación son importantes cuando queremos guardar valores a nivel global, la cual
deba ser compartida por todos los usuarios del servidor Web.
Asignación: Applicattion.Add(“Visitantes”,0)  crea la variable de aplicación Visitantes, con valor

inicial 0.
Recuperación: NumVisitantes = Application.Get(“Visitantes”)
Variables de Session
En otras oportunidades es necesario que la sesión de usuario solamente “recuerde” los contenidos de
ciertas variables de usuario. Funciona similar a las de aplicación con la diferencia que solamente
puede guardar los valores de una sesión de usuario particular.
Asignación: Session.Add(“Nombre”,TextBox1.Text)  crea la variable de sesión Nombre, con valor

inicial del contenido de TextBox1.Text
Recuperación: NombreUsuario = Session(“Nombre”)
Para demostrar el uso de estos tipos de variables vamos a crear una pequeña aplicación. Para ello
sigue los siguientes pasos:
1. Pulsa sobre el botón Inicio de Windows, selecciona Todos los programas y luego Microsoft
Visual Studio y nuevamente Microsoft Visual Studio.
2. Una vez en Microsoft Visual Studio selecciona en el menú principal las opciones Archivo y
Nuevo Sitio Web.
3. Selecciona a continuación la opción Sitio Web ASP .NET y ponle WebSessionApplication al
nombre del proyecto y pulsa el botón Aceptar. Observa la ilustración 18 para que tengas una
idea de la ubicación y nombre del proyecto.
Ilustración 18
4. Procede a cambiar el nombre del formulario Web que se crea por defecto (Visual Studio lo
nombra como default.aspx) Cámbiaselo a webForm1. Para ello pulsa con el botón derecho
del mouse sobre este formulario y ponle webForm1. Observa la ilustración 19.
Ilustración 19
5. En el webForm1 arrastra tres controles label (etiquetas), un textbox (caja de texto) y un
button (botón de comando) tal y como se muestra en la ilustración 20.
Ilustración 20
La tabla de configuración de estos objetos se muestra a continuación:

ID Label1
Label Text PAGINA 1
ID Label2
Label
Text Nombre del Usuario:
ID Label3
Label
Text Visitantes:
ID TextBox1
TextBox
Text
ID Button1
Button
Text Siguiente>>
Tabla No. 4
6. Procede a crear otro formulario Web. Ponle webForm2. Deberás colocar tres label
(etiquetas) y un button (botón de comando) Será similar al mostrado en la ilustración 21.
Ilustración 21
La tabla de configuración de estos objetos se muestra a continuación:

ID Label1
Label Text PAGINA 2
ID Label2
Label
Text Contenido Variable Session:
ID Label3
Label
Text Contenido Variable Aplicación:
ID Button1
Button
Text Atras>>
Tabla No. 5
7. Ahora debemos agregar un archivo global.asax, el cual se conoce como archivo de aplicación
ASP .NET. Este archivo contiene código que se utiliza en eventos a nivel de aplicación en
ASP .NET o por módulos HTTP. El archivo global.asax radica en el directorio raíz de una
aplicación ASP .NET.
En este ejercicio la usaremos para inicializar una variable global, denominada NumUsers, la
cual se encargará de ir “contando” los usuarios que establezcan conexión a nuestro sitio
Web. Para ello utilizaremos algunos eventos que se gestionan a nivel de aplicación. Es
decir, que inicializaremos una variable a nivel de aplicación que se gestionará a nivel general
y se conocerá su valor en toda la ejecución del sitio.
En el archivo global.asax existen varios eventos programables que tienen que ver con la
lógica de aplicación general. Para agregar un archivo global.asax debes pulsar con el botón
derecho del mouse sobre el nombre del proyecto Web (WebSessionApplication) y seleccionar
Agregar nuevo elemento… Observa la ilustración 22 para que tengas una idea de este
procedimiento.
Ilustración 22
Una vez pulsada esta opción deberás seleccionar el archivo global.asax que se presenta en
una ventana de objeto. Observa la ilustración 23 donde se muestra esta opción. No cambies
el nombre del global.asax (déjalo con ese nombre) Pulsa el botón Agregar.
Ilustración 23
8. Una vez que has pulsado el botón Agregar debes programar el archivo global.asax, para que
almacenes una variable global que vaya incrementando el número de sesiones activas del
sitio. Recuerda que las variables de aplicación se utilizan para cuando estamos controlando
valores a nivel de aplicación (generales) como lo es un sitio Web accesado por una
considerable cantidad de usuarios. Así pues, este ejemplo, lo que pretende es ir
estableciendo cuantos usuarios están conectados al mismo tiempo. La programación del
global.asax queda como sigue (solo escribe lo que está señalado)
Sub Application_Start(ByVal sender As Object, ByVal e As EventArgs)

' Código que se ejecuta al iniciarse la aplicación
Application.Lock() „Bloqueo la aplicación
'Aca inicializamos una variable para contar usuarios activos
Application("NumUsers") = 0
Application.UnLock() „Desbloqueo la aplicación.
End Sub
Sub Application_End(ByVal sender As Object, ByVal e As EventArgs)

' Código que se ejecuta durante el cierre de aplicaciones
End Sub
Sub Application_Error(ByVal sender As Object, ByVal e As EventArgs)

' Código que se ejecuta al producirse un error no controlado
End Sub
Sub Session_Start(ByVal sender As Object, ByVal e As EventArgs)

' Código que se ejecuta cuando se inicia una nueva sesión
'Aca podemos incrementar la variable que contiene el numero de usuarios activos
Application("NumUsers") += 1
End Sub
Sub Session_End(ByVal sender As Object, ByVal e As EventArgs)

' Código que se ejecuta cuando finaliza una sesión.
' Nota: El evento Session_End se desencadena sólo con el modo sessionstate
' se establece como InProc en el archivo Web.config. Si el modo de sesión se establece como
' StateServer
' o SQLServer, el evento no se genera.
' Se desencadena cuando termina la sesión
'Aca podemos decrementar la variable que contiene el numero de usuarios activos
Application("NumUsers") -= 1
End Sub
9. Guarda el archivo global.asax y procede a programar el webForm1. Estando en modo diseño

pulsa sobre cualquier lugar del formulario Web y escribe el siguiente código:
En el evento Load del formulario webForm1:
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _

Handles Me.Load
Label2.Text = Label2.Text & " " & Application.Get("NumUsers")
'En esta línea se asigna a la propiedad Text del Label2 el contenido del mismo label2 como
'además la variable NumUsers a través del comando Application.Get.
End Sub
Protected Sub btnSiguiente_Click(ByVal sender As Object, ByVal e As System.EventArgs) _
Handles btnSiguiente.Click
Session.Add("Nombre", TextBox1.Text)
'En esta línea se crea la variable de sesión Nombre y se le agrega el valor inicial que el usuario
'escribe en la propiedad Text del objeto TextBox1
Response.Redirect("webForm2.aspx")
'Redirecciona hacia la página WebForm2.Aspx
End Sub
10. Ahora vayamos al formulario webForm2 y codifiquemos las acciones que se van a realizar
aquí. El código es el siguiente:
Protected Sub btnAtras_Click(ByVal sender As Object, ByVal e As System.EventArgs) _

Handles btnAtras.Click
Response.Redirect("webForm1.aspx")
'Redirecciona hacia la página WebForm1.Aspx
End Sub
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _

Handles Me.Load
Label1.Text = Label1.Text & " " & Session.Item("Nombre")
'Recupera la variable de sesión Nombre a través de Session.Item y la asigna a Label1.Text
Label2.Text = Label2.Text & " " & Application.Get("NumUsers")
'Recupera la variable de Aplicación NumUsers a través de Application.Get y la asigna a
'Label1.Text
End Sub
11. La ejecución del sitio Web puedes observarlo en las ilustraciones 24 y 25.
Ilustración 24
Ilustración 25
Cookies
¿Qué son las cookies?
Las cookies constituyen un tema importante en todas las aplicaciones Web. Lógicamente, no es
recomendable basar una aplicación en el funcionamiento de las cookies, dado que el usuario
fácilmente podría borrarlas o modificarlas.
Podríamos definir una cookie como un pequeño trozo de código que acompaña a las solicitudes de
usuario y a las páginas Web mientras éstas viajan hacia el servidor Web y viceversa. Estas cookies
contienen información que la aplicación Web puede leer cada vez que el usuario visita el sitio.
Consideremos el hecho que un usuario se autentica a un determinado sitio Web, el nombre del
usuario podría guardarse en la máquina del usuario, para que la próxima vez que ingrese a ese sitio
pueda cargar, desde la cookie, ese nombre de usuario y no tener que volverlo a digitar.
Cabe indicar que las cookies se asocian a un determinado sitio Web y no a una página específica. Por
tanto, si en el ejemplo anterior el usuario ingreso al sitio de Hotmail o Yahoo, el nombre de usuario
que se almacenará en su computadora será el que se usa en cualquiera de esos sitios.
Existen dos tipos de cookies: Temporales y las Persistentes.
Las cookies temporales se denominan cookies de sesión o no persistentes. Solo existen en la

memoria del navegador que se utilice. Cuando éste se deja de utilizar las cookies temporales
desaparecen con el.
Las cookies persistentes se asemejan a las temporales con excepción que éstas poseen un tiempo de
expiración. Estas cookies se guardan en el disco duro de la máquina del usuario y se puede crear por
dias, meses o inclusive años.
Limitaciones de las cookies
Una limitación de las cookies es aquella producto de la mayoría de exploradores que solo admiten
cookies de un tamaño máximo de 4096 bytes. Por tanto, se limita a que las cookies solo puedan
almacenar pequeñas cantidades de datos.
También muchos exploradores imponen restricciones en cuanto el número máximo de cookies que
cada sitio puede almacenar. Por ejemplo, la mayoría de exploradores solo permiten almacenar 20
cookies por sitio, conservando solo las últimas 20 que se agreguen del sitio y eliminando las más
viejas. En cuanto la totalidad de cookies que se puedan almacenar en la máquina del usuario, el
explorador generalmente podrá permitir alrededor de 300.
También puede configurarse para que los exploradores rechacen las cookies. Esto constituye un
problema por cuanto muchos sitios Web desearían almacenar información específica del usuario en
su propia máquina y no lo podría hacer porque no puede utilizar cookies, ni tampoco a través de
estados de sesión por que éstos dependen también de las cookies.
Vamos a crear un pequeño ejemplo de la utilización de cookies. Por tanto, sigue las siguientes
instrucciones:
1. Ingresa a Visual Studio .NET y crea un nuevo sitio Web denominado webCookies.
2. Renombra el formulario Web que se crea por defecto. Cámbiale el nombre por webLogin.
3. Desde la barra de controles ubica el agrupador de objetos denominado Inicio de Sesion y
arrastra desde ahí el objeto Login y colócalo en el formulario Web, tal y como se muestra en
la ilustración siguiente:
Ilustración 26
4. Una vez que has colocado el control Login, pulsa sobre cualquier parte del formulario Web,
excepto sobre el control Login y escribe el siguiente código:
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
If Not IsNothing(Request.Cookies("usuario")) Then

Response.Cookies.Set(Request.Cookies("usuario"))
Else
'Creamos elemento HttpCookie con su nombre y su valor inicial
Response.Cookies.Set(New HttpCookie("usuario", ""))
End If
'le asignamos un fecha de expiración a la cookie usuario: en un 1 año
Response.Cookies("usuario").Expires = DateTime.Today.AddYears(1)
Login1.UserName = Request.Cookies("usuario").Value
If Response.Cookies("usuario").Value = "" Then
Login1.UserName = "No hay cookie"
Else
Login1.UserName = Request.Cookies("usuario").Value
End If
End Sub
5. Una vez programado el evento Load del formulario Web vamos a programar el objeto Login
del formulario. Pulsa dos veces sobre el objeto Login y una vez en la edición de código
escribe lo siguiente:
Response.Cookies("usuario").Value = Login1.UserName
Response.Redirect("weblogin.aspx")
6. Ahora podrás probar nuestro sitio Web. Pulsa CTRL-F5 y verás como el nombre de usuario
que digites en el control se almacenará en una cookie en tu propia computadora.
Referencias Webs:
http://msdn2.microsoft.com/es-es/library/ms178193(VS.80).aspx
Utilización de controles (textbox, label, dropdownlist, etc)

La funcionalidad de los controles de ASP .NET sufren algunas modificaciones con respecto a la
utilización en aplicaciones Windows.
A continuación realizaremos un ejercicio donde expondremos el uso de algunos componentes

básicos. Posteriormente, iremos agregando más componentes y su funcionalidad en el resto de
aplicaciones Web que vayamos desarrollando.
Para iniciar debemos crear un sitio Web denominado WebControlesComunes, que tiene una interface
similar a la mostrada en la ilustración 26. Los pasos a seguir son los siguientes:
1. Cree un sitio Web nuevo denominado WebControlesComunes, tal y como se muestra en la

ilustración 26. Los controles que debe colocar en el formulario que se crea por defecto se
ilustran en la tabla No. 6.
Ilustración 27
La configuración de controles se muestra en la siguiente tabla:

ID Label1
Label
Text Digite su nombre:
ID Label2
Label
Text Digite su email:
ID Label3
Label
Text Digite su edad (años):
ID Label4
Label
Text Sexo:
ID Label5
Label
Text País de Nacimiento:
ID Label6
Label
Text Escribir Contraseña:
ID Label7
Label
Text Validar Contraseña:
ID TextBox1
TextBox
Text
ID TextBox2
TextBox
Text
ID TextBox3
TextBox
Text
ID TextBox4
TextBox
Text
ID TextBox5
TextBox
Text
Tabla No. 6
Nota: Todos las etiquetas (label) deben tener su propiedad Text en tamaño (size) large.
ID RegularExpressionValidator1
ValidationExpression Dirección de correo electrónico
RegularExpressionValidator de Internet
ErrorMessage Dirección de email incorrecto!
ID RequiredFieldValidator1
RequiredFieldValidator ErrorMessage Se requiere su edad
ID CompareValidator1
ControlToCompare TextBox4
CompareValidator
ErrorMessage Las Contraseñas no coinciden!
RadioButtonList ID RadioButtonList1
DropDownList ID DropDownList1
ID Button1
Button
Text Enviar
Tabla No. 6 (continuación)
2. Luego de haber colocado los objetos que se indican en la tabla anterior, deben configurarse,
en tiempo de diseño, los objetos RadioButtonList1 y DropDownList1, tal y como se muestra
en la ilustración No. 27. Observe la flecha en negrita que aparece en la esquina superior
derecha del objeto RadioButtonList1. Pulse sobre ella e inmediatamente aparecerá un menú
de contexto (como en la ilustración 27) Inmediatamente pulse sobre la opción Editar
elementos…
Ilustración 28
3. En la ventana que aparece (observe la ilustración 28) agregue los elementos Masculino y
Femenino. En el botón Agregar se crea una opción en la lista de botones de opción. En la
propiedad Text del objeto creado se agrega el texto que se desea que aparezca cuando se
encuentre en modo ejecución. La propiedad Value permite inicializar el valor del objeto en
tiempo de diseño. Finalmente, en la propiedad Selected si se inicializa en True entonces
aparecerá como habilitado en el momento que el objeto se ejecute. Ponga el objeto
Masculino creado con la propiedad Selected en True.
Ilustración 29
4. Una vez configurado el objeto RadioButtonList1 se deberá hacerlo con el DropDownList1. Su

configuración es similar al de RadioButtonList1 con la diferencia de los valores que se le
agregarán en la ventana Editor de la colección ListItem (observe la ilustración 28) las cuales
son: Costa Rica, Nicaragua, Honduras, El Salvador y Guatemala.
5. Procede inmediatamente a ejecutar el sitio Web que acabas de desarrollar pulsando al mismo
tiempo las teclas CTRL F5. La ejecución se mostraría como la ilustración 29.
Ilustración 30
6. Como último paso configura las propiedades TextMode del TextBox4 y TextBox5
(contraseñas) con el valor inicial Password para que no se visualice lo digitado en ambos
textbox.
Autoevaluación
1. Explique tres métodos utilizados para agregar código a un formulario Web en ASP .NET.
2. Determine la diferencia entre validación del lado del cliente y validación del lado del servidor.
Explique cuáles son las ventajas de uno u otro tipo de validación.
3. Explique la funcionalidad y las diferencias de variables de sesión y variables de aplicación.
¿En qué casos particulares podrían utilizarse una u otro tipo?
4. ¿Qué son las cookies? ¿Cuándo y en qué circunstancias es adecuado utilizarlas?
5. Explique cuáles son las limitaciones de las cookies.
Caso de Aplicación.
Desarrolle un sitio Web que cumpla con las siguientes condiciones:
1. Una formulario Web que valide en el lado del cliente una palabra clave que contenga los
siguientes requisitos:
a) La longitud de la palabra no exceda los 12 caracteres y que no sea inferior a 8.
b) Que la palabra inicie y termine con una letra.
c) Que a cada letra le anteceda y preceda un número.
d) Contraseñas válidas: a1b2c3d4e, A8B4d5F7t, Y3y6u8m3b5i
Nota de ayuda: Puede validar que los pares de la cadena sean números y los impares
sean letras. Puede utilizar la línea If System.Char.IsLetter(VARIABLE CHAR) = True Then
…
2. En el mismo formulario valide en el lado del servidor que el password concuerde con alguna
de cuatro variables globales creadas en la aplicación. De ahí tomará los datos del nombre
del usuario, país de nacimiento y edad del mismo. Estos datos son también globales.
3. Cree un nuevo formulario Web donde se visualicen los datos del usuario, tal como el nombre,
país de nacimiento y edad. Asimismo que en el título del formulario se visualice el mensaje
“Buenos días “ & NombreUsuario (si es antes de las 12 md) o “Buenas tardes “ &
NombreUsuario (si es después de las 12 md)
TEMA 4: Fundamentos de Web Services
Actualmente Internet facilita a las empresas una mejor comunicación interna y externa de la
información relevante a su funcionamiento. Con Internet se facilitan los negocios en línea, se
proporciona un medio más rápido y oportuno de acceso a la información, se intercomunica a las
personas a través de la conexión de un Chat a Internet o la investigación se enriquece con la
búsqueda y análisis de datos.
Las empresas actuales requieren de sitios Web programables que integren organizaciones,
aplicaciones y servicios. Ese enlace entre aplicaciones lo proporcionan los actuales servicios Web que
ponen a disposición muchas organizaciones con el fin de brindar valor agregado a sus clientes. Esto
proporciona una importante expansión de la funcionalidad de los sitios Web actuales.
Definición de Servicio Web XML

Muchos sitios Web que se construyen requerirán en algún momento integrarse para ofrecer mayor
funcionalidad a los usuarios. Sin embargo, se podría presentar el problema que alguno de los sitios
estén desarrollados en distintas plataformas o que se ejecute en un distinto sistema operativo. En
este contexto surge la solución a través de aplicaciones construidas y que resuelven la integración de
aplicaciones Web. Estos servicios Web XML proporcionan un modelo simple, flexible y basado en
estándares para conectar aplicaciones a través de Internet.
Características de los Servicios Web XML

Los servicios Web poseen las siguientes características:
 La lógica programable de un WS (Web Services) es accesible mediante protocolos Web

estándares. A través del protocolo http se puede acceder directamente la funcionalidad del
servicio Web. Por ejemplo, puede construirse una aplicación Web o Windows en Visual Basic
.NET o C# e invocar resultados o valores devueltos por un WS desarrollado por una empresa
ajena a nosotros. Supóngase que desarrollamos una aplicación para la proveeduría de la
empresa que requiera, todos los días, invocar un WS del Banco Central para obtener el tipo
de cambio del dólar o del euro del día para gestionar compras o registrar contratos externos.
 Permite la recepción y envio de información a través de Internet. A través de una referencia
Web podemos hacer uso de un WS. Podemos remitir valores al WS para que éste resuelva
algún tipo de procesamiento, cálculo o devolución de datos y lo retorne de otra forma. Esto
es, la parametrización hacia y desde el WS es la funcionalidad requerida para una
integración de aplicaciones.
 Independiente del lenguaje de programación, protocolo y plataforma. No importa en que
lenguaje se haya desarrollado un sitio Web determinado o el WS que deseamos utilizar.
Obviamente, esos lenguajes deben estar basados en Microsoft .NET. Los WS XML se
comunican utilizando protocolos Web y formatos de datos estándares, tales como http, XML
o SOAP (Simple Object Access Protocol)
 Posee una arquitectura sin estado. Cuando un WS brinda una respuesta crea un nuevo
objeto, con un nuevo estado. Por ende, cada uno es individual en su gestión, a menos que
se utilicen los servicios de gestión de estados de Microsoft ASP .NET para mantener el estado
entre peticiones. De otra manera el estado de la respuesta se pierde en el servidor del WS.
 Posibilidad de asincronismo. Un objeto que realiza una petición en una aplicación cliente y un
objeto WS lo hace sobre una comunicación SOAP que no requieren una conexión compartida.
Esto permite que la aplicación cliente como el WS se procesen independientemente mientras
la interacción está en funcionamiento.
 Se basa en un estándar W3C desarrollado. El estandar W3C (World Wide Web Consortium)
sigue evolucionando y con ello las características genéricas de los WS. El estandar W3C
sigue su desarrollo y sobre ello los WS basan su estandarización. Visite www.w3c.org para
mayor información sobre este estándar.
Creando el primer servicio Web (aplicación calculadora

científica)
Iniciaremos a incursionar en los WS creando un pequeño ejemplo. La idea general es la siguiente:
 Desarrollaremos un WS con las funciones básicas que podría tener una calculadora científica
en la Web.
 Desarrollaremos un sitio Web que invoque ese WS para llamar a sus funciones y plasmar sus
resultados en los objetos creados para tal fin en el sitio.
Por tanto, iniciemos nuestro ejemplo:
1. Ingrese a Visual Studio .NET, seleccione Archivo, Nuevo sitio Web… y Servicio Web ASP
.NET, tal y como se muestra en la ilustración 30. Se nombrará wsCalculadora.
Ilustración 31
2. Pulse el botón Aceptar. Una vez ahí, se le presentará el editor de código requerido (un WS
no tiene interface, solamente funcionalidad a través de código) Observe la ilustración 31 para
que tenga una idea del entorno que le proporciona el editor del WS. Elimine de este ejercicio
lo que se muestra marcado en la ilustración 31.
Ilustración 32
3. Observe en la ilustración 31 la palabra <WebMethod> Esto significa que todo procedimiento

que se escriba en un WS será un método Web (WebMethod) Por lo tanto, vamos a crear
nuestros propios métodos para nuestro Servicio Web (WS)
Para ello, escribamos los siguientes métodos:
Imports System.Web
Imports System.Web.Services
Imports System.Web.Services.Protocols
<WebService(Nombrespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class Service
Inherits System.Web.Services.WebService
#Region "AritMetica"
<WebMethod()> Public Function Suma(ByVal x As Double, _
ByVal y As Double) As Double
Return x + y
End Function
<WebMethod()> Public Function Resta(ByVal x As Double, _
Return x - y
End Function
<WebMethod()> Public Function Multiplicacion(ByVal x As Double, _
Return x * y
End Function
<WebMethod()> Public Function Division(ByVal x As Double, _
If x / y > 0 Then
Return x / y
Else
Return 0
End If
End Function
#End Region
#Region "Calculo"
<WebMethod()> Public Function Potencia(ByVal x As Double, _
Return Math.Pow(x, y)
End Function
<WebMethod()> Public Function RaizCuadrada(ByVal x As Double) As Double
Return Math.Sqrt(x)
End Function
<WebMethod()> Public Function Logaritmo10(ByVal x As Double) As Double
Return Math.Log10(x)
End Function
<WebMethod()> Public Function Seno(ByVal x As Double) As Double
Return Math.Sin(x) 'Devuelve el seno del angulo especificado.
End Function
<WebMethod()> Public Function Tangente(ByVal x As Double) As Double
Return Math.Tan(x) 'Devuelve la tangente del angulo especificado.
End Function
<WebMethod()> Public Function Coseno(ByVal x As Double) As Double
Return Math.Cos(x) 'Devuelve el coseno del angulo especificado.
End Function
#End Region
End Class
Observaciones:
Observa que existen dos regiones: Aritmetica y Calculo. La primera región considera todas las funciones para realizar
operaciones aritméticas (suma, resta, multiplicación y división) la segunda región incorpora las operaciones de cálculo tales
como potencia, raíz cuadrada, seno, coseno, etc.
Las regiones se crean para efectos de facilidad de programación, por ejemplo, podemos colapsar la región de Aritmetica
quedando visible solamente la de Calculo y facilitarnos la escritura de código. Luego podemos expandir la región de Aritmetica
y colapsar la de Calculo y la visible en este caso sería la de Aritmetica y la no visible la de Calculo.
Referencias Webs:
http://www.w3c.es/Divulgacion/GuiasBreves/ServiciosWeb
4. Una vez programado el WS se puede probar los resultados que arrojaría nuestro WS. Al
igual que los sitios Web podemos pulsar las teclas CTRL F5 y se ejecutará nuestro WS. Por
ende, procederemos a ejecutarlo y el entorno muestra lo de la ilustración 32.
Ilustración 33
5. Procedamos a ejecutar este WS pulsando sobre la función Potencia. Se nos mostrará la

imagen de la ilustración 33.
Ilustración 34
6. Los valores pasados en x, y son 8 y 2, lo que equivale a 82 que es igual a 64. Este resultado
puede observarse al pulsar el botón Invocar en la ilustración 34.
7. Observe, en medio del círculo, el resultado de la invocación de la función Potencia del WS.
8. Guarde el archivo.
En la próxima sección procederemos a crear un sitio Web que utilice el WS que desarrollamos.
Caso de Aplicación: calculadora científica mediante Web

services (servicios Web)
A continuación crearemos un sitio Web que utilice el WS que creamos en la sección anterior. Para ello
siga las instrucciones que se le indican a continuación:
 Cree un nuevo sitio Web denominado webCalculadora. El formulario Web por defecto, debe
ser similar al mostrado en la ilustración 34.
Ilustración 35
 La configuración de los objetos del formulario Web anterior se indican en la tabla No. 7

ID Label1
Label Text Valor 1:
Font y Size Large
ID Label2
Label Text Valor 2:
Font y Size Large
ID Label3
Label Text Resultado:
Font y Size Large
ID Label4
Label Text
Font y Size Large
ID TextBox1
TextBox
Text
ID TextBox2
TextBox
Text
Button ID btnSumar
Button ID btnRestar
Button ID btnMultiplicar
Button ID btnDividir
Button ID btnRaizCuadrada
Button ID btnPotencia
Button ID btnLog10
Button ID btnSen
Button ID btnCosen
Button ID btnTan
Tabla No. 7
Nota: En todos los objetos Button configure la propiedad Text de cada uno con el titulo
que aparece en la ilustración 34.
 Una vez configurados los objetos de este formulario Web proceda a crear la referencia Web
necesaria para implementar el WS que desarrollamos anteriormente. Para ello pulse sobre el
nombre del proyecto y seleccione agregar referencia Web…, tal y como se muestra en la
ilustración 35.
Ilustración 36
 Una vez pulsada esta opción, se visualizará una pantalla que le permitirá buscar los servicios
Web disponibles, sea en la solución actual (la aplicación actual), los WS implementados en el
equipo local o un servidor. La ilustración 36 muestra esta pantalla.
Ilustración 37
 Seleccione la opción Servicios Web del equipo local donde ubicará, entre otros, el WS que
desarrollamos anteriormente. Observe la ilustración 37 para seleccionar el WS requerido.
Ilustración 38
 Una vez pulsado sobre el nombre del servicio Web (SERVICE) proceda a nombrar la
referencia. Póngale el nombre WSCalculadora y pulse el botón Agregar Referencia. Observe
la ilustración 38.
Ilustración 39
 Para utilizar la funcionalidad del WS debemos ahora instanciarlo. Para ello pulse dos veces
sobre el formulario Web y cree una instancia del WS tal y como se muestra en el código
siguiente (sombreado):

Dim aux As New WSCalculadora.Service
End Class
La instancia del WS se denomina aux.
 A continuación vamos a utilizar el WS invocando a una de sus funciones (Sumar) Para ello
pulse sobre el botón Sumar y escriba el siguiente código:
Label4.Text = aux.Suma(Val(TextBox1.Text), Val(TextBox2.Text))
 En el botón Sqrt (Raíz Cuadrada) el código:
Label4.Text = aux.RaizCuadrada(Val(TextBox1.Text))
 En el botón X^Y (Potencia) el código:
Label4.Text = aux.Potencia(Val(TextBox1.Text), Val(TextBox2.Text))
 Ahora pruebe la aplicación pulsando las teclas CTRL F5. La ejecución mostrará una pantalla
como la ilustración 39.
Ilustración 40
Como ejercicio final, implemente las demás funciones del WS en este sitio Web.
Autoevaluación
1. Defina la funcionalidad de un servicio Web ASP .NET.
2. Cite y explique 4 características fundamentales de los servicios Web ASP .NET
3. Identifique tres aplicaciones prácticas que usted le daría a servicios Web ASP .NET.
Desarrolle un servicio Web y su respectiva implementación en un sitio Web ASP .NET
1. Una función que devuelva los pagos mensuales de un préstamo (utilice la función
Pmt(Rate,Nper,PV))
2. Una función que determine el valor futuro de una anualidad basada en pagos fijos periódicos
e intereses de tasa fija (utilice FV(Rate,Nper,Pmt))
3. Una función que reciba dos parámetros (multiplicador y multiplicando) y aplique el método
de multiplicación á la russe:
(http://micronet.cujae.edu.cu/Docencia/Programacion%20I/Conferencias/CONF1.PDF)
para devolver el resultado de la multiplicación.
4. Implemente el uso del servicio Web en un formulario Web adecuado.
TEMA 5: Uso de datos XML
XML es un lenguaje que está presente en muchas de las opciones de Visual Studio .NET y en el
propio .NET Framework. Mediante XML hay una separación de los datos de presentación y el
proceso que los transforma, de tal manera que permite procesarlos y mostrarlos de la forma en que
se desee. La estructuración de información en XML se basa en etiquetas las cuales no están
predefinidas como en HTML, sino que se pueden anidar unas dentro de otras para crear un esquema
de etiquetas de forma padre e hijo.
Definición de XML
XML (eXtended Markup Language) es un metalenguaje que proporciona un formato para la
descripción de datos. Esto facilita la declaración de contenido de archivos y los resultados de
búsquedas de datos en varias plataformas.
Se podría definir de la siguiente manera: XML es un formato universal que se utiliza para describir e
intercambiar documentos y datos estructurados en Internet.
Algunas características son:
 Suministra un método que permite describir e intercambiar datos estructurados.

 Permite que se definan elementos y atributos personalizados.
 Permite el anidamiento de elementos.
Componentes de un documento XML

Un documento XML está compuesto por:
 Elementos
 Atributos
 Comentarios
A continuación se puede observar la conformación de estos tres componentes.
<?xml version=”1.0”?>
<autores>
Elementos
<autor ID = “1”>
<nombre>Enrique</nombre> Atributos
</autor>
<!—No más autores.—> Comentarios
</autores>
Los elementos tienen las siguientes características:
 Están formados por un par de etiquetas: una de inicio y una de cierre.

 Entre las etiquetas de inicio y fin está el contenido del elemento (datos) u otros elementos.
 El primer elemento contiene el resto de elementos de un documento XML. A este elemento
se le denomina elemento raíz, los demás son secundarios.
Un elemento tiene el siguiente aspecto en XML:
<LIBRO>...<TITLE>XML programando XML</TITLE>...</LIBRO>
Los atributos tienen las siguientes características:
 Cualquier elemento puede contener atributos.

 Los atributos pueden ser una alternativa al uso de elementos para el almacenamiento de
información
 Los atributos se definen para un único elemento.
Recuerda que los atributos son partes o propiedades de los elementos. Por ejemplo, para el caso de
<LIBRO>...<TITLE>XML programando XML</TITLE>...</LIBRO>, este elemento tiene un atributo
denominado Editor, tal y como se muestra en la siguiente línea de código XML:
<EDITOR DE LIBRO= "UNED">XML programando XML </LIBRO>< /p>< /p>< /p>
Los atributos no pueden ser jerárquicos lo que significa que no pueden contener subelementos. Sin
embargo, podría cambiarse el atributo por su propio elemento. El código sería:
<PUBLICACION>
<LIBRO>XML programando XML </BOOK>
<EDITOR>UNED</EDITOR>
</PUBLICACION>
Tecnologías XML
XML ha venido innovando a través de los últimos años y las tecnologías que se han gestado son las
siguientes:
 XSD
 XSLT
 XPath
 DOM
 XQuery
XSD es un estándar que se utiliza para la definición de esquemas, definiendo la estructura requerida
por un documento XML válido. Puede ser un documento aislado que actúa como un documento
maestro y el cual es referenciado por otros documentos, denominados instancia. El documento
aislado tendrá una extensión .xsd.
XSLT, permite la transformación del contenido de un documento XML fuente en otro documento
diferente en formato o estructura. XSLT es parte de XSL (eXtensible Stylesheet Language) XSLT
utiliza un archivo origen, que tiene un formato correcto y sirve como entrada para la transformación
a XSLT. Por ejemplo, el siguiente es XML válido:
<?xml version="1.0" ?>
<?xml-stylesheet type="text/xsl" href="Empleados.xsl"?>
<empleados>
<empleado>
<nombre>Enrique Gómez Jiménez</nombre>
<profesion>Profesor</profesion>
</empleado>
<empleado>
<nombre>Enrique Gómez Duarte</nombre>
<profesion>Programador</profesion>
</empleado>
</empleados>
El segundo paso es convertir el archive XML válido (Empleados.xsl) al formato XSLT. Por tanto, el
código será el siguiente:
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:template match="/">
<xsl:apply-templates select="//empleado" />
</xsl:template>
<xsl:template match="empleado">
<P>
<xsl:apply-templates />
<HR />
</P>
</xsl:template>
<xsl:template match="nombre">
<FONT COLOR="red" />
<B>
<xsl:value-of select="." />
</B>
</xsl:template>
<xsl:template match="profesion">
<BR/>
<FONT COLOR="blue" />
<xsl:value-of select="." />
</xsl:template>
</xsl:stylesheet>
El documento resultante, producto de la transformación a XSLT, producirá como salida:
Enrique Gómez Jiménez

Profesor
Enrique Gómez Duarte

Programador
X Path, permite direccionar partes de un documento XML. Es un lenguaje que permite referenciar
elementos en documentos XML. En un modelo de objetos XPath, un documento XML se representa
mediante un árbol de nodos.
DOM, es un modelo de objetos para trabajar en memoria, mediante programación. El documento

XML se almacena en la caché de memoria en forma de árbol, permitiendo la navegación y edición del
documento XML. Por ejemplo, se puede escribir un script que se ejecute en el lado del servidor Web
y mediante DOM crear un documento en el navegador del lado del cliente.
XQuery, es un lenguaje utilizado para consultas en XML. Dado que la cantidad de información que se
almacena en memoria aumenta cada vez más, es necesario contar con un lenguaje que permita
realizar consultas sobre los datos XML que se almacenaron. Aquí reviste importancia el lenguaje de
consulta XQuery. XQuery permite consultar tanto bases de datos como documentos XML.
Referencias Webs:
http://www.w3c.org
http://www.w3c.es/divulgacion/guiasbreves/tecnologiasXML
http://www.w3c.es/Presentaciones/2003/1211-eadmin-JA/12.html
http://www.w3c.es/gira/paradas/presentaciones/Gregorio_XML.pdf
Caso de Aplicación
Vamos a realizar una pequeña aplicación que demuestre el uso de XML en aplicaciones Web. Para
ello sigue las siguientes instrucciones:
1. Ingresa a Visual Studio .NET y crea un nuevo sitio Web denominado webXML. A
continuación coloca los objetos que se indican en la siguiente tabla:

ID Label1
Label Text Carnet
Font y Size Large
ID Label2
Label Text Nombre:
Font y Size Large
ID Label3
Label Text Dirección:
Font y Size Large
ID TextBox1
TextBox Text 123
Font y Size Large
ID TextBox2
TextBox
Text Enrique
ID TextBox2
TextBox
Text Grecia
Button ID btnIncluirRegistro
Button ID btnGenerarXML
Button ID btnCargarXML
Table ID Table1
DataGrid ID DataGrid1
Tabla No. 8
2. El formulario Web que se diseñaría, según los objetos de la tabla 8, sería similar al mostrado
en la siguiente ilustración:
Ilustración 41
3. Una vez que has definido el formulario Web y todos los objetos que contiene, procederemos
a programarlo. Inicialmente, en las declaraciones del formulario Web invoca el namespace
que utilizaremos. Recuerda que los imports van arriba de la declaración del nombre del
formulario (en este caso del formulario Web Partial Class _Default)
Imports System.Xml
4. En la sección de declaraciones generales debe programarse lo siguiente:
'Se utilizará para cargar los datos provenientes del archivo XML
Dim dst As New Data.DataSet
'Se utilizará como documento XML donde se creará el archivo XML
Dim arbol As New XmlDocument „
'Se utilizará como nodo del documento (cada registro es un nodo)
Dim nodo As XmlNode
5. En el evento Load del formulario Web debemos escribir el siguiente código:
'Se crea el nodo que servirá como nodo raíz del árbol de registros del XML
nodo = arbol.CreateElement("Estudiantes")
'Se agrega el nodo al árbol, que es el documento XML a crear
arbol.AppendChild(nodo)
'Se crea una tabla de 10 elementos como ejemplo de creación de registros.
CrearTabla()
6. El código del método CrearTabla es el siguiente:

Sub CrearTabla()
Dim filas As Integer = 10
Dim celdas As Integer = 3
Dim j As Integer
For j = 0 To filas - 1
Dim r As New TableRow()
Dim k As Integer
For k = 0 To celdas - 1
Dim c As New TableCell()
r.Cells.Add(c)
Next k
Table1.Rows.Add(r)
Next j
If Not Page.IsPostBack Then Session("fila") = 0
End Sub
7. El botón btnCargarXML tiene el código siguiente:
Try
dst.ReadXml(Server.MapPath("Prueba.xml"))
DataGrid1.DataSource = dst.Tables(0)
DataGrid1.DataBind()
Catch ex As Exception
Response.Write(ex.Message)
End Try
8. El botón btnIncluirRegistro tiene el código siguiente:
Dim i = Session("fila")
Table1.Rows(i).Cells(0).Text = TextBox1.Text
i=i+1
Session("fila") = i
9. El botón btnGenerarXML tiene el código siguiente:
Dim ruta$ = Server.MapPath("Prueba.xml")

Dim Escritor As New XmlTextWriter(ruta, Encoding.UTF8)
Escritor.Formatting = Formatting.Indented
Escritor.WriteStartDocument()
Escritor.WriteStartElement("Estudiantes")
Dim f As TableRow
For Each f In Table1.Rows
If f.Cells(0).Text <> "" Then
Escritor.WriteStartElement("Estudiante")
Escritor.WriteElementString("Carnet", f.Cells(0).Text)
Escritor.WriteElementString("Nombre", f.Cells(1).Text)
Escritor.WriteElementString("Direccion", f.Cells(2).Text)
Escritor.WriteEndElement()
End If
Next
Escritor.Close()
10. Una corrida típica de esta aplicación será similar a la mostrada en la ilustración siguiente:
Ilustración 42
11. Finalmente, puedes poner otro botón de comando en el formulario Web que te direccione
directamente al archivo XML creado. La instrucción que pondrías en este botón sería la
siguiente:
Response.Redirect("http://localhost/WebXML/Prueba.xml")
12. Se mostraría el documento XML adecuadamente formateado.
Autoevaluación
1. Defina el concepto XML. Investigue un poco sobre XAML.
2. Cite y explique los componentes de un documento XML.
3. Cite y explique al menos tres tecnologías XML actuales.
Desarrolle un sitio Web que cumpla con las siguientes condiciones:
1. Capture los datos de un estudiante (carnet, nombre, apellidos y dirección)

2. Capture los datos de la matricula de un periodo cualquiera (nombredelcurso, horario,
valordecreditos)
3. Una vez capturados genere un archivo XML que será mostrado en un formulario Web
diferente del formulario donde se cargaron los datos.
4. Diseño otro formulario Web donde lea desde el archivo XML generado en el punto 2 y los
muestre en un dataGrid.
TEMA 6: Depuración y corrección de errores
Capturar los errores de código cuando apenas se desarrolla un sitio Web es tarea difícil, casi que
imposible. En realidad los errores (o las excepciones) ocurren en tiempo de compilación o de
ejecución. El compilador de Visual Studio .NET localiza los errores de sus aplicaciones en tiempo de
compilación y para obtenerlos en tiempo de ejecución se debe utilizar el depurador de Visual Studio
.NET, el objeto Trace o el objeto Debug.
Información en tiempo de ejecución

En tiempo de ejecución de una aplicación Web podríamos habilitar el seguimiento y los mensajes
informativos de esta ejecución pueden ayudarnos a diagnosticar problemas o analizar el rendimiento
de nuestro sitio Web. Para ello podemos utilizar el trace o el trace.
El objeto Trace de Microsoft ASP .NET permite mostrar información de una página Web o guardarla
en memoria. El objeto Debug permite mostrar información de depuración en la ventana Resultados
del depurador. Para utilizar Debug necesitamos importar el espacio de nombres
System.Diagnostics.
Durante el tiempo de ejecución podemos:
 Ver los valores de variables.

 Determinar si se cumple o no una cierta condición mediante el método Trave.WriteIf (este
método muestra un mensaje si se satisface una determinada condición)
 Monitorizar la ruta de ejecución de la aplicación, siguiendo la lógica de programación de un
formulario Web, por ejemplo.
Habilitar el seguimiento
El seguimiento de depuración se puede habilitar a nivel de página o a nivel de aplicación.
A nivel de página significa que podemos habilitar el seguimiento para que muestre instrucciones en la
página configurada. Para habilitar este seguimiento basta con ubicarse en el código de la página
(ver ilustración 14) y en la directiva @ Page habilitaremos el trace.
Inicialmente esta directiva está configurada de la siguiente manera:
Y para habilitar el seguimiento la modificaríamos así:
<%@ Page Language="VB" Trace=”true” AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" %>
Observa que lo único que se incluyó fue Trace = “true”

A nivel de aplicación podemos habilitar el seguimiento para que aplique para todas las páginas del
sitio Web. Esto permite mayor flexibilidad al escribir instrucciones de seguimiento. En el
seguimiento a nivel de páginas los mensajes se agregan en la página donde se habilitó, en el
seguimiento de aplicación se pueden escribir los mensajes de seguimiento en la página que se
ejecuta o en memoria. Con el visor de seguimiento a nivel de aplicación, trace.axd se pueden
acceder los datos de seguimiento almacenados en memoria.
Para habilitar el seguimiento a nivel de aplicación se debe modificar el archivo Web.config. Para ello
se agrega el Web.config quedaría configurado de la siguiente manera:
<?xml version="1.0"?>

<configuration>
<system.web>
<trace enabled="true" pageOutput="true" localOnly="true"/>
<compilation debug="true"/>
</system.web>
<appSettings>
<add key="WSCalculadora.Service" value="http://localhost/wsCalculadora/Service.asmx"/>
</appSettings>
<connectionStrings/>

</configuration>
La parte más sombreada configura el seguimiento de depuración en el equipo local. En este caso, se
utilizó el sitio webCalculadora para habilitar el seguimiento de depuración a nivel de aplicación. Para
que se escriban en la página se utiliza el atributo pageOutput del elemento trace. El valor puesto en
True hace que las instrucciones se escriben en cada página. Si se pone en false se escribirían en
memoria y se utilizaría el visor de seguimiento trace.axd para acceder a ellas.
Uso del objeto Trace

Se pueden escribir mensajes de seguimiento de depuración en una página o en memoria, mediante
los métodos Trace.Write y Trace.Warn Tambien podemos utilizar la propiedad IsEnabled del
objeto Trace para cambiar dinámicamente el estado de seguimiento de una página.
Trace.Write y Trace.Warn trabajan de forma idéntica, con la diferencia de que Warn escribe
mensajes de seguimiento en color rojo.
Por ejemplo, si en el botón sumar del sitio Web webCalculadora modificamos el código de la siguiente
manera:
Protected Sub btnSumar_Click(ByVal sender As Object, ByVal e As _

System.EventArgs) Handles btnSumar.Click
Label4.Text = aux.Suma(Val(TextBox1.Text), Val(TextBox2.Text))
Trace.Write("El resultado de la suma en el WS", "WSCalculadora")
Trace.Warn("El resultado de la suma en el WS", "WSCalculadora")
End Sub
Obtendríamos el resultado de la ejecución del llamado al WS (para realizar la suma) y el mensaje de

seguimiento tanto del trace.write como del trace.warn. Algo similar a la siguiente figura se
mostraría:
En algunas ocasiones es posible que deseemos ver los mensajes generados a nivel de página o de
aplicación Web. En este caso, el objeto Trace tiene una propiedad lógica denominada IsEnabled
que permite llamar a cualquiera de los métodos (Write o Warn) solo cuando el seguimiento está
habilitado. Bastaría con averiguar si esta habilitado el seguimiento mediante la instrucción If
Trace.IsEnabled = True Then …. También es posible habilitar o deshabilitar dinámicamente el estado
del seguimiento de una página mediante la instrucción Trace.IsEnabled = False o True
Visualización de resultados de seguimiento

Los resultados del seguimiento a nivel de página se muestran en la parte inferior de la página una
vez que es ejecutada. Estos resultados contienen mucha información, conjuntamente con los
mensajes personalizados que se crean con Trace.Write y Trace.Warn.
En los resultados de seguimiento se muestran varias categorías, entre las que destacan:
 Detalles de la petición: Muestra información sobre la identificación de la sesión (ID), la hora

de la solicitud, tipo y estado de la misma.
 Información de seguimiento: Muestra información sobre el seguimiento estándar o
personalizado. Existe la columna "Desde los primeros" registra el tiempo desde la ejecución
hasta que se ejecuta el seguimiento. También contiene la columna "Desde los últimos" que
muestra la duración del incremento.
 Árbol de control: Muestra todos los elementos y su tamaño en la página
 Colección Cookies: Muestra las cookies que se están utilizando.
 Colección Headers: Muestra los elementos de la cabecera HTTP.
 Colección Form: Muestra los controles y sus valores en el formulario en ejecución.
 Variables de servidor: Muestra las variables de servidor y sus valores.
Uso de seguimiento a nivel de aplicación

A nivel de aplicación las instrucciones de seguimiento se muestran en las páginas individuales. La
configuración a nivel de página sigue vigente cuando habilitamos el seguimiento a nivel de aplicación.
Si está configurado el seguimiento a nivel de aplicación y se deshabilita el seguimiento en una página
individual del sitio Web éste funcionara solo a nivel de esa página.
Autoevaluación
1. Explique la funcionalidad de los objetos Trace y Debug.
2. ¿Qué permite habilitar el visor de seguimiento a nivel de aplicación (Trace.axd)? ¿Dónde se
habilita?
3. ¿Qué función realizan los métodos Trace.Write y Trace.Warm? ¿Cómo podemos cambiar
dinámicamente su estado?
4. Cite y explique al menos cuatro categorías de resultados generados en el visor de
seguimiento.
Caso de Aplicación
Aplique la funcionalidad de los objetos Trace y Debug en el seguimiento y depuración del
sitio Web creado en el tema anterior.
TEMA 7: Administración del Estado
En el tema 3 estudiamos las variables de sesión. Recordemos que la conexión que se establece entre
un usuario (equipo cliente) y un servidor Web se denomina sesión. Las sesiones pueden abarcar
múltiples páginas Web, por lo cual el seguimiento a través de ellas debe administrarse a través de
estados. Este proceso se denomina administración del estado y básicamente la intención es
mantener la misma información a través de múltiples peticiones de páginas Web.
Introducción a la administración del estado

En la siguiente ilustración podemos determinar cómo se puede ejecutar un sitio Web de varias
páginas con o sin administración del estado. En el primer caso, si no hay administración del estado
de sesión podría ocurrir que de una a otra página se perdieran los valores de un usuario por ejemplo.
En el caso de un sitio con administración del estado, la variable de sesión puede “viajar” a través de
las páginas Web del sitio y conservar su valor entre ellas.
Sin Administración del Estado Con Administración del Estado
Estado de Cuenta: Estado de Cuenta:

Usuario:???? Usuario: Enrique Gómez
Servidor
Web
En la figura anterior podemos notar dos escenarios. El primero trabaja sin administración del estado y
la segunda si utiliza administración del estado. En el primer caso una página de Login invoca al
servidor y cuando este valida el usuario lo remite a una página de listado de estado de cuenta, sin
embargo, no puede identificar al usuario por cuanto el dato no se ha conservado. En el segundo
caso, como si se administra el estado, desde el cliente se determinó el usuario, viajó hasta el
servidor, conservando este dato y reutilizándolo cuando ingreso a la página que muestra su estado
de cuenta.
Cabe indicar que las páginas se crean cada vez que se invocan y se destruyen cada vez que se sale
de ellas para ingresar en otra (con cada petición al servidor) Con ello se crean o se eliminan las
variables y objetos que puedan contener en un instante de tiempo. La información contenida en la
página tiene un ciclo de vida asociada con su ejecución.
ASP .NET permite administrar el estado de sesiones, guardando información en el servidor entre
ejecución de páginas. Esto ayuda a mantener la continuidad de la información (estado) y su
reutilización entre páginas Web de un servidor.
Existen dos tipos de administración del estado: del lado del servidor y del lado del cliente.
La administración del estado del lado del servidor se da a nivel de aplicación, sesión o de bases de
datos. Tiene las siguientes características:
 La información está disponible para todos los usuarios de una aplicación Web (estado de la
aplicación) Por ejemplo, el número de usuarios conectados al servidor.
 La información está disponible para un usuario particular o de una sesión específica (estado
de sesión) Por ejemplo, los registros de cuenta de un usuario particular conectado a una
aplicación Web financiera.
 La información puede estar disponible para todos o para un usuario particular con ayuda de
bases de datos que preservan el estado de sesión en cualquiera de los casos.
La administración del estado del lado del cliente se presenta a nivel de cookies, propiedades de
ViewState o Cadenas de consultas. Tiene las siguientes características:
 En el caso de las cookies, éstas son archivos de texto que almacenan información en la
máquina del cliente para mantener el estado de dicha información. Por ejemplo, puede
mantener el nombre del usuario que se conecta a un determinado sitio Web.
 En el caso del ViewState, se permite mantener un diccionario con información del estado
permitiendo guardar y restaurar el estado de vista de un control de servidor en las diferentes
solicitudes de una página. La propiedad ViewState se mantiene como un campo oculto en la
página.
 Una cadena de consulta es aquel que se agrega al final de la dirección Web del sitio que
accesamos. Por ejemplo, podríamos tener el caso de que estamos utilizando el sitio Web
www.Acme.com y determinado momento pasamos de una página
www.acme.com/agencias.aspx a www.acme.com/distribuidores.aspx podría que en ésta
última se arrastre un determinado valor tal como:
www.acme.com/distribuidores.aspx?sucursal=”La Lima” Observe que en esta ruta la cadena
de consulta se inicia con un signo de interrogación e incluye un atributo (sucursal) y un valor
(La Lima)
Cookies y sesiones que no utilizan cookies

Las cookies permiten que un cliente pueda remitir información a un servidor de una aplicación Web
con cada solicitud de HTTP. La devolución que pueda realizar el servidor puede servir para mantener
el estado de sesión del cliente entre múltiples peticiones.
En el tema 3 creamos una aplicación demostrativa del uso de variables de

aplicación y sesión. Asimismo, la utilización de cookies.
Autoevaluación
1. Explique cómo funciona la administración con o sin estado de las sesiones en un sitio Web
ASP .NET.
2. Cite y explique las tres características básicas de la administración del estado de sesión del
lado del servidor.
3. Cite las tres características básicas de la administración del estado del lado del cliente. ¿A
qué tipo de nivel se presenta (cookies, cadenas de consultas, etc.)?
Caso de Aplicación
Se somete a consideración el desarrollo de un sitio Web de una clínica dental que utilice tanto
variables de aplicación, como de sesión y cookies. Algunas condiciones son las siguientes:
 Los pacientes tendrán un usuario y contraseña para consultar su historial médico.

 Se controlará el número de usuarios que utilicen el sitio Web.
 Se podrá ingresar como usuario invitado (Guest) para consultar los servicios de la clínica.
 Se controlarán los registros de médicos, pacientes, servicios, consultas, recetas, etc.
 Puede ampliar los requerimientos de la aplicación y utilizar todos los conocimientos
adquiridos en los temas anteriores.
TEMA 8: Acceso a datos mediante ADO .NET
ADO .NET permite gestionar datos en forma desconectada luego de cargarlos desde una fuente de
datos. Esto permite a una aplicación Web trabajar casi de forma independiente de la fuente de
datos, al gestionar los datos a nivel de memoria. Para la transmisión de datos utiliza XML (eXtensible
Markup Language) como formato universal para la transmisión de datos. Con ello garantiza la
interoperabilidad en cualquier plataforma que soporte XML.
Existen dos objetos que permiten la gestión de datos en ADO .NET: Dataset y DataReader.
Los Dataset permiten almacenar varias tablas (DataTables) extraídas desde una fuente de datos.
El Dataset es como una base de datos virtual que se carga en la memoria, siendo como una copia fiel
de la que radica en el servidor. Las relaciones de integridad referencial y reglas de validación se
conservan en el Dataset.
Los objetos Datareader se utilizan para leer datos desde una fuente, cargarlos en memoria y
desconectarse de la fuente cuando ya los cargó. Proporcionan acceso solo hacia adelante (forward-
only) y son de solo lectura (read-only).
El objeto Dataset se mantiene desconectado de la fuente mientras que el Datareader se mantiene

conectado mientras realiza la lectura de los datos. El acceso del Datareader es mucho más rápido
que el de un Dataset.
Debemos utilizar Dataset o Datareader en los siguientes casos:
 Si se requiere escritura y lectura hacia y desde una fuente de datos (los Datareader son solo
de lectura)
 Si se requiere combinar tablas de una o más bases de datos. Los Datareader lo hacen de
una sola base de datos a través de una instrucción SQL.
 Si se requiere que un formulario Web se enlacen los datos a más de un control. Los
Datareader lo hacen a un único control.
 Si requerimos que los datos permanezcan desconectados. Los Datareader mantienen
conexión a la base de datos.
 Si se requiere realizar búsquedas en cualquier sentido en una colección de datos (hacia
adelante y hacia atrás de los registros) El Datareader solo realiza búsquedas hacia adelante.
 Si se requiere una consulta muy rápida se utiliza el Datareader. El Dataset es mucho más
lento que un objeto Datareader para realizar una consulta. El Dataset almacena los datos en
un objeto del servidor Web.
Si requiere ampliar su conocimiento sobre la optimización de uso de estos objetos consulte:

http://msmvps.com/blogs/cwalzer/archive/2007/09/24/anti-pr-225-cticas-i-acceso-a-datos-con-
ado-net.aspx
ADO .NET en sitios Web
Mediante ADO .NET es posible gestionar datos en un sitio Web utilizando los objetos Dataset y
Datareader. Las condiciones para utilizar uno u otro objeto se explicó líneas arriba por lo que ahora
nos avocaremos a detallar cada uno de esos objetos.
Utilización de Dataset
Un objeto DataSet constituye una copia local en memoria de una base de datos, la cual proviene de
una fuente de datos. Utilizar un objeto DataSet en un formulario Web significa que éste posee una
semi independencia de la fuente de datos que representa. Se utiliza conjuntamente con un objeto
DataAdapter (Adaptador de Datos) el cual permite establecer la conexión y ejecutar la consulta a la
base de datos fuente. Mediante este objeto se puede conectar y desconectar de la base de datos en
cualquier momento y luego sincronizar los mismos. El framework de Visual Studio .NET incluye un
adaptador de datos para bases de datos nativas SQL Server denominado SqlDataAdapter y otro para
otros origenes de datos que se denomina OleDBAdapter
El objeto DataSet puede cargar datos de una base de datos pero también un archivo XML (recuerda
como cargamos los datos de estudiantes en el tema 5) El objeto DataAdapter es el que permite
rellenar de datos el DataSet cuando existe una conexión a una base de datos. Esto lo hace mediante
la ejecución de una consulta o el llamado a un procedimiento almacenado y estableciendo una
conexión a la base de datos.
La declaración y uso de un objeto DataAdapter se puede realizar mediante el siguiente código:
Dim strConn As String ="data source=localhost; initial catalog=Universidad;integrated security=true"

Dim Da As New SqlClient.SqlDataAdapter("Select *From Estudiantes", strConn)
En la primera línea de arriba se define la cadena de conexión a la base de datos SQL Server (más
adelante en este mismo tema desarrollamos el mismo) La segunda línea invocamos al adaptador de
datos SQLClient (Cliente SQL) le enviamos una consulta (todos los estudiantes) de una tabla
denominada estudiantes y además le pasamos como parámetro la cadena de conexión.
Existen otras funcionalides importantes de conocer con el DataAdapter. Por ejemplo, las acciones
que se puedan ejecutar sobre los datos que referencia el DataAdapter. Las propiedades del
DataAdapter que permiten estos son:
 SelectCommand: permite recuperar filas de la fuente de datos según la instrucción Select.

 InsertCommand: permite escribir filas insertadas en un DataSet en la respectiva fuente de
datos referenciada por el DataAdapter, quien es el que los relaciona.
 UpdateCommand: escribe filas modificadas en el DataSet a la base de datos referenciada
por el DataAdapter que usa el DataSet.
 DeleteCommand: escribe filas modificadas en el DataSet a la base de datos referenciada
por el DataAdapter que usa el DataSet.
La imagen siguiente muestra la funcionalidad de estas propiedades:

Observa en la imagen que el DataSet es un conjunto de datos almacenados en memoria, los cuales
son marcados con una bandera que indica si el dato fue modificado, eliminado o es un nuevo dato.
Cuando el DataAdapter realiza la sincronización con la base de datos física (indicada en el origen) se
da cuenta de los cambios en el DataSet y procede a ejecutar, sea UpdateCommand, DeleteCommand
o InsertCommand, según corresponda.
A continuación se muestra un trozo de código que muestra el uso de estas propiedades:
'Define la cadena de conexión a la base de datos.

Dim dst as New DataSet
'Crea un adaptador de datos SQL
Dim da As SqlClient.SqlDataAdapter = New SqlClient.SqlDataAdapter
'Crea un objeto de tipo Command (cmd) que es el que permite ejecutar una sentencia SQL o llamar a
'procedimiento almacenado en la base de datos.
Dim cmd As SqlClient.SqlCommand
'Se configura el objeto command (cmd) con un procedimiento almacenado.
cmd = New SqlClient.SqlCommand("SELECT * FROM Estudiantes " & _
"WHERE Provincia = @mProvincia AND Canton = @mCanton", strConn)
'Se configuran los dos parámetros del procedimiento almacenado
cmd.Parameters.Add("@Provincia", SqlDbType.NVarChar, 35)
cmd.Parameters.Add("@Canton", SqlDbType.NVarChar, 35)
'Se ejecuta el comando en el dataAdapter según la configuración del objeto Command
da.SelectCommand = cmd
'Se crea la inserción de un registro.
cmd = New SqlClient.SqlCommand("INSERT INTO Estudiantes (CarnetID, Nombre) " & _
"VALUES (@mCarnetID, @mNombre)", strConn)
'Se configura el objeto Command (cmd) con los parámetros requeridos por el procedimiento
cmd.Parameters.Add("@mCarnetID", SqlDbType.NChar, 15, "CarnetID")
cmd.Parameters.Add("@mNombre", SqlDbType.NVarChar, 50, "Nombre")
da.InsertCommand = cmd
'Llena el DataSet con datos.
da.Fill(dst)
Se puede utilizar un objeto DataTables para poblar un objeto DataSet. El siguiente ejemplo muestra
su utilización:
Dim Da As New SqlClient.SqlDataAdapter("Select *From Estudiantes", strConn)
Dim ds as New DataSet()
Dim Str As String
Dim X,Y As Integer
'Se rellena el DataSet ds y se especifica el DataTable Estudiantes.
Da.Fill(ds, "Estudiantes")
'Se obtienen el número de filas y columnas del objeto DataTable.
X = ds.Tables("Estudiantes").Rows.Count
Y = ds.Tables("Estudiantes").Columns.Count
'Se declara una variable de tipo DataRow para recorrer cada fila del DataTable Estudiantes.
Dim r As DataRow
For Each r In Ds.Tables("Estudiantes").Rows
Str &= r("Carnet")
Str &= r("Nombre")
Next
Se puede observar en el código anterior como se llena el DataSet (ds) por parte del DataAdapter (da)
mediante el método Fill, creando un DataTable denominado "Estudiantes" Posteriormente se lee este
DataTable y se almacena su contenido en una variable de tipo String denominada Str.
Para mostrar datos de un DataSet podemos utilizar un DataGrid o un objeto DataView. En el caso de
un DataGrid podemos utilizar el siguiente código:
DataGrid1.DataSource = ds.Tables("Estudiantes").DefaultView
Un DataGrid es un objeto que se compone de filas y columnas que se parecen a una matríz de datos.
Un DataView es una vista personalizada y enlazable de un único objeto DataTable, en el cual el
usuario puede clasificar, filtrar, buscar, editar y navegar por los datos. El objeto DataGrid también
puede ser configurado para realice la misma función.
Cada objeto DataTable posee una propiedad DefaultView que devuelve la vista predeterminada de la
tabla. El siguiente ejemplo muestra lo anterior:
'Se declara una variable de tipo DataView y se carga con el DataTable Estudiantes
Dim dv As DataView = ds.Tables("Estudiantes").DefaultView
'Se crea un filtro de la vista del DataView. En este caso es por el campo provincia Guanacaste
dv.RowFilter = "Provincia = 'Guanacaste'"
'Una vez filtrado el DataView se procede a ordenar el mismo por el campo Nombre
dv.Sort = "Nombre"
Hemos trabajado hasta aquí la conectividad de datos SQL a través de DataSet y DataTables. A
continuación desarrollaremos el tema de conectividad a través de un DataReader.
Utilización de DataReader
Ya determinamos como utilizar un objeto DataSet para la conectividad de datos con ADO .NET y
como este objeto proporciona una copia desconectada de la base de datos. También determinamos
que la mejor opción para gestionar datos de larga duración en una aplicación Web era mediante
DataSet. Sin embargo, muchos veces solo requerimos realizar pequeñas operaciones de datos como
por ejemplo autenticarse en un sitio Web donde solo utilizamos los datos de usuario y la contraseña.
En este caso, es mejor utilizar un DataReader.
Existen casos en que necesitamos acceder una gran cantidad de registros de una base de datos.
Supongamos que requerimos leer unos 5000 registros de una base de datos y los almacenamos en
un objeto DataTable. Se requerirá memoria para que el DataTable almacene esa cantidad de
registros. Si se conectan 100 usuarios y realizan la misma consulta se requerirá la cantidad de
memoria requerida por los 5000 registros para los 100 usuarios conectados ¡Esto es un factor crítico
de uso de memoria! En este tipo de situaciones el objeto DataReader, el cual está diseñado para
generar un flujo de solo lectura (Read Only) y solo hacia delante (Forward Only) Por tanto, solo se
almacena 1 registro en memoria cada vez en el servidor.
Se ha demostrado que un DataReader es mucho más rápido que un DataSet (vea:

http://msmvps.com/blogs/cwalzer/archive/2007/09/24/anti-pr-225-cticas-i-acceso-a-datos-con-ado-
net.aspx) Esta diferencia se debe a que el objeto DataSet están sobrecargados por la capacidad que
tienen de leer y escribir datos, examinar hacia delante y hacia atrás. El DataReader, por su parte,
solamente lee y recorre los datos hacia delante.
ADO .NET incluye dos tipos de objetos DataReader: sqlDataReader y OleDbDataReader. El primero
es proveedor de datos exclusivamente para la gestión de datos en SQL Server y el segundo para
cualquier otro proveedor de datos. Los objetos SqlCommand y OleDbCommand, conjuntamente con
el método ExecuteReader sirven para transferir datos a un objeto DataReader.
Un objeto DataReader tiene las siguientes características:
 La conexión de un DataReader a una fuente de datos debe gestionarse por si misma. Es

decir, la conexión a una fuente de datos debe realizarse manualmente a diferencia del
DataAdapter que abre y cierra una conexión automáticamente.
 La navegación entre registros debe realizarse programáticamente en el DataReader. También
se puede realizar mediante vinculación de un control enlazado a lista. En ambos casos
debemos escribir el código necesario para que se realice.
 Al estar los datos cargados en memoria, el DataReader consume menos recursos del
servidor.
Para utilizar un objeto DataReader se deben considerar los siguientes pasos:
1. Crear una conexión a la fuente de datos con el objeto requerido. Para una base de datos
SQL Server sería un objeto SQLConnection y para otras OleDbConnection.
2. Abrir la conexión a la fuente de datos.
3. Crear un objeto Command en lugar del DataAdapter.
4. Crear un objeto DataReader desde el objeto Command.
5. Invocar al objeto ExecuteReader
6. Utilizar el objeto DataReader
7. Cerrar el objeto DataReader
8. Cerrar la conexión a la fuente de datos
Se puede utilizar el controlador de excepciones Try … Catch … Finally como aglutinador de los pasos
anteriores.
A continuación se presenta un trozo de código como ejemplo de manejo del objeto DataReader:

Dim objConn as New SqlConnection(strConn)
Dim cmdEstudiantes As New Data.SqlClient.SqlCommand("Select *From Estudiantes", objConn)
Try
objConn.Open
Dim dr as sqlDataReader
dr = cmdEstudiantes.ExecuteReader()
Do While dr.Read()
TextBox1.Text = dr.Items("Carnet")
TextBox2.Text = dr.Items("Nombre")
Loop
dr.Close()
objConn.Close()
Catch (e as Exception)
Response.Write(e.message)
End Try
En el ejemplo anterior tenemos un DataReader que mediante un objeto Command se ejecuta y carga
los datos programáticamente en controles TextBox. A continuación te presento el código ejemplo
para vincular un objeto DataReader a un objeto lista.

Dim objConn as New SqlConnection(strConn)
Dim cmdEstudiantes as New SqlCommand("Select *From Estudiantes",objConn)
Dim dr as SqlDataReader
Try
objConn.Open
dr.cmdEstudiantes.ExecuteReader()
lstEstudiantes.DataSource = dr
lstEstudiantes.DataTextField = "Nombre"
lstEstudiantes.DataBind()
dr.Close()
objConn.Close()
Catch (e as Exception)
Response.Write(e.message)
End Try
En el código anterior se vinculan los datos de un DataReader a un objeto ListBox y le almacena los
valores contenidos en uno de sus atributos (el nombre del estudiante)
Autenticación en SQL Server

Existen dos formas de conectarse a una base de datos SQL Server: autenticación en modo mixto y
autenticación en modo solo Windows. El que más se utiliza es el de autenticación mediante
Windows.
Autenticación en modo mixto:
La autenticación en modo mixto utiliza la configuración predeterminada de ASP .NET y de la

aplicación Web. En este caso, cada usuario del sitio Web debe poseer una cuenta de usuario añadida
al grupo Logins de SQL Server. Aquí la debilidad radica en que la autenticación del nombre del
usuario y las contraseñas se envían al servidor SQL Server en formato HTML y no está encriptado.
Esto representa un peligro por cuanto se exponen estos datos a terceros. También se necesita
administrar cuentas de usuario tanto en el servidor Web como en el servidor de SQL Server.
Para conectarse a un servidor SQL Server, utilizando el modo mixto, se puede utilizar la siguiente
cadena de conexión:
Dim strConn As String = "data source=localhost; initial catalog=northwind; user id=egomez;password=1A2X1bc"

Dim conn As New SqlConnection(strConn)
Autenticación en modo Windows:

La autenticación en modo Windows es el método que más se utiliza para realizar conexiones Web a
una base de datos SQL Server. En este tipo de conexión, SQL Server no necesita el nombre del
usuario ni la contraseña para autenticarse, dado que es una conexión de confianza que ha pasado la
autenticación Windows.
La autenticación en modo Windows utiliza una sola cuenta denominada ASPNET para todos los
accesos a SQL Server desde la aplicación WEB y elimina el problema de transmitir los nombres y
contraseñas de usuario no encriptados. Asimismo, se dispensa de la necesidad de mantener cuentas
de usuario tanto en los servidores Windows como en el servidor de SQL Server. En resumen, cuando
los usuarios acceden a un formulario Web lo hacen como usuarios anónimos ASPNET.
Para conectarse a un servidor SQL Server, utilizando el modo Windows, se puede utilizar la siguiente
cadena de conexión:
Dim strConn As String = "data source=localhost; initial catalog=northwind;integrated security=true"

Dim conn As New SqlConnection(strConn)
Cómo cambiar el modo de autenticación de SQL Server

Para cambiar el modo de autenticación de SQL Server ejecute el siguiente procedimiento:
Alternativa 1:
1. Pulse sobre el botón de Inicio de Windows y pulse sobre la opción Administrar de Mi PC.
2. En la consola Administración de equipos expanda la carpeta Servicios y Aplicaciones y la
carpeta Servidores Microsoft SQL Server.
3. Pulse con el botón derecho del mouse en el servidor SQL Server (local) y pulse sobre
Propiedades.
4. En el cuadro de propiedades que aparece Propiedades de SQL Server, en la ficha Seguridad,
haga click sobre el botón de opción SQL Server y Windows o la opción solo Windows de la
sección autenticación. Pulse el botón Aceptar.
Alternativa 2:
1. Pulse sobre el botón de Inicio de Windows y pulse sobre la opción Todos los programas,
Microsoft SQL Server 2005, SQL Server Management Studio.
2. Autentíquese mediante el usuario de Windows.
3. Una vez en el motor de la base de datos pulse con el botón derecho del mouse sobre el
nombre del servidor y seleccione Propiedades.
4. En la opción Seguridad escoja el tipo de autenticación que va a utilizar.
Creación de la base de datos de la aplicación de ejemplo

Para poner en práctica los temas estudiados vamos a desarrollar un sitio Web sencillo denominado
miUniversidad. Este sitio Web utilizará una base de datos denominada dbUniversidad y una serie de
tablas que permitirán el mantenimiento (por parte de los operadores del sitio) como de consultas (de
los usuarios) Por lo tanto, iniciemos con la creación de la base de datos dbUniversidad:
2. Autentíquese mediante el usuario de Windows y Pulse Conectar. Observe la ilustración 43.
Ilustración 43
3. Una vez en el motor de la base de datos pulse con el botón derecho del mouse sobre el
nombre del servidor y seleccione Bases de Datos y seleccione Nueva base de datos...
4. Nombre la base de datos como dbUniversidad y cree el esquema de bases de datos (tablas y
relaciones) La ilustración 44 muestra dicho esquema, con los campos, tipos y longitudes, así
como las relaciones entre tablas. Cuando hayas terminado de crear el diagrama de la base
de datos nómbrala como dgUniversidad.
Ilustración 44
5. Cierra el diseñador de diagrama y ubicando la tabla tbEstudiantes pulsa con el botón derecho
del mouse y selecciona Abrir tabla … e incluye el registro Carnet = 123, Nombre = Enrique
Apellido1 = Gómez Apellido2 = Jiménez, Direccion= La Cruz, Guanacaste, Telefono=
8885083, Clave=123.
6. Puedes cerrar el servidor de bases de SQL Server o minimizarlo por cuanto la próxima tarea a
realizar es crear el Website que utilizará esa base de datos.
Conectividad WebConfig y System.ConfigurationManager

Una vez que hemos creado nuestra base de datos vamos a proceder a crear nuestro sencillo sitio
Web. Lo denominaremos webUniversidad. Antes de eso vamos a resumir un poco lo que es el
WebConfig y System.ConfigurationManager.
¿Qué es Web.Config?
El archivo Web.Config es el principal archivo de configuración y ajustes de una aplicación Web. Es un

documento XML que define la configuración del sitio Web, conteniendo secciones definidas de
conectividad, seguridad, control de sesiones, idioma, etc.
¿Qué es System.ConfigurationManager?
Mediante el ConfigurationManager se puede acceder a las secciones configuradas en el Web.Config

de una aplicación Web. Por ejemplo, obtener la cadena de conexión almacenada en la sección
ConfigurationSetting del Web.Config.
Ahora vamos a crear nuestro sitio webUniversidad. Para ello sigue el siguiente procedimiento:
Microsoft Visual Studio 2008, Microsoft Visual Studio 2008.
2. Cree un nuevo sitio Web denominado webUniversidad. Recuerde que debe ser de tipo HTTP.
3. Una vez creado debemos pulsar sobre el archivo web.config que crea automáticamente el
sitio Web. Si no lo hace debemos agregarlo al proyecto. Para ello pulse con el botón derecho
del mouse sobre el nombre del proyecto (http://localhost/webUniversidad) y Agregar nuevo
elemento… y seleccione web.config en la lista de objetos que se presentan.
4. Pulse sobre el archivo web.config y observe el código que aparece ¡XML! En este archivo
vamos a configurar la sección de connectionString, para establecer una cadena de conexión
que posteriormente vamos a obtener mediante ConfigurationManager. Mejor ciérralo ¡lo
configuraremos utilizando un atajo!
5. Bueno, vamos a incluir la sección connectionString en el web.config. Para ello, estando en el
formulario Web arrastra de la barra de controles el objeto sqlDataSource
al formulario Web
6. Una vez arrastrado el control observa que en la esquina superior derecha se ubica una
pequeña punta de flecha. Si pulsa con el puntero del mouse sobre esta punta de flecha
aparecerá la opción configurar origen de datos.
7. En la ventana que aparece (Elegir la conexión de datos) pulse la opción Nueva Conexión… y
luego en la ventana Elegir origen de datos pulse la opción Microsoft SQL Server y el botón
Continuar.
8. En la ventana Agregar conexión seleccione el nombre del servidor. Póngale (local) Habilite la
opción Utilizar Autenticación Windows y en Seleccionar o escribir nombre de bases de datos
seleccione la base de datos dbUniversidad. Pulse el botón Siguiente.
9. En la pantalla siguiente Guardar la cadena de conexión en el archivo de configuración de la
aplicación habilite la caja de verificación que aparece sobre el nombre por defecto, pero
cámbiele este nombre por connUniversidad.
10. En la siguiente ventana Configurar la instrucción select escoja la tabla tbEstudiantes y pulse
sobre el asterisco que aparece de primero en la descripción de las columnas de la tabla.
Pulse a continuación el botón Siguiente.
11. En la siguiente ventana pulse el botón Finalizar.
12. Elimine el objeto SqlDataSource (paso 5) porque ya no lo necesitará.
13. Pulse sobre el archivo web.config y observe la nueva sección que agrego en el archivo. Es
como sigue:
<connectionStrings>
<add name="connUniversidad" connectionString="Data Source=(local);Initial _
Catalog=dbUniversidad;Integrated Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
14. Con ello ya configuramos el web.config de la aplicación Web que vamos a construir.
Utilización de DataSet y DataReader en la aplicación

ejemplo:
Vamos a desarrollar nuestro primer sitio Web. Como lo hemos señalado anteriormente constituirá un
sitio Web de estudiantes, cursos y sus respectivas notas (ver ilustración 44) Para lo anterior vamos a
crear nuestro primer formulario Web, siendo éste el webLogin. Procedamos entonces a la obra.
15. Ya ha creado el sitio Web webUniversidad. Ha configurado el web.config del sitio y por
defecto se ha creado el primer formulario Web del mismo. Se le ha denominado, por
defecto, default.aspx. Pulse con el botón derecho del mouse sobre este formulario Web y
seleccione la opción Cambiar nombre y póngale webLogin.
16. Antes de programar el formulario Web webLogin vamos a crear otro formulario Web. La idea
es que el primer formulario validará al usuario que desea ingresar a la aplicación Web. Si
está registrado en la base de datos podrá ingresar al sitio, de lo contrario se le desplegará un
mensaje de error. Para crearlo pulse con el botón derecho del mouse sobre el nombre del
proyecto y seleccione Agregar nuevo elemento… y escoja un nuevo Web Form. El nombre
que le debe dar a este formulario es webMenu.
17. Una vez creado el formulario Web webMenu ubíquese en el formulario webLogin y arrastre
hasta el formulario un componente Login. Puede seleccionarlo pulsar la opción Diseño y
Posición y ubicarlo en el centro del formulario Web. Asimismo, pulse sobre la punta de
flecha del control Login y seleccione la opción formato automático. De las opciones que
ofrece escoja elegante.
18. Una vez configurado el control, nuestro primer formulario Web será similar al mostrado en la
ilustración 45.
Ilustración 45
19. Una vez que establecimos este control en nuestro sitio Web procedamos a programarlo.
Para ello pulsa sobre el control Login y escribe el siguiente código:
Protected Sub Login1_Authenticate(ByVal sender As Object, ByVal e As _

System.Web.UI.WebControls.AuthenticateEventArgs) Handles Login1.Authenticate
'Utilizando ConfigurationManager obtenemos de la sección ConnectionString la configuración de
'connUniversidad y la almacenamos en strConn
Dim strConn = ConfigurationManager.ConnectionStrings("connUniversidad").ConnectionString
'Declaramos como String la variable SQL y le asignamos un Select de SQL
Dim SQL$
SQL = "Select *From tbEstudiantes Where CarnetID='" & Login1.UserName & "'"
SQL = SQL & " And Clave = '" & Login1.Password & "'"
'Declaramos la variable de conexión, tipo SQLClient y le asignamos lo contenido en strConn
Dim objConn As New Data.SqlClient.SqlConnection(strConn)
'Declaramos la variable cmdEstudiantes de tipo SQLClientCommand y le pasamos como
' parámetro el SQL para obtener los datos y la conexion de donde los obtendrá
Dim cmdEstudiantes As New Data.SqlClient.SqlCommand(SQL, objConn)
Try
'abrimos la conexión si está cerrrada
If objConn.State = Data.ConnectionState.Closed Then objConn.Open()
'declaramos un objetos de tipo SQLDataReader
Dim dr As Data.SqlClient.SqlDataReader
'ejecutamos el objeto de tipo SQLCommand y el resultado lo almacenamos en el DataReader
'(dr)
'leemos el DataReader
dr.Read()
'preguntamos que si tiene al menos una fila de datos
If dr.HasRows Then
'si hay datos nos redirecciona al formulario Web del menu
'guardamos dos variables tipo sesión para utilizarlas luego.
Session.Add("Usuario", dr.Item("Nombre") & " " & dr.Item("Apellido1") & " " & _
dr.Item("Apellido2"))
Session.Add("Clave", dr.Item("Clave"))
Response.Redirect("webMenu.aspx")
Else
Response.Write("Usuario NO Existente")
End If
'cerramos el DataReader
dr.Close()
'Cerramos la conexion
If objConn.State = Data.ConnectionState.Open Then objConn.Close()
'No ponemos nada dado que el objeto Login valida los datos
End Try
End Sub
20. Ejecutemos el sitio Web y cuando se habilite el formulario Web webLogin escribamos en el
usuario un nombre y contraseña cualquiera. Veamos que pasa. Probablemente te muestre
el error de “Usuario o contraseña inválida” Ahora prueba con usuario=123 y
contraseña=123. Ahora podrás notar que se accedió a la página WebMenu.
21. En el formulario webMenu, agregue el siguiente código:
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load

'recupera la variable de sesion "Usuario"
Dim NombreUsuario = Session("Usuario")
If Date.Now.Hour > 12 Then
'Muestra en el formulario el titulo respectivo.
Page.Title = "Buenas Tardes " & NombreUsuario
Else
Page.Title = "Buenos días " & NombreUsuario
End If
End Sub
22. En el formulario Web webMenu proceda a colocar los objetos que se le indican en la
siguiente tabla:

Image1 ImageURL AG001g3.GIF
Image2 ImageURL miUniversidad.jpg
ImageButton1 ImageURL Connected_multiple.jpg
ImageButton2 ImageURL Wi0054-48.gif
ImageButton3 ImageURL Contract.gif
ImageButton4 ImageURL Folder_view.gif
Hyperlink1 Text Mantenimiento de Estudiantes
Hyperlink2 Text Mantenimiento de Cursos
Hyperlink3 Text Mantenimiento de Notas
Text Mi Universidad es una entidad sin animo
TextBox1 de lucro. Orientada a la creación de
profesionales de gran calidad técnica.
TextMode Multiline
Tabla No. 9
23. El formulario web creado se muestra en la ilustración 46.
Ilustración 46
24. Pudimos utilizar un control menú para crear las opciones en lugar de los botones de imagen,
pero se consideró un poco menos modesto el crearlo con estos botones.
25. Una vez creado el formulario principal (webMenu) vamos a crear tres formularios más para
terminar nuestro sitio: webEstudiantes, webCursos, webEvaluaciones y webConsultas. Para el
caso del formulario webConsultas elaboraremos dos formularios más denominados
webConsultaPorMateria y webConsultaGeneral.
26. En cada imageButton debe colocar la instrucción para que ejecute cada formulario. La
instrucción es: response.redirect(“nombreformulario.aspx”) Por ejemplo, en el caso del
imageButton de Mantenimiento de estudiante debe colocarse la instrucción
response.redirect(“webEstudiantes.aspx”) En el caso de los Hyperlink debe pulsar con el
botón derecho del mouse sobre cada uno de ellos y configurar la propiedad NavigateURL
pulsar sobre el botón que aparece a un lado de la descripción y seleccionar el formulario
respectivo. En el caso del hyperlink debajo del imageButton Mantenimiento de Estudiantes
debe seleccionarse el formulario Web webEstudiantes en este hipervínculo.
27. Una vez creados los formularios Web anteriormente indicados, procederemos a programar
cada formulario por separado. Estos son los procedimientos para cada uno de ellos:
Formulario Web webEstudiantes:
1. Ubicándonos en el formulario webEstudiantes proceda a colocar los objetos que se indican en

la siguiente tabla:

Label1 Text Carnet:
Label2 Text Nombre:
Label3 Text Apellido 1:
Label4 Text Apellido 2:
Label5 Text Dirección:
Label6 Text Teléfono:
TextBox1 Text
TextBox2 Text
TextBox3 Text
TextBox4 Text
TextBox5 Text
TextBox6 Text
btnAgregar Text Agregar
btnModificar Text Modificar
btnEliminar Text Eliminar
imgBtnBuscar ImageURL SEARCH.gif
imgBtnCancelar ImageURL Up.gif
Tabla No. 10
2. El formulario Web respectivo se muestra en la ilustración 47.
Ilustración 47
Observa que los botones Agregar, Modificar y Eliminar tienen la propiedad Enabled en False.
Es decir, están inicialmente inhabilitados. Lo mismo debes hacer con el imageButton
imgBtnCancelar.
3. Una vez que has terminado de diseñar el formulario para el mantenimiento de estudiantes,
programa en el botón imgBtnBuscar el siguiente código:

Dim SQL$
SQL = "Select *From tbEstudiantes Where CarnetID='" & TextBox1.Text & "'"
Try
Dim dr As Data.SqlClient.SqlDataReader
dr.Read()
If dr.HasRows Then
TextBox2.Text = "" & dr.Item("Nombre")
TextBox3.Text = "" & dr.Item("Apellido1")
TextBox4.Text = "" & dr.Item("Apellido2")
TextBox5.Text = "" & dr.Item("Direccion")
TextBox6.Text = "" & dr.Item("Telefono")
TextBox1.Enabled = False
btnAgregar.Enabled = False
btnModificar.Enabled = True
btnEliminar.Enabled = True
Else
Response.Write("Usuario NO Existente")
TextBox1.Enabled = True
btnAgregar.Enabled = True
btnModificar.Enabled = False
btnEliminar.Enabled = False
End If
imgBtnCancelar.Enabled = True
dr.Close()
End Try
4. En el imgBtnCancelar el código:
LimpiarCajas()
imgBtnCancelar.Enabled = False
5. En el código anterior se incluyó el procedimiento denominado LimpiarCajas() :
Sub LimpiarCajas()
TextBox1.Text = ""
TextBox2.Text = ""
TextBox3.Text = ""
TextBox4.Text = ""
TextBox5.Text = ""
TextBox6.Text = ""
TextBox1.Focus()
End Sub
6. En el botón Modificar incluyamos el siguiente código:

Dim SQL$
SQL = "Update tbEstudiantes Set Nombre ='" & TextBox2.Text & "'," & _
"Apellido1 ='" & TextBox3.Text & "'," & _
"Apellido2 ='" & TextBox4.Text & "'," & _
"Direccion ='" & TextBox5.Text & " '," & _
"Telefono ='" & TextBox6.Text & " '" & _
" Where CarnetID = '" & TextBox1.Text & "'"
Try
cmdEstudiantes.ExecuteNonQuery()
LimpiarCajas()
End Try
7. Y, finalmente, en el botón Eliminar el código:

Dim SQL$
SQL = "Delete From tbEstudiantes Where CarnetID = '" & TextBox1.Text & "'"
Try
cmdEstudiantes.ExecuteNonQuery()
LimpiarCajas()
End Try
8. Pruebe el formulario Web con toda su funcionalidad. Tendremos que realizarle algunas
correcciones de estilo, o quizás de programación, pero eso se lo dejo de tarea.
Finalmente, vamos a crear un formulario de Consulta de Estudiantes

(webConsultaEstudiantesGeneral) donde utilizaremos un DataSet para recuperar los datos. En los
formularios anteriores en todos utilizamos el DataReader como objeto de obtención de datos.
Procedamos entonces a realizar esta última práctica con DataReader para que pasemos al otro tema
donde aterrizaremos con la funcionalidad implementada en estos formularios Web de Estudiantes y
de Consultas pero en Servicios Web.
1. Habilita el formulario web webConsultaEstudiantesGeneral y coloca los objetos que se indican

en la siguiente tabla:

DataGrid1
Label1
Button Text Regresar al Menú
Tabla No. 11
2. El formulario respectivo es el mostrado en la ilustración 48.
Ilustración 48
3. La funcionalidad de este formulario será que cuando se cargue el mismo invocará a un

procedimiento de carga de los datos de los estudiantes actualmente registrados. Para ello
escribe el siguiente código en el evento Load del formulario:
CargarEstudiantes()
4. Siendo el código para CargarEstudiantes() el siguiente:
Sub CargarEstudiantes()
Try
Dim SQL = "Select CarnetID As Carnet, Nombre, Apellido1, Apellido2, Direccion, Telefono _
From tbEstudiantes"
Dim da As New Data.SqlClient.SqlDataAdapter(SQL, objConn)
Dim ds As New Data.DataSet()
da.Fill(ds, "Estudiantes")
Dim X = ds.Tables("Estudiantes").Rows.Count
DataGrid1.DataSource = ds.Tables("Estudiantes").DefaultView
Label1.Text = "Numero de Estudiantes Registrados " & X
End Try
End Sub
5. Finalmente, en el botón Regresar al Menú el código a escribir es el siguiente:
Response.Redirect("webMenu.aspx")
6. Ahora prueba esta página Web.
Hasta aquí hemos programado dos páginas Web de datos utilizando el DataReader y el DataSet. El
tema siguiente trata la misma situación pero utilizando servicios Web.
Autoevaluación
1. Cite y explique los dos tipos de objetos de ADO .NET que permiten la gestión de datos en
ASP .NET.
2. Cite y explique tres casos de cada uno en que se puede utilizar un DataSet para la gestión de
datos en una aplicación ASP .NET.
3. Explique la funcionalidad de un objeto DataSet.
4. Explique la funcionalidad de un objeto DataReader.
5. Defina la funcionalidad de un DataAdapter y las propiedades que le permiten la gestión de
datos en sitios Web ASP .NET.
6. Cite y explique las propiedades de un DataReader en una aplicación ASP .NET.
7. Enumere los pasos requeridos para la utilización de un objeto DataReader.
8. Cite y explique los dos modos de autenticación en SQL Server. ¿Cómo funciona cada modo?
9. Defina que es Web.Config y para que se utiliza en una aplicación Web ASP .NET.
10. Defina y explique la funcionalidad del System.ConfigurationManager en una aplicación Web
ASP .NET.
Casos de Aplicación
1. Considere continuar el desarrollo del sitio Web de la Clínica Dental, agregando la
funcionalidad de una base de datos.
2. Considere el diseño y desarrollo de un sitio Web denominado Oficina Virtual de un banco
determinado. Entre las condiciones básicas se tienen:
a. Una pantalla de logín para la autenticación del usuario. Debe validarse a nivel de
cliente que la longitud de la contraseña sea mayor o igual a 8 caracteres e inferior a
12. Además debe iniciar y terminar con una letra mayúscula y entre ellas debe
haber al menos 4 dígitos.
b. Debe crearse un perfil para administradores del sitio, quienes incluirán los datos de
cuenta del cliente, recibos pendientes de pago (agua, luz, teléfono, etc), los ingresos
(cheques y depósitos, notas de crédito o débito) y préstamos.
c. Un formulario Web para la cancelación de pagos por servicios como agua,
electricidad, teléfono, televisión por cable, etc.
d. Un formulario Web para la cancelación de préstamos (sean del cliente o de otro
cliente) El monto a cancelar (sea la cuota o el préstamo total) debe ser menor o
igual al contenido económico de la cuenta a devengar.
e. Un formulario Web para transferencia de fondos entre cuentas (no de una misma
cuenta) Se permite la transferencia de debe ser de una cuenta del cliente a cualquier
otra cuenta del banco. NO podrá superarse el monto de la cuenta origen.
f. Un formulario para cambio de contraseñas.
g. Un formulario para atención de consultas.
TEMA 9: Procedimientos almacenados SQL
Los procedimientos almacenados constituyen una forma de escribir código en una base de datos con
el fin de que realice una determinada operación. Generalmente se escriben en un lenguaje de bases
de datos propietarios como PL/SQL para Oracle o PL/PgSQL para PostgreSQL. La ventaja de un
procedimiento almacenado es que al ejecutarse, ante una solicitud de usuario, lo hace directamente
en el motor de la base de datos, por lo que su rendimiento es mayor. El procedimiento almacenado
se encuentra precompilado en la base de datos.
Definición de procedimiento almacenado

Un procedimiento almacenado se puede definir como:
"programa (o procedimiento) que se almacena físicamente en una base de datos que realiza
alguna operación sobre ella”
Un procedimiento almacenado contiene código SQL que puede, entre otras cosas, seleccionar una
colección de registros, insertarlos, actualizarlos o eliminarlos. También pueden alterar la estructura
de una base de datos, cambiando sus columnas, insertándolas, eliminándolas o actualizándolas.
Existen 3 tipos de procedimientos almacenados:
1. Procedimiento almacenado que retorna registros: Se utilizan para buscar registros

específicos, ordenar o filtrarlos y generar un resultado el cual se almacenan en un DataSet o
en un control de lista. Se basan en instrucciones SQL. Ejemplo: las notas de los estudiantes
del último ciclo lectivo, los cuales se almacenan en un DataSet o en un ListBox.
2. Pocedimiento Almacenado que retorna un valor: Se utilizan para ejecutar un comando en
una base de datos o una función que retorne un valor único. Generalmente, esta devolución
se almacena en una variable. Por ejemplo, obtener el promedio de un curso específico de
todas las notas registradas de ese curso durante el ciclo lectivo anterior.
3. Procedimiento almacenado que realiza una acción:Se utiliza para realizar una determinada
acción en una base de datos. No retorna ningún valor ni ningún registro. Se usan
principalmente para realizar actualizaciones (inserciones, actualizaciones y eliminaciones) en
una base de datos. Por ejemplo, actualizar los datos de un determinado estudiante.
Usos de procedimientos almacenados

Algunos usos que se le dan a los procedimientos almacenados son:
1. Validación de datos mediante Triggers (disparadores o dispatch)

2. Encapsular un proceso grande o complejo.
3. Programar una consulta genérica de mucho uso.
Los procedimientos almacenados son ventajosos en el sentido que se puede incluir la lógica de una
aplicación directamente en la base de datos.
Creación de Procedimientos Almacenados.
Según la necesidad podemos crear procedimientos almacenados para seleccionar, agregar, actualizar
o eliminar registros en una base de datos. Nos interesan estas operaciones aunque existen otras que
se pueden realizar sobre la base de datos.
Vamos a obviar en este material la sintaxis estricta de la creación de un procedimiento almacenado,

citando la forma simple que utilizaremos para crearlos para nuestro sitio Web. Esta sintaxis básica es
la siguiente:
CREATE PROCEDURE <nombre_procedimiento> [ { @parameter data_type } ] [ ,...n ]

AS <Sentencia SQL> [ ...n ]
En el caso anterior el nombre del procedimiento es obligatorio necesitamos saber como se llama el
procedimiento! Asimismo, los parámetros son opcionales pero la sentencia SQL es obligatoria.
A continuación crearemos unos ejemplos que servirán también para utilizarlos en nuestro sitio Web.
Creación de los procedimientos almacenados de la

aplicación ejemplo
A continuación se presentan los procedimientos almacenados que nos servirán en nuestra aplicación.
2. Autentíquese mediante el usuario de Windows y Pulse Conectar. Observe la ilustración 43.
3. Expanda la carpeta nombrada Bases de Datos y ubique la base de datos dbUniversidad.
Expándala y busque las carpetas Programación y Procedimientos almacenados.
4. Pulse con el botón derecho del mouse sobre la carpeta Procedimientos almacenados y seleccione
la opción Nuevo procedimiento almacenado. En el editor borre lo que aparece y escriba el
siguiente código:
-- ================================================
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author: Enrique Gomez Jimenez
-- Create date: Abril 22, 2008
-- Description: Permite buscar un estudiante
-- =============================================
CREATE PROCEDURE ValidarUsuario @prmCarnetID char(10),
@prmClave char(10)
AS SELECT *FROM tbEstudiantes
Where tbEstudiantes.CarnetID = @prmCarnetId
AND tbEstudiantes.Clave = @prmClave
GO
5. Ubique el botón Ejecutar, el cual aparece ligeramente arriba del editor de procedimientos y
púlselo. Cierre el editor de código.
6. Ahora crearemos cuatro procedimientos almacenados más, a saber:
 Un procedimiento para insertar los datos de estudiantes: IncluirEstudiante.
 Un procedimiento para modificar datos de un estudiante: EditarEstudiante.
 Un procedimiento para eliminar los datos de un estudiante: BorrarEstudiante.
 Un procedimiento para listar las notas de un determinado estudiante: MostrarNotas.
7. El código para el procedimiento IncluirEstudiante es:
set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
go
-- =============================================
-- Description: Permite agregar un estudiante
-- =============================================
Create PROCEDURE IncluirEstudiante(@pCarnetID char(10),
@pNombre varchar(100), @pApellido1 varchar(50), @pApellido2 varchar(50),
@pDireccion varchar(200), @pTelefono char(15))
AS
Insert Into tbEstudiantes(CarnetId,Nombre,Apellido1,Apellido2,Direccion,Telefono)
Values(@pCarnetID,@pNombre,@pApellido1,@pApellido2,@pDireccion, @pTelefono)
8. El código para el procedimiento EditarEstudiante es:
set ANSI_NULLS ON
go
-- =============================================
-- Description: Permite modificar un estudiante
-- =============================================
Create PROCEDURE EditarEstudiante(@pCarnetID char(10),
@pNombre varchar(100), @pApellido1 varchar(50), @pApellido2 varchar(50),
@pDireccion varchar(200), @pTelefono char(15))
AS
Update tbEstudiantes set nombre=@pNombre, Apellido1=@pApellido1,
Apellido2 = @pApellido2, Direccion = @pDireccion, Telefono = @pTelefono
Where CarnetId = @pCarnetID
9. El código para el procedimiento BorrarEstudiante es:
set ANSI_NULLS ON
go
-- =============================================
-- Description: Permite Eliminar un estudiante
-- =============================================
Create PROCEDURE BorrarEstudiante(@pCarnetID char(10))
AS
Delete From tbEstudiantes Where CarnetId = @pCarnetID
10. El código para el procedimiento MostrarNotas es:
set ANSI_NULLS ON
go
-- =============================================
-- Description: Permite modificar un estudiante
-- =============================================
CREATE PROCEDURE MostrarNotas(@pCarnetID char(10))

AS
SELECT dbo.tbCursos.CursoID, dbo.tbCursos.Nombre, dbo.tbCursos.Creditos,
dbo.tbCursosEstudiante.CarnetId, dbo.tbCursosEstudiante.Nota_Obtenida
FROM dbo.tbCursos INNER JOIN
dbo.tbCursosEstudiante ON dbo.tbCursos.CursoID = dbo.tbCursosEstudiante.CursoID
WHERE (dbo.tbCursosEstudiante.CarnetId = @pCarnetID)
11. Con esto ya hemos programado los procedimientos básicos de nuestro sitio Web.
Funciones en SQL Server

Ya hemos citado que los procedimientos almacenados pueden definir reglas de negocios sencillas o
complejas. También controlar la modificación de datos, limitar los accesos a los datos, proporcionar
integridad a las transacciones que se realicen sobre la base de datos, etc.
Existen también funciones definidas por el usuario, la cual es una rutina que encapsula lógica útil
para utilizar en otras consultas. Las vistas, por ejemplo, las cuales están limitadas a una sola
instrucción SELECT pueden ser sustituidas por funciones, las cuales si pueden tener varias
instrucciones SELECT. Estas funciones de usuario devuelven un determinado valor, pudiendo ser
también un conjunto de datos.
Un ejemplo de función es:
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =====================================================
-- Author: Enrique Gómez Jiménez
-- Create date: 14/04/08
-- Description: Crear una función que devuelva una tabla
-- de notas segun carnet del estudiante.
-- =====================================================
CREATE FUNCTION fn_Notas
( @Carnet char(10) )
RETURNS table
AS
RETURN (
SELECT tbCursosEstudiante.CarnetId, tbEstudiantes.Nombre, tbEstudiantes.Apellido1,
tbEstudiantes.Apellido2,
tbCursosEstudiante.CursoID, tbCursos.Nombre AS [Nombre Curso], tbCursos.Creditos,
tbCursosEstudiante.Nota_Obtenida As Promedio
FROM tbCursos INNER JOIN
tbCursosEstudiante ON tbCursos.CursoID = tbCursosEstudiante.CursoID INNER JOIN
tbEstudiantes ON tbCursosEstudiante.CarnetId = tbEstudiantes.CarnetId AND
tbCursosEstudiante.CarnetId = tbEstudiantes.CarnetId
WHERE tbCursosEstudiante.CarnetId = @Carnet
)
Para probar esta function basta con escribir la consulta:
select *From fn_Notas('123')
Autoevaluación
1. Defina que es un Procedimiento Almacenado.
2. Enumere y explique los tres tipos de procedimientos almacenados existentes.
3. Explique cuáles usos se les puede dar a un procedimiento almacenado.
4. ¿Cuál es la ventaja de utilizar procedimientos almacenados en la lógica de datos de una
aplicación (puede ser a través de Web Services) Web ASP .NET?
5. Explique para qué son útiles las funciones en SQL.
Casos de Aplicación
1. Cree un procedimiento almacenado que obtenga las notas, con su nombre de curso
respectivo, de un estudiante determinado.
2. Cree un procedimiento almacenado que obtenga los cursos matriculados y los respectivos
nombres de estudiantes.
3. Cree una función que resuelva la misma solicitud del punto anterior.
TEMA 10: Procedimientos almacenados y
Web Services
En el tema anterior incluimos algunos procedimientos en la base de datos. En este tema vamos a
utilizar esos procedimientos almacenados, invocándolos desde Servicios Web.
Creación de Web Services para la utilización en los

procedimientos almacenados
Ahora vamos a crear un servicio Web que encapsule parte de la lógica del sitio Web webUniversidad.
Para ello sigamos los siguientes pasos:
Microsoft Visual Studio 2008, Microsoft Visual Studio 2008.
2. Pulse Archivo y Nuevo sitio Web. Cuando se muestre la pantalla de los diferentes proyectos
que se pueden crear en Visual Studio .NET seleccione Servicio Web ASP .NET Nómbrelo
como wsGestionDatos.
3. Proceda a configurar el web.config de este servicio Web, agregando el siguiente código
(recuerde la lección de configurar el web.config) y sálvelo.
<connectionStrings>
<add name="connUniversidad" connectionString="Data Source=(local);Initial _
Catalog=dbUniversidad;Integrated Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
4. En el editor de código que se muestra, proceda a escribir el código siguiente (sin lo

enfatizado):
Imports System.Web
Imports System.Web.Services
Imports System.Web.Services.Protocols
Imports System.Data.SqlClient
<WebService(Namespace:="http://miUniversidad.ac.cr/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class Service
Inherits System.Web.Services.WebService
Public objConn As New Data.SqlClient.SqlConnection(strConn)
<WebMethod()> Public Sub AbrirCerrarConexion()

Try
If objConn.State = Data.ConnectionState.Closed Then objConn.Open() : Exit Sub
End Try
End Sub
<WebMethod()> Public Sub MuestraNotasEstudiante(ByVal argUsuario$, _

ByRef ds As Data.DataSet)
Dim dataAdapt As New Data.SqlClient.SqlDataAdapter
Dim cmdParametrizado As Data.SqlClient.SqlCommand
Dim prmUsuario As Data.SqlClient.SqlParameter
cmdParametrizado = New SqlCommand("MostrarNotas", objConn)
cmdParametrizado.CommandType = Data.CommandType.StoredProcedure
prmUsuario = cmdParametrizado.Parameters.Add("@pCarnetID", Data.SqlDbType.Char)
prmUsuario.Direction = Data.ParameterDirection.Input
prmUsuario.Value = argUsuario
dataAdapt = New Data.SqlClient.SqlDataAdapter(cmdParametrizado)
dataAdapt.Fill(ds)
End Sub
<WebMethod()> Function ActualizaEstudiante(ByVal wCarnetID$, ByVal wNombre$, _

ByVal wApellido1$, ByVal wApellido2$, ByVal wDireccion$, ByVal wTelefono$, _
ByVal TipoActualiza%) As Boolean
Dim prmCarnet As Data.SqlClient.SqlParameter
Dim prmNombre As Data.SqlClient.SqlParameter
Dim prmApellido1 As Data.SqlClient.SqlParameter
Dim prmApellido2 As Data.SqlClient.SqlParameter
Dim prmDireccion As Data.SqlClient.SqlParameter
Dim prmTelefono As Data.SqlClient.SqlParameter
Try
AbrirCerrarConexion()
If TipoActualiza = 1 Then 'Modifica el registro del estudiante
cmdParametrizado = New SqlCommand("EditarEstudiante", objConn)
Else 'Ingresa información de un nuevo estudiante
cmdParametrizado = New SqlCommand("IncluirEstudiante", objConn)
End If
prmCarnet = cmdParametrizado.Parameters.Add("@pCarnetID", Data.SqlDbType.Char)
prmCarnet.Direction = Data.ParameterDirection.Input
prmCarnet.Value = wCarnetID
prmNombre = cmdParametrizado.Parameters.Add("@pNombre", Data.SqlDbType.Char)

prmNombre.Direction = Data.ParameterDirection.Input
prmNombre.Value = wNombre
prmApellido1 = cmdParametrizado.Parameters.Add("@pApellido1", Data.SqlDbType.Char)

prmApellido1.Direction = Data.ParameterDirection.Input
prmApellido1.Value = wApellido1
prmApellido2 = cmdParametrizado.Parameters.Add("@pApellido2", Data.SqlDbType.Char)

prmApellido2.Direction = Data.ParameterDirection.Input
prmApellido2.Value = wApellido2
prmDireccion = cmdParametrizado.Parameters.Add("@pDireccion", Data.SqlDbType.Char)

prmDireccion.Direction = Data.ParameterDirection.Input
prmDireccion.Value = wDireccion
prmTelefono = cmdParametrizado.Parameters.Add("@pTelefono", Data.SqlDbType.Char)

prmTelefono.Direction = Data.ParameterDirection.Input
prmTelefono.Value = wTelefono
cmdParametrizado.ExecuteNonQuery()
Return True
Return False
End Try
End Function
<WebMethod()> Function EliminarEstudiante(ByVal wCarnetID$) As Boolean

Dim prmCarnet As Data.SqlClient.SqlParameter
Try
cmdParametrizado = New SqlCommand("BorrarEstudiante", objConn)
prmCarnet = cmdParametrizado.Parameters.Add("@pCarnetID", Data.SqlDbType.Char)

prmCarnet.Direction = Data.ParameterDirection.Input
prmCarnet.Value = wCarnetID
cmdParametrizado.ExecuteNonQuery()
Return True
Return False
End Try
End Function
<WebMethod()> Sub ObtenerDatos(ByVal cSQL As String, ByRef ds As Data.DataSet)

Try
'Dim objConn As New Data.SqlClient.SqlConnection(strConn)
Dim da As New Data.SqlClient.SqlDataAdapter(cSQL, objConn)
da.Fill(ds, "Estudiantes")
Catch
End Try
End Sub
<WebMethod()> Function ActualizarDatos(ByVal cSQL As String) As Boolean

Try
Dim cmd As New Data.SqlClient.SqlCommand(cSQL, objConn)
cmd.ExecuteNonQuery()
Return True
Catch
Return False
End Try
End Function
End Class
5. El código anterior nos servirá como clase genérica con la funcionalidad para utilizar los
procedimientos almacenados en la base de datos que creamos y otros métodos que reciben
una cadena SQL y devuelven o no un conjunto de registros.
6. Podemos probar nuestro servicio Web pulsando las teclas CTRL+F5. La pantalla mostrada es
similar a la ilustración 49.
Ilustración 49
7. En el caso de querer realizar la prueba de alguno de los métodos basta con pulsar sobre
cualquiera de ellos. Por ejemplo, podemos probar el método ActualizarEstudiante.
Inmediatamente se desplegará una pantalla donde podemos incluir los datos de Inserción o
de Modificación, los cuales utilizan un mismo método. La pantalla que se muestra es similar
a la ilustración 50.
Ilustración 50
8. Observe que el campo TipoActualiza no es parte de la tabla tbEstudiantes, sino más bien una
variable que me permite indicar si la operación es una actualización (se coloca un 1) o una
inserción (se coloca un 2) En este caso, cuando pulsamos sobre el botón Invocar
ejecutamos el método del servicio Web. Una vez ejecutado (y con resultados positivos) nos
muestra un mensaje como el siguiente:
<?xml version="1.0" encoding="utf-8" ?>

<boolean xmlns="http://miUniversidad.ac.cr/">true</boolean>
9. Observe que nos devuelve un valor true lo que indica que la función se realizó exitosamente,
de lo contrario nos devolvería false.
10. Ya probado el servicio Web y convencidos de que funciona, vamos a generarlo como un
archivo DLL que se pondrá a disposición de los desarrolladores para que lo utilicen. En este
caso ubiquemos en el menú la opción Generar y seleccionamos Generar sitio web.
11. Ya hemos generado nuestro Servicio Web.
Prueba de los Web Services generados

Como ya hemos generado nuestro servicio Web ahora nos corresponde probarlo en el sitio Web que
estamos construyendo. Para ello siga las siguientes instrucciones:
1. Proceda a crear la referencia Web al servicio Web creado. Recuerde lo visto en el tema 4 al
respecto (como crear una referencia a un servicio Web)
2. En el nombre del Servicio Web escriba wsGestionDatos.
3. Vamos a ubicar el formulario Web webConsultaEstudiantesGeneral.aspx y vamos a colocar
un nuevo botón de comando llamado btnPruebaWS que pueda invocar al servicio Web. El
titulo del botón será Probar WebService. En ese botón debemos escribir el siguiente código:
Dim aux As New wsGestionDatos.Service

aux.AbrirCerrarConexion()
Dim SQL$
SQL ="Select CarnetID As Carnet, Nombre, Apellido1, Apellido2, Direccion, Telefono "
SQL = SQL & " From tbEstudiantes"
aux.ObtenerDatos(SQL, dst)
Dim X = dst.Tables("Estudiantes").Rows.Count
DataGrid1.DataSource = dst.Tables("Estudiantes").DefaultView
Label1.Text = "Numero de Estudiantes Registrados " & X
4. En este formulario en el evento Load estaba el llamado a un método local para cargar los
datos de estudiante. Debes inhabilitarlo anteponiendo una comilla simple (como comentario)
para que se utilice solo el código del botón btnPruebaWS.
5. Ejecuta este formulario Web y observa como el resultado es el mismo que utilizando el
código en la misma página a diferencia que ahora lo hace invocando el servicio Web.
Prueba del Servicio Web con el formulario webCursos:
6. Ubíquese en el formulario webCursos. Para ello debe colocar los objetos que se le indican en
la siguiente tabla:

Label1 Text Código del Curso:
Label2 Text Nombre del Curso:
Label3 Text Créditos:
TextBox1 Text
TextBox2 Text
TextBox3 Text
btnAgregar Text Agregar
btnModificar Text Modificar
btnEliminar Text Eliminar
imgBtnCancelar ImageURL Up.gif
Tabla No. 12
7. El formulario Web respectivo es el mostrado en la ilustración 51.

Ilustración 51
8. El código que contendría este formulario Web en la parte de declaraciones generales sería el
siguiente:

Dim SQL$
9. En el método LimpiarCajas:
Sub LimpiarCajas()
TextBox2.Text = ""
TextBox3.Text = ""
imgBtnCancelar.Enabled = False
TextBox1.Text = ""
TextBox1.Focus()
End Sub
10. En el botón de imagen imgBtnBuscar:
Protected Sub imgBtnBuscar_Click(ByVal sender As Object, ByVal e As _

System.Web.UI.ImageClickEventArgs) Handles imgBtnBuscar.Click
SQL$ = "Select *From tbCursos Where CursoID = '" & TextBox1.Text & "'"
Try
aux.ObtenerDatos(SQL, dst)
If dst.Tables(0).Rows.Count > 0 Then
TextBox2.Text = dst.Tables(0).Rows(0).Item(1)
TextBox3.Text = dst.Tables(0).Rows(0).Item(2)
btnModificar.Enabled = True
btnEliminar.Enabled = True
TextBox1.Enabled = False
Else
btnAgregar.Enabled = True
End If
imgBtnCancelar.Enabled = True
Response.Write("No hay datos")
End Try
End Sub
11. En el botón de imagen imgBtnCancelar:
Protected Sub imgBtnCancelar_Click(ByVal sender As Object, ByVal e As _

System.Web.UI.ImageClickEventArgs) Handles imgBtnCancelar.Click
btnAgregar.Enabled = False : btnModificar.Enabled = False : btnEliminar.Enabled = False
LimpiarCajas()
End Sub
12. En el método Procesar:
Sub Procesar()
Try
aux.ActualizarDatos(SQL)
End Try
LimpiarCajas()
End Sub
13. En los botones de agregar, modificar y eliminar:
Protected Sub btnAgregar_Click(ByVal sender As Object, ByVal e As System.EventArgs) _

Handles tnAgregar.Click
SQL = "Insert Into tbCursos(CursoID,Nombre,Creditos)"
SQL = SQL & " Values('" & Trim(TextBox1.Text) & "','" & Trim(TextBox2.Text) & _
"'," & Val(TextBox3.Text) & ")"
Procesar()
End Sub
Protected Sub btnModificar_Click(ByVal sender As Object, ByVal e As System.EventArgs) _

Handles btnModificar.Click
SQL = "Update tbCursos set Nombre = '" & TextBox2.Text & "',Creditos=" & _
Val(TextBox3.Text)
SQL = SQL & " Where CursoID = '" & TextBox1.Text & "'"
Procesar()
End Sub
Protected Sub btnEliminar_Click(ByVal sender As Object, ByVal e As System.EventArgs) _

Handles btnEliminar.Click
SQL = "Delete From tbCursos "
SQL = SQL & " Where CursoID = '" & TextBox1.Text & "'"
Procesar()
End Sub
14. Ya puedes ejecutar el formulario de mantenimiento de cursos y probar su funcionalidad.

Observa que aquí utilizamos el servicio Web desarrollado y en éste el objeto DataSet.
Prueba del Servicio Web con el formulario webConsultasCursos:
15. Vamos a crear un nuevo formulario Web denominado webConsultaCursos. La tabla siguiente
muestra los objetos que debes incluir en éste:

Label1 Text Carnet:
Label2 Text Nombre Estudiante:
Label3
TextBox1 Text
btnRegresar Text Regresar al Menú
Tabla No. 12
16. El formulario respectivo es como el mostrado en la ilustración 52
Ilustración 52
17. El código que debe agregar en este formulario Web es:
Protected Sub imgBtnBuscar_Click(ByVal sender As Object, _

ByVal e As System.Web.UI.ImageClickEventArgs) Handles imgBtnBuscar.Click
Dim SQL$
'Probando la funcion fn_Notas grabada en la base de datos dbUniversidad
SQL = "select *From fn_Notas('" & Trim(TextBox1.Text) & "')"
Try
Dim Da As New Data.SqlClient.SqlDataAdapter(SQL, objConn)
Dim dst As New Data.DataSet()
Da.Fill(dst, "Estudiantes")
If dst.Tables("Estudiantes").Rows.Count = 0 Then
Label3.Text = "No hay datos para este carnet..."
DataGrid1.DataSource = Nothing
Exit Sub
End If
Dim NombreCompleto As String = ""
Dim i%
For i = 1 To 3
NombreCompleto = NombreCompleto & dst.Tables(0).Rows(1).Item(i).ToString() & " "
Next
Label3.Text = NombreCompleto
Dim r As Data.DataRow
Dim dst2 As New Data.DataSet
Dim dt As New Data.DataTable
dt.Columns.Add(New Data.DataColumn("Carnet", GetType(String)))
dt.Columns.Add(New Data.DataColumn("Nombre del Curso", GetType(String)))
dt.Columns.Add(New Data.DataColumn("Creditos", GetType(String)))
dt.Columns.Add(New Data.DataColumn("Promedio", GetType(Integer)))
For Each r In dst.Tables("Estudiantes").Rows
Dim dr As Data.DataRow
dr = dt.NewRow
dr("Carnet") = r.Item("CursoID")
dr("Nombre del Curso") = r.Item("NombreCurso")
dr("Creditos") = r.Item("Creditos")
dr("Promedio") = r.Item("Promedio")
dt.Rows.Add(dr)
Next
dst2.Tables.Add(dt)
DataGrid1.DataSource = dst2.Tables(0)
End Try
End Sub
18. Ahora probemos nuestro formulario Web. Pulsa CTRL F5 y lo que debe mostrarse, tras digitar
un carnet válido y pulsar el botón de consultar, es similar a la ilustración 53.
Ilustración 53
Con este formulario Web cumplimos con diseñar una consulta de notas por estudiante. Como te
darás cuenta dichas notas fueron incluidas directamente en la tabla tbCursosEstudiante, por lo que a
continuación diseñaremos el formulario de inclusión de notas. Lo llamaremos webEvaluaciones.
Iniciemos su diseño:
1. Crea un nuevo formulario Web denominado webEvaluaciones. Si ya lo habías creado

simplemente habilítalos para incluir los siguiente objetos:

Label1 Text Carnet:
Label2 Text Nombre Estudiante:
Label3 Text Código Curso:
Label4 Text Nombre Curso:
Label5 Text Nota Obtenida:
Label6 Name lblNombreEstudiante
Label7 Name lblCodigoCurso
Label8 Name lblNombreCurso
TextBox1 Text
TextBox1 Text
Button Name btnAgregar
imgVerEstudiantes ImageURL SEARCH.gif
imgVerCursos ImageURL SEARCH.gif
DataGrid1 Name dgEstudiantes
DataGrid2 Name dgCursos
Tabla No. 13
2. El formulario Web correspondiente a la tabla 13 se muestra en la ilustración 54.

Ilustración 54
3. El código respectivo a este formulario Web es el siguiente:
En las declaraciones generales del formulario Web:
En el load del formulario:
CargarDatos("select *From tbCursos", 1)

CargarDatos("select *From tbEstudiantes", 2)
El método CargarDatos es el siguiente:
Sub CargarDatos(ByVal SQL$, ByVal Opcion%)

Try
Dim Da As New Data.SqlClient.SqlDataAdapter(SQL, objConn)
Dim dst As New Data.DataSet()
Dim dst2 As New Data.DataSet
Da.Fill(dst, "Estudiantes")
Dim r As Data.DataRow
Dim dt As New Data.DataTable
If Opcion = 1 Then
dt.Columns.Add(New Data.DataColumn("Codigo Curso", GetType(String)))
dt.Columns.Add(New Data.DataColumn("Nombre del Curso", GetType(String)))
dt.Columns.Add(New Data.DataColumn("Creditos", GetType(String)))
Else
dt.Columns.Add(New Data.DataColumn("Carnet", GetType(String)))
dt.Columns.Add(New Data.DataColumn("Nombre del Estudiante", GetType(String)))
End If
For Each r In dst.Tables("Estudiantes").Rows

Dim dr As Data.DataRow
dr = dt.NewRow
If Opcion = 1 Then
dr("Codigo Curso") = r.Item("CursoID")
dr("Nombre del Curso") = r.Item("Nombre")
dr("Creditos") = r.Item("Creditos")
Else
dr("Carnet") = r.Item("CarnetID")
dr("Nombre del Estudiante") = r.Item("Nombre") & " " & _
r.Item("Apellido1") & " " & r.Item("Apellido2")
End If
dt.Rows.Add(dr)
Next
dst2.Tables.Add(dt)
If Opcion = 1 Then
dgCursos.DataSource = dst2.Tables(0)
dgCursos.DataBind()
Else
dgEstudiantes.DataSource = dst2.Tables(0)
dgEstudiantes.DataBind()
End If
End Try
End Sub
En el botón imgVerEstudiantes:
dgCursos.Visible = False
dgEstudiantes.Visible = True
En el botón imgVerCursos:
dgCursos.Visible = True
dgEstudiantes.Visible = False
En el DataGrid1 (dgEstudiantes)
Dim x% = dgEstudiantes.SelectedIndex
TextBox1.Text = dgEstudiantes.Items(x).Cells(1).Text
lblNombreEstudiante.Text = dgEstudiantes.Items(x).Cells(2).Text
En el DataGrid (dgCursos)
Dim x% = dgCursos.SelectedIndex
lblCodigoCurso.Text = dgCursos.Items(x).Cells(1).Text
lblNombreCurso.Text = dgCursos.Items(x).Cells(2).Text
Finalmente, en el botón Agregar:
Dim SQL$
SQL = "Insert into tbCursosEstudiante(CarnetId,CursoID,Nota_Obtenida) Values('"
SQL = SQL & TextBox1.Text & "','" & lblCodigoCurso.Text & "'," & Val(txtNota.Text) & ")"
Try
aux.ActualizarDatos(SQL)
End Try
4. Ahora prueba este formulario Web y observa la funcionalidad de la misma. Solo puedes
agregar notas de cursos por estudiante. Como tarea te dejo que implementes el modificar la
nota de un estudiante por curso y también como eliminar una nota de un curso de un
estudiante.
Finalmente, vamos a crear un formulario Web que agrupe todos los formularios Web de consulta. Lo
denominaremos webConsultas
1. Crea un nuevo formulario Web o si ya lo tenías creado habilítalo.

2. Desde la cejila Exploración de la barra de controles Web, selecciona un Control Menu.
Arrástralo hasta el formulario webConsultas
3. Una vez ahí, configúralo seleccionando la flecha que se encuentra en la esquina superior
izquierda. Escoge la opción Editar elementos del menú … Observa la ilustración 55 para que
te des una idea de la configuración de este tipo de objeto.
Ilustración 55
4. Agrega las opciones:
 Consultas Cursos por Carnet en NavigateUrl escoge: webConsultaEstudiantesGeneral.aspx

 Consultas de Cursos en NavigateUrl escoge: webConsultaCursos.aspx
5. En formato automático, selecciona Multicolor

6. Finalmente, en la propiedad del objeto selecciona horizontal para la propiedad Orientation.
7. En el menú principal del sitio Web (webmenu) habilita el botón y el hipervínculo para que
acceda a este formulario.
Con este formulario Web damos por concluido nuestro sitio Web básico. Estamos conscientes
que falta mucho por hacer, muchas cosas que validar y mejorar. Con la ayuda de tu profesor o
tutor podrás hacerle cambios al sitio, modificar código, mejorar la apariencia, etc. Asimismo, con
las referencias Web y otras ayudas podrás personalmente darle valor agregado a lo que hayas
aprendido en este tema.
TEMA 11: Seguridad en aplicaciones Web
ASP .NET
El tema de la seguridad de las aplicaciones Web es bastante crítico, dado que requiere una cuidadosa
preparación y planificación del esquema que tendrá. Con ASP .NET tenemos de aliados el propio
framework de Visual Studio y IIS (Internet Information Server) Asi las cosas podemos asegurar
nuestras aplicaciones Web aplicando varias a estrategias que conoceremos a continuación.
Descripción de la seguridad para aplicaciones Web

Para iniciar trabajos relacionados con la seguridad de aplicaciones Web debemos saber que ésta se
basa en dos conceptos: autenticación y autorización.
La autenticación es el proceso mediante el cual un sitio Web acepta las credenciales de un usuario y
las verifica.
La seguridad de las aplicaciones Web las podemos orientar en:
 Autenticación basada en Windows.

 Autenticación basada en formularios.
 Autenticación basada en Microsoft® Passport.
Una autorización actúa en función de las credenciales del usuario. Esto es, de acuerdo a su perfil
(que se obtiene mediante la autenticación) se conoce cuales son sus derechos de accesos a los
recursos del sitio Web.
Autenticación basada en Windows

La autenticación basada en Windows utiliza el sistema operativo Windows. ASP .NET conjunta la
autenticación Windows con la autenticación IIS. Esto es, un usuario se autentica en la PC de usuario
mediante sus datos de usuarios en Windows (usuario y contraseña) Una vez autenticado estos datos
pasan por el IIS quien las valida y si son aceptables puede acceder el primer recurso del sitio Web
que es la pagina de Login, por ejemplo. Nuevamente, IIS verifica las credenciales y si son correctas
dirige la solicitud original a la aplicación Web y el usuario recibe la página Web segura.
Ventajas:
 Utiliza la infraestructura Windows existente.

 Se puede controlar el acceso a información confidencial.
Desventajas:
 No se aconseja su utilización en la mayoría de aplicaciones Web.
La autenticación basada en Windows se recomienda en situaciones que una empresa o entidad

dispone de un número fijo de usuarios con cuentas Windows. En este caso, podría pensarse en la
creación de un sitio Web que funcione como una Intranet local. De acuerdo a los perfiles de usuarios
Windows se podrían determinar los recursos de acceso de todos y cada uno de ellos. Por ejemplo,
los funcionarios de Recursos Humanos podrían verse restringidos a tan solo utilizar los recursos de su
sección en el sitio global.
La inconveniencia de este tipo de autenticación es que se basa en usuarios Windows registrados por
lo que su acceso se restringe a que si un usuario desea ingresar al sitio Web debe registrarse primero
en Windows.
Habilitando la autenticación basada en Windows

El proceso de crear seguridad en aplicaciones Web mediante autenticación basada en Windows,
requiere cuatro pasos:
1. Configurar IIS.
2. Configurar la autenticación en el web.config
3. Configurar la autorización en web.config.
4. IIS solicita información de inicio de sesión a los usuarios.
El siguiente código en el web.config de un sitio Web permitiría el uso de la autenticación basada en

Windows:
<?xml version="1.0"?>
<configuration>
<appSettings/>
<connectionStrings/>
<location path="webPrincipal.aspx">
<system.web>
<authorization>
<deny users="?"/>
</authorization>
</system.web>
</location>
<system.web>
<authentication mode="Windows"/>
</system.web>
</configuration>
Observe como en el web.config se configura la autenticación Windows (<authentication

mode="Windows"/>) y se deniega cualquier acceso anónimo (<deny users="?"/>) Por tanto, al
iniciar la ejecución del sitio, lo primero que se mostraría sería una pantalla solicitando autenticación,
tal y como muestra la ilustración 56.
Ilustración 56
Si el usuario y la contraseña están registrados en Windows, entonces podrá accederse el sitio Web.
Autenticación basada en formularios

La autenticación basada en formularios utiliza un sistema donde las solicitudes que no se autentican
son enviadas a un formulario HTML, redireccionandolo en el cliente a través de HTTP. Una vez que
el usuario proporciona las credenciales en el formulario a éste se le suministra una cookie de
autenticación
Ventajas:
 Se considera muy adecuada para aplicaciones de Internet.

 Soporta una variedad importante de clientes Web.
Desventajas:
 Se basa en cookies.
Habilitando la autenticación basada en formularios

La autenticación basada en formularios se puede utilizar si el sitio Web se configura a nivel
personalizado. Esto es, se puede almacenar la información del usuario en sus formularios, sea en el
web.config, en un archivo XML o en base de datos, con la personalización de presentación del sitio.
Depende de las cookies para determinar la identidad del usuario y poder acceder al sitio Web.
Para configurar la autenticación de formularios se deben realizar el siguiente procedimiento:
1. Configurar el modo de autenticación modificando la sección de autenticación en el web.config

de la aplicación Web.
2. Denegar el acceso de usuarios anónimos en uno o más directorios de la aplicación, mediante
la modificación de la sección authorization en los archivos web.config de los directorios
privados.
3. Crear una página de registro con un formulario que permita la identificación de usuarios.
4. Crearse una base de datos con una tabla de usuarios para que la página de identificación de
usuarios pueda validarse contra ella.
El siguiente código permite establecer la seguridad a nivel de formulario:
<?xml version="1.0" encoding="utf-8"?>

<configuration>
<system.web>
<authentication mode="Forms">
<forms name="FormaAutentica.NuevaAuth" loginUrl="webLogin.aspx"
protection="All" timeout="10" path="/">
<credentials passwordFormat="Clear">
<user name="adm" password="myadm"/>
</credentials>
</forms>
</authentication>
<compilation debug="false" />
</system.web>
</configuration>
Del código anterior podemos señalar:
1. En forms name, name es el nombre de la cookie de navegador que contiene la entrada de

autenticación.
2. Login url es la página donde se redireccionará el usuario una vez que se valida
correctamente.
3. Timeout tiempo de duración, en minutos, en los cuales la cookie tiene validez. 30 minutos
es el tiempo por defecto.
4. Protection espefica la protección que se le da a los datos de la cookie. All es el valor por
defecto.
Autenticación de Microsoft® Passport

La autenticación mediante Passport® consiste en un procedimiento centralizado que proporciona
Microsoft® En ella se ofrece una única opción de inicio de sesión y los servicios se inician con un
perfil básico a los sitios suscritos.
Ventajas:
 Existe un único proceso de autenticación para muchos sitios Web.

 No se necesita base de datos para almacenar los datos del usuario.
 Permite personalizar el aspecto de la página de inscripción.
Desventajas:
 Se basa en cookies.
 Hay que pagar una cuota de suscripción.
La autenticación Microsoft® Passport® permite a los usuarios utilizar el mismo nombre de usuario
para varios sitios Web, facilitando que el usuario no olvide su nombre de usuario ni su contraseña
para cada uno de los sitios, dado que es uno para todos. No se requiere una base de datos para
mantener los datos del usuario, dado que es Microsoft® quien se encarga de esa labor.
Habilitando la autenticación basada en Microsoft® Passport®

Los eventos que se presentan cuando se utiliza una autenticación basada en Microsoft® Passport®
se presentan en la ilustración 57. En dicha ilustración se muestra la forma en cómo se opera en este
tipo de autenticación
Ilustración 57

Material Digital 3075 Fundamentos de Programacion Web

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Material Digital 3075 Fundamentos de Programacion Web

Cargado por

Copyright:

Formatos disponibles

UNED

Fundamentos de Programación Web

Autor: Prof. Enrique Gómez Jiménez

Fecha Versión Descripción de Cambios Modificó

Documento digital oficial del curso.

TEMA 2: Creación de Web Forms ........................................... 8

TEMA 3: Agregando código a un Web Form ............................. 18

TEMA 4: Fundamentos de Web Services ................................. 40

TEMA 5: Uso de datos XML ................................................. 50

TEMA 6: Depuración y corrección de errores .......................... 58

Elaboró Revisó Autorizó Versión Clave Página

TEMA 7: Administración del Estado ...................................... 62

TEMA 8: Acceso a datos mediante ADO .NET ........................... 65

TEMA 9: Procedimientos almacenados SQL ............................. 83

TEMA 10: Procedimientos almacenados y Web Services ............. 88

TEMA 11: Seguridad en aplicaciones Web ASP .NET ................. 102

La principal ventaja de ASP es que los servidores de Microsoft® manifestaron siempre su

Visual Studio .NET. El paradigma.

Algunas características de Visual Studio .NET son las siguientes:

 Un IDE para múltiples lenguajes y múltiples tipos de proyectos.

Introducción a NET Framework

Componentes del NET Framework

 Proveer un entorno de programación orientada a objetos que permita el almacenamiento y

Introducción a ASP .NET

Entre las características más importantes de ASP .NET tenemos:

IDE (Intregrated Development Environment)

Ubicación de Proyectos ASP .NET (archivos, http://,

1. Cuando no es posible o no desea instalarse el IIS en el equipo de desarrollo.

Observe la figura 4 para ubicar el servidor IIS.

La habilitación de IIS local puede ser útil en los siguientes casos:

El IIS es un programa que se ejecuta en un equipo servidor y que se encarga de proporcionar

Navegación entre Web Form (response.redirect)

5. A continuación busca en la barra de controles los componentes Label y Button y arrástralos

Objeto Propiedad Valor Inicial

La ilustración 9 muestra esta interface de creación de un nuevo formulario Web.

8. La configuración de este nuevo formulario será similar al primero (default.aspx) con la

Objeto Propiedad Valor Inicial

En realidad, el editor de código viene acompañado de una herramienta denominada

Una vez aquí digital el siguiente código:

En realidad existen tres métodos para agregar código a un Web Form:

1. Ubicando el código en el mismo archivo de contenido. Básicamente, el código se encuentra

El siguiente código es un ejemplo de código en línea.

Por su parte, el código subyacente (que se encuentra en el archivo default.aspx.vb) generó el

Partial Class _Default

Protected Sub btnEjecutar_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles _

¿Cómo trabajan estos dos archivos (aspx y aspx.vb)?

<%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" %>

Uso de eventos del lado del cliente o del servidor

Del lado del servidor:

1. Creación del control que genera el evento en el formulario Web.

Solicitud de página Web

Página Web validada

Controles de validación de ASP

A. REQUIREDFIELVALIDATOR: Se utiliza para comprobar que un control tenga contenido (algún

A continuación vamos a desarrollar un nuevo Sitio Web. Lo denominaremos CustomValidatorVb dado

Objeto Propiedad Valor Inicial

<%@ Page Language="vb" AutoEventWireup="false" Inherits="CustomValidatorVb.WebForm1"

Private Sub CustomValidator1_ServerValidate(ByVal source As System.Object, _

Asignación: Applicattion.Add(“Visitantes”,0)  crea la variable de aplicación Visitantes, con valor

Recuperación: NumVisitantes = Application.Get(“Visitantes”)

Asignación: Session.Add(“Nombre”,TextBox1.Text)  crea la variable de sesión Nombre, con valor

Recuperación: NombreUsuario = Session(“Nombre”)

La tabla de configuración de estos objetos se muestra a continuación:

Objeto Propiedad Valor Inicial