Introduccion A Visual Studio NET

Introducción a Visual Studio .
NET
Manual de Referencia
por Federico Gabriel Rudolph
.NET
Primera Edición
Del Autor
2010
Material de Apoyo para
Cursos de Capacitación en .NET

Título original: Introducción a Visual Studio .NET
Autor: Federico G. Rudolph
Primera Edición Del Autor, 2010
Diseño 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 reproducción parcial o total, el almacenamiento, el alquiler, la

transmisión o la transformación de este libro, en cualquier forma o por cualquier
medio, sea electrónico o mecánico, mediante fotocopias, digitalización u otros
métodos, sin el permiso previo y escrito del editor. Su infracción está penada por la
ley.
Introducción a Visual Studio .NET i
Tabla de Contenidos
Tabla de Contenidos ...................................................................................... i
Introducción .................................................................................................. 1
Descripción de la plataforma.............................................................................................................1
Marco de trabajo .................................................................................................................................2
Compilación y ejecución de código..................................................................................................3
Ensamblados.......................................................................................................................................3
Características de los lenguajes .......................................................................................................5
Tipos de Datos ....................................................................................................................................5
Visual Basic .NET .......................................................................................... 7

Bases del lenguaje..............................................................................................................................7
Distinción entre mayúsculas y minúsculas....................................................................................................... 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
Parámetros por valor y por referencia............................................................................................................ 13
Sobrecarga de procedimientos y funciones ................................................................................................... 13
Delegados...................................................................................................................................................... 13
Espacios de Nombre ........................................................................................................................14
Importación de espacios de nombre .............................................................................................................. 14
Tratamiento de Excepciones ...........................................................................................................14
Captura de excepciones ................................................................................................................................ 15
Lanzamiento de excepciones......................................................................................................................... 15
ASP.NET ...................................................................................................... 16
Ejecución de aplicaciones Web ......................................................................................................16
Ejecución de aplicaciones ASP.NET ..............................................................................................16
Aplicaciones ASP.NET .....................................................................................................................17
Federico Gabriel Rudolph

Introducción a Visual Studio .NET ii
Tipos de archivos ASP.NET.............................................................................................................18

Distribución aplicaciones Web ....................................................................................................................... 19
Configuración de aplicaciones Web............................................................................................................... 19
Directorios virtuales .........................................................................................................................19
Creación de aplicaciones ASP.NET ................................................................................................24
Bibliografía .................................................................................................... A
Colaboraciones.............................................................................................. A

Introducción a Visual Studio .NET 1
Introducción
Descripción de la plataforma
.NET es una plataforma de ejecución 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 abstracción entre el Sistema Operativo y el código ejecutable,
encapsulando la totalidad de las API’s 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 librerías comunes (como,
por ejemplo, todo el conjunto de runtimes de Visual Basic) en una serie de librerías de clases, las que
pueden ser accedidas desde cualquier lenguaje soportado por esta plataforma de ejecución de
Aplicaciones en forma totalmente transparente y a un nivel más alto de programación que sucede con
otros lenguajes existentes.
Con esta plataforma, Microsoft pretende llevar al próximo 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 programación bajo un único criterio y disminuyendo el ciclo de Producción de las
Aplicaciones.
Como resultados inmediatos del uso de esta plataforma para la construcción de Aplicaciones se logra:
• La Disminución de los Tiempos de Desarrollo,
• La Compatibilidad, Portabilidad y Reutilización de Código entre plataformas operativas y

lenguajes de desarrollo.
Otros beneficios que otorga .NET son:

• La Transparencia de Ubicación de Código, y
• Un mejor Control de Versiones, tanto de la aplicación como de las librerías de clases.
.NET es un entorno de programación implementado a través del siguiente conjunto de tecnologías:
• Entornos de Desarrollo .NET (Visual Studio .NET, WebMatrix, Delphi 8 .NET etc.), los más
completos aportan una Interfaz de Diseño Visual para el programador con herramientas
suficientes para la codificación, ejecución y depuración de código fuente.
• Lenguajes de Desarrollo .NET, como por ejemplo: Visual Basic .NET, ASP.NET, Java#, C#,
Delphi 8 .NET y otros.
• Entorno Común de Ejecución (CLR, Common Language Runtime), CLR es el motor de

ejecución (intérprete) de .NET encargado de la ejecución de todos los programas escritos para
esta plataforma. Este motor, además, proporciona una serie de servicios como son: la
administración automática de memoria, servicios de seguridad, la optimización de recursos y el
recolector de basura entre otros. El entorno de ejecución 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 instalación que permite la ejecución de las aplicaciones
escritas en .NET.
• Biblioteca de Clases de .NET, esta biblioteca, integrada por una serie de DLL’s, recolecta
(encapsula) miles de funciones y procedimientos totalmente reutilizables por cualquier lenguaje
.NET; este conjunto de librerías reemplaza el uso de las librerías (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
comunicación entre procesos, entre otros. El beneficio directo del uso de esta biblioteca de
clases es una reducción 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 tecnologías. El entorno .NET permite contener en una misma
aplicación código escrito en diferentes lenguajes de programación haciendo uso (todos ellos)
de las mismas librerías de clases, ya sean propias del marco de trabajo, librerías desarrolladas
específicamente para su uso dentro de la Organización o librerías 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 ejecución para las
aplicaciones escritas para el entorno .NET.
En el siguiente dibujo se muestra cómo se comunican entre sí los diversos componentes de una
Aplicación .NET:
p licación .NET
A
it
Mo Web bForm T
AD XML
olK
BCL
We .NE
s
rne s
Inte rvice
tTo
O.
P
NE
bile Se
AS
CLR T
SO
Visual Basic .NET

WinForms
Figura 1
El código escrito bajo el entorno .NET se denomina código administrable. El código administrable
puede ser depurado por cualquier herramienta de depuración escrita para .NET. Una aplicación .NET
puede coexistir e interactuar con aplicaciones o elementos del Sistema que no han sido desarrollados
bajo esta tecnología; en cuyo caso el código dejaría 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 asignación de memoria a

medida que una Aplicación escrita para este entorno lo requiere. Consecuentemente, la liberación de
memoria se realiza automáticamente a través del “Recolector de Basura” de .NET. El Recolector de
Basura se encarga, también, de liberar cualquier conexión abierta, ya sea: conexiones de red,
conexiones a bases de datos y otras.

Compilación y ejecución de código

Para hacer posible el desarrollo de aplicaciones .NET Microsoft tuvo que rediseñar su conjunto de lenguajes para el marco
.NET rompiendo radicalmente la compatibilidad con las versiones anteriores.
El paquete de Instalación de Visual Studio .NET permite la instalación conjunta de Visual Basic .NET,
Java# (con sus respectivos subconjuntos de programación: 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 construcción de Clases utilizando Visual Basic .NET, por ejemplo,
haciendo uso e implementación de las tres características pilares de la Programación 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 código fuente será indefectiblemente compilado a un
mismo lenguaje intermedio, conocido como MSIL (Microsoft Intermediate Language), CIL ó
simplemente IL. El CLR sólo es capaz de ejecutar código IL, razón por la cual la mayoría de los
lenguajes .NET resultan muy similares. Como se mencionó al principio, Microsoft ha liberado un
conjunto de especificaciones para la construcción de lenguajes basados en .NET (CLS, Common
Language Specifications) que define los requisitos básicos y los estándares que permiten que otras
compañías escriban lenguajes ejecutables bajo el CLR (Common Language Runtime).
A continuación se puede ver cómo se lleva a cabo la ejecución de código .NET:
Código en Código enC# Código en otro

VB.NET lenguaje .NET
Compilador
Compilador Compilador otro
VB.NET C# lenguaje .NET
Código IL
(Lenguaje
Intermedio)
Ejecución del
código IL
a través del CLR
Figura 2
Ensamblados
El código IL se compila en módulos denominados Assemblies (Ensamblados), la mayor parte de las
veces estos Assemblies se alojan en DLL’s o archivos ejecutables (.EXE) independientes unos de
otros. Un Assembly puede contener toda una Librería de Clases o una única clase en su interior.

Para ejecutar un Assembly, el CLR utiliza el camino de búsqueda 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 código de las aplicaciones.
A diferencia de los Assemblies, los objetos COM que requieren ser registrados en el Registro de
Windows para su funcionamiento, no permitiéndose la coexistencia de diferentes versiones de
un mismo Objeto COM (Interfaz).
Además, cualquier cambio en la Interfaz de estos Objetos, obliga a que los mismos deban ser
registrados nuevamente.
La distribución de los Assemblies, por otra parte, se simplifica al tratarse simplemente de una
operación de copia de archivos. En caso de que el Assembly a reemplazar esté ejecutándose en
memoria a la hora de su actualización, la misma se hará en forma totalmente transparente, con lo
cual la aplicación que está corriendo continuará ejecutando la vieja versión del Assembly sin
enterarse de este proceso. La próxima vez que se cargue la aplicación, se cargarán y ejecutarán las
nuevas versiones de estos archivos.
La razón 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 versión, la próxima
llamada al Assembly se hará desde una copia más reciente (en este supuesto caso existirán dos
copias del Assembly – distintas versiones – en memoria a un mismo tiempo). La siguiente figura
explica este comportamiento.
Assembly
CACHE
Aplicaciones .NET Assembly

Assembly
Control de Versión
Versión A
Solicitudes de Servicio
Ve
rs
ió Versión B
n
n
ió
m
rs
ás
Ve
re
a
cie
ev
nt
Nu
Versión N
Figura 3
Una característica a tener en cuenta provista por .NET es el Sistema Común de Tipos para los datos
que van a ser procesados por la Aplicación. Los compiladores .NET contemplan esta característica a
los efectos de asegurar la compatibilidad binaria entre Assemblies, sin importar el lenguaje en el cual
fueron escritos.

Los compiladores .NET generan código Intermedio similar al código nativo de la CPU, pero
independiente de la Arquitectura de hardware.
Características de los lenguajes

Tanto Visual Basic. NET como ASP.NET siguen las mismas reglas de programación que Visual Basic
6, sobre todo en lo que respecta a la Sintaxis.
ASP.NET presenta un conjunto reducido de posibilidades (librería clases) para la creación de

Formularios [Web] debido a las limitaciones del entorno de ejecución final (limitaciones propias del
Explorador Web, que es desde donde se ejecuta la aplicación, 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 debería resultar muy fácil pasar del desarrollo de aplicaciones Web a
la creación 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
programación Orientado a Eventos antes que a Objetos), VB.NET implementa en un 100% los
requisitos necesarios para el desarrollo de aplicaciones orientadas a objetos:
• Construcción de Clases
• Manipulación de Objetos
• Implementación de Herencia, Polimorfismo y Encapsulamiento
• Definición de Propiedades, Métodos y Eventos
Tipos de Datos
Todos los lenguajes .NET utilizan los mismos tipos de datos para la definición 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
característica de la plataforma .NET permite el intercambio directo de datos entre módulos y
lenguajes de programación creados en distintos lenguajes en forma nativa, sin la necesidad de
efectuar conversión alguna.
Estos tipos básicos están proporcionados por la Biblioteca de Clases de .NET y son los que se
muestran en la tabla siguiente:
Tipo
Tipo de
Tipo de de
Dato en Contiene
Dato BCL Dato
VB.NET
en C#
Byte Byte byte Un entero de 0 a 255
Int16 Short short Un entero de –32.768 a 32.767

Un entero de –2.147.483.648 a
Int32 Integer int
2.147.483.647
Un entero de aproximadamente –
Int64 Long long
9.2e18 a 9.2e18
Un número decimal de precisión
Single Single float simple de aproximadamente –3.48e38
a 3.48e38
Un número decimal de doble precisión
Double Double double de aproximadamente –1.8e308 a
1.8e308
Un número de 128 bits fraccional de
Decimal Decimal decimal punto fijo que admite hasta 28 dígitos
significativos

Tipo
Tipo de
Tipo de de
Dato en Contiene
Dato BCL Dato
VB.NET
en C#
Char Char Char Un único character Unicode de 16 bits
Una serie de caracteres de longitud
String String string
variable de caracteres Unicote
Boolean Boolean bool Un valor True o False
Cualquier día y hora desde las 12:00
am del 1 de enero del año 1 del
calendario gregoriano hasta las 11:59
DateTime Date N/A pm del 31 de diciembre del año 9.999.
Los valores hora tienen un intervalo de
100 nanosegundos. Internamente, este
tipo de datos es un entero de 64 bits
Un período de tiempo. El intervalo más
TimeSpan N/A N/A pequeño posible es 1 “tick” (cien
nanosegundos)
La clase base de todos los tipos .NET.
Object Object object 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 están 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 genérico 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 precisión de lo normal (hasta nanosegundos).
Como mención 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 dinámica operaciones de manipulación de
listas que involucren: cambio de tamaño, cambio en el orden de los ítems, inserción, 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 básicos mencionados, es también una clase o tipo de objeto).
Las colecciones proveen en forma nativa los métodos y propiedades necesarias para la ejecución de
los procesos mencionados y otros.
Además 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 sección anterior se describió, brevemente, el comportamiento, características y tipos de datos
disponibles con cualquier lenguaje .NET.
En esta sección se explicará en forma más detallada la sintaxis, consideraciones y utilización de

algunos componentes del lenguaje Visual Basic .NET y ASP.NET.
La información disponible en esta sección está destinada a brindarle al programador una orientación
respecto al correcto uso del lenguaje y las diferentes posibilidades de implementación existentes.
Todos los lenguajes .NET comparten los mismos conceptos aquí volcados y requieren de los mismos
conocimientos; con lo que, nuevamente, debería resultar muy fácil pasar de programar de un lenguaje
a otro sobre esta plataforma de trabajo (por ejemplo: de VB.NET a C#). Las diferencias se encuentran
más que nada en la estructura del lenguaje, antes de que en los tipos de datos, procedimientos,
funciones, clases, objetos y librerías disponibles.
Realmente, cualquier código escrito en un lenguaje .NET debería ser pasible de ser traducido en un
100% a otro lenguaje .NET sin mayores inconvenientes. Igualmente, el paso de un lenguaje a otro no
debería representar ninguna mejora en la ejecución del código o en la administración de los recursos
del sistema, tales como la memoria; como tampoco en la velocidad de ejecución, ya que recordemos
que el compilador del lenguaje genera código MSIL, y en última instancia este es único código que se
ejecuta. Por ello, la decisión en cuanto al lenguaje de programación es una cuestión más bien de tipo
personal.
Esto es tan cierto, que como contrapartida y para mejorar el rendimiento, la interoperabilidad, el
conjunto de características 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

Distinción entre mayúsculas y minúsculas
Al igual que sus antecesores VB.NET no hace distinción entre mayúsculas y minúsculas.
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 apóstrofe y no pueden extenderse más allá
del final de línea.
‘Esta es una línea de comentario

‘Esta es otra línea de comentario
Sentencias
En Visual Basic no se utilizan caracteres para indicar un final de línea tal como sucede con C# y otros
lenguajes; las sentencias se escriben en una única línea (se puede escribir una sentencia en varias
líneas utilizando el carácter de subrayado “_”, pero se seguirá considerando la sentencia como una
sola línea).

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 construcción (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 tamaño.
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 (métodos) directamente a un
string. Algunas funciones (propiedades y métodos) disponibles para los strings son:
Miembro de la clase
Descripción
String
Length Devuelve un Entero con la longitud de la cadena
ToUpper() Convierte la cadena a mayúsculas
ToLower() Convierte la cadena a minúsculas
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() Añade caracteres a la izquierda de la cadena
PadRight() Añade 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

Determina si una cadena comienza con una subcadena
StartsWith()
especificada
Determina si una cadena termina con una subcadena
EndsWith()
especificada
Encuentra la primera posición que ocupa una subcadena
IndexOf()
dentro de una cadena
Encuentra la última posición que ocupa una subcadena dentro
LasIndexOf()
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 declaración de variables puede ir seguida, además, por un valor inicial para la misma:

Dim ErrorCode As Integer = 10

Dim Nombre As String = “Andrés”
En Visual Basic .NET se puede utilizar una variable sin inicializar. Los números se inicializan
automáticamente a 0 y las cadenas a una cadena vacía (“”).
Visual Basic .NET establece por defecto la cláusula 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 compilación. Es conveniente mantener esta opción en ON para
mejorar el estilo de programación y facilitar la compilación de código.
La opción OPTION EXPLICIT puede indicarse dentro del código del programa, o bien desde las
opciones del proyecto.
Arrays
Los vectores se declaran indicando la cantidad de elementos por cada dimensión. Por defecto el
límite inferior de un vector (elemento menor) es 0.
‘Declaración 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 declaración:
‘Declaración e inicialización de arrays en una sóla instrucción

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 número o números de índice encerrados
entre corchetes:
‘Manipulación 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 cláusula 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
‘Código
‘Código
‘Código
Next
Para redimensionar un array se utiliza la cláusula 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 sólo se pueda
modificar la última dimensión, de otro modo producirá un error en tiempo de ejecución:
‘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 ejecución

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 métodos, 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 sinnúmero de colecciones predefinidas que pueden

ser utilizadas por el programador. La manipulación de una colección 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
código 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:
‘Definición 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 deberían 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

Accesible sólo desde procedimientos de la clase actual
Private
(predeterminado si no se indica otro)
Accesible desde cualquier procedimiento del Ensamblado
Friend
actual
Accesible desde cualquier procedimiento de la clase y desde
Protected
cualquier procedimientos de clases que hereden de la actual
Accesibles desde cualquier procedimiento de la aplicación y
Protected Friend desde cualquier procedimiento de clases que hereden de la
actual
Tabla 3

Además, si se define una variable dentro de un bloque de código (cláusa FOR, por ejemplo), la misma
será accesible sólo dentro de dicho bloque:
‘Ámbito a nivel de bloque

For i = 0 to 10
Dim Aux As Integer
‘La variable AUX sólo es visible dentro de este bloque FOR
Next
‘La variable AUX no es visible fuera del bloque FOR
Operaciones con variables

Además de los operadores estándar para operaciones matemáticas (+, -, /, *, ^) y expresiones de tipo
String (+ ó &) Visual Basic .NET expone una serie de abreviaturas de asignación y operación:
Operador Descripción
+= Asignación y suma
&= Asignación y concatenación de strings
-= Asignación y resta
*= Asignación y multiplicación
/= Asignación y división (devuelve un decimal)
\= Asignación y división (devuelve un entero)
^= Asignación y exponenciación
<<= Desplazamiento a la izquierda
>>= Desplazamiento a la dercha
Tabla 4
A continuación se muestran algunos ejemplos y sus correspondientes equivalencias de estos

operadores:
‘Asignación y suma (Equivale a X = X + 10)

X += 10
‘Asignación y resta (Equivale a X = X - 10)

X -= 10
‘Asignación y multiplicación (Equivale a X = X * 10)
X *= 10
‘Asignación y división (Equivale a X = X / 10)
X /= 10
Conversiones de tipo
Visual Basic .NET permite la restricción de conversiones automáticas de tipo a través de la cláusula
OPTION STRICT establecida en ON al principio de una archivo de código. En este caso las
conversiones de tipo se deberán especificar en forma explícita (por ejemplo, para convertir una
variable de tipo String en numérica).
En caso de requerir una conversión de tipo, lo normal es hacer uso de la función CTYPE.
Es conveniente indicar la cláusula OPTION STRICT para evitar errores de conversión en tiempo de
ejecución y que los mismos sean minimizados a la hora de la compilación del código fuente. Esta
opción se puede establecer también desde las propiedades del proyecto.
La conversión 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 conversión 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:
‘Cláusula If
If x > 10 Then
‘Sentencias
End If
‘Cláusula If/ElseIf/Else
If x > 10 Then
‘Sentencias
ElseIf x < 5 Then
‘Otras sentencias
Else
‘Otras sentencias
End If
‘Cláusula 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:
‘Cláusula For
Dim i As Integer
For i = 1 To 10 Step 1
‘Este código se ejecuta 10 veces
Next
‘Cláusula Do
Dim i As Integer = 1
Do
i += 1
Loop While i < 10
‘Cláusula 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 paréntesis (en
todos los casos), aún cuando no se indique ningún parámetro.
En el caso de las funciones se puede utilizar o bien el nombre de la función o bien la palabra
reservada RETURN para devolver el resultado de la función.
La declaración de parámetros (si no se especifica de forma explícita) se establece por valor (BYVAL)
a los efectos de asegurar un mayor nivel de protección y claridad.

Visual Basic .NET permite la declaración de parámetros opcionales. En este caso se deberá
establecer el valor por defecto de los mismos:
‘Declaración de un procedimiento con parámetros opcionales

Private Sub Algo(ByVal Optional Parametro1 As Integer = 20)
Parámetros por valor y por referencia
Los procedimientos admiten dos tipos de parámetros: por valor o por referencia. Cuando los
parámetros 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 parámetro, permitiendo su modificación dentro del mismo (el cambio se propaga al
procedimiento que efectuó la llamada).
Por esta causa, los parámetros declarados por referencia sólo admiten el paso de variables. Los
parámetros 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 más de
una función o procedimiento con el mismo nombre variando el tipo y cantidad de parámetros.
El CLR al momento de su ejecución, elegirá automáticamente el procedimiento correcto para cada

caso. Lo que hace el CLR es examinar el orden y tipo de parámetros pasados al procedimiento o
función en cuestión y ejecutar la versión que se corresponda con este orden y tipo de parámetros.
No puede haber más que una versión del procedimiento o función con un mismo tipo y orden de
parámetros. De otro modo el CLR no podrá distinguir cuál es la función o procedimiento a ejecutar
(independientemente del nombre de los parámetros utilizados).
Para sobrecargar un procedimiento se utiliza la palabra reservada OVERLOADS, tal como se muestra
a continuación:
‘Sobrecarga de un procedimiento
Private Overloads Function GetDomicilio(IdPersona As Integer) As String
‘Código de la función
End Function
Private Overloads Function GetDomicilio(Ape As String, Nom AsString) As String
‘Código de la función
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 función.
Los delegados se declaran con la palabra reservada DELEGATE indicando el orden y tipo de
parámetros para el prototipo de la función o procedimiento:
‘Declaración 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
‘Código de la función de búsqueda 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 construcción para los eventos. Aunque se
utilizan a un nivel más elevado y transparente dentro del lenguaje.
Espacios de Nombre
A los efectos de ordenar y reutilizar trozos de código 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.
Además, es posible declarar un espacio de nombre dentro de otro. Para declara un espacio de
nombres se utiliza la cláusula NAMESPACE:
‘Declaración de espacios de nombres

Namespace System
NameSpace Web
‘Declaración de clases, procedmientos, funciones, etc.
End Namespace
End Namespace
El espacio de nombres “System” contiene todos los tipos básicos 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
‘Código del procedimiento
End Sub
End Namespace
NameSpace ODBC
Private Function GetConn(ConnString As String) As ODBCConn
‘Código del procedimiento
End Sub
End Namespace
End NameSpace
Dim ADOConnection As ADOConn = DataAccess.ADO.GetConn(“”)
Dim ODBCConnection As ODBCConn = DataAccess.ODBC.GetConn(“”)
Importación de espacios de nombre
En lugar de tener que escribir el nombre completamente cualificado Visual Basic .NET permite la
importación de espacios de nombre, permitiendo el uso de los elementos en forma más directa. Para
importar espacios de nombre se utiliza la cláusula IMPORTS. Estas sentencias deben aparecer al
comienzo del archivo de código, fuera de cualquier espacio de nombre o estructura de código.
‘Importación 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 ejecución.
El código que el programador considera potencialmente peligroso (que pude producir un error en
tiempo de ejecución) se deberá encerrar entre las cláusulas TRY y las cláusulas CATCH o FINALLY
para poder manipular los errores que puedan llegar a producirse al momento de ejecutar el programa.

En caso de producirse algún error, el programa ejecutará el código que sigue a la palabra reservada
CATCH o FINALLY (alguna de las dos deberá estar presente).
El código que sigue a FINALLY siempre se ejecuta, independientemente de que se haya producido
un error o no. El bloque de código después de FINALLY sirve para asegurar la ejecución de
determinados comandos de cierre y liberación de variables, conexiones y otros.
Si se quiere salir del bloque de protección ofrecido por TRY se puede utilizar la cláusula EXIT TRY.
Try
‘Código que puede fallar
‘Se puede usar la cláusula EXIT TRY para salir de este bloque
Catch
‘Código de captura de excepciones
Finally
‘Código de finalización que siempre se ejecuta
End Try
El uso de la cláusula TRY permite la protección de código en tiempo de ejecución.
Captura de excepciones
La cláusula CATCH permite tratar cada error en forma general o particular. Si se quiere tratar algún
tipo de error en forma específica se deberá indicar el tipo de Excepción. Puede haber más de una
cláusula CATCH dentro de un mismo bloque TRY.
Los errores son objetos que derivan de la clase “Exception” o alguna de sus hijas.
La cláusula FINALLY se destina para asegura la liberación de recursos, aún cuando se haya
producido un error.
Private Sub CodigoConErrores

Dim Resultado As Integer
Try
‘Esto provoca una división por cero
Resultado = 22 / 0
‘Esta línea no se ejecuta
MessageBox.Show(Resultado)
Catch E As Exception
‘Muestra el error
MessageBox.Show(E.Message)
Finally
‘Esta línea siempre se ejecuta
MessageBox(“Fin”)
End Try
End Sub
Lanzamiento de excepciones
Además de capturar y tratar los errores en tiempo de ejecución es posible generar nuestros propios
errores y pasárselos a la clásula CATCH o FINALLY utilizando la cláusula THROW.
Si se utiliza la cláusula THROW fuera de un bloque TRY o después de las cláusulas 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 módulo 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 página Web, los Servidores Web deben ejecutar
algún software que haga posible el intercambio de correo electrónico, 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 básicas de un servidor Web son:
• Alojamiento de archivos
• Respuesta a peticiones de servicio de los clientes
Ejecución de aplicaciones Web

Para desarrollar páginas Web utilizando ASP.NET es necesario contar con un Servidor Web corriendo
IIS, para cubrir estas funciones.
IIS, ante cualquier solicitud de un cliente, evalúa 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 página Web HTML o un archivo FTP, el servidor simplemente envía la página solicitada al
cliente y este la muestra utilizando para ello el Explorador Web que está corriendo localmente. El
servidor no ejecuta ninguna acción más que enviar una copia del archivo al cliente previamente
autenticando los permisos del usuario remoto.
Ejecución de aplicaciones ASP.NET

El caso de las páginas ASP.NET es enteramente distinto.
Una página ASP.NET contiene en su interior código HTML más código ASP.NET.
En consecuencia, la ejecución de una página ASP.NET es muy distinta a la ejecución de una página
HTML.
Además, las páginas ASP.NET se pueden ejecutar, parte en el cliente (por el Explorador Web) y parte
en el Servidor Web (a través de IIS).
Las páginas ASP.NET son páginas dinámicas, ya que una misma página se puede ver de muy
distintas maneras dependiendo de lo que indique el usuario (permiten la interacción 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 ejecución de este tipo de páginas Web.
Cuando un cliente Web solicita una página ASP.NET el servidor Web accede a la página ASP.NET,
ejecuta el código contenido en la misma y devuelve al cliente una página HTML que se corresponde
con la petición solicitada. La página HTML se construye en el momento.
En algunos casos, la página HTML devuelta se acompaña de código JScript.
El servicio ASP.NET asegura la devolución de una página HTML al cliente 100% compatible con el
Explorador Web que se esté ejecutando. Esto garantiza que una misma página ASP.NET pueda ser
“ejecutada” desde prácticamente cualquier explorador Web. El cliente no necesita ninguna
configuración o instalación adicional para ejecutar este tipo de código. Realmente es el servidor Web
el único que puede interpretar código 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 páginas ASP.NET llevan
la extensión aspx, a diferencia de las páginas ASP (extensión .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 aplicación 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 configuración, imágenes y otros. El ámbito de una aplicación ASP.NET
está establecido, primeramente, por la carpeta contenedora de dicha aplicación, y, en segundo lugar,
por los recursos comunes que utiliza durante su ejecución.
Una aplicación ASP.NET es una combinación de archivos, páginas, manejadores, módulos y código
ejecutable que puede invocarse desde un directorio virtual (y, opcionalmente, sus subdirectorios) de
un servidor Web. El directorio virtual es la estructura de agrupación básica que delimita una aplicación
ASP.NET.
Las aplicaciones ASP.NET se ejecutan siempre sobre un servidor ASP (IIS).
Las aplicaciones ASP.NET pueden estar compuestas por varias páginas Web, pero siempre se
ejecutan dentro de un dominio de aplicación separado del resto de las aplicaciones. Los dominios de
aplicación se aíslan en memoria, lo que provoca que cualquier error dentro de la aplicación no afecte
a otras aplicaciones que estén corriendo simultáneamente en el mismo servidor Web.
Una aplicación ASP.NET no puede acceder a la información de otra aplicación que esté almacenada
en la memoria del servidor. Cada aplicación que corre en un servidor Web tiene su propio conjunto de
caché, aplicación y estados de sesión.

Figura 5
Tipos de archivos ASP.NET

Las aplicaciones ASP.NET admiten varios tipos de archivos diferentes. Visual Studio .NET añade
automáticamente 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 creación de estos
archivos al programador.
Una aplicación 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
aplicación ASP.NET.
Tipo de
Uso
archivo
Páginas ASP.NET con la interfaz del usuario y parte o todo del código
*.aspx subyacente. Los usuarios solicitan o navegan directamente a una de
estas páginas para iniciar la aplicación Web.
Controles de usuario ASP.NET. Los controles de usuario permiten
*.ascx
desarrollar piezas de la interfaz de usuario para su posterior reutilización.
Servicios Web ASP.NET. Son trozos de código que se ejecutan en un
*.asmx
servidor Web y que pueden ser llamados por distintas aplicaciones.
Archivo de configuración de la aplicación en formato XML. Incluye
web.config opciones de seguridad personalizada, administración de estados,
administración de memoria y otros.
Archivo global de la aplicación, utilizado para la definición de variables y
global.asax
acciones de eventos globales de la aplicación.
*.disco,
Archivos de descripción.
*.vsdisco
Archivos de código escritos en VB.NET con la lógica del programa
*.vb
cuando ésta se separa de la página Web.
*.resx Archivos de recursos asociados a la aplicación.
Archivos de información de soluciones y proyectos. Contienen las
*.sln, *.suo,
opciones del Entorno de Trabajo (VS.NET) para el proyecto o solución.
*.vbproj
Se utilizan durante el desarrollo y son exclusivos de VS.NET.
Tabla 5

Otros archivos que se pueden encontrar asociados a una aplicación ASP.NET son: las hojas de estilo
en cascada (CSS), archivos de imágenes (bmp, gif, jpg y jpeg) y otros.
En caso de utilizarse ensamblados en una aplicación ASP.NET (DLL’s y archivos ejecutables) los
mismos estarán dentro del directorio “bin” de la aplicación.
ASP.NET detecta automáticamente la presencia de cualquier archivo ubicado en este directorio y lo

ejecuta inmediatamente de ser necesario (siempre que la aplicación lo llame).
Distribución aplicaciones Web
Tal como se mencionó anteriormente, una de las características más útiles de ASP.NET es la llamada
distribución sin retoques (zero-touch) que permite modificar y redistribuir una aplicación ASP.NET sin
necesidad de reiniciar el servidor o dar de baja a los clientes Web.
Si se modifica un archivo de código o un formulario Web, ASP.NET recompila automáticamente la

nueva versión con la siguiente solicitud del cliente. Las nuevas solicitudes del cliente siempre
utilizarán la última versión compilada de la página ASP.NET.
ASP.NET utiliza compilación automática a código nativo (MSIL) y mantiene las páginas Web en un
caché para mejorar el rendimiento.
Como consecuencia, es posible reemplazar cualquier ensamblado del directorio “bin” con una nueva
versión, aún cuando la actual esté en uso. Los archivos ASP.NET nunca se bloquean. Igualmente se
pueden añadir o eliminar ensamblados con el mismo resultado.
Ante una nueva modificación ASP.NET se encarga de crear un nuevo dominio de aplicación que será
luego utilizada por cualquier nueva solicitud del cliente.
Cuando se finalizan todas las solicitudes existentes se eliminan los dominios de aplicación de las
versiones más antiguas tanto de los componentes como de las páginas Web ASP.NET.
Configuración de aplicaciones Web
Cada aplicación ASP.NET administra una configuración propia de IIS. Esta configuración se define
utilizando el archivo “web.config” (uno por aplicación). El archivo de configuración “web.config”
almacena la información de configuración de la aplicación en un archivo de texto en formato XML.
La modificación de los archivos de configuración de una aplicación ASP.NET provocan que cuando
son volcados al servidor Web, se cree un nuevo dominio de aplicación 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 físico dentro de una unidad de disco.
El contenido de un directorio virtual lo proporciona IIS a través de una petición de un cliente Web.
Dentro de un directorio virtual puede haber subdirectorios, páginas Web, archivos de configuración y
otros tipos de archivos. Una aplicación 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 código que
contiene (por ejemplo páginas ASP.NET). Cualquiera de estas peticiones se realizan a través de IIS y
del motor de la aplicación correspondiente (por ejemplo: el motor ASP.NET realiza el tratamiento de
las solicitudes a las páginas .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 resultaría de recorrer el mismo directorio [físico]
utilizando el explorador de Windows.
Las páginas ASP.NET sólo 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 más rápida para hacerlo es la siguiente:
1) Desde el escritorio de Windows se debe ingresar al Administrador de equipos (esto sólo funciona con
los sistemas operativos Windows NT 4.0 / 2000 y XP):
Figura 6
2) Una vez en el Administrador de equipos se deberán seleccionar los “Servicios de Internet Information
Server”, y luego pararse en el “Sitio Web predeterminado” tal como se muestra continuación:
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 botón derecho del Mouse y elegir la opción “Nuevo Directorio virtual”.

También se puede utilizar la Acción 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 opción se abrirá un asistente que nos indicará el resto de los pasos a seguir. El
asistente nos irá guiando en la creación del directorio virtual y nos irá pidiendo una serie de datos
necesarios para la creación 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 físico).

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 página 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) Después, le indicaremos el nombre del directorio físico 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 ejecución de este Asistente:
Figura 11
7) Por último, indicaremos el tipo de acceso (política de seguridad) disponible para este directorio para
todos los cliente Web que quieran ingresar al contenido del mismo.

Las opciones disponibles son: Lectura, Ejecución de secuencias de comando (archivos ASP y
ASP.NET), Ejecución de aplicaciones (ISAPI o CGI), Escritura y Examen del directorio para poder ver su
contenido. Estas opciones se podrán cambiar posteriormente desde el Administrador de Equipos.
Las acciones que podrá efectuar el cliente Web sobre el directorio virtual dependerán directamente de
las opciones que se seleccionen durante su creación o las que se indiquen posteriormente.
Existen otras opciones de configuración que estarán disponibles posteriormente a la creación de nuestro
directorio virtual, a las cuales se podrá acceder, también, desde el Administrador de Equipos:
Figura 12
8) Una vez completados todos estos pasos, el Asistente Finalizará la creación 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 página ASP.NET será, entonces, crear el directorio virtual de
la aplicación tal como se mostró anteriormente.
Visual Studio .NET proporciona una manera más simple de crear un directorio virtual.
Cuando se crea un nuevo proyecto Web, Visual Studio .NET se encarga automáticamente de la
creación del directorio virtual, además de crear los archivos web.config, global.asax y otros
predeterminados a los efectos de facilitar estas tareas al programador.
Creación de aplicaciones ASP.NET

Una aplicación ASP.NET, como se mencionó previamente, debe consistir al menos de un archivo
.aspx para considerarse como tal.
Las aplicaciones ASP.NET ejecutan código Visual Basic. Cuando se ejecuta una aplicación de este
tipo el servidor Web crea una página en formato HTML consistente del código HTML contenido en el
archivo .aspx más el código HTML proporcionado por la ejecución del código Visual Basic. Todo esto
es ejecutado por el motor de ASP.NET (consistente en una librería de enlace dinámico o archivo “dll”).
El resultado de la ejecución del código ASP.NET (siempre en HTML) se envía al cliente Web
(explorador Web). Los exploradores Web NO ejecutan código ASP.NET. Sólo un servidor IIS es
capaz de ejecutar este tipo de código, y sólo si previamente se ha instalado en él, el framework de
.NET.
Es importante aclarar que el código que escribe el programador ASP.NET no es el mismo código que
ve el Cliente Web.
Un archivo .aspx consiste de código HTML más scripts en lenguaje Visual Basic .NET, o simplemente
en código HTML.
El archivo .aspx soporta una serie de tags (marcas) especiales para la construcción de la página Web
que sólo 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 página Web.
Los archivos .aspx son archivos de texto plano, por lo que pueden ser editados a través 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 edición de este tipo de archivos, pero a través de una interfaz gráfica.
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 código dentro de un archivo
.aspx.
Supongamos que el directorio virtual se llame “prueba” y que el mismo apunta al directorio físico
“c:\prueba”. Dentro de este directorio físico crearemos con el notepad el archivo “prueba1.aspx” con el
código arriba indicado.

Una vez hecho esto, cargaremos el explorador Web (Internet Explorer o similar) y ejecutaremos la
página Web. En este caso, y se creo la página Web en el equipo local se deberá escribir la siguiente
dirección Web: “http://localhost/prueba/prueba1.aspx”.
El resultado que se debe obtener es el siguiente:
Figura 14
Si inspeccionamos el código fuente de este archivo notaremos lo siguiente:
Figura 15

Como se puede ver, el código HTML generado por el Servidor Web (el que interpreta el Explorador
Web) no coincide plenamente con el código escrito para la página .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 información de estado de la página (View State). La razón de
este comportamiento reside en que el archivo .aspx no es en realidad una página Web sino una serie
de instrucciones escritas en ASP.NET que se encargan de elaborar una página HTML en forma
dinámica cuando se ejecuta el archivo .aspx. Tal como se mencionó, el código resultante es código
HTML.
.NET asegura que sin importar cual sea el Explorador Web que esté corriendo, éste será siempre
capaz de visualizar una página escrita en ASP.NET. Para ello el servidor Web le proporciona al motor
de ASP.NET información de sesión respecto al cliente que hace llamada a la página. Esta información
incluye: el tipo de Explorador que esta corriendo en el cliente, información de sesión y de otro tipo,
que utiliza .NET, para crear la página Web que será devuelta al cliente. Puede que dos versiones
distintas de clientes Web visualicen de manera distinta la misma página Web. Pero en ambos casos
la página 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 código 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 código Visual Basic .NET. El resultado será, o bien un mensaje de error, o bien que no
se mostrará nada en el Explorador Web.

Introducción a Visual Studio .NET A
Bibliografía
ASP.NET. Manual de Referencia
Mathew MacDonald, McGraw-Hill/Interamericana de España, S.A.U., 2002
Curso de iniciación a la programación 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 Córdoba
Marcelo Salgado
División de Desarrollo Informático de la Policía de la Provincia de Córdoba

Introduccion A Visual Studio NET

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Introduccion A Visual Studio NET

Cargado por

Copyright:

Formatos disponibles

Introducción a Visual Studio .

Material de Apoyo para

Cursos de Capacitación en .NET

Autor: Federico G. Rudolph

Primera Edición Del Autor, 2010

Diseño de portada: Federico G. Rudolph

Copyright © Federico G. Rudolph, 2004 – 2010

Para contactar con el autor:

No se permite la reproducción parcial o total, el almacenamiento, el alquiler, la

Tabla de Contenidos ...................................................................................... i

Visual Basic .NET .......................................................................................... 7

Federico Gabriel Rudolph

Tipos de archivos ASP.NET.............................................................................................................18

Federico Gabriel Rudolph

• La Disminución de los Tiempos de Desarrollo,

• La Compatibilidad, Portabilidad y Reutilización de Código entre plataformas operativas y

Otros beneficios que otorga .NET son:

• Un mejor Control de Versiones, tanto de la aplicación como de las librerías de clases.

.NET es un entorno de programación implementado a través del siguiente conjunto de tecnologías:

• Entorno Común de Ejecución (CLR, Common Language Runtime), CLR es el motor de

Federico Gabriel Rudolph

Visual Basic .NET

El motor .NET es el encargado de gestionar las peticiones de acceso y asignación de memoria a

Federico Gabriel Rudolph

Compilación y ejecución de código

A continuación se puede ver cómo se lleva a cabo la ejecución de código .NET:

Código en Código enC# Código en otro

Federico Gabriel Rudolph

Aplicaciones .NET Assembly

Federico Gabriel Rudolph

Características de los lenguajes

ASP.NET presenta un conjunto reducido de posibilidades (librería clases) para la creación de

• Implementación de Herencia, Polimorfismo y Encapsulamiento

• Definición de Propiedades, Métodos y Eventos

Int16 Short short Un entero de –32.768 a 32.767

Federico Gabriel Rudolph

Un tipo enumerado representa y se define como un conjunto finito de constantes, identificadores o

Federico Gabriel Rudolph

Visual Basic .NET

En esta sección se explicará en forma más detallada la sintaxis, consideraciones y utilización de

Bases del lenguaje

Las siguientes declaraciones son equivalentes:

‘Esta es una línea de comentario

Federico Gabriel Rudolph

ToUpper() Convierte la cadena a mayúsculas

ToLower() Convierte la cadena a minúsculas

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() Añade caracteres a la izquierda de la cadena

PadRight() Añade 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

Join() Une un vector de subcadenas en una cadena

Dim ErrorCode As Integer

Dim ErrorCode As System.Int32

Federico Gabriel Rudolph

Dim ErrorCode As Integer = 10

‘Declaración de un vector de 10 elementos

‘Declaración e inicialización de arrays en una sóla instrucción

Los arrays pueden incluir cualquier tipo de datos.