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: [email protected]

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

Federico Gabriel Rudolph

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

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ódi go 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:

SO

ADO

.NET

XML

AS

P.N

ET

Web

Form

sW

ebS

ervi

ces

Mob

ile In

tern

etTo

olK

it

Visual Basic .NETWinForms

CLR

BCL

Aplicación .NET

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 enVB.NET

Código enC# Código en otrolenguaje .NET

CompiladorVB.NET

CompiladorC#

Compiladorotro

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.

Solicitudes de Servicio

Aplicaciones .NET Assembly

AssemblyCACHE

Assembly

Versión A

Versión B

Versión N

Control de Versión

Nueva

Ver

sión

Versión más reciente

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 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 número decimal de precisión simple de aproximadamente –3.48e38 a 3.48e38

Double Double double Un número decimal de doble precisión de aproximadamente –1.8e308 a 1.8e308

Decimal Decimal decimal Un número de 128 bits fraccional de punto fijo que admite hasta 28 dígitos 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 día y hora desde las 12:00 am del 1 de enero del año 1 del calendario gregoriano hasta las 11:59 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

TimeSpan N/A N/A Un período de tiempo. El intervalo más pequeño 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 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 String Descripción

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

StartsWith() Determina si una cadena comienza con una subcadena especificada

EndsWith() Determina si una cadena termina con una subcadena especificada

IndexOf() Encuentra la primera posición que ocupa una subcadena dentro de una cadena

LasIndexOf() Encuentra la última posición 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 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

Private Accesible sólo 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 aplicación y 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 ‘Este código se ejecuta 10 veces i += 1 Loop While i < 10 ‘Cláusula Do While Dim i As Integer = 1 Do While i < 10 ‘Este código se ejecuta 10 veces 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 archivo Uso

*.aspx Páginas ASP.NET con la interfaz del usuario y parte o todo del código subyacente. Los usuarios solicitan o navegan directamente a una de estas páginas para iniciar la aplicación Web.

*.ascx Controles de usuario ASP.NET. Los controles de usuario permiten desarrollar piezas de la interfaz de usuario para su posterior reutilización.

*.asmx Servicios Web ASP.NET. Son trozos de código que se ejecutan en un servidor Web y que pueden ser llamados por distintas aplicaciones.

web.config Archivo de configuración de la aplicación en formato XML. Incluye opciones de seguridad personalizada, administración de estados, administración de memoria y otros.

global.asax Archivo global de la aplicación, utilizado para la definición de variables y acciones de eventos globales de la aplicación.

*.disco, *.vsdisco Archivos de descripción.

*.vb Archivos de código escritos en VB.NET con la lógica del programa cuando ésta se separa de la página Web.

*.resx Archivos de recursos asociados a la aplicación.

*.sln, *.suo, *.vbproj

Archivos de información de soluciones y proyectos. Contienen las opciones del Entorno de Trabajo (VS.NET) para el proyecto o solución. 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 Ba sic .NET Guilermo Som, 2002

.NET MSDN training – Module 2: Development Environm ent Features Microsoft Corporation, 2002

.NET MSDN training – Module 3: Language and Syntax Enhancements Microsoft Corporation, 2002

.NET MSDN training – Module 4: Object-Oriented Desi gn for Visual Basic .NET Microsoft Corporation, 2002

.NET MSDN training – Module 6: Using Windows Forms Microsoft Corporation, 2002

.NET MSDN training – Module 8: Using ADO.NET Microsoft Corporation, 2002

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

Documents

Introduccion a Visual Studio NET