Introduccion A Visual Studio NET

Introduccin a Visual Studio .
NET

Manual de Referencia
por Federico Gabriel Rudolph

.NET

Primera Edicin
Del Autor

2010

Material de Apoyo para
Cursos de Capacitacin en .NET
Ttulo original: Introduccin a Visual Studio .NET

Autor: Federico G. Rudolph

Primera Edicin Del Autor, 2010

Diseo de portada: Federico G. Rudolph

Copyright Federico G. Rudolph, 2004 2010
Todos los derechos reservados
Registro de Propiedad Intelectual de Safe Creative

Para contactar con el autor:
vsnet@federicogrudolph.com.ar

No se permite la reproduccin parcial o total, el almacenamiento, el alquiler, la
transmisin o la transformacin de este libro, en cualquier forma o por cualquier
medio, sea electrnico o mecnico, mediante fotocopias, digitalizacin u otros
mtodos, sin el permiso previo y escrito del editor. Su infraccin est penada por la
ley.
Introduccin a Visual Studio .NET i
Federico Gabriel Rudolph
Tabla de Contenidos
Tabla de Contenidos ...................................................................................... i
Introduccin.................................................................................................. 1
Descripcin de la plataforma.............................................................................................................1
Marco de trabajo .................................................................................................................................2
Compilacin y ejecucin de cdigo..................................................................................................3
Ensamblados.......................................................................................................................................3
Caractersticas de los lenguajes.......................................................................................................5
Tipos de Datos ....................................................................................................................................5
Visual Basic .NET.......................................................................................... 7
Bases del lenguaje..............................................................................................................................7
Distincin entre maysculas y minsculas....................................................................................................... 7
Comentarios..................................................................................................................................................... 7
Sentencias ....................................................................................................................................................... 7
Strings..................................................................................................................................................8
Variables..............................................................................................................................................8
Arrays...................................................................................................................................................9
Tipos enumerados............................................................................................................................10
mbito y Accesibilidad ....................................................................................................................10
Operaciones con variables..............................................................................................................11
Conversiones de tipo .......................................................................................................................11
Estructuras condicionales...............................................................................................................12
Bucles ................................................................................................................................................12
Procedimientos y funciones............................................................................................................12
Parmetros por valor y por referencia............................................................................................................ 13
Sobrecarga de procedimientos y funciones ................................................................................................... 13
Delegados...................................................................................................................................................... 13
Espacios de Nombre ........................................................................................................................14
Importacin de espacios de nombre.............................................................................................................. 14
Tratamiento de Excepciones...........................................................................................................14
Captura de excepciones ................................................................................................................................ 15
Lanzamiento de excepciones......................................................................................................................... 15
ASP.NET ...................................................................................................... 16
Ejecucin de aplicaciones Web ......................................................................................................16
Ejecucin de aplicaciones ASP.NET ..............................................................................................16
Aplicaciones ASP.NET.....................................................................................................................17
Introduccin a Visual Studio .NET ii
Tipos de archivos ASP.NET.............................................................................................................18
Distribucin aplicaciones Web....................................................................................................................... 19
Configuracin de aplicaciones Web............................................................................................................... 19
Directorios virtuales .........................................................................................................................19
Creacin de aplicaciones ASP.NET................................................................................................24
Bibliografa.................................................................................................... A
Colaboraciones.............................................................................................. A

Introduccin a Visual Studio .NET 1
Introduccin
Descripcin de la plataforma
.NET es una plataforma de ejecucin de Aplicaciones basada en objetos y desarrollada por la
empresa Microsoft destinada a facilitar la vida de los desarrolladores de aplicaciones (en especial los
usuarios de Visual Basic y Visual Interdev).
.NET introduce de una capa de abstraccin entre el Sistema Operativo y el cdigo ejecutable,
encapsulando la totalidad de las APIs de Windows, las rutinas de acceso a datos (ADO), las llamadas
a los protocolos de internet (HTTP y SMTP, por ejemplo) y el uso de otras libreras comunes (como,
por ejemplo, todo el conjunto de runtimes de Visual Basic) en una serie de libreras de clases, las que
pueden ser accedidas desde cualquier lenguaje soportado por esta plataforma de ejecucin de
Aplicaciones en forma totalmente transparente y a un nivel ms alto de programacin que sucede con
otros lenguajes existentes.
Con esta plataforma, Microsoft pretende llevar al prximo paso a todo su conjunto de herramientas y
lenguajes de desarrollo a la vez que permite, a terceros, integrar sus propias herramientas y
lenguajes de desarrollo a esta plataforma en forma totalmente nativa, compatibilizando los distintos
lenguajes de programacin bajo un nico criterio y disminuyendo el ciclo de Produccin de las
Aplicaciones.
Como resultados inmediatos del uso de esta plataforma para la construccin de Aplicaciones se logra:
La Disminucin de los Tiempos de Desarrollo,
La Compatibilidad, Portabilidad y Reutilizacin de Cdigo entre plataformas operativas y
lenguajes de desarrollo.
Otros beneficios que otorga .NET son:
La Transparencia de Ubicacin de Cdigo, y
Un mejor Control de Versiones, tanto de la aplicacin como de las libreras de clases.
.NET es un entorno de programacin implementado a travs del siguiente conjunto de tecnologas:
Entornos de Desarrollo .NET (Visual Studio .NET, WebMatrix, Delphi 8 .NET etc.), los ms
completos aportan una Interfaz de Diseo Visual para el programador con herramientas
suficientes para la codificacin, ejecucin y depuracin de cdigo fuente.
Lenguajes de Desarrollo .NET, como por ejemplo: Visual Basic .NET, ASP.NET, Java#, C#,
Delphi 8 .NET y otros.
Entorno Comn de Ejecucin (CLR, Common Language Runtime), CLR es el motor de
ejecucin (intrprete) de .NET encargado de la ejecucin de todos los programas escritos para
esta plataforma. Este motor, adems, proporciona una serie de servicios como son: la
administracin automtica de memoria, servicios de seguridad, la optimizacin de recursos y el
recolector de basura entre otros. El entorno de ejecucin se distribuye junto con la biblioteca de
clases de .NET en lo que se ha dado en llamar el marco de trabajo de .NET (framework). Este
marco de trabajo es un paquete de instalacin que permite la ejecucin de las aplicaciones
escritas en .NET.
Biblioteca de Clases de .NET, esta biblioteca, integrada por una serie de DLLs, recolecta
(encapsula) miles de funciones y procedimientos totalmente reutilizables por cualquier lenguaje
.NET; este conjunto de libreras reemplaza el uso de las libreras (runtimes) de VB, algunos
componentes ActiveX (OCX), como por ejemplo los objetos ADO que han sido reescritos para
su uso en forma directa dentro del lenguaje, las llamadas a la API de Windows y la
comunicacin entre procesos, entre otros. El beneficio directo del uso de esta biblioteca de
clases es una reduccin en la curva de aprendizaje, ya que el programador utiliza un nico
medio para obtener toda esta funcionalidad y no necesita aprender el uso de otras
herramientas, conceptos o tecnologas. El entorno .NET permite contener en una misma
aplicacin cdigo escrito en diferentes lenguajes de programacin haciendo uso (todos ellos)
de las mismas libreras de clases, ya sean propias del marco de trabajo, libreras desarrolladas
especficamente para su uso dentro de la Organizacin o libreras desarrolladas por terceros.
Marco de trabajo
El Marco de trabajo de .NET (framework) se compone del CLR y la BCL. Este marco de trabajo se
superpone al Sistema Operativo y representa la nica interfaz existente de ejecucin para las
aplicaciones escritas para el entorno .NET.
En el siguiente dibujo se muestra cmo se comunican entre s los diversos componentes de una
Aplicacin .NET:

SO
A
D
O
.
N
E
T
X
M
L
A
S
P
.
N
E
T
W
e
b
F
o
r
m
s
W
e
b
S
e
r
v
i
c
e
s
M
o
b
i
l
e

I
n
t
e
r
n
e
t
T
o
o
l
K
i
t
Visual Basic .NET
WinForms
CLR
BCL
A
p
l
i
c
a
cin
.N
E
T

Figura 1
El cdigo escrito bajo el entorno .NET se denomina cdigo administrable. El cdigo administrable
puede ser depurado por cualquier herramienta de depuracin escrita para .NET. Una aplicacin .NET
puede coexistir e interactuar con aplicaciones o elementos del Sistema que no han sido desarrollados
bajo esta tecnologa; en cuyo caso el cdigo dejara de ser administrable (la parte NO escrita en
.NET). Un ejemplo, de esto ltimo, son las llamadas a Objetos COM.
El motor .NET es el encargado de gestionar las peticiones de acceso y asignacin de memoria a
medida que una Aplicacin escrita para este entorno lo requiere. Consecuentemente, la liberacin de
memoria se realiza automticamente a travs del Recolector de Basura de .NET. El Recolector de
Basura se encarga, tambin, de liberar cualquier conexin abierta, ya sea: conexiones de red,
conexiones a bases de datos y otras.
Compilacin y ejecucin de cdigo
Para hacer posible el desarrollo de aplicaciones .NET Microsoft tuvo que redisear su conjunto de lenguajes para el marco
.NET rompiendo radicalmente la compatibilidad con las versiones anteriores.
El paquete de Instalacin de Visual Studio .NET permite la instalacin conjunta de Visual Basic .NET,
Java# (con sus respectivos subconjuntos de programacin: ASP.NET y Jscript .NET) y C#.
Todos los nuevos lenguajes desarrollados para la plataforma .NET son Lenguajes Orientados a
Objetos. Ahora es posible la construccin de Clases utilizando Visual Basic .NET, por ejemplo,
haciendo uso e implementacin de las tres caractersticas pilares de la Programacin Orientada a
Objetos: el Encapsulamiento, la Herencia y el Polimorfismo.
Sin importar el lenguaje que el programador utilice para desarrollar sobre la plataforma .NET (esto
incluye lenguajes desarrollados por terceros), el cdigo fuente ser indefectiblemente compilado a un
mismo lenguaje intermedio, conocido como MSIL (Microsoft Intermediate Language), CIL
simplemente IL. El CLR slo es capaz de ejecutar cdigo IL, razn por la cual la mayora de los
lenguajes .NET resultan muy similares. Como se mencion al principio, Microsoft ha liberado un
conjunto de especificaciones para la construccin de lenguajes basados en .NET (CLS, Common
Language Specifications) que define los requisitos bsicos y los estndares que permiten que otras
compaas escriban lenguajes ejecutables bajo el CLR (Common Language Runtime).
A continuacin se puede ver cmo se lleva a cabo la ejecucin de cdigo .NET:

Cdigo en
VB.NET
Cdigo enC# Cdigo en otro
lenguaje .NET
Compilador
VB.NET
Compilador
C#
Compilador
otro
lenguaje .NET
Cdigo IL
(Lenguaje
Intermedio)
Ejecucin del
cdigo IL
a travs del CLR

Figura 2
Ensamblados
El cdigo IL se compila en mdulos denominados Assemblies (Ensamblados), la mayor parte de las
veces estos Assemblies se alojan en DLLs o archivos ejecutables (.EXE) independientes unos de
otros. Un Assembly puede contener toda una Librera de Clases o una nica clase en su interior.
Para ejecutar un Assembly, el CLR utiliza el camino de bsqueda del Sistema Operativo (Variable de
entorno PATH); esto es lo que permite, justamente, mantener diferentes versiones de una misma DLL
(Assemblies) en diferentes carpetas sin romper la compatibilidad de cdigo de las aplicaciones.

A diferencia de los Assemblies, los objetos COM que requieren ser registrados en el Registro de
Windows para su funcionamiento, no permitindose la coexistencia de diferentes versiones de
un mismo Objeto COM (Interfaz).
Adems, cualquier cambio en la Interfaz de estos Objetos, obliga a que los mismos deban ser
registrados nuevamente.

La distribucin de los Assemblies, por otra parte, se simplifica al tratarse simplemente de una
operacin de copia de archivos. En caso de que el Assembly a reemplazar est ejecutndose en
memoria a la hora de su actualizacin, la misma se har en forma totalmente transparente, con lo
cual la aplicacin que est corriendo continuar ejecutando la vieja versin del Assembly sin
enterarse de este proceso. La prxima vez que se cargue la aplicacin, se cargarn y ejecutarn las
nuevas versiones de estos archivos.
La razn de este comportamiento es que cada vez que se hace un llamado a un Assembly, se hace
una copia del mismo en una cach en memoria, y en caso de que se actualice la versin, la prxima
llamada al Assembly se har desde una copia ms reciente (en este supuesto caso existirn dos
copias del Assembly distintas versiones en memoria a un mismo tiempo). La siguiente figura
explica este comportamiento.

Solicitudes de Servicio
Aplicaciones .NET Assembly
Assembly
CACHE
Assembly
Versin A
Versin B
Versin N
Control de Versin
N
u
e
v
a

V
e
r
s
i
n
V
e
r
s
i
n

m
s

r
e
c
i
e
n
t
e

Figura 3

Una caracterstica a tener en cuenta provista por .NET es el Sistema Comn de Tipos para los datos
que van a ser procesados por la Aplicacin. Los compiladores .NET contemplan esta caracterstica a
los efectos de asegurar la compatibilidad binaria entre Assemblies, sin importar el lenguaje en el cual
fueron escritos.
Los compiladores .NET generan cdigo Intermedio similar al cdigo nativo de la CPU, pero
independiente de la Arquitectura de hardware.
Caractersticas de los lenguajes
Tanto Visual Basic. NET como ASP.NET siguen las mismas reglas de programacin que Visual Basic
6, sobre todo en lo que respecta a la Sintaxis.
ASP.NET presenta un conjunto reducido de posibilidades (librera clases) para la creacin de
Formularios [Web] debido a las limitaciones del entorno de ejecucin final (limitaciones propias del
Explorador Web, que es desde donde se ejecuta la aplicacin, y limitaciones propias del protocolo
HTML). Sin embargo, el lenguaje empleado para crearlas es, en ambos casos, el mismo: Visual
Basic.NET o VB.NET.
Por lo tanto, al programador le debera resultar muy fcil pasar del desarrollo de aplicaciones Web a
la creacin de Formularios para Windows (o viceversa), teniendo en cuenta siempre las diferencias
presentes en cada una de ellas.
Visual Basic .NET, al igual que cualquier lenguaje soportado por esta plataforma, es un lenguaje
Orientado a Objetos. A diferencia de sus predecesores (Visual Basic 6 es un lenguaje de
programacin Orientado a Eventos antes que a Objetos), VB.NET implementa en un 100% los
requisitos necesarios para el desarrollo de aplicaciones orientadas a objetos:
Construccin de Clases
Manipulacin de Objetos
Implementacin de Herencia, Polimorfismo y Encapsulamiento
Definicin de Propiedades, Mtodos y Eventos
Tipos de Datos
Todos los lenguajes .NET utilizan los mismos tipos de datos para la definicin de variables y
constantes. Cada lenguaje puede darle a estos tipos un nombre diferente (El tipo Integer de Visual
Basic es igual al tipo int de C#, por ejemplo) pero el CLR los trata de igual manera. Esta
caracterstica de la plataforma .NET permite el intercambio directo de datos entre mdulos y
lenguajes de programacin creados en distintos lenguajes en forma nativa, sin la necesidad de
efectuar conversin alguna.
Estos tipos bsicos estn proporcionados por la Biblioteca de Clases de .NET y son los que se
muestran en la tabla siguiente:

Tipo de
Dato BCL
Tipo de
Dato en
VB.NET
Tipo
de
Dato
en C#
Contiene
Byte Byte byte Un entero de 0 a 255
Int16 Short short Un entero de 32.768 a 32.767
Int32 Integer int
Un entero de 2.147.483.648 a
2.147.483.647
Int64 Long long
Un entero de aproximadamente
9.2e18 a 9.2e18
Single Single float
Un nmero decimal de precisin
simple de aproximadamente 3.48e38
a 3.48e38
Double Double double
Un nmero decimal de doble precisin
de aproximadamente 1.8e308 a
1.8e308
Decimal Decimal decimal
Un nmero de 128 bits fraccional de
punto fijo que admite hasta 28 dgitos
significativos
Tipo de
Dato BCL
Tipo de
Dato en
VB.NET
Tipo
de
Dato
en C#
Contiene
Char Char Char Un nico character Unicode de 16 bits
String String string
Una serie de caracteres de longitud
variable de caracteres Unicote
Boolean Boolean bool Un valor True o False
DateTime Date N/A
Cualquier da y hora desde las 12:00
am del 1 de enero del ao 1 del
calendario gregoriano hasta las 11:59
pm del 31 de diciembre del ao 9.999.
Los valores hora tienen un intervalo de
100 nanosegundos. Internamente, este
tipo de datos es un entero de 64 bits
TimeSpan N/A N/A
Un perodo de tiempo. El intervalo ms
pequeo posible es 1 tick (cien
nanosegundos)
Object Object object
La clase base de todos los tipos .NET.
Puede contener cualquier tipo de datos
u objetos (incluyendo los anteriores)
Tabla 1

Los tipos de datos ofrecidos por la plataforma .NET no son enteramente compatibles con anteriores
versiones de Visual Basic y de otros lenguajes.

Se debe considerar que en .NET no estn permitidas las cadenas de longitud fija.
No est admitido el uso del tipo Variant (soportados por distintos lenguajes); en su lugar ha sido
reemplazado por el tipo genrico Object que puede contener datos de cualquier tipo.
El tipo Date funciona de manera diferente que en otros lenguajes, ya que soporta un mayor
rango y precisin de lo normal (hasta nanosegundos).

Como mencin particular, se prefiere el uso de las colecciones (objetos) en lugar del uso de vectores
y matrices. Este tipo de datos permite realizar en forma dinmica operaciones de manipulacin de
listas que involucren: cambio de tamao, cambio en el orden de los tems, insercin, borrado. Son
especialmente indicados para el manejo de listas, pilas y punteros enlazados. Sin embargo, hay
casos en los cuales seguir siendo necesario el uso de vectores (en realidad el tipo array, al igual que
los tipos bsicos mencionados, es tambin una clase o tipo de objeto).
Las colecciones proveen en forma nativa los mtodos y propiedades necesarias para la ejecucin de
los procesos mencionados y otros.
Adems de las colecciones es posible definir tipos enumerados en cualquiera de los lenguajes
soportados por la plataforma.
Un tipo enumerado representa y se define como un conjunto finito de constantes, identificadores o
etiquetas. Cada uno de los elementos del conjunto enumerado representa, en realidad, un valor
entero predefinido. El compilador traduce la etiqueta asociada al valor entero correspondiente.
Visual Basic .NET
En la seccin anterior se describi, brevemente, el comportamiento, caractersticas y tipos de datos
disponibles con cualquier lenguaje .NET.
En esta seccin se explicar en forma ms detallada la sintaxis, consideraciones y utilizacin de
algunos componentes del lenguaje Visual Basic .NET y ASP.NET.
La informacin disponible en esta seccin est destinada a brindarle al programador una orientacin
respecto al correcto uso del lenguaje y las diferentes posibilidades de implementacin existentes.
Todos los lenguajes .NET comparten los mismos conceptos aqu volcados y requieren de los mismos
conocimientos; con lo que, nuevamente, debera resultar muy fcil pasar de programar de un lenguaje
a otro sobre esta plataforma de trabajo (por ejemplo: de VB.NET a C#). Las diferencias se encuentran
ms que nada en la estructura del lenguaje, antes de que en los tipos de datos, procedimientos,
funciones, clases, objetos y libreras disponibles.
Realmente, cualquier cdigo escrito en un lenguaje .NET debera ser pasible de ser traducido en un
100% a otro lenguaje .NET sin mayores inconvenientes. Igualmente, el paso de un lenguaje a otro no
debera representar ninguna mejora en la ejecucin del cdigo o en la administracin de los recursos
del sistema, tales como la memoria; como tampoco en la velocidad de ejecucin, ya que recordemos
que el compilador del lenguaje genera cdigo MSIL, y en ltima instancia este es nico cdigo que se
ejecuta. Por ello, la decisin en cuanto al lenguaje de programacin es una cuestin ms bien de tipo
personal.
Esto es tan cierto, que como contrapartida y para mejorar el rendimiento, la interoperabilidad, el
conjunto de caractersticas del lenguaje o los tiempos de desarrollo de las aplicaciones todos los
lenguajes dependen directamente de una mejora en el marco de trabajo (framework) de .NET.
Bases del lenguaje
Distincin entre maysculas y minsculas
Al igual que sus antecesores VB.NET no hace distincin entre maysculas y minsculas.
Las siguientes declaraciones son equivalentes:

Dim A as String
dim a as string
DIM A AS STRING
Dim a AS STRING
Comentarios
Los comentarios en VB.NET siempre comienzan con un apstrofe y no pueden extenderse ms all
del final de lnea.

Esta es una lnea de comentario
Esta es otra lnea de comentario
Sentencias
En Visual Basic no se utilizan caracteres para indicar un final de lnea tal como sucede con C# y otros
lenguajes; las sentencias se escriben en una nica lnea (se puede escribir una sentencia en varias
lneas utilizando el carcter de subrayado _, pero se seguir considerando la sentencia como una
sola lnea).
Por otro lado, los bloques de sentencias se enmarcan entre un principio y fin de bloque. Para ello se
utiliza la palabra reservada END seguido del bloque de construccin (sentencia compuesta) a cerrar.
Por ejemplo: END FOR, END IF, etc.
Strings
Los strings (cadenas de caracteres) en Visual Basic .NET se deben encerrar entre comillas dobles.
No est permitido declarar strings de ancho fijo. Todos los strings se declaran sin una longitud
determinada, pudiendo ser de cualquier tamao.
Los strings son del tipo Object (al igual que todos los tipos de datos posibles). Esto significa que es
posible efectuar diversas operaciones o aplicar distintas funciones (mtodos) directamente a un
string. Algunas funciones (propiedades y mtodos) disponibles para los strings son:

Miembro de la clase
String
Descripcin
Length Devuelve un Entero con la longitud de la cadena
ToUpper() Convierte la cadena a maysculas
ToLower() Convierte la cadena a minsculas
Trim() Elimina los espacios al principio y al final de la cadena
TrimEnd() Elimina los espacios al final de la cadena
TrimStart() Elimina los espacios al principio de la cadena
PadLeft() Aade caracteres a la izquierda de la cadena
PadRight() Aade caracteres a la derecha de la cadena
Insert() Inserta una cadena dentro de otra
Remove() Elimina caracteres de una cadena
Replace() Reemplaza una subcadena por otra
Substring() Extrae una subcadena de una cadena
StartsWith()
Determina si una cadena comienza con una subcadena
especificada
EndsWith()
Determina si una cadena termina con una subcadena
especificada
IndexOf()
Encuentra la primera posicin que ocupa una subcadena
dentro de una cadena
LasIndexOf()
Encuentra la ltima posicin que ocupa una subcadena dentro
de una cadena
Split() Divide una subcadena en un vector de subcadenas
Join() Une un vector de subcadenas en una cadena
Tabla 2
Variables
Para declarar una variable en VB.NET se debe indicar la palabra reservada DIM seguida del nombre
y tipo de variable:

Dim ErrorCode As Integer
Dim Nombre, Apellido As String
Como alternativa se pude indicar el nombre de la biblioteca de clases donde est definido el tipo:

Dim ErrorCode As System.Int32
Dim Nombre As System.String

La declaracin de variables puede ir seguida, adems, por un valor inicial para la misma:

Dim ErrorCode As Integer = 10
Dim Nombre As String = Andrs
En Visual Basic .NET se puede utilizar una variable sin inicializar. Los nmeros se inicializan
automticamente a 0 y las cadenas a una cadena vaca ().
Visual Basic .NET establece por defecto la clusula OPTION EXPLICIT en ON. Esto quiere decir que
el uso de variable requiere que las mismas sean declaradas siempre antes de poder utilizarlas. De
otro modo se producir un error de compilacin. Es conveniente mantener esta opcin en ON para
mejorar el estilo de programacin y facilitar la compilacin de cdigo.
La opcin OPTION EXPLICIT puede indicarse dentro del cdigo del programa, o bien desde las
opciones del proyecto.
Arrays
Los vectores se declaran indicando la cantidad de elementos por cada dimensin. Por defecto el
lmite inferior de un vector (elemento menor) es 0.

Declaracin de un vector de 10 elementos
Dim Strings(10) As String
Igualmente, es posible darle un valor inicial a los elementos del array al momento de su declaracin:

Declaracin e inicializacin de arrays en una sla instruccin
Dim DiasDeLaSemana As Integer = {1, 2, 3, 4, 5, 6, 7}
Dim Numeros As Integer = {1, 2, 3, 4}
Para acceder a un elemento del array es necesario indicar el nmero o nmeros de ndice encerrados
entre corchetes:

Manipulacin de un array
Dim Dias As String = {Lu, Ma, Mi, Ju, Vi, Sa, Do}

DiaDeHoy = Dias(2)
Los arrays pueden incluir cualquier tipo de datos.
Si se quiere recorrer un vector se pude utilizar la clusula FOR EACH:

Uso de FOR EACH con vectores
Dim Dias As String = {Lu, Ma, Mi, Ju, Vi, Sa, Do}
Dim Dia As Integer

For Each Dia In Dias
Cdigo
Cdigo
Cdigo
Next
Para redimensionar un array se utiliza la clusula REDIM:

Uso de REDIM
Dim X(10, 10) As Integer

ReDim X(20, 20)

El uso de REDIM elimina el contenido del array. Si se quiere preservar su contenido se deber
anteponer al nombre del array la palabra reservada PRESERVE. Esto exige que slo se pueda
modificar la ltima dimensin, de otro modo producir un error en tiempo de ejecucin:

Uso de PRESERV
Dim X(10, 10) As Integer

ReDim Preserve X(10, 20) Esta sentencia es correcta
ReDim Preserve X(20, 20) Esta sentencia provoca un error de ejecucin

Al igual que sucede con los Strings, y con cualquier tipo de datos en .NET, el tipo array es en realidad
un tipo de la clase Object.
Los arrays soportan un conjunto de mtodos, propiedades y eventos predefinidos dentro del lenguaje
para operar con este tipo de datos.

Como ya se mencion, se prefiere el uso de las colecciones antes que los arrays.
La biblioteca de clases de .NET contiene un sinnmero de colecciones predefinidas que pueden
ser utilizadas por el programador. La manipulacin de una coleccin presenta mayores ventajas
y posibilidades que un vector.

Tipos enumerados
En lugar de utilizar valores constantes para los datos, es posible definir tipos enumerados dentro del
cdigo para facilitar su legibilidad. Los tipos enumerados son conjuntos de constantes identificados
por nombres. Cada elemento de un tipo enumerado se corresponde con un entero predefinido, si no
se indica el primero corresponder al valor 0 y as sucesivamente.
Los tipos enumerados se declaran con la palabra reservada ENUM:

Definicin de un Tipo Enumerado
Enum Dias
Lunes
Martes
Miercoles
Jueves
Viernes
Sabado
Domingo
End Enum
Una vez declarado el tipo enumerado es posible declarar, a su vez, una variable de ese tipo:

Uso de un Tipo Enumerado
Dim Dia As Dias

Dia = Dias.Lunes
mbito y Accesibilidad
Las variables pueden ser declaradas para ser usadas ya sea dentro de un procedimiento o por todo
un formulario, en cuyo caso ser conveniente indicar el nivel de accesibilidad para la misma, de modo
que no sea visible desde partes del programa que no deberan hacer uso de ella.
Visual Basic .NET establece cinco niveles de visibilidad para una variable. Estos niveles son los que
se ven en la tabla siguiente:

Palabra clave Nivel de Accesibilidad
Public Accesible desde cualquier otra clase
Private
Accesible slo desde procedimientos de la clase actual
(predeterminado si no se indica otro)
Friend
Accesible desde cualquier procedimiento del Ensamblado
actual
Protected
Accesible desde cualquier procedimiento de la clase y desde
cualquier procedimientos de clases que hereden de la actual
Protected Friend
Accesibles desde cualquier procedimiento de la aplicacin y
desde cualquier procedimiento de clases que hereden de la
actual
Tabla 3

Adems, si se define una variable dentro de un bloque de cdigo (clusa FOR, por ejemplo), la misma
ser accesible slo dentro de dicho bloque:

mbito a nivel de bloque
For i = 0 to 10
Dim Aux As Integer
La variable AUX slo es visible dentro de este bloque FOR

Next
La variable AUX no es visible fuera del bloque FOR
Operaciones con variables
Adems de los operadores estndar para operaciones matemticas (+, -, /, *, ^) y expresiones de tipo
String (+ &) Visual Basic .NET expone una serie de abreviaturas de asignacin y operacin:

Operador Descripcin
+= Asignacin y suma
&= Asignacin y concatenacin de strings
-= Asignacin y resta
*= Asignacin y multiplicacin
/= Asignacin y divisin (devuelve un decimal)
\= Asignacin y divisin (devuelve un entero)
^= Asignacin y exponenciacin
<<= Desplazamiento a la izquierda
>>= Desplazamiento a la dercha
Tabla 4

A continuacin se muestran algunos ejemplos y sus correspondientes equivalencias de estos
operadores:

Asignacin y suma (Equivale a X = X + 10)
X += 10

Asignacin y resta (Equivale a X = X - 10)
X -= 10

Asignacin y multiplicacin (Equivale a X = X * 10)
X *= 10

Asignacin y divisin (Equivale a X = X / 10)
X /= 10
Conversiones de tipo
Visual Basic .NET permite la restriccin de conversiones automticas de tipo a travs de la clusula
OPTION STRICT establecida en ON al principio de una archivo de cdigo. En este caso las
conversiones de tipo se debern especificar en forma explcita (por ejemplo, para convertir una
variable de tipo String en numrica).
En caso de requerir una conversin de tipo, lo normal es hacer uso de la funcin CTYPE.
Es conveniente indicar la clusula OPTION STRICT para evitar errores de conversin en tiempo de
ejecucin y que los mismos sean minimizados a la hora de la compilacin del cdigo fuente. Esta
opcin se puede establecer tambin desde las propiedades del proyecto.
La conversin de tipos, sin embargo, no siempre resulta, ya que este tipo de conversiones pueden ser
de dos clases: de estrechamiento o de ensanchamiento. Las conversiones de ensanchamiento
siempre se llevan a cabo. El resultado de una conversin de estrechamiento depender del valor a
convertir.

Conversiones de tipos
Option Strict On
Dim Count As Integer
Dim CountString As String = 10
Count = CType(CountString, Integer)
Estructuras condicionales
Las estructuras condicionales proporcionadas por Visual Basic .NET son las mismas que las
presentes en anteriores versiones:

Clusula If
If x > 10 Then
Sentencias
End If

Clusula If/ElseIf/Else
If x > 10 Then
Sentencias
ElseIf x < 5 Then
Otras sentencias
Else
Otras sentencias
End If

Clusula Select
Select Case x
Case 1
Sentencias
Case 2
Otras sentencias
Case 3
Otras sentencias
End Select
Bucles
Igual que sucede con las estructuras condicionales, Visual Basic .NET proporciona las mismas
estructuras de control (bucles) que sus antecesores:

Clusula For
Dim i As Integer
For i = 1 To 10 Step 1
Este cdigo se ejecuta 10 veces
Next

Clusula Do
Dim i As Integer = 1
Do
i += 1
Loop While i < 10

Clusula Do While
Dim i As Integer = 1
Do While i < 10
Loop
Procedimientos y funciones
Los procedimientos y funciones en Visual Basic .NET se deben utilizar seguidos de parntesis (en
todos los casos), an cuando no se indique ningn parmetro.
En el caso de las funciones se puede utilizar o bien el nombre de la funcin o bien la palabra
reservada RETURN para devolver el resultado de la funcin.
La declaracin de parmetros (si no se especifica de forma explcita) se establece por valor (BYVAL)
a los efectos de asegurar un mayor nivel de proteccin y claridad.
Visual Basic .NET permite la declaracin de parmetros opcionales. En este caso se deber
establecer el valor por defecto de los mismos:

Declaracin de un procedimiento con parmetros opcionales
Private Sub Algo(ByVal Optional Parametro1 As Integer = 20)
Parmetros por valor y por referencia
Los procedimientos admiten dos tipos de parmetros: por valor o por referencia. Cuando los
parmetros se pasan por valor, el procedimiento trabaja en forma interna con una copia de la variable
original. Cuando se pasan por referencia (utilizando la palabra reservada BYREF), se pasa la variable
original al parmetro, permitiendo su modificacin dentro del mismo (el cambio se propaga al
procedimiento que efectu la llamada).
Por esta causa, los parmetros declarados por referencia slo admiten el paso de variables. Los
parmetros que se pasan por valor admiten tanto el paso de variables, como de constantes,
funciones y / o expresiones indistintamente.
Sobrecarga de procedimientos y funciones
Visual Basic .NET admite la sobrecarga de procedimientos. Esto es, la posibilidad de crear ms de
una funcin o procedimiento con el mismo nombre variando el tipo y cantidad de parmetros.
El CLR al momento de su ejecucin, elegir automticamente el procedimiento correcto para cada
caso. Lo que hace el CLR es examinar el orden y tipo de parmetros pasados al procedimiento o
funcin en cuestin y ejecutar la versin que se corresponda con este orden y tipo de parmetros.
No puede haber ms que una versin del procedimiento o funcin con un mismo tipo y orden de
parmetros. De otro modo el CLR no podr distinguir cul es la funcin o procedimiento a ejecutar
(independientemente del nombre de los parmetros utilizados).
Para sobrecargar un procedimiento se utiliza la palabra reservada OVERLOADS, tal como se muestra
a continuacin:

Sobrecarga de un procedimiento
Private Overloads Function GetDomicilio(IdPersona As Integer) As String
Cdigo de la funcin
End Function

Private Overloads Function GetDomicilio(Ape As String, Nom AsString) As String
Cdigo de la funcin
End Function
Delegados
Los delegados son definiciones de tipo para procedimientos y funciones. Es decir, un delegado es un
tipo de dato para guardar un procedimiento o funcin.
Los delegados se declaran con la palabra reservada DELEGATE indicando el orden y tipo de
parmetros para el prototipo de la funcin o procedimiento:

Declaracin de un tipo delegado
Private Delegate Function FuncionDeBusqueda(Id As Integer) As String
Se pueden declarar variables de un tipo delegado y utilizarlas luego:

Uso de un tipo delegado
Private Function BusquedaDePersonas(IdPersona As Integer) As String
Cdigo de la funcin de bsqueda de personas
End Function

Private Sub Prueba
Dim Fx As FuncionDeBusqueda

Fx = AddressOf BusquedaDePersonas
Fx(1)
End Sub
En Visual Basic .NET los delegados representan la base de construccin para los eventos. Aunque se
utilizan a un nivel ms elevado y transparente dentro del lenguaje.
Espacios de Nombre
A los efectos de ordenar y reutilizar trozos de cdigo en .NET se ha establecido el uso de espacios de
nombre o Name Spaces. Las clases de .NET se declaran dentro de espacios de nombre.
Adems, es posible declarar un espacio de nombre dentro de otro. Para declara un espacio de
nombres se utiliza la clusula NAMESPACE:

Declaracin de espacios de nombres
Namespace System
NameSpace Web
Declaracin de clases, procedmientos, funciones, etc.
End Namespace
End Namespace
El espacio de nombres System contiene todos los tipos bsicos de .NET y viene como parte de la
BCL de .NET.
Para utilizar un elemento declarado dentro de un espacio de nombre se deber utilizar un nombre
completamente cualificado (el nombre del elemento precedido por los espacios de nombres que lo
contienen). Esto permite declarar diferentes clases, funciones o procedimientos con un mismo
nombre, pero en distintos espacios de nombre:

Uso de un espacio de nombre
Namespace DataAccess

NameSpace ADO
Private Function GetConn(ConnString As String) As ADOConn
Cdigo del procedimiento
End Sub
End Namespace

NameSpace ODBC
Private Function GetConn(ConnString As String) As ODBCConn
Cdigo del procedimiento
End Sub
End Namespace

End NameSpace

Dim ADOConnection As ADOConn = DataAccess.ADO.GetConn()
Dim ODBCConnection As ODBCConn = DataAccess.ODBC.GetConn()
Importacin de espacios de nombre
En lugar de tener que escribir el nombre completamente cualificado Visual Basic .NET permite la
importacin de espacios de nombre, permitiendo el uso de los elementos en forma ms directa. Para
importar espacios de nombre se utiliza la clusula IMPORTS. Estas sentencias deben aparecer al
comienzo del archivo de cdigo, fuera de cualquier espacio de nombre o estructura de cdigo.

Importacin de espacios de nombre
Imports DataAccess
Imports DataAccess.ADO

Dim ADOConnection1 As ADOConn = ADO.GetConn()
Dim ADOConnection2 As ADOConn = GetConn()
Dim ODBCConnection As ODBCConn = ODBC.GetConn()
Tratamiento de Excepciones
Visual Basic .NET ofrece la sentencia TRY para poder tratar cualquier tipo de excepciones en tiempo
de ejecucin.
El cdigo que el programador considera potencialmente peligroso (que pude producir un error en
tiempo de ejecucin) se deber encerrar entre las clusulas TRY y las clusulas CATCH o FINALLY
para poder manipular los errores que puedan llegar a producirse al momento de ejecutar el programa.
En caso de producirse algn error, el programa ejecutar el cdigo que sigue a la palabra reservada
CATCH o FINALLY (alguna de las dos deber estar presente).
El cdigo que sigue a FINALLY siempre se ejecuta, independientemente de que se haya producido
un error o no. El bloque de cdigo despus de FINALLY sirve para asegurar la ejecucin de
determinados comandos de cierre y liberacin de variables, conexiones y otros.
Si se quiere salir del bloque de proteccin ofrecido por TRY se puede utilizar la clusula EXIT TRY.

Try
Cdigo que puede fallar
Se puede usar la clusula EXIT TRY para salir de este bloque
Catch
Cdigo de captura de excepciones
Finally
Cdigo de finalizacin que siempre se ejecuta
End Try
El uso de la clusula TRY permite la proteccin de cdigo en tiempo de ejecucin.
Captura de excepciones
La clusula CATCH permite tratar cada error en forma general o particular. Si se quiere tratar algn
tipo de error en forma especfica se deber indicar el tipo de Excepcin. Puede haber ms de una
clusula CATCH dentro de un mismo bloque TRY.
Los errores son objetos que derivan de la clase Exception o alguna de sus hijas.
La clusula FINALLY se destina para asegura la liberacin de recursos, an cuando se haya
producido un error.

Private Sub CodigoConErrores
Dim Resultado As Integer
Try
Esto provoca una divisin por cero
Resultado = 22 / 0
Esta lnea no se ejecuta
MessageBox.Show(Resultado)
Catch E As Exception
Muestra el error
MessageBox.Show(E.Message)
Finally
Esta lnea siempre se ejecuta
MessageBox(Fin)
End Try
End Sub
Lanzamiento de excepciones
Adems de capturar y tratar los errores en tiempo de ejecucin es posible generar nuestros propios
errores y pasrselos a la clsula CATCH o FINALLY utilizando la clusula THROW.
Si se utiliza la clusula THROW fuera de un bloque TRY o despus de las clusulas CATCH o
FINALLY el error ser lanzado al proceso que hizo la llamada:

Private Sub PruebaDeErrores(ByVal Valor As Integer)
Dim Resultado As Integer
Try
If Valor = 0 then
Throw New Exception(El valor es igual a cero)
Else
Throw New Exception(El valor es menor de cero)
End If
Catch E As Exception
MessageBox.Show(E.Message)
Finally
If Valor = 10 then
Lanza un error hacia el mdulo de llamada
Throw New Exception(El Valor es iguala a 10)
End If
End Try
End Sub

ASP.NET
Para hacer posible el acceso al contenido de una pgina Web, los Servidores Web deben ejecutar
algn software que haga posible el intercambio de correo electrnico, el acceso a sitios FTP y HTTP,
y cualquier otro tipo de servicio solicitado por el cliente Web.
Las plataformas Windows utilizan normalmente como software Internet Information Server (IIS) para
dar servicio a las peticiones de los clientes Web.
Las funciones bsicas de un servidor Web son:
Alojamiento de archivos
Respuesta a peticiones de servicio de los clientes
Ejecucin de aplicaciones Web
Para desarrollar pginas Web utilizando ASP.NET es necesario contar con un Servidor Web corriendo
IIS, para cubrir estas funciones.
IIS, ante cualquier solicitud de un cliente, evala primero, normalmente, el tipo de archivo a devolver o
ejecutar y dependiendo del mismo utiliza alguno de los servicios instalados. Por ejemplo, si el cliente
solicita una pgina Web HTML o un archivo FTP, el servidor simplemente enva la pgina solicitada al
cliente y este la muestra utilizando para ello el Explorador Web que est corriendo localmente. El
servidor no ejecuta ninguna accin ms que enviar una copia del archivo al cliente previamente
autenticando los permisos del usuario remoto.
Ejecucin de aplicaciones ASP.NET
El caso de las pginas ASP.NET es enteramente distinto.
Una pgina ASP.NET contiene en su interior cdigo HTML ms cdigo ASP.NET.
En consecuencia, la ejecucin de una pgina ASP.NET es muy distinta a la ejecucin de una pgina
HTML.
Adems, las pginas ASP.NET se pueden ejecutar, parte en el cliente (por el Explorador Web) y parte
en el Servidor Web (a travs de IIS).
Las pginas ASP.NET son pginas dinmicas, ya que una misma pgina se puede ver de muy
distintas maneras dependiendo de lo que indique el usuario (permiten la interaccin con ste).
Cuando se instala el marco de trabajo de .NET sobre un servidor que corre IIS se instala el servicio
ASP.NET que permite la ejecucin de este tipo de pginas Web.
Cuando un cliente Web solicita una pgina ASP.NET el servidor Web accede a la pgina ASP.NET,
ejecuta el cdigo contenido en la misma y devuelve al cliente una pgina HTML que se corresponde
con la peticin solicitada. La pgina HTML se construye en el momento.
En algunos casos, la pgina HTML devuelta se acompaa de cdigo JScript.
El servicio ASP.NET asegura la devolucin de una pgina HTML al cliente 100% compatible con el
Explorador Web que se est ejecutando. Esto garantiza que una misma pgina ASP.NET pueda ser
ejecutada desde prcticamente cualquier explorador Web. El cliente no necesita ninguna
configuracin o instalacin adicional para ejecutar este tipo de cdigo. Realmente es el servidor Web
el nico que puede interpretar cdigo ASP.NET (siempre que est instalado IIS y el framework de
.NET en el mismo).
Cada tipo de archivo en IIS est asociado a un servicio distinto. Por ello, las pginas ASP.NET llevan
la extensin aspx, a diferencia de las pginas ASP (extensin .asp).
El servicio ASP.NET es una DLL que se instala en el Servidor Web (el nombre de la DLL es
aspnet_isapi.dll). Las solicitudes ASP las maneja el archivo asp.dll. As con cada tipo de archivo.
La forma en que se manejan las solicitudes de servicios en IIS se puede ver en la figura siguiente:

Figura 4
Aplicaciones ASP.NET
Cuando se desarrolla una aplicacin de tipo ASP.NET, la misma rara vez est formada por un nico
archivo. Por el contrario, normalmente las aplicaciones ASP.NET se componen de un conjunto de
archivos .aspx, archivos de configuracin, imgenes y otros. El mbito de una aplicacin ASP.NET
est establecido, primeramente, por la carpeta contenedora de dicha aplicacin, y, en segundo lugar,
por los recursos comunes que utiliza durante su ejecucin.
Una aplicacin ASP.NET es una combinacin de archivos, pginas, manejadores, mdulos y cdigo
ejecutable que puede invocarse desde un directorio virtual (y, opcionalmente, sus subdirectorios) de
un servidor Web. El directorio virtual es la estructura de agrupacin bsica que delimita una aplicacin
ASP.NET.
Las aplicaciones ASP.NET se ejecutan siempre sobre un servidor ASP (IIS).
Las aplicaciones ASP.NET pueden estar compuestas por varias pginas Web, pero siempre se
ejecutan dentro de un dominio de aplicacin separado del resto de las aplicaciones. Los dominios de
aplicacin se aslan en memoria, lo que provoca que cualquier error dentro de la aplicacin no afecte
a otras aplicaciones que estn corriendo simultneamente en el mismo servidor Web.
Una aplicacin ASP.NET no puede acceder a la informacin de otra aplicacin que est almacenada
en la memoria del servidor. Cada aplicacin que corre en un servidor Web tiene su propio conjunto de
cach, aplicacin y estados de sesin.


Figura 5
Tipos de archivos ASP.NET
Las aplicaciones ASP.NET admiten varios tipos de archivos diferentes. Visual Studio .NET aade
automticamente a los proyectos algunos de estos archivos, ya que las aplicaciones se crean por
medio de plantillas predeterminadas y para facilitarle en cierta medida la tarea de creacin de estos
archivos al programador.
Una aplicacin Web no necesariamente necesita contener todos estos archivos, sino que su uso es
completamente opcional. Basta con que exista un nico archivo .aspx o .asmx para crear una
aplicacin ASP.NET.

Tipo de
archivo
Uso
*.aspx
Pginas ASP.NET con la interfaz del usuario y parte o todo del cdigo
subyacente. Los usuarios solicitan o navegan directamente a una de
estas pginas para iniciar la aplicacin Web.
*.ascx
Controles de usuario ASP.NET. Los controles de usuario permiten
desarrollar piezas de la interfaz de usuario para su posterior reutilizacin.
*.asmx
Servicios Web ASP.NET. Son trozos de cdigo que se ejecutan en un
servidor Web y que pueden ser llamados por distintas aplicaciones.
web.config
Archivo de configuracin de la aplicacin en formato XML. Incluye
opciones de seguridad personalizada, administracin de estados,
administracin de memoria y otros.
global.asax
Archivo global de la aplicacin, utilizado para la definicin de variables y
acciones de eventos globales de la aplicacin.
*.disco,
*.vsdisco
Archivos de descripcin.
*.vb
Archivos de cdigo escritos en VB.NET con la lgica del programa
cuando sta se separa de la pgina Web.
*.resx Archivos de recursos asociados a la aplicacin.
*.sln, *.suo,
*.vbproj
Archivos de informacin de soluciones y proyectos. Contienen las
opciones del Entorno de Trabajo (VS.NET) para el proyecto o solucin.
Se utilizan durante el desarrollo y son exclusivos de VS.NET.
Tabla 5
Otros archivos que se pueden encontrar asociados a una aplicacin ASP.NET son: las hojas de estilo
en cascada (CSS), archivos de imgenes (bmp, gif, jpg y jpeg) y otros.
En caso de utilizarse ensamblados en una aplicacin ASP.NET (DLLs y archivos ejecutables) los
mismos estarn dentro del directorio bin de la aplicacin.
ASP.NET detecta automticamente la presencia de cualquier archivo ubicado en este directorio y lo
ejecuta inmediatamente de ser necesario (siempre que la aplicacin lo llame).
Distribucin aplicaciones Web
Tal como se mencion anteriormente, una de las caractersticas ms tiles de ASP.NET es la llamada
distribucin sin retoques (zero-touch) que permite modificar y redistribuir una aplicacin ASP.NET sin
necesidad de reiniciar el servidor o dar de baja a los clientes Web.
Si se modifica un archivo de cdigo o un formulario Web, ASP.NET recompila automticamente la
nueva versin con la siguiente solicitud del cliente. Las nuevas solicitudes del cliente siempre
utilizarn la ltima versin compilada de la pgina ASP.NET.
ASP.NET utiliza compilacin automtica a cdigo nativo (MSIL) y mantiene las pginas Web en un
cach para mejorar el rendimiento.
Como consecuencia, es posible reemplazar cualquier ensamblado del directorio bin con una nueva
versin, an cuando la actual est en uso. Los archivos ASP.NET nunca se bloquean. Igualmente se
pueden aadir o eliminar ensamblados con el mismo resultado.
Ante una nueva modificacin ASP.NET se encarga de crear un nuevo dominio de aplicacin que ser
luego utilizada por cualquier nueva solicitud del cliente.
Cuando se finalizan todas las solicitudes existentes se eliminan los dominios de aplicacin de las
versiones ms antiguas tanto de los componentes como de las pginas Web ASP.NET.
Configuracin de aplicaciones Web
Cada aplicacin ASP.NET administra una configuracin propia de IIS. Esta configuracin se define
utilizando el archivo web.config (uno por aplicacin). El archivo de configuracin web.config
almacena la informacin de configuracin de la aplicacin en un archivo de texto en formato XML.
La modificacin de los archivos de configuracin de una aplicacin ASP.NET provocan que cuando
son volcados al servidor Web, se cree un nuevo dominio de aplicacin para las nuevas solicitudes de
los clientes.
Directorios virtuales
Los directorios virtuales se registran en IIS y pueden ser accedidos por cualquier cliente Web. Un
directorio virtual es una referencia a un directorio fsico dentro de una unidad de disco.
El contenido de un directorio virtual lo proporciona IIS a travs de una peticin de un cliente Web.
Dentro de un directorio virtual puede haber subdirectorios, pginas Web, archivos de configuracin y
otros tipos de archivos. Una aplicacin ASP.NET se debe alojar en un directorio virtual, de modo de
poder ser accedida por un cliente Web.
Los directorios virtuales se pueden recorrer, se puede ver su contenido o ejecutar el cdigo que
contiene (por ejemplo pginas ASP.NET). Cualquiera de estas peticiones se realizan a travs de IIS y
del motor de la aplicacin correspondiente (por ejemplo: el motor ASP.NET realiza el tratamiento de
las solicitudes a las pginas .aspx, .asmx y .ascx, entre otras).
Por ello, la forma en que se ven los archivos y subdirectorios contenidos en un directorio virtual (por
medio de un explorador Web) no es la misma que resultara de recorrer el mismo directorio [fsico]
utilizando el explorador de Windows.
Las pginas ASP.NET slo se pueden ejecutar desde un directorio virtual creado sobre IIS.
Un directorio virtual puede ser creado manualmente desde al Administrador del Equipo (el que debe
tener instalado IIS); y la forma ms rpida para hacerlo es la siguiente:
1) Desde el escritorio de Windows se debe ingresar al Administrador de equipos (esto slo funciona con
los sistemas operativos Windows NT 4.0 / 2000 y XP):

Figura 6

2) Una vez en el Administrador de equipos se debern seleccionar los Servicios de Internet Information
Server, y luego pararse en el Sitio Web predeterminado tal como se muestra continuacin:

Figura 7

Desde aqu es posible ver los distintos directorios virtuales creados en el quipo y los archivos que
contienen cada uno de ellos:
3) El siguiente paso ser crear un directorio virtual en el Sitio Web predeterminado. Para ello ser
necesario hacer clic con el botn derecho del Mouse y elegir la opcin Nuevo Directorio virtual.
Tambin se puede utilizar la Accin Nuevo Directorio Virtual presente en el men del Administrador de
equipos. Se debe recordar que el directorio virtual se crear debajo del directorio o Sitio Web
seleccionado:

Figura 8

4) Seleccionada esta opcin se abrir un asistente que nos indicar el resto de los pasos a seguir. El
asistente nos ir guiando en la creacin del directorio virtual y nos ir pidiendo una serie de datos
necesarios para la creacin de dicho directorio:

Figura 9

5) En primer lugar deberemos proporcionarle al Asistente el nombre (alias) para nuestro directorio virtual
(no tiene por que ser el mismo del directorio fsico).
El nombre del directorio virtual es el que utilizar el Explorador Web del cliente. Por ejemplo:
http://localhost/pruebas. Donde localhost ser el nombre del servidor Web (en nuestro caso) donde
est alojado el directorio virtual. Si la pgina est publicada en Internet, se utilizar el nombre del sitio
Web en lugar de localhost para acceder al directorio virtual y todo su contenido:

Figura 10

6) Despus, le indicaremos el nombre del directorio fsico al cual hace referencia nuestro directorio virtual.
Se debe tener en cuenta que debe ser un nombre de directorio existente, por lo cual habr que crearlo
previamente a la ejecucin de este Asistente:

Figura 11

7) Por ltimo, indicaremos el tipo de acceso (poltica de seguridad) disponible para este directorio para
todos los cliente Web que quieran ingresar al contenido del mismo.
Las opciones disponibles son: Lectura, Ejecucin de secuencias de comando (archivos ASP y
ASP.NET), Ejecucin de aplicaciones (ISAPI o CGI), Escritura y Examen del directorio para poder ver su
contenido. Estas opciones se podrn cambiar posteriormente desde el Administrador de Equipos.
Las acciones que podr efectuar el cliente Web sobre el directorio virtual dependern directamente de
las opciones que se seleccionen durante su creacin o las que se indiquen posteriormente.
Existen otras opciones de configuracin que estarn disponibles posteriormente a la creacin de nuestro
directorio virtual, a las cuales se podr acceder, tambin, desde el Administrador de Equipos:

Figura 12

8) Una vez completados todos estos pasos, el Asistente Finalizar la creacin de nuestro nuevo directorio
virtual y podremos volver al Administrador de Equipos (donde se deber visualizar el nuevo directorio
virtual).

Figura 13

El primer paso para poder ejecutar una pgina ASP.NET ser, entonces, crear el directorio virtual de
la aplicacin tal como se mostr anteriormente.

Visual Studio .NET proporciona una manera ms simple de crear un directorio virtual.
Cuando se crea un nuevo proyecto Web, Visual Studio .NET se encarga automticamente de la
creacin del directorio virtual, adems de crear los archivos web.config, global.asax y otros
predeterminados a los efectos de facilitar estas tareas al programador.
Creacin de aplicaciones ASP.NET
Una aplicacin ASP.NET, como se mencion previamente, debe consistir al menos de un archivo
.aspx para considerarse como tal.
Las aplicaciones ASP.NET ejecutan cdigo Visual Basic. Cuando se ejecuta una aplicacin de este
tipo el servidor Web crea una pgina en formato HTML consistente del cdigo HTML contenido en el
archivo .aspx ms el cdigo HTML proporcionado por la ejecucin del cdigo Visual Basic. Todo esto
es ejecutado por el motor de ASP.NET (consistente en una librera de enlace dinmico o archivo dll).
El resultado de la ejecucin del cdigo ASP.NET (siempre en HTML) se enva al cliente Web
(explorador Web). Los exploradores Web NO ejecutan cdigo ASP.NET. Slo un servidor IIS es
capaz de ejecutar este tipo de cdigo, y slo si previamente se ha instalado en l, el framework de
.NET.
Es importante aclarar que el cdigo que escribe el programador ASP.NET no es el mismo cdigo que
ve el Cliente Web.
Un archivo .aspx consiste de cdigo HTML ms scripts en lenguaje Visual Basic .NET, o simplemente
en cdigo HTML.
El archivo .aspx soporta una serie de tags (marcas) especiales para la construccin de la pgina Web
que slo pueden ser reconocidas por el motor ASP.NET.
Estas marcas especiales se utilizan para crear los formularios Web (Web Forms), que son la base de
las aplicaciones ASP.NET. Un formulario Web es el equivalente .NET de una pgina Web.
Los archivos .aspx son archivos de texto plano, por lo que pueden ser editados a travs de cualquier
editor de texto (tales como el notepad, wordpad u otros). A su vez, los entorno de desarrollo para la
plataforma .NET soportan la edicin de este tipo de archivos, pero a travs de una interfaz grfica.
El siguiente es un ejemplo de un archivo ASP.NET:

<html>
<script language="vb" runat="server">
Public Sub Page_Load()
Label1.Text = "Se ejecut el evento Load_Page."
End Sub
</script>

<body>
<form id="Form1" runat="server">
<asp:Label id="Label1" runat="server" />
</form>

</body>
</html>
Para probar el mismo, se puede crear un directorio virtual y copiar este cdigo dentro de un archivo
.aspx.
Supongamos que el directorio virtual se llame prueba y que el mismo apunta al directorio fsico
c:\prueba. Dentro de este directorio fsico crearemos con el notepad el archivo prueba1.aspx con el
cdigo arriba indicado.
Una vez hecho esto, cargaremos el explorador Web (Internet Explorer o similar) y ejecutaremos la
pgina Web. En este caso, y se creo la pgina Web en el equipo local se deber escribir la siguiente
direccin Web: http://localhost/prueba/prueba1.aspx.
El resultado que se debe obtener es el siguiente:

Figura 14

Si inspeccionamos el cdigo fuente de este archivo notaremos lo siguiente:

Figura 15

Como se puede ver, el cdigo HTML generado por el Servidor Web (el que interpreta el Explorador
Web) no coincide plenamente con el cdigo escrito para la pgina .aspx.
El tag del archivo .aspx:

<asp:Label id=Label1 runat=server/>

Fue reemplazado por el siguiente:

<span id=Label1>Se ejecut el evento Load_Page.</span>

Aparte, el servidor Web ha agregado informacin de estado de la pgina (View State). La razn de
este comportamiento reside en que el archivo .aspx no es en realidad una pgina Web sino una serie
de instrucciones escritas en ASP.NET que se encargan de elaborar una pgina HTML en forma
dinmica cuando se ejecuta el archivo .aspx. Tal como se mencion, el cdigo resultante es cdigo
HTML.
.NET asegura que sin importar cual sea el Explorador Web que est corriendo, ste ser siempre
capaz de visualizar una pgina escrita en ASP.NET. Para ello el servidor Web le proporciona al motor
de ASP.NET informacin de sesin respecto al cliente que hace llamada a la pgina. Esta informacin
incluye: el tipo de Explorador que esta corriendo en el cliente, informacin de sesin y de otro tipo,
que utiliza .NET, para crear la pgina Web que ser devuelta al cliente. Puede que dos versiones
distintas de clientes Web visualicen de manera distinta la misma pgina Web. Pero en ambos casos
la pgina estar siempre disponible.
Los tags <asp:> corresponden a controles Web que se crean en el servidor. Cada control Web (Web
control) se corresponde con un tag HTML equivalente (en realidad, cada tag ASP.NET puede
corresponderse con uno o con un conjunto de controles HTML).
La propiedad runat indica el cdigo que deber ser ejecutado del lado del servidor. Si no se indica (o
no se estable como server). El explorador Web del cliente no podr interpretar las marcas del
lenguaje o el cdigo Visual Basic .NET. El resultado ser, o bien un mensaje de error, o bien que no
se mostrar nada en el Explorador Web.

Introduccin a Visual Studio .NET A

Bibliografa
ASP.NET. Manual de Referencia
Mathew MacDonald, McGraw-Hill/Interamericana de Espaa, S.A.U., 2002
Curso de iniciacin a la programacin con Visual Basic .NET
Guilermo Som, 2002
.NET MSDN training Module 2: Development Environment Features
Microsoft Corporation, 2002
.NET MSDN training Module 3: Language and Syntax Enhancements
.NET MSDN training Module 4: Object-Oriented Design for Visual Basic .NET
.NET MSDN training Module 6: Using Windows Forms
.NET MSDN training Module 8: Using ADO.NET
MSDN Library for Visual Studio .NET 2003
Microsoft Corporation, 1987-2002
Colaboraciones
Marcela Garay Moyano
Gerencia de Sistemas Ministerio de Seguridad de la Provincia de Crdoba
Marcelo Salgado
Divisin de Desarrollo Informtico de la Polica de la Provincia de Crdoba

Introduccion A Visual Studio NET

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Introduccion A Visual Studio NET

Încărcat de

Drepturi de autor:

Formate disponibile

Introduccin a Visual Studio .

S-ar putea să vă placă și