Programación II

Visual Basic .NET

----------------------------------------------------------------------------------------------------------

MÓDULO 1 : INTRODUCCION A LA PLATAFORMA .NET

1.1 QUE ES LA PLATAFORMA .NET

¿Qué es .NET?

.NET es toda una nueva arquitectura tecnológica, desarrollada por Microsoft para la creación
y distribución del software como un servicio. Esto quiere decir, que mediante las
herramientas de desarrollo proporcionadas por esta nueva tecnología, los programadores
podrán crear aplicaciones basadas en servicios para la web.

1.2 LA ARQUITECTURA .NET

.NET Framework o también conocida como La plataforma .NET constituye la plataforma y

elemento principal sobre el que se asienta Microsoft .NET. De cara al programador, es la
pieza fundamental de todo este nuevo modelo de trabajo, ya que proporciona las
herramientas y servicios que necesitará en su labor habitual de desarrollo. .NET Framework
permite el desarrollo de aplicaciones a través del uso de un conjunto de herramientas y
servicios que proporciona, y que pueden agruparse en tres bloques principales: el Entorno de
Ejecución Común o Common Language Runtime (CLR a partir de ahora); la jerarquía de
clases básicas de la plataforma o .NET Framework Base Classes; y el motor de generación de
interfaz de usuario, que permite crear interfaces para la web o para el tradicional entorno
Windows, así como servicios para ambos entornos operativos. La Figura muestra un
diagrama con la distribución de elementos dentro del entorno de .NET Framework.

-Commonm Language Runtime (Runtine del Lenguaje comun)

Esta capa es la responsable de los servicios básicos de .NET, tales como la administración de
memoria, la recolección de los elementos no utilizados, el control estructurado de
excepciones y del subprocesamiento múltiple.

----------------------------------------------------------------------------------------------------------
-ISIV- Página 4 de 67
Programación II
Visual Basic .NET
----------------------------------------------------------------------------------------------------------

-Base Class Libraty (Biblioteca de clases base) BCL

La BCL es la parte de .NET que define todos los tipos de datos basicos, tales como tipos
numéricos y de fechas, el tipo string, matrices y colecciones. Contiene también las clases
que administraran las características centrales de .NET como las E/S de archivos,
subprocesamiento, serializacion y seguridad.

-ADO.NET, XML, Enterprise Services

Contiene las clases que trabajan con base de datos y con XML. De hecho, el XML se puede
considerar como el formato que utiliza el .NET para almacenar prácticamente cualquier tipo
de información. Todos los archivos de configuración están guardados en XML.
ADO.NET es equivalente al ADO de versiones anteriores como Visual Basic 6 si bien tiene
nombres similares son muy distintos en sus arquitecturas como veremos mas adelante.

-ASP.NET – WINDOWS FORMS

Contienen todas las clases que la interfaz de usuario podrá generar, usando el explorador en
ASP y ventanas standares WIN32 en Windows Forms.

-El Lenguaje Intermedio y el CLS

Al contrario que otros entornos, la plataforma .NET no está atada a un determinado lenguaje
de programación ni favorece a uno determinado frente a otros. En la actualidad existen
implementaciones para varias decenas de lenguajes que permiten escribir aplicaciones para
la plataforma .NET. Los más conocidos son Visual Basic .NET o C#, pero existen
implementaciones de todo tipo, como F#, Python, Fortran, e incluso COBOL.
Lo mejor de todo es que cualquier componente creado con uno de estos lenguajes puede ser
utilizado de forma transparente desde cualquier otro lenguaje .NET. Además, como ya se ha
comentado, es posible ejecutar el código .NET en diferentes plataformas y sistemas
operativos.

¿Cómo se consigue esta potente capacidad?

Dentro del CLI, existe un lenguaje llamado IL (Intermediate Language o Lenguaje

Intermedio) que está pensado de forma independiente al procesador en el que se vaya a
ejecutar. Es algo parecido al código ensamblador pero de más alto nivel y creado para un
hipotético procesador virtual que no está atado a una arquitectura determinada.
Cuando se compila una aplicación escrita en un lenguaje .NET cualquiera (da igual que sea
VB, C# u otro de los soportados), el compilador lo que genera en realidad es un nuevo
código escrito en este lenguaje intermedio. Así, todos los lenguajes .NET se usan como capa
de más alto nivel para producir código IL.
Un elemento fundamental del CLR es el compilador JIT (just-in-time). Su cometido es el de
compilar bajo demanda y de manera transparente el código escrito en lenguaje intermedio a
lenguaje nativo del procesador físico que va a ejecutar el código.

- La especificación común de los lenguajes y el sistema de tipos comunes

Para conseguir la interoperabilidad entre lenguajes, no sólo se llega con el lenguaje
intermedio, sino que es necesario disponer de unas "reglas del juego" que definan un
conjunto de características que todos los lenguajes deben incorporar y cumplir. A este
conjunto regulador se le denomina Common Language Specification (CLS) o, en castellano,
especificación común de los lenguajes.
Entre las cuestiones que regula el CLS se encuentran la nomenclatura, la forma de definir los
miembros de los objetos, los metadatos de las aplicaciones, etc... Una de las partes más
importantes del CLS es la que se refiere a los tipos de datos.
Si alguna vez ha programado la API de Windows o ha tratado de llamar a una DLL escrita en
C++ desde Visual Basic 6, habrá comprobado lo diferentes que son los tipos de datos de VB6

----------------------------------------------------------------------------------------------------------
-ISIV- Página 5 de 67
Programación II
Visual Basic .NET
----------------------------------------------------------------------------------------------------------

y de C++. Para evitar este tipo de problemas y poder gestionar de forma eficiente y segura
el acceso a la memoria, el CLS define un conjunto de tipos de datos comunes (Common Type
System o CTS) que indica qué tipos de datos se pueden manejar, cómo se declaran y se
utilizan éstos, y de qué manera se deben gestionar durante la ejecución.
Cada lenguaje .NET utiliza una sintaxis diferente para cada tipo de datos. Así, por ejemplo, el
tipo común correspondiente a un número entero de 32 bits (System.Int32) se denomina
Integer en Visual Basic .NET, pero se llama int en C#. En ambos casos representan el mismo
tipo de datos que es lo que realmente cuenta (System.Int32).

1.3 ACCESO A DATOS CON ADO .NET

ADO .NET es la nueva versión del modelo de objetos ADO (ActiveX Data Objects), es decir, la
estrategia que ofrece Microsoft para el acceso a datos. ADO .NET ha sido ampliado para
cubrir todas las necesidades que ADO no ofrecía, y está diseñado para trabajar con
conjuntos de datos desconectados, lo que permite reducir el tráfico de red. ADO .NET utiliza
XML como formato universal de transmisión de los datos.
ADO .NET posee una serie de objetos que son los mismos que aparecen en la versión
anterior de ADO, como pueden ser el objeto Connection o Command, e introduce nuevos
objetos tales como el objeto DataReader, DataSet o DataView.

ADO .NET se puede definir como:

• Un conjunto de interfaces, clases, estructuras y enumeraciones que permiten el acceso a
datos desde la plataforma .NET de Microsoft
• La evolución lógica del API ADO tradicional de Microsoft
• Permite un modo de acceso desconectado a los datos, los cuales pueden provenir de
múltiples fuentes de datos, de diferente arquitectura de almacenamiento Programación con
Visual Basic .NET
• Soporta un completo modelo de programación y adaptación, basado en el estándar XML
Seguidamente vamos a realizar una descripción genérica de la arquitectura de ADO .NET, y
más tarde veremos como utilizarlo desde aplicaciones VB.NET

- Arquitectura de ADO.NET
El concepto más importante que hay que tener claro sobre ADO.NET es su modo de
funcionar, que se revela claramente al analizar su arquitectura:

----------------------------------------------------------------------------------------------------------
-ISIV- Página 6 de 67
Programación II
Visual Basic .NET
----------------------------------------------------------------------------------------------------------

Existen dos capas fundamentales dentro de su arquitectura: la capa conectada y la

desconectada.

Capa conectada
La primera de ellas contiene objetos especializados en la conexión con los orígenes de datos.
Así, la clase genérica Connection se utiliza para establecer conexiones a los orígenes de
datos. La clase Command se encarga de enviar comandos de toda índole al origen de datos.
Por fin la clase DataReader está especializada en leer los resultados de los comandos
mientras se permanece conectado al origen de datos.
La clase DataAdapter hace uso de las tres anteriores para actuar de puente entre la capa
conectada y la desconectada. Estas clases son abstractas, es decir, no tienen una
implementación real de la que se pueda hacer uso directamente. Es en este punto en donde
entran en juego los proveedores de datos. Cada origen de datos tiene un modo especial de
comunicarse con los programas que los utilizan, además de otras particularidades que se
deben contemplar.
Un proveedor de datos de ADO.NET es una implementación concreta de las clases
conectadas abstractas que hemos visto, que hereda de éstas y que tiene en cuenta ya todas
las particularidades del origen de datos en cuestión.
Así, por ejemplo, las clases específicas para acceder a SQL Server se llaman SqlConnection,
SqlCommand, SqlDataReader y SqlDataAdapter y se encuentran bajo el espacio de nombres
System.Data.SqlClient. Es decir, al contrario que en ADO clásico no hay una única clase
Connection o Command que se use en cada caso, si no que existen clases especializadas
para conectarse y recuperar información de cada tipo de origen de datos.
Existen proveedores nativos, que son los que se comunican directamente con el origen de
datos (por ejemplo el de SQL Server o el de Oracle), y proveedores "puente", que se utilizan
para acceder a través de ODBC u OLEDB cuando no existe un proveedor nativo para un
determinado origen de datos.

Capa desconectada
Una vez que ya se han recuperado los datos desde cualquier origen de datos que requiera
una conexión ésta ya no es necesaria. Sin embargo sigue siendo necesario trabajar con los
datos obtenidos de una manera flexible. Es aquí cuando la capa de datos desconectada entra

----------------------------------------------------------------------------------------------------------
-ISIV- Página 7 de 67
Programación II
Visual Basic .NET
----------------------------------------------------------------------------------------------------------

en juego. Además, en muchas ocasiones es necesario tratar con datos que no han sido
obtenidos desde un origen de datos relacional con el que se requiera una conexión. A veces
únicamente necesitamos un almacén de datos temporal pero que ofrezca características
avanzadas de gestión y acceso a la información.
Por otra parte las conexiones con las bases de datos son uno de los recursos más escasos
con los que contamos al desarrollar. Su mala utilización es la causa más frecuente de cuellos
de botella en las aplicaciones y de que éstas no escalen como es debido. Esta afirmación es
especialmente importante en las aplicaciones Web en las que se pueden recibir muchas
solicitudes simultáneas de cualquier parte del mundo.
Finalmente otro motivo por el que es importante el uso de los datos desconectado de su
origen es la transferencia de información entre capas de una aplicación. Éstas pueden
encontrarse distribuidas por diferentes equipos, e incluso en diferentes lugares del mundo
gracias a Internet. Por ello es necesario disponer de algún modo genérico y eficiente de
poder transportar los datos entre diferentes lugares, utilizarlos en cualquiera de ellos y
posteriormente tener la capacidad de conciliar los cambios realizados sobre ellos con el
origen de datos del que proceden.
Todo esto y mucho más es lo que nos otorga el uso de los objetos DataSet. Es obvio que no
se trata de tareas triviales, pero los objetos DataSet están pensados y diseñados con estos
objetivos en mente. Como podremos comprobar más adelante en este curso es bastante
sencillo conseguir estas funcionalidades tan avanzadas y algunas otras simplemente usando
de manera adecuada este tipo de objetos.

----------------------------------------------------------------------------------------------------------
-ISIV- Página 8 de 67
Programación II
Visual Basic .NET
----------------------------------------------------------------------------------------------------------

APLICACIONES WINDOWS FORMS

Las aplicaciones de escritorio son aquellas basadas en ventanas y controles comunes de

Windows que se ejecutan en el sistema local. Son el mismo tipo de aplicaciones que antes
construiríamos con Visual Basic 6 u otros entornos similares.
En la plataforma .NET, el espacio de nombres que ofrece las clases necesarias para construir
aplicaciones de escritorio bajo Windows se denomina Windows Forms. Este es también el
nombre genérico que se le otorga ahora a este tipo de programas basados en ventanas.
Windows Forms está constituido por multitud de clases especializadas que ofrecen
funcionalidades para el trabajo con ventanas, botones, rejillas, campos de texto y todo este
tipo de controles habituales en las aplicaciones de escritorio.
Visual Studio ofrece todo lo necesario para crear visualmente este tipo de programas, de un
modo similar aunque más rico al que ofrecía el entorno de desarrollo integrado de Visual
Basic.

Al contrario que en en VB6, .NET proporciona control sobre todos los aspectos de las
ventanas y controles, no dejando nada fuera del alcance del programador y otorgando por lo
tanto la máxima flexibilidad. Los formularios (ventanas) son clases que heredan de la clase
base Form, y cuyos controles son miembros de ésta. De hecho se trata únicamente de
código y no es necesario (aunque sí muy recomendable) emplear el diseñador gráfico de
Visual Studio para crearlas.
Este es el aspecto que presenta parte del código que genera la interfaz mostrada en la
anterior figura:

----------------------------------------------------------------------------------------------------------
-ISIV- Página 9 de 67
Programación II
Visual Basic .NET
----------------------------------------------------------------------------------------------------------

Figura 1.5.- Código autogenerado por Visual Studio para crear la interfaz
de la figura anterior.

----------------------------------------------------------------------------------------------------------
-ISIV- Página 10 de 67