ASP.

NET
Manual del Participante

Curso: ASP.NET
 Tabla de Contenido
1 Overview: ....................................................................................................................... 3
2 Principios:....................................................................................................................... 4
3 ASP.NET vs ASP: .......................................................................................................... 4
4 WebForms: ..................................................................................................................... 5
4.1 <% y %> ................................................................................................................. 6
4.2 WebControls........................................................................................................... 8
4.3 Code Behind ........................................................................................................... 9
4.4 Clases y WebControls .......................................................................................... 12
4.4.1 System.Web.UI.Page.................................................................................... 12
4.4.2 System.Web.HttpRequest............................................................................. 15
4.4.3 System.Web.HttpResponse .......................................................................... 17
4.4.4 Trabajando con HttpResponse y HttpRequest.............................................. 18
4.4.4.1 Cookies ..................................................................................................... 18
4.4.4.2 Manipulando el Response Stream ............................................................ 20
4.4.4.3 Recibiendo Archivos ................................................................................ 22
4.4.5 HttpSession................................................................................................... 24
4.4.6 System.Web.UI.WebControls.Button .......................................................... 27
4.4.7 System.Web.UI.WebControls.Label ............................................................ 27
4.4.8 System.Web.UI.WebControls.TextBox ....................................................... 27
4.4.9 System.Web.UI.WebControls.LinkButton................................................... 28
4.4.10 System.Web.UI.WebControls.ImageButton ................................................ 28
4.4.11 System.Web.UI.WebControls.DropDownList ............................................. 29
4.4.12 DataBinding.................................................................................................. 31
4.4.13 System.Web.UI.WebControls.ListBox ........................................................ 35
4.4.14 System.Web.UI.WebControls.DataGrid ...................................................... 35
4.4.15 System.Web.UI.WebControls.Repeater ....................................................... 37
4.4.16 System.Web.UI.WebControls.CheckBox .................................................... 40
4.4.17 System.Web.UI.WebControls.CheckBoxList .............................................. 41
4.4.18 System.Web.UI.WebControls.RadioButtonList........................................... 43
4.4.19 System.Web.UI.WebControls.Calendar....................................................... 43
4.4.20 System.Web.UI.WebControls.AdRotator .................................................... 44
4.4.21 Validators ..................................................................................................... 46
4.5 WebUserControls y WebCustomControls ........................................................... 49

Curso: ASP.NET
1 Overview:
ASP.NET es un framework de desarrollo construido sobre el CLR que sirve
para desarrollar aplicaciones Web, ASP.NET ofrece varias ventajas
importantes sobre modelos de desarrollo Web anteriores.

Algunas características importantes:

• Mejor desempeño: ASP.NET es código CLR corriendo en el servidor, a

diferencia de sus predecesores interpretados, ASP.NET puede tomar
ventaja de “early binding”, JIT, optimización nativa, servicios de caché,
etc. Esto incrementa dramáticamente el desempeño.
• Poder y Flexibilidad: Como ASP.NET se basa en el CLR, el poder y
flexibilidad de toda la plataforma de .NET esta disponible para el
desarrollo Web. ASP.NET también es independiente del lenguaje.
• Simplicidad: ASP.NET hace fácil realizar tareas sencillas, el framework
de ASP.NET permite construir interfaces de usuario que separan de
manera clara la lógica de la aplicación con la presentación, y logra un
manejo sencillo de eventos.
• Manejabilidad: ASP.NET emplea un sistema de configuración
jerárquico, basado en texto (XML), que simplifica la aplicación de
elementos de configuración al ambiente del servidor y aplicaciones
Web.
• Escalabilidad y disponibilidad: ASP.NET fue diseñado con la
escalabilidad en mente, mejorando el rendimiento en ambientes de
clusters y multiprocesadores. Los procesos son monitoreados por el
runtime de ASP.NET, así, si uno se comporta de manera indebida
(deadlock) un nuevo proceso puede ser creado en su lugar, lo que logra
que la aplicación se encuentre constantemente disponible para manejar
solicitudes.
• Extensibilidad: ASP.NET brinda una arquitectura que permite a los
desarrolladores enchufar su código en el nivel apropiado.
• Seguridad: ASP.NET permite autentificación basada en windows y
configuración por aplicación.

Curso: ASP.NET
2 Principios:

Aun que ASP.NET toma su nombre de la tecnología predecesora de microsoft

(ASP), la diferencia entre ambas son grandes.

ASP.NET es un framework de desarrollo construido sobre el CLR que sirve

para desarrollar aplicaciones Web, ASP.NET ofrece varias ventajas
importantes sobre modelos de desarrollo Web anteriores. Microsoft
reconstruyó completamente ASP.NET, basándose en el CLR y .NET. Se
pueden desarrollar código AP.NET usando cualquier lenguaje soportado por el
framework de .NET. ASP.NET es mas rápido debido a que el sitio Web
completo puede ser precompilado en uno o mas assemblys.

ASP.NET simplifica la transición de desarrolladores desde aplicaciones de

escritorio hacia las aplicaciones Web, permitiendo desarrollar paginas
compuesta de controles similares a las GUI. Un WebControl, como un botón o
etiqueta, funciona de una manera similar a si contraparte GUI, se le pueden
asignar propiedades y puede responder a eventos. Los controls conocen como
renderearse, los WebControls generan HTML que los representan.

ASP.NET promueve el desarrollo de aplicaciones usando un paradigma de UI

manejada por eventos a la vez de la aproximación de scripting.

3 ASP.NET vs ASP:
• Código compilado significa que las aplicaciones corren mas rápido y se
detectan mas errores al momento del desarrollo
• Las metáforas similares a las App GUI hacen mas sencilla la transición
• Un conjunto rico de controles y librerías permiten el desarrollo rápido
de aplicaciones.
• El caché mejora el rendimiento
• Si la aplicación de ASP.NET tiene problemas, el runtime de ASP.NET
descarga el AppDomain y vuelve a cargar la aplicación en un nuevo
AppDomain.

Curso: ASP.NET
4 WebForms:

El frameworw de paginas ASP.NET es un modelo de programación del CLR

escalable que puede ser usado para servir paginas Web generadas
dinámicamente.

Los WebForms de ASP.NET han sido diseñados para atacar un conjunto de

deficiencias claves de los modelos previos, particularmente provee:

• La habilidad de crear y usar controles de UI re-usables que pueden

encapsular funcionalidad común y así reducir la cantidad de código que
un desarrollador Web necesita escribir.
• La habilidad para el desarrollador de estructurar claramente la lógica de
la pagina
• La habilidad para las herramientas de desarrollo de proveer soporte de
diseño WYSIWYG para paginas.

Los WebForms son archivos de texto plano con una extensión aspx. Cuando
un browser solicita un recurso aspx, el runtime de ASP.NET parsea y compila
el archivo en una clase de .NET. Esta clase puede ser usada para procesar
dinámicamente solicitudes entrantes. El aspx es solo compila una ves, en las
siguientes peticiones se rehúsa la clase ya compilada.

Una pagina de ASP.NET puede ser creada simplemente tomando un archivo

existente de HTML y cambiando su extensión. En el siguiente ejemplo una
pagina toma un nombre y lo envía de vuelta al servidor cuando un botón es
presionado.

Ejemplo 1:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<input type="text" name="nombre"> <input type="submit"
value="Enviar">
</form>
</body>
</HTML>

Curso: ASP.NET
 4.1 <% y %>

ASP.NET soporta los bloques <% %> de código por cuestiones de

compatibilidad. Dentro de estos bloque se puede poner código para renderear
alguna parte de la pagina. Para lograr esto se debe de incluir el encabezado
<%@ Page language="c#" %> para indicar en que lenguaje se encuentra el
código de la pagina. En el siguiente ejemplo generamos texto de varios
tamaños usando código inline.

Ejemplo 2:
<%@ Page language="c#"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<div align="center">
<%
int i = 7;
bool Forward = true;
while (i != 8)
{
Response.Write (string.Format (
"<p><font size={0}>Texto en {0}</h{0}></p>", i));
if (Forward)
{
i--;
if (i == -1)
{
Forward = false;
i = 1;
}
}
else
i++;
}
%>
</div>
</form>
</body>
</HTML>

Curso: ASP.NET
Algo que es importante hacer notar, es que a diferencia de ASP, ASP.NET
compila el código dentro de <% %> en vez de interpretarlo.

Aparte de generar contenido, se puede modificar la pagina dependiendo de la

información introducida por el usuario.

Ejemplo 3:

<%@ Page language="c#" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
¿Que tipo de programador eres?
<select name="KindOfCoder">
<%
string[] KindOfCoders = {"Newby", "Script Kiddie",
"Regular", "Bueno", "Hacker", "Guru", "Wizard"};
int OptSelected;
try {
OptSelected = int.Parse
(Request.Form["KindOfCoder"]);
}
catch (Exception)
{
OptSelected = -1;
}
for (int i = 0; i < KindOfCoders.Length; i++)
{

Response.Write (string.Format ("<option

value='{0}'{2}>{1}</option>", i, KindOfCoders[i],
(OptSelected == i ? " selected" :
"")));
}
%>
</select>
<%
if (OptSelected != -1)
Response.Write ("Eres un programador " +
KindOfCoders[OptSelected]);
%>
<input type="submit" value="enviar">
</form>
</body>

</HTML>

Curso: ASP.NET
 4.2 WebControls

Los WebControls son clases re-usable que ofrecen cierta funcionalidad, tiene
propiedades, métodos y eventos. Los WebControls generan código HTML que
los representa cuando la pagina debe ser rendereada. Los WebControls
permiten manejar una pagina ASP.NET de una manera sencilla desde código,
como si se estuviese trabajando con controles de una GUI.

Un aspecto importante de los WebControls es que mantienen su estado entre

postbacks de una pagina.

Ejemplo 4
<%@ Page language="c#" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
Nombre:
<asp:TextBox id="Nombre" runat="server"></asp:TextBox>
Wisdom Level:
<asp:DropDownList id="Tipo" runat="server">
<asp:ListItem Value="Newby">Newby</asp:ListItem>
<asp:ListItem Value="Kiddie">Kiddie</asp:ListItem>
<asp:ListItem Value="So so">So so</asp:ListItem>
<asp:ListItem Value="Hacker">Hacker</asp:ListItem>
<asp:ListItem Value="Guru">Guru</asp:ListItem>
<asp:ListItem Value="Wizard">Wizard</asp:ListItem>
</asp:DropDownList>
<asp:Button id="Button1" runat="server" Text="Just Send
It!"></asp:Button>
</form>
</body>
</HTML>

Los WebControls pueden responder a eventos, cuando esto ocurre se genera

un PostBack al servidor Web. El código del evento debe de estar dentro de un
método dentro de un bloque <script language=”C#” runat=”server”>.

Curso: ASP.NET
Ejemplo 5:
<%@ Page language="c#"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
<script language="c#" runat="server">
void Enviar_Click (object sender, EventArgs args)
{
Response.Write ("Escribistes " + Nombre.Text);
}
</script>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:TextBox id="Nombre" runat="server"></asp:TextBox>
<asp:Button id="Enviar" runat="server" Text="Enviar"
OnClick="Enviar_Click"></asp:Button>
</form>
</body>
</HTML>

4.3 Code Behind

La forma en la que hemos estado desarrollando paginas Web, es algo sucia

como pudieron haber observado, se tiene en un solo documento código
HTML, código javascript del lado del cliente y código ASP.NET del lado del
servidor. Se tiene altamente acoplado la funcionalidad con la interfase grafica.
Para solucionar este problema ASP.NET ofrece algo llamado Code Behind.
Esto consiste en crear una clase que herede de System.Web.UI.Page, la cual
contendrá todos los métodos (principalmente los metos suscritos a eventos)
para la lógica de la pagina. Así cada pagina tiene una clase que contiene su
comportamiento, todas estas se almacenan en un assembly (dll) que se guarda
en el directorio bin del sitio Web. Para enlazar una pagina aspx con una clase
en el encabezado de la pagina se debe de agregar:
<%@ Page language="c#" Inherits="Nombreclase" %>

Curso: ASP.NET
La clase además debe de modificar el comportamiento del método OnInit,
donde se suscribirá a todos los eventos requeridos. Por cada WebControl en
una pagina aspx, debe de existir una variable del tipo de webcontrol que le
corresponda para poder manipularlos, el nombre de la variable deberá ser el id
del WebControl.

A continuación el ejemplo anterior usando code behind.

Ejemplo 6:
<%@ Page language="c#" Inherits="Ejemplo6.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:TextBox id="Nombre" runat="server"></asp:TextBox>
<asp:Button id="Enviar" runat="server"
Text="Enviar"></asp:Button>
</form>
</body>
</HTML>

Curso: ASP.NET
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace Ejemplo6
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.Button Enviar;
protected System.Web.UI.WebControls.TextBox Nombre;

private void Page_Load(object sender, System.EventArgs e)

{

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Enviar.Click += new
System.EventHandler(this.Enviar_Click);
this.Load += new System.EventHandler(this.Page_Load);

private void Enviar_Click(object sender, System.EventArgs e)

{
Response.Write ("Escribistes " + Nombre.Text);
}
}
}

Curso: ASP.NET
 4.4 Clases y WebControls
4.4.1 System.Web.UI.Page

La clase Page representa una pagina ASP.NET. A continuación una lista de las
propiedades, métodos y eventos principales con las que cuenta esta clase.

• Evento Load: Este evento ocurre cuando se carga una pagina debido a
una petición de un cliente. Este evento se ejecuta siempre antes que
cualquier otro evento de algún control.
• Propiedad IsPostBack: Esta propiedad devuelve verdadero cuando la
pagina se esta cargando debido a un PostBack (se disparo algún evento
del lado del cliente), es útil en el cuerpo del evento Load, para realizar
acciones de inicialización solamente la primera vez que se carga la
pagina.
• Propiedad Response: Esta propiedad regresa la instancia de
HttpResponse asignada a la pagina actual. Este objeto representa la
respuesta que se le dará al cliente por su petición y será visto mas
adelante.
• Propiedad Request: Esta propiedad retorna un objeto HttpRequest
asignado a la pagina actual. Este representa la petición del cliente y
será revisado mas adelante.
• Propiedad Session: Retorna una instancia de HttpSessionState que
representa la sesión con el cliente, su uso y utilidad será detallado mas
adelante.
• Propiedad Controls: Regresa una colección de todos los WebControls
contenidos en la pagina actual.
• Evento Error: Se lanza cuando se propaga cualquier unhandled
exception.
• Propiedad IsValid: Devuelve true si todos los validadores activados
devuelven true. Los controles validadores serán vistos mas adelante.
• Metodo MapPath: Devuelve la ubicación en el sistema de archivos de
un PATH absoluto o relativo del servidor Web.
• Metodo ResolveUrl : Devuelve un PATH absoluto al WebServer del
PATH relativo dado.
• Propiedad Validators: Devuelve una colección de WebControls
Validators de la pagina, estos controles serán estudiados mas adelante.

Curso: ASP.NET
Ejemplo Page:
<%@ Page language="c#" Inherits="EjemploPage.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:Button id="FooButton" runat="server"
Text="Click!"></asp:Button>
<asp:Button id="ErrorGenerator" runat="server"
Text="RaiseError"></asp:Button>
</form>
</body>
</HTML>

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace EjemploPage
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.Button ErrorGenerator;
protected System.Web.UI.WebControls.Button FooButton;

private void Page_Load(object sender, System.EventArgs e)

{
Page.res
Response.Write ("Now loading.. " + Page.MapPath
("./Default.aspx") + " => " + Page.ResolveUrl ("./Default.aspx"));
if (Page.IsPostBack)
Response.Write ("<p>Esto es un postback</p>");
else
{
Response.Write ("<p>Esta es la primera vez que se
carga la pagina</p>");
this.ErrorPage = "error.html";
}
}

Curso: ASP.NET
 override protected void OnInit(EventArgs e)
{

InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.FooButton.Click += new
System.EventHandler(this.FooButton_Click);
this.ErrorGenerator.Click += new
System.EventHandler(this.ErrorGenerator_Click);
this.Load += new System.EventHandler(this.Page_Load);
this.Error += new System.EventHandler (Page_Error);

void Page_Error (object sender, EventArgs args)

{
Response.Redirect ("error.html");
}

private void FooButton_Click(object sender, System.EventArgs

e)
{
Response.Write ("<p>Ejecutando evento click!</p>");
}

private void ErrorGenerator_Click(object sender,

System.EventArgs e)
{
throw new Exception ("Error Raiser in action!");
}
}
}

Curso: ASP.NET
 4.4.2 System.Web.HttpRequest

La clase HttpRequest representa un solicitud de un cliente para obtener una

pagina, puede ser accedido a través de la propiedad Request de la clase Page.
Miembros mas importantes:

• Propiedad AcceptTypes: Devuelve un arreglo de cadenas conteniendo

todos los tipos MIME que acepta el cliente.
• Propiedad ApplicationPath: Devuelve un string que contiene el
directorio raíz virtual de la aplicación en el servidor.
• Propiedad Browser: Regresa una instancia de HttpBrowserCapabilities
que contiene la información de las características del navegador del
cliente.
• Propiedad Cookies: Regresa una colección de HttpCookie que
representas las Cookies enviadas por el cliente.
• Propiedad Files: Collecion de HttpPostedFiles que representa los
archivos enviados por el cliente.
• Propiedad Form: Regresa un hashtable que contiene los conjuntos de
clave y valor de la información enviada por el cliente (vía POST).
• Propiedad HttpHeaders: Regresa un hastable con los headers enviados
por el cliente
• Propiedad HttpMethod: Regresa el tipo de método de solicitud (GET,
POST, PUT)
• Propiedad Params: Regresa un hastable con la unión de variables
enviadas por GET, POST, COOKIES y SERVER VARIABLES.
• Propiedad QueryString: Regresa un hastable con los valores enviados
por GET.
• Propiedad RequestType: Regresa el tipo de solicitud (GET, POST).
• Propiedad ServerVariables: Regresa un hastable con las variables de
servidor
• Propiedad UserAgent: Regresa la información del navegador

Ejemplo HttpRequest:

Curso: ASP.NET
<%@ Page language="c#" Inherits="EjemploHttpRequest.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:hyperlink id="Link" runat="server"
NavigateUrl="RequestSender.html">Ir a Request
Sender</asp:hyperlink></form>
</body>
</HTML>

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace EjemploHttpRequest
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.HyperLink Link;

private void Page_Load(object sender, System.EventArgs e)

{
Response.Write ("<p>Listando MIME Types que hacepta el
navegador</p><p>");
foreach (string mime in Request.AcceptTypes)
Response.Write (mime +
"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
Response.Write ("</p><p>" + Request.ApplicationPath +
"</p>");
Response.Write ("<p>Listando valores y claves enviados
por POST</p>");
for (int i = 0; i < Request.Form.Count; i++)
Response.Write (string.Format ("<p>{0} =>
{1}</p>", Request.Form.GetKey (i), Request.Form[i]));
Response.Write ("<p>Listando los HttpHeaders enviados
por el cliente</p>");
for (int i = 0; i < Request.Headers.Count; i++)
Response.Write (string.Format ("<p>{0} =>
{1}</p>", Request.Headers.GetKey (i), Request.Headers[i]));
Response.Write ("<p>Modo de HTTP " + Request.HttpMethod
+ "</p>");

Response.Write ("<p>Listando todos los valores</p>");

for (int i = 0; i < Request.Params.Count; i++)

Curso: ASP.NET
 Response.Write (string.Format ("<p>{0} =>
{1}</p>", Request.Params.GetKey (i), Request.Params[i]));
Response.Write ("<p>Listando valores y claves enviados
por GET</p>");
for (int i = 0; i < Request.QueryString.Count; i++)
Response.Write (string.Format ("<p>{0} =>
{1}</p>", Request.QueryString.GetKey (i), Request.QueryString[i]));
Response.Write ("Request Type " + Request.RequestType);
Response.Write ("<p>Listando las variables de
servidor</p>");
for (int i = 0; i < Request.ServerVariables.Count; i++)
Response.Write (string.Format ("<p>{0} =>
{1}</p>", Request.ServerVariables.GetKey (i),
Request.ServerVariables[i]));
Response.Write ("<p>Estas usando el navegador " +
Request.UserAgent + "</p>");
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Load += new System.EventHandler(this.Page_Load);

}
}
}

4.4.3 System.Web.HttpResponse

La clase HttpResponse representa la respuesta a una solicitud de un cliente,

puede ser accedido a través de la propiedad Response de la clase Page.
Miembros mas importantes:

• Metodo AddHeader: Agrega un http Header a la respuesta de petición.

• Metodo AppendCookie: Agrega una cookie a la respuesta.
• Propiedad ContentEncoding: El encoding en el cual esta codificada la
respuesta (UNICODE, ASCII, UTF7, UTF8, UTF16, etc).
• Propiedad ContentType: El tipo MIME de la respuesta.
• Propiedad OutputStream: El stream de la respuesta.
• Metodo Redirect: Redirecciona al cliente a otra pagina.
• Metodo Write: Escribe en el OutputStream de la respuesta.

Curso: ASP.NET
 4.4.4 Trabajando con HttpResponse y HttpRequest

4.4.4.1 Cookies

Una cookie es un paquete de información enviada por un servidor Web a un

browser, este la almacena y la envía al servidor cada vez que realiza una
petición. Una cookie sirve para almacenar información del usuario entre
solicitud y solicitud, muchas veces se usa para brindar persistencia de estado
en la Web, cuyo protocolo es sin estado por naturaleza (HTTP). Las cookies
pueden tener una fecha de caducidad, llegada tal el browser la eliminara, si no
se especifica esta fecha la cookie será destruida al cerrar el browser. Las
cookies pertenecen al dominio que la genero, no siendo posible enviarlas a
otro dominio distinto del que la genero por cuestiones de seguridad.

Una cookie es representada por la clase HttpCookie, puede ser enviada al

browser a través de un HttpResponse, y puede ser leída por medio de una
HttpRequest.

Ejemplo Cookies:
<%@ Page language="c#" Inherits="Cookies.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:TextBox id="texto" runat="server"></asp:TextBox>
<asp:Button id="Guardar" runat="server" Text="Guardar
Cookie"></asp:Button>
</form>
</body>
</HTML>

Curso: ASP.NET
using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace Cookies
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.TextBox texto;
protected System.Web.UI.WebControls.Button Guardar;

private void Page_Load(object sender, System.EventArgs e)

{
HttpCookie cookie = Request.Cookies["FooCookie"];
if (cookie == null)
Response.Write ("No hay cookie");
else
Response.Write (string.Format ("Cookie con valor
{0}", cookie.Value));
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Guardar.Click += new
System.EventHandler(this.Guardar_Click);
this.Load += new System.EventHandler(this.Page_Load);

private void Guardar_Click(object sender, System.EventArgs e)

{
HttpCookie cookie = new HttpCookie ("FooCookie",
texto.Text);
Response.AppendCookie (cookie);
}
}
}

Curso: ASP.NET
 4.4.4.2 Manipulando el Response Stream

Como se había mencionado, un HttpResponse contiene un Stream que es la

información que se envía de vuelta al usuario, sin embargo ese stream no
requiere ser únicamente de contenido HTML o XML. Se puede hacer que el
stream regrese cualquier tipo de contenido, ya sea generado al vuelo, tomado
de una base de datos o algún otro medio de almacenamiento. Para esto se debe
de especificar el tipo de contenido MIME y escribir directamente en el
Response.OutputSream.

En el siguiente ejemplo se crea una pagina ASP.NET que regresa una imagen
aleatoria generada al vuelo.

Ejemplo DinamicImages:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<META NAME="GENERATOR" Content="Microsoft Visual Studio 7.0">
<TITLE></TITLE>
</HEAD>
<BODY>
<img src="ImageGen.aspx">
</BODY>
</HTML>

<%@ Page language="c#" Inherits="DinamicImages.WebForm1" %>

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace DinamicImages
{
public class WebForm1 : System.Web.UI.Page
{
private void Page_Load(object sender, System.EventArgs e)
{
//Establecemos el MimeType
Response.ContentType = "image/jpeg";
//Obtenemos la cadena de la imagen a generar
string MD5 = "";
System.Security.Cryptography.MD5CryptoServiceProvider
Cryp;
Cryp = new
System.Security.Cryptography.MD5CryptoServiceProvider ();

Curso: ASP.NET
 byte[] tmpBuffer =
System.Text.Encoding.Default.GetBytes (DateTime.Now.Ticks.ToString
().ToCharArray ());
byte[] tmpResC = Cryp.ComputeHash (tmpBuffer);
foreach (byte CharAct in tmpResC)
MD5+= ((CharAct < 16) ? "0" : "") +
CharAct.ToString("x");
MD5 = MD5.Substring (0, 8);
//Generamos la imagen
Bitmap Bmp = new Bitmap (160, 30);
Graphics Imagen = Graphics.FromImage (Bmp);
SolidBrush Brocha = new SolidBrush (Color.White);
Imagen.FillRectangle (Brocha, 0, 0, 160, 30);
Brocha.Color = Color.Black;
Font Fuente = new Font("Arial",24);
StringFormat Alineacion = new StringFormat();
Alineacion.Alignment = StringAlignment.Center;
Imagen.DrawString (MD5, new Font("Arial Black", 18),
Brocha, 80, 0, Alineacion);
//Imprimimos basura
Brocha.Color = Color.Brown;
Pen Lapiz = new Pen(Brocha,1);
Point Punto1 = new Point(0,0);
Point Punto2 = new Point(0,0);
Random RN = new Random (DateTime.Now.Millisecond);
int Inc = RN.Next (6) + 3;
for (int i = Inc; i <= 190; i += Inc)
{
Punto1.Y = 0;
Punto1.X = Punto2.X = i;
Punto2.Y = 30;
Imagen.DrawLine (Lapiz, Punto1, Punto2);
}
//Escribimos en el Response
Bmp.Save (Response.OutputStream, ImageFormat.Jpeg);
Imagen.Dispose ();
Bmp.Dispose ();
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Load += new System.EventHandler(this.Page_Load);
}
}
}

Curso: ASP.NET
 4.4.4.3 Recibiendo Archivos

Un formulario puede contener archivos, los cuales se mandan junto con la

información de la solicitud del cliente, para poder acceder a estos archivos se
usa la propiedad Files de HttpRequest. Note que es necesario asignar la
propiedad enctype un valor de multipart/form-data al formulario para que el
ejemplo funcione correctamente.

Ejemplo de envio de archivos:

<%@ Page language="c#" Inherits="Archivos.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server"
enctype="multipart/form-data">
<INPUT type="file" id="archivo" runat="server">
<asp:Button id="Enviar" runat="server"
Text="Enviar"></asp:Button>
</form>
</body>
</HTML>

Curso: ASP.NET
using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace Archivos
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.Button Enviar;
protected System.Web.UI.HtmlControls.HtmlInputFile archivo;

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Enviar.Click += new
System.EventHandler(this.Enviar_Click);
}

private void Enviar_Click(object sender, System.EventArgs e)

{
for (int i = 0; i < Request.Files.Count; i++)
Request.Files[i].SaveAs (string.Format ("{0}/{1}-
{2}", Page.MapPath ("./files"), DateTime.Today.ToString ("dd-MM-yyyy"),
Request.Files[i].FileName));
Response.Write (string.Format ("{0} files uploaded",
Request.Files.Count));
}

}
}

Curso: ASP.NET
 4.4.5 HttpSession

HttpSession representa una sesión con un cliente, normalmente se accede

con Page.Session. HTTP es un protocolo sin estado, por lo que cualquier
información se pierde entre una solicitud y otra. Para esto existe
HttpSession que logra la conservación de estado en un protocolo sin
estado, para esto almacena la información del estado en memoria o bien en
una base de datos (esto puede configurarse), y le asigna a los clientes
tickets con la id de sesión. Estos la almacenan o bien en una cookie o la
envían como parámetro GET en cama solicitud (esto puede configurarse).
De tal manera que con cada solicitud el servidor recibe el ticket de sesión y
busca la información de sesión para que sea accedida por la pagina
ASP.NET. HttpSession guarda la información deseada en una hastable, la
cual vive durante todo el transcurso de la sesión.

Miembros mas comunes:

• Método Abandon: Elimina la sesión actual.

• Método Add: Agrega un nuevo elemento al hastable de sesión.
• Propiedad IsCookieless: Devuelbe true si no se están usando cookies
para referenciar a la sesión.
• Propiedad IsNewSession: Indica si la sesión ha sido creada en la
solicitud actual.
• Propiedad Mode: Indica si se esta almacenando la sesión en memoria
o en una base de datos.
• Propiedad TimeOut: Indica la cantidad de tiempo entre solicitudes
que causaría la eliminación de la sesión.

Curso: ASP.NET
Ejemplo Sesiones:
<%@ Page language="c#" Inherits="Sesiones.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:TextBox id="Usuario" runat="server"></asp:TextBox>
<asp:Button id="Enviar" runat="server"
Text="Login"></asp:Button>
</form>
</body>
</HTML>
using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace Sesiones
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.TextBox Usuario;
protected System.Web.UI.WebControls.Button Enviar;

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Enviar.Click += new
System.EventHandler(this.Enviar_Click);
}

private void Enviar_Click(object sender, System.EventArgs e)

{
Session["Usuario"] = Usuario.Text;
Response.Redirect ("Inicio.aspx");
}
}
}

<%@ Page language="c#" Inherits="Sesiones.Inicio" %>

Curso: ASP.NET
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>Inicio</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Inicio" method="post" runat="server">
<asp:Button id="Logout" runat="server" Text="Cerrar
cesion"></asp:Button>
</form>
</body>
</HTML>
using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace Sesiones
{
public class Inicio : System.Web.UI.Page
{
protected System.Web.UI.WebControls.Button Logout;

private void Page_Load(object sender, System.EventArgs e)

{
string usuario = Session["Usuario"] as string;
if (usuario == null)
Response.Redirect ("Default.aspx");
Response.Write ("Hola " + usuario);
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Logout.Click += new
System.EventHandler(this.Logout_Click);
this.Load += new System.EventHandler(this.Page_Load);

private void Logout_Click(object sender, System.EventArgs e)

{
Session.Abandon ();
Response.Redirect ("Default.aspx");
}
}
}

Curso: ASP.NET
 4.4.6 System.Web.UI.WebControls.Button

El WebControl Button representa un botón, es representado con

<asp:Button>, cada vez que se presiona se ocasiona un postback, su evento
principal es Click. Este WebControl ya se ha usado en ejemplos anteriores
y no necesita mas explicación.

4.4.7 System.Web.UI.WebControls.Label

Este control representa una etiqueta, se le puede asignar texto con la

propiedad Text, su representacion es <asp:Label>.

4.4.8 System.Web.UI.WebControls.TextBox

Este control es una caja de texto, se puede asignar o leer su contenido con
la propiedad Text. Su evento principal es TextChanged, se debe de
recordar que este evento es lanzado cuando en el lado del cliente se
modifica el contenido y se pierde el foco, es decir, no se lanza por cada
pulsación en el campo, y esto solamente si AutoPostBack es true. La
representación del control es <asp:TextBox>

Ejemplo TextBox:
<%@ Page language="c#" Inherits="EjemploTextBox.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:TextBox id="Caja" runat="server"
AutoPostBack="True"></asp:TextBox>
</form>
</body>
</HTML>

Curso: ASP.NET
using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace EjemploTextBox
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.TextBox Caja;

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Caja.TextChanged += new
System.EventHandler(this.Caja_TextChanged);

private void Caja_TextChanged(object sender, System.EventArgs

e)
{
Response.Write ("se cambio a " + Caja.Text);
}
}
}

4.4.9 System.Web.UI.WebControls.LinkButton

Identico a Button, con la diferencia que este es rendereado como un

hipervínculo en el lado del cliente. La representación del control es
<asp:LinkButton>.

4.4.10 System.Web.UI.WebControls.ImageButton

Identico a Button, con la diferencia que este es rendereado como una

imagen, la imagen a mostrar esta dada por la propiedad ImageUrl. La
representación del control es <asp:ImageButton>

Curso: ASP.NET
 4.4.11 System.Web.UI.WebControls.DropDownList

El control DropDownList contiene varios elementos a seleccionar, cuenta

con un evento SelectedItemChanged y una colección de claves-valor que
son los elementos del combo. La propiedad SelectedItem nos devuelve el
ListItem seleccionado. Su representación es <asp:DropDownList>.

Ejemplo DropDownList:
<%@ Page language="c#" Inherits="EjemploDropDown.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:dropdownlist id="Combo" runat="server"
AutoPostBack="True"></asp:dropdownlist></form>
</body>
</HTML>

Curso: ASP.NET
using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace EjemploDropDown
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.DropDownList Combo;

private void Page_Load(object sender, System.EventArgs e)

{
if (Page.IsPostBack)
return;
Combo.Items.Add (new ListItem ("foo", "bar"));
Combo.Items.Add (new ListItem ("marco", "polo"));
Combo.Items.Add (new ListItem ("napoleon",
"bonaparte"));
Combo.Items.Add (new ListItem ("erick", "raymond"));
Combo.Items.Add (new ListItem ("matt", "groening"));
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Combo.SelectedIndexChanged += new
System.EventHandler(this.Combo_SelectedIndexChanged);
this.Load += new System.EventHandler(this.Page_Load);

private void Combo_SelectedIndexChanged(object sender,

System.EventArgs e)
{
Response.Write (string.Format ("{0} - {1}",
Combo.SelectedItem.Value, Combo.SelectedItem.Text));
}
}

Curso: ASP.NET
 4.4.12 DataBinding

Se pueden enlazar controles con un DataSet, de esta manera obtienen su

información de la base de datos. Para esto se crea una Connection,
posteriormente un DataAdapter y por fin un DataSet. Se une el adaptador
con la conexión y en el código se llena el DataSet con el adaptador. La
propiedad DataSource del control se le asigna al DataSet. Para llenar el
control con los datos se llama al método DataBind.

Ejemplo de Databinding con un DropDownList:

<%@ Page language="c#" Inherits="DropDownDB.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:DropDownList id=Combo runat="server"
DataSource="<%# Datos %>" DataTextField="Nombre" DataValueField="Puesto"
AutoPostBack="True">
</asp:DropDownList>
</form>
</body>
</HTML>

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace DropDownDB
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Data.SqlClient.SqlConnection Coneccion;
protected System.Data.SqlClient.SqlDataAdapter Adaptador;
protected System.Data.SqlClient.SqlCommand sqlSelectCommand1;
protected System.Data.SqlClient.SqlCommand sqlInsertCommand1;
protected System.Data.SqlClient.SqlCommand sqlUpdateCommand1;
protected System.Data.SqlClient.SqlCommand sqlDeleteCommand1;
protected System.Data.DataSet Datos;
protected System.Web.UI.WebControls.DropDownList Combo;

Curso: ASP.NET
 private void Page_Load(object sender, System.EventArgs e)
{
if (!IsPostBack)
{
Adaptador.Fill (Datos, "Empleados");
Combo.DataBind ();
}
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Coneccion = new
System.Data.SqlClient.SqlConnection();
this.Adaptador = new
System.Data.SqlClient.SqlDataAdapter();
this.sqlSelectCommand1 = new
System.Data.SqlClient.SqlCommand();
this.sqlInsertCommand1 = new
System.Data.SqlClient.SqlCommand();
this.sqlUpdateCommand1 = new
System.Data.SqlClient.SqlCommand();
this.sqlDeleteCommand1 = new
System.Data.SqlClient.SqlCommand();
this.Datos = new System.Data.DataSet();

((System.ComponentModel.ISupportInitialize)(this.Datos)).BeginInit(
);
this.Combo.SelectedIndexChanged += new
System.EventHandler(this.Combo_SelectedIndexChanged);
//
// Coneccion
//
this.Coneccion.ConnectionString = "pwd=PWD;data
source=HOST;initial catalog=DB;persist security info=F" +
"alse;user id=USER;workstation id=HOST;packet
size=4096";
//
// Adaptador
//
this.Adaptador.DeleteCommand = this.sqlDeleteCommand1;
this.Adaptador.InsertCommand = this.sqlInsertCommand1;
this.Adaptador.SelectCommand = this.sqlSelectCommand1;

this.Adaptador.TableMappings.AddRange(new
System.Data.Common.DataTableMapping[] {

Curso: ASP.NET
 new System.Data.Common.DataTableMapping("Table", "Empleados", new
System.Data.Common.DataColumnMapping[] {

new System.Data.Common.DataColumnMapping("Nombre",
"Nombre"),

new System.Data.Common.DataColumnMapping("Puesto",
"Puesto")})});
this.Adaptador.UpdateCommand = this.sqlUpdateCommand1;
//
// sqlSelectCommand1
//
this.sqlSelectCommand1.CommandText = "SELECT Nombre,
Puesto FROM Empleados";
this.sqlSelectCommand1.Connection = this.Coneccion;
//
// sqlInsertCommand1
//
this.sqlInsertCommand1.CommandText = "INSERT INTO
Empleados(Nombre, Puesto) VALUES (@Nombre, @Puesto); SELECT Nombre, P" +
"uesto FROM Empleados WHERE (Nombre = @Nombre)";
this.sqlInsertCommand1.Connection = this.Coneccion;
this.sqlInsertCommand1.Parameters.Add(new
System.Data.SqlClient.SqlParameter("@Nombre",
System.Data.SqlDbType.VarChar, 50, "Nombre"));
this.sqlInsertCommand1.Parameters.Add(new
System.Data.SqlClient.SqlParameter("@Puesto",
System.Data.SqlDbType.VarChar, 50, "Puesto"));
//
// sqlUpdateCommand1
//
this.sqlUpdateCommand1.CommandText = "UPDATE Empleados
SET Nombre = @Nombre, Puesto = @Puesto WHERE (Nombre = @Original" +
"_Nombre) AND (Puesto = @Original_Puesto); SELECT
Nombre, Puesto FROM Empleados W" +
"HERE (Nombre = @Nombre)";
this.sqlUpdateCommand1.Connection = this.Coneccion;
this.sqlUpdateCommand1.Parameters.Add(new
System.Data.SqlClient.SqlParameter("@Nombre",
System.Data.SqlDbType.VarChar, 50, "Nombre"));
this.sqlUpdateCommand1.Parameters.Add(new
System.Data.SqlClient.SqlParameter("@Puesto",
System.Data.SqlDbType.VarChar, 50, "Puesto"));
this.sqlUpdateCommand1.Parameters.Add(new
System.Data.SqlClient.SqlParameter("@Original_Nombre",
System.Data.SqlDbType.VarChar, 50, System.Data.ParameterDirection.Input,
false, ((System.Byte)(0)), ((System.Byte)(0)), "Nombre",
System.Data.DataRowVersion.Original, null));

Curso: ASP.NET
 this.sqlUpdateCommand1.Parameters.Add(new
System.Data.SqlClient.SqlParameter("@Original_Puesto",
System.Data.SqlDbType.VarChar, 50, System.Data.ParameterDirection.Input,
false, ((System.Byte)(0)), ((System.Byte)(0)), "Puesto",
System.Data.DataRowVersion.Original, null));
//
// sqlDeleteCommand1
//
this.sqlDeleteCommand1.CommandText = "DELETE FROM
Empleados WHERE (Nombre = @Original_Nombre) AND (Puesto = @Original_P" +
"uesto)";
this.sqlDeleteCommand1.Connection = this.Coneccion;
this.sqlDeleteCommand1.Parameters.Add(new
System.Data.SqlClient.SqlParameter("@Original_Nombre",
System.Data.SqlDbType.VarChar, 50, System.Data.ParameterDirection.Input,
false, ((System.Byte)(0)), ((System.Byte)(0)), "Nombre",
System.Data.DataRowVersion.Original, null));
this.sqlDeleteCommand1.Parameters.Add(new
System.Data.SqlClient.SqlParameter("@Original_Puesto",
System.Data.SqlDbType.VarChar, 50, System.Data.ParameterDirection.Input,
false, ((System.Byte)(0)), ((System.Byte)(0)), "Puesto",
System.Data.DataRowVersion.Original, null));
//
// Datos
//
this.Datos.DataSetName = "Datos";
this.Datos.Locale = new
System.Globalization.CultureInfo("es-MX");
this.Load += new System.EventHandler(this.Page_Load);

((System.ComponentModel.ISupportInitialize)(this.Datos)).EndInit();

private void Combo_SelectedIndexChanged(object sender,

System.EventArgs e)
{
Response.Write (string.Format ("{0} - {1}",
Combo.SelectedItem.Value, Combo.SelectedItem.Text));
}
}
}

Curso: ASP.NET
 4.4.13 System.Web.UI.WebControls.ListBox

El ListBox es idéntico al DropDownList, la diferencia radica en la forma

en que se renderea al usuario.

4.4.14 System.Web.UI.WebControls.DataGrid

El DataGrid es un control que se conecta directamente a un DataSet y

muestra su información en forma de tabla.

Ejemplo de DataGrid:
<%@ Page language="c#" Inherits="EjemploDataGrid.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:DataGrid id=Grid runat="server" DataSource="<%#
Datos %>">
</asp:DataGrid>
</form>
</body>
</HTML>
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace EjemploDataGrid
{
/// <summary>
/// Summary description for WebForm1.
/// </summary>
public class WebForm1 : System.Web.UI.Page
{
protected System.Data.SqlClient.SqlConnection Coneccion;
protected System.Data.SqlClient.SqlDataAdapter Adaptador;
protected System.Data.SqlClient.SqlCommand sqlSelectCommand1;
protected System.Data.DataSet Datos;

Curso: ASP.NET
 protected System.Web.UI.WebControls.DataGrid Grid;

private void Page_Load(object sender, System.EventArgs e)

{
if (!Page.IsPostBack)
{
Adaptador.Fill (Datos, "Empleados");
Grid.DataBind ();
}
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Coneccion = new
System.Data.SqlClient.SqlConnection();
this.Adaptador = new
System.Data.SqlClient.SqlDataAdapter();
this.sqlSelectCommand1 = new
System.Data.SqlClient.SqlCommand();
this.Datos = new System.Data.DataSet();

((System.ComponentModel.ISupportInitialize)(this.Datos)).BeginInit(
);
//
// Coneccion
//
this.Coneccion.ConnectionString = "pwd=PWD;data
source=HOST;initial catalog=DB;persist security info=F" +
"alse;user id=sa;workstation id=HOST;packet
size=4096";
//
// Adaptador
//
this.Adaptador.SelectCommand = this.sqlSelectCommand1;
this.Adaptador.TableMappings.AddRange(new
System.Data.Common.DataTableMapping[] {

new System.Data.Common.DataTableMapping("Table", "Empleados", new

System.Data.Common.DataColumnMapping[] {

new System.Data.Common.DataColumnMapping("Nombre",
"Nombre"),

Curso: ASP.NET
 new System.Data.Common.DataColumnMapping("Puesto",
"Puesto")})});
//
// sqlSelectCommand1
//
this.sqlSelectCommand1.CommandText = "SELECT Nombre,
Puesto FROM Empleados";
this.sqlSelectCommand1.Connection = this.Coneccion;
//
// Datos
//
this.Datos.DataSetName = "NewDataSet";
this.Datos.Locale = new
System.Globalization.CultureInfo("es-MX");
this.Load += new System.EventHandler(this.Page_Load);

((System.ComponentModel.ISupportInitialize)(this.Datos)).EndInit();

}
}

4.4.15 System.Web.UI.WebControls.Repeater

El Repeater es un control el cual nos permite mostrar de la forma que uno

deseé la información de un DataSet, esto se logra mediante el uso de
templates HTML dentro del are del control. Los elementos que lo
conforman son:

• <HeaderTempleate>
• <ItemTempleate>
• <SeparatorTemplate>
• <FooterTemplate>

Dentro del <ItemTemplate> se usa <%# DataBinder.Eval

(Container.DataItem, "NombreCampo")%> Para obtener el valor de un campo
en el registro actual del Repeater.

Curso: ASP.NET
 Ejemplo de Repeater:
<%@ Page language="c#" Inherits="EjemploRepeater.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:Repeater id="Repetidor" runat="server">
<ItemTemplate>
<tr>
<td><%# DataBinder.Eval
(Container.DataItem, "Nombre")%></td>
<td><%# DataBinder.Eval
(Container.DataItem, "Puesto")%></td>
</tr>
</ItemTemplate>
<HeaderTemplate>
<table>
<tr>
<td>NOMBRE</td>
<td>Puesto</td>
</tr>
</HeaderTemplate>
<FooterTemplate>
</table>
FIN
</FooterTemplate>
<SeparatorTemplate>
<tr bgcolor="yellow">
<td colspan="2">--</td>
</tr>
</SeparatorTemplate>
</asp:Repeater>
</form>
</body>

</HTML>

Curso: ASP.NET
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace EjemploRepeater
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.Repeater Repetidor;

private void Page_Load(object sender, System.EventArgs e)

{
if (!IsPostBack)
{
string CS = "pwd=PWD;data source=127.0.0.1;initial
catalog=FooDb;user id=sa;";
SqlConnection Con = new SqlConnection (CS);
SqlDataAdapter adap = new SqlDataAdapter ("Select
Nombre, Puesto from Empleados", Con);
DataSet data = new DataSet ();
adap.Fill (data, "Empleados");
Repetidor.DataSource = data;
Repetidor.DataBind ();

}
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Load += new System.EventHandler(this.Page_Load);

}
}
}

Curso: ASP.NET
 4.4.16 System.Web.UI.WebControls.CheckBox

El CheckBox representa una casilla de verificación, tiene una propiedad

Checked que devuelve si esta marcada la casilla, así como un evento
CheckedChanged.

Ejemplo CheckBox:
<%@ Page language="c#" Inherits="EjemploCheckBox.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:CheckBox id="Check" runat="server" Text="Siguen
despiertos?" AutoPostBack="True"></asp:CheckBox>
</form>
</body>
</HTML>

Curso: ASP.NET
using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace EjemploCheckBox
{

public class WebForm1 : System.Web.UI.Page

{
protected System.Web.UI.WebControls.CheckBox Check;

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Check.CheckedChanged += new
System.EventHandler(this.Check_CheckedChanged);

private void Check_CheckedChanged(object sender,

System.EventArgs e)
{
Response.Write ("Se ha cambiado el estado, ahora esta "
+ Check.Checked);
}
}
}

4.4.17 System.Web.UI.WebControls.CheckBoxList

Conjunto de CheckBoxs, con un evento SelectedIndexChanged. Cada

elemento del control es un ListItem con la propiedad Selected. Para
acceder a los elementos se usa la propiedad Items.

Ejemplo CheckBoxList

Curso: ASP.NET
<%@ Page language="c#" Codebehind="Default.aspx.cs"
AutoEventWireup="false" Inherits="EjemploCheckBoxList.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
<meta name="GENERATOR" Content="Microsoft Visual Studio 7.0">
<meta name="CODE_LANGUAGE" Content="C#">
<meta name="vs_defaultClientScript" content="JavaScript">
<meta name="vs_targetSchema"
content="http://schemas.microsoft.com/intellisense/ie5">
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:CheckBoxList id="Lista" runat="server"
AutoPostBack="True">
<asp:ListItem Value="C">Coding</asp:ListItem>
<asp:ListItem Value="A">Anime &amp;
Manga</asp:ListItem>
<asp:ListItem Value="M">Cine</asp:ListItem>
</asp:CheckBoxList>
</form>
</body>
</HTML>

using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace EjemploCheckBoxList
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.CheckBoxList Lista;

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Lista.SelectedIndexChanged += new
System.EventHandler(this.Lista_SelectedIndexChanged);
}

Curso: ASP.NET
 private void Lista_SelectedIndexChanged(object sender,
System.EventArgs e)
{
Response.Write ("<p>Alguien cambio la seleccion");
foreach (ListItem i in Lista.Items)
if (i.Selected)
Response.Write ("<p>" + i.Text + "-" +
i.Value + "</p>");
}
}
}

4.4.18 System.Web.UI.WebControls.RadioButtonList

Este control tiene un comportamiento similar al CheckButtonList, con la

diferencia que la elección de los elementos es excluyente.

4.4.19 System.Web.UI.WebControls.Calendar

Este control es un calendario, la propiedad SelectedDates devuelve una

colección de las fechas seleccionadas y el evento SelectionChanged es
lanzado cuando la selección de fechas es modificada.

Ejemplo:
<%@ Page language="c#" Codebehind="Default.aspx.cs"
AutoEventWireup="false" Inherits="Calendario.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:Calendar id="Calendario" runat="server"
SelectionMode="DayWeekMonth"></asp:Calendar>
</form>
</body>
</HTML>

Curso: ASP.NET
using System;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace Calendario
{

public class WebForm1 : System.Web.UI.Page

{
protected System.Web.UI.WebControls.Calendar Calendario;

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Calendario.SelectionChanged += new
System.EventHandler(this.Calendario_SelectionChanged);
}

private void Calendario_SelectionChanged(object sender,

System.EventArgs e)
{
foreach (DateTime fecha in Calendario.SelectedDates)
Response.Write ("<p>" + fecha.ToString ("dd-MM-
yyyy") + "</p>");
}
}
}

4.4.20 System.Web.UI.WebControls.AdRotator

Este control es útil para la inserción de baners publicitarios, el control toma

un Xml con el listado de imágenes y las muestra aleatoriamente. Este
archivo se asigna con la propiedad AdvertisementFile. Ademas se puede
filtrar el tipo de baners a mostrar con la propiedad KeywordFilter,
permitiendo mantener un solo archivo de baners, y filtrarlo en las secciones
necesarias.

Curso: ASP.NET
 Ejemplo:
<%@ Page language="c#" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<asp:AdRotator id="Rot" runat="server"
AdvertisementFile="adv.xml"></asp:AdRotator>
</form>
</body>
</HTML>

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

<Advertisements>
<Ad>
<ImageUrl>gnome.png</ImageUrl>
<NavigateUrl>http://gnome.org</NavigateUrl>
<AlternateText>GNOME Desktop</AlternateText>
<Keyword>Computers</Keyword>
<Impressions>80</Impressions>
</Ad>
<Ad>
<ImageUrl>mono.fire.gif</ImageUrl>
<NavigateUrl>http://go-mono.com</NavigateUrl>
<AlternateText>Mono Project</AlternateText>
<Keyword>Computers</Keyword>
<Impressions>80</Impressions>
</Ad>
<Ad>
<ImageUrl>openoffice.jpg</ImageUrl>
<NavigateUrl>http://www.openoffice.org</NavigateUrl>
<AlternateText>Open Office.Org Suite de Oficina</AlternateText>
<Keyword>Computers</Keyword>
<Impressions>80</Impressions>
</Ad>
<Ad>
<ImageUrl>trust.png</ImageUrl>
<NavigateUrl>http://www.GetFirefox.com</NavigateUrl>
<AlternateText>Firefox, rediscover the web</AlternateText>
<Keyword>Computers</Keyword>
<Impressions>80</Impressions>
</Ad>
</Advertisements>

Curso: ASP.NET
 4.4.21 Validators

ASP.NET introduce una manera muy útil y sencilla de realizar

validaciones. Esto lo hace con la inclusión de los WebControls Validators,
los cuales son unos controles con ciertas reglas especificas para validar el
valor de otros controles, como:

• RequiredValidator: Verifica que el campo no se encuentre vació

• ComarerValidator: Verifica que el contenido de dos campos sean el
mismo
• RangeValidator: Verifica que el valor de un capo se encuentre entre
un rango
• RegularExpresionValidator: Verifique que un campo cumpla con
una expresión regular dada.

Cada validator tiene una propiedad llamada Text, que será el indicador de
error, ErrorMessage que será el mensaje de error mostrado, y
ControlToValidate que será el control a evaluar. Además de los validators se
necesita un ValidationSummary, que es el control donde se mostraran los
ErrorMessages de todos los validators de la pagina.

Para saber si todos los validators fueron satisfactorios, se usa la propiedad

IsValid de la clase HttpPage.

Ejemplo:
<%@ Page language="c#" Inherits="Validadores.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
</HEAD>
<body MS_POSITIONING="GridLayout">
<form id="Form1" method="post" runat="server">
<table>
<tr>
<td>Valor</td>
<td>
<asp:TextBox id="t1"
runat="server"></asp:TextBox>
<asp:RequiredFieldValidator
id="RequiredFieldValidator1" runat="server" ErrorMessage="Debes de dar un
valor" EnableClientScript="False"
ControlToValidate="t1">*</asp:RequiredFieldValidator>&nbsp;</td>
</tr>
<tr>
<td>Repite el valor</td>

Curso: ASP.NET
 <td>
<asp:TextBox id="t2"
runat="server"></asp:TextBox>
<asp:CompareValidator
id="CompareValidator1" runat="server" ErrorMessage="Los valores no son
iguales" EnableClientScript="False" ControlToValidate="t2"
ControlToCompare="t1">*</asp:CompareValidator></td>
</tr>
<tr>
<td>Numero entre 1 y 10</td>
<td>
<asp:TextBox id="t3"
runat="server"></asp:TextBox>
<asp:RangeValidator
id="RangeValidator1" runat="server" ErrorMessage="Numero en rango
invalido" EnableClientScript="False" ControlToValidate="t3"
MaximumValue="10" MinimumValue="1"
Type="Integer">*</asp:RangeValidator></td>
</tr>
<tr>
<td>Dame tu pagina</td>
<td>
<asp:TextBox id="t4"
runat="server"></asp:TextBox>
<asp:RegularExpressionValidator
id="RegularExpressionValidator1" runat="server" ErrorMessage="Esa no es
una pagina" ControlToValidate="t4" ValidationExpression="http://([\w-
]+\.)+[\w-]+(/[\w-
./?%&amp;=]*)?">*</asp:RegularExpressionValidator></td>
</tr>
<tr>
<td colspan="2" align="right">
<asp:Button id="Ok" runat="server"
Text="OK"></asp:Button>
</td>
</tr>
<tr>
<td colspan="2">
<asp:ValidationSummary id="Resumen"
runat="server" EnableClientScript="False"></asp:ValidationSummary>
</td>
</tr>
</table>
</form>
</body>
</HTML>

using System;
using System.Web;

Curso: ASP.NET
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace Validadores
{
public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.RequiredFieldValidator
RequiredFieldValidator1;
protected System.Web.UI.WebControls.CompareValidator
CompareValidator1;
protected System.Web.UI.WebControls.RangeValidator
RangeValidator1;
protected System.Web.UI.WebControls.TextBox t1;
protected System.Web.UI.WebControls.TextBox t2;
protected System.Web.UI.WebControls.TextBox t3;
protected System.Web.UI.WebControls.TextBox t4;
protected System.Web.UI.WebControls.ValidationSummary
Resumen;
protected System.Web.UI.WebControls.Button Ok;
protected
System.Web.UI.WebControls.RegularExpressionValidator
RegularExpressionValidator1;

private void Page_Load(object sender, System.EventArgs e)

{
}

override protected void OnInit(EventArgs e)

{
InitializeComponent();
base.OnInit(e);
}

private void InitializeComponent()

{
this.Ok.Click += new
System.EventHandler(this.Ok_Click);
this.Load += new System.EventHandler(this.Page_Load);

private void Ok_Click(object sender, System.EventArgs e)

{
if (Page.IsValid)
Response.Write ("Todo bien");
else
Response.Write ("Todo te tengo que decir?");
}
}
}

Curso: ASP.NET
 4.5 WebUserControls y WebCustomControls

Si ningún webcontrol existente cumple con las necesidades de algún proyecto,

se puede crear un WebUserControl o bien un WebCustomContol que
encapsule la funcionalidad deseada. La principal diferencia entre los dos
controles radica en la facilidad de creación contra el rehusó y la facilidad de
uso en modo de diseño.

Los Web User contros son fáciles de hacer, pero pueden ser menos
convenientes en ciertos escenarios. Los Web User Controls se desarrollan casi
como una pagina ASP.NET. Los Web User Controls son compilados
dinámicamente al momento de ejecución, y no pueden ser agregados a la barra
de herramientas de VS.NET. Además solo funciona en un solo proyecto, para
rehusarlo se necesita crear una copia de el, con los problemas de
mantenimiento que esto representa.

Los Web Custom Controls son código compilado, que los hace mas sencillos
de usar pero mas difíciles de crear. Además los Web Custom Controls pueden
ser instalados en el GAC.

Para un ejemplo ver WebUserControl y EjemploWebCustomControl.

Curso: ASP.NET