Lenguaje de Programacion Con Visual Basic NET

Rector
José Narro Robles

Secretario General
Sergio M. Alcocer Martínez de Castro
Director General de Servicios de Cómputo Académico
Ignacio J. Ania Briseño
Directora de Cómputo para la Docencia
Carmen Bravo Chaveste
Guías y Textos de Cómputo. Lenguaje de programación Visual Basic .NET
Coordinación de la publicación
María Guadalupe Izquierdo Dyrzo
Autor
Tomás Gregorio Serrano Escamilla
Revisión técnica
Juana Figueroa Reséndiz
Corrección de estilo
Gabriela Seoane San Martín
Martha Patricia García Morales
Diseño editorial
Gabriela Lili Morales Naranjo
Diseño de portada
María Cristina Gispert Galván
Editor
DR © Universidad Nacional Autónoma de México
Ciudad Universitaria, Coyoacán, CP. 04510, México, DF.
DIRECCIÓN GENERAL DE SERVICIOS DE CÓMPUTO ACADÉMICO

Circuito exterior s/n, Ciudad Universitaria, Coyoacán, CP. 04510, México DF.
Prohibida la reproducción total o parcial por cualquier medio
sin la autorización escrita del titular de los derechos patrimoniales
1ª. edición 2008

ISBN XXXXXXX
Impreso y hecho en México

Lenguaje de programación Visual Basic .NET
Contenido
1. El .NET Framework .............................................................................................. 1

1.1. Conceptos generales .................................................................................... 1
1.2. Estructura de una aplicación .NET ................................................................. 4
1.3. El enfoque de construcción de software .......................................................... 5
1.3.1. Aplicaciones de consola...................................................................... 6
1.3.2. Aplicaciones para Windows................................................................. 6
1.3.3. Aplicaciones web (ASP.NET) ................................................................ 7
1.4. Common Language Specification (CLS).......................................................... 7
1.5. Common Type System (CTS).......................................................................... 7
1.6. Administración de memoria automática ......................................................... 8
1.7. Modelo de seguridad ................................................................................... 8
1.8. Componentes .............................................................................................. 9
1.8.1. Microsoft Intermediate Language (MSIL).............................................. 10
1.8.2. Just-in Time (JIT) Compiler................................................................. 10
1.8.3. CLR (Common Language Runtime)..................................................... 11
1.8.4. La biblioteca de clases (.NET Framework Class Library) ........................ 13
1.9. Ensamblados (Assemblies)........................................................................... 14
1.10. Espacios de nombres ................................................................................ 15
2. El entorno de desarrollo de Visual Studio .NET ..................................................... 16

2.1. Estructura de una solución .......................................................................... 17
2.2. Estructura de un proyecto............................................................................ 17
2.2.1. Ejecución de Visual Studio .NET......................................................... 18
2.2.2. Creación de una solución y un proyecto ............................................. 19
2.3. El explorador de soluciones......................................................................... 20
2.3.1. Estructura de una solución y un proyecto ............................................ 21
2.3.2. Cuadro de herramientas ................................................................... 22
I
2.3.3. Ventana de propiedades ....................................................................22

2.3.4. El editor de código ............................................................................23
2.3.5. Intellisense ........................................................................................24
2.4. La vista de clases.........................................................................................24
2.5. El sistema de ayuda.....................................................................................25
2.6. Personalización del IDE................................................................................26
3. Sintaxis del lenguaje ...........................................................................................29

3.1. Convenciones del lenguaje ..........................................................................30
3.2. Variables y tipos de datos ............................................................................31
3.3. Tipos de datos elementales (enteros, no enteros, caracter, lógico, fecha) .........33
3.4. Tipos de datos compuestos (enumeraciones, estructuras y matrices).................35
3.5. Literales y constantes ...................................................................................37
3.6. Alcance de las variables...............................................................................38
3.7. Tipos de acceso (visibilidad de las propiedades) ............................................39
3.8. Conversión entre tipos de datos....................................................................40
3.9. Funciones de conversión..............................................................................40
3.10. Operadores y precedencia.........................................................................42
3.11. Estructuras de decisión...............................................................................43
3.11.1. If...Then…Else.................................................................................44
3.11.2. Select...Case ...................................................................................45
3.12. Estructuras de ciclo....................................................................................46
3.12.1. While .............................................................................................46
3.12.2. Do...Loop .......................................................................................46
3.12.3. For...Next .......................................................................................47
3.12.4. For each Next .................................................................................47
3.13. Funciones y procedimientos .......................................................................48
3.13.1. Crear e invocar procedimientos ........................................................48
3.13.2. Paso de argumentos a procedimientos ..............................................51
3.14. Colecciones..............................................................................................54
4. Manejo de excepciones.......................................................................................55
4.1. La clase Exception .......................................................................................55
4.2. Generación de excepciones .........................................................................57
4.3. Try… Catch ................................................................................................57
4.4. Errores lógicos y depuración ........................................................................59
4.4.1. Ejecución del código paso a paso.......................................................60
4.4.2. Puntos de Interrupción .......................................................................61
4.4.3 Puntos de interrupción condicionales....................................................61
5. Uso de la programación orientada a objetos ........................................................64
II Dirección General de Servicios de Cómputo Académico

5.1. Creación de una clase................................................................................ 64

5.2. Agregar un módulo de clase ....................................................................... 65
5.3. Definir propiedades de la clase. .................................................................. 66
5.4. Propiedades compartidas............................................................................ 66
5.7. Visibilidad de las propiedades ..................................................................... 67
5.8. Definición de métodos ................................................................................ 69
5.9. Métodos compartidos ................................................................................. 70
5.10. Definición del constructor.......................................................................... 71
5.11. Definición del destructor ........................................................................... 73
5.12. Objetos basados en clases (referencias) ..................................................... 75
5.13 Vinculación temprana y tardía .................................................................... 76
6. Herencia ........................................................................................................... 77
6.1. Clase base y subclases ............................................................................... 77
6.2. Reemplazo de métodos de la clase base ...................................................... 80
6.3. La palabra clave MyBase ............................................................................ 86
6.4. La palabra clave MyClass ........................................................................... 87
6.5. Interfases ................................................................................................... 91
7. Polimorfismo ..................................................................................................... 95
7.1. Polimorfismo mediante herencia .................................................................. 95
7.2. Polimorfismo mediante interfases ................................................................. 96
8. System Windows Forms ...................................................................................... 97

8.1. System.Windows.Forms.Form ...................................................................... 97
8.2. Label......................................................................................................... 98
8.3. TextBox...................................................................................................... 99
8.4. Button ..................................................................................................... 100
8.5. GroupBox................................................................................................ 100
8.6. RadioButton ............................................................................................. 101
8.7. CheckBox ................................................................................................ 101
8.8. ComboBox .............................................................................................. 102
8.9. ListBox..................................................................................................... 103
8.10. Panel .................................................................................................... 103
8.11. LinkLabel ............................................................................................... 104
8.12. CheckedListBox ...................................................................................... 104
8.13. PictureBox.............................................................................................. 105
8.14. Timer .................................................................................................... 105
8.15. TabControl ............................................................................................ 105
8.16. Trackbar................................................................................................ 106
8.17. ProgressBar ........................................................................................... 106
III
8.18. MainMenu (MenuStrip VB.NET 2005) .......................................................106

8.19. ToolBar (ToolStrip VB.NET 2005)..............................................................107
8.20. StatusBar(StatusStrip VB.NET 2005) ..........................................................107
8.21. InputBox y MsgBox ..................................................................................107
9. Desarrollo de un proyecto en Visual Basic.NET....................................................112

9.1. Clases: Cliente, Producto, Pedido y Venta ...................................................112
9.2. Módulo con las colecciones de clientes, productos, pedidos y ventas.............121
9.3. Funcionalidad del formulario principal ........................................................122
9.4. Funcionalidad del formulario registro de clientes..........................................123
9.5. Funcionalidad del formulario de registro de productos .................................126
9.6. Funcionalidad del formulario de bienvenida (Autenticación)..........................127
9.7. Funcionalidad del formulario de pedidos ....................................................129
Bibliografía ..........................................................................................................134
IV Dirección General de Servicios de Cómputo Académico

CAPÍTULO
El .NET Framework
Visual Basic .NET es un lenguaje de programación orientado a objetos diseñado por Microsoft,
cuyo antecesor es el Visual Basic que apareció en 1991, el cual fue a su vez una evolución de
un lenguaje llamado QuickBasic que nació con la idea de ser un lenguaje muy sencillo de
utilizar comparado con sus homólogos de ese entonces. Es un lenguaje ampliamente utilizado
para el desarrollo de aplicaciones Windows, que cuenta con características como la herencia,
el polimorfismo, control estructurado de excepciones y creación de aplicaciones con múltiples
hilos de ejecución, además de tener disponible una amplia librería de objetos para el desarrollo
de aplicaciones Windows y de aplicaciones web, así como incorporar servicios web para
permitir la interoperabilidad entre diferentes tecnologías.
Visual Basic .NET forma parte de la plataforma .NET de Microsoft. En este capítulo
describiremos qué es la plataforma .NET y los elementos que la integran, poniendo especial
atención a su principal componente: el marco de trabajo .NET (.NET Framework).
1.1 Conceptos generales

La plataforma .NET es un estándar proporcionado por Microsoft para desarrollar
aplicaciones web y para Windows, que permite utilizar diversos lenguajes (Visual Basic
.NET, Visual C++, Visual C#, entre otros) para desarrollar una misma aplicación.
La plataforma .NET representa todo un rango de tecnologías y conceptos como se
muestra en la siguiente figura.
Aplicaciones del usuario

Son las aplicaciones .NET cuyo soporte para su desarrollo y ejecución es proporcionada por el
.NET Framework.
Marco de trabajo (.NET Framework)

Proporciona dos componentes: BCL (Base Class Library) la librería de clases fundamentales para el
desarrollo de una aplicación .NET y el CLR (Common Language Runtime) que es el motor que las ejecuta.
1
Servidores .NET (.NET Enterprise Servers)

Windows, BizTalk, Exchange, SQL, Application Center
Diseñados para proveer los servicios básicos para sus aplicaciones .NET (Sistema Operativo,
Bases de datos, Correo Electrónico, Servicios XML etcétera).
Dispositivos .NET
Dispositivos desde los que se accederá a su aplicación .NET, es la combinación de hardware (PCs,
PDAs, Smart Clients, NoteBooks, etc.) y software (Windows 9x, ME, 2000, XP, CE, etcétera).
Componentes de hardware
Las aplicaciones .NET se pueden ejecutar en diversas plataformas de hardware sin necesidad de
realizarles cambio alguno.
Figura 1. Elementos que conforman la plataforma .NET
Los objetivos de la plataforma .NET son:

• Independencia del lenguaje: la plataforma .NET permite desarrollar soluciones
conformadas por proyectos codificados con lenguajes de programación distintos
(Visual Basic, C#, Visual C++, entre otros), es decir, con .NET usted puede
programar aplicaciones sin depender de un lenguaje y mejor aun puede combinar
diversos lenguajes. Una de las ventajas de lo anterior es, que dentro de los equipos
de desarrollo, algunos integrantes podrían elegir a Visual Basic .NET como el
lenguaje más adecuado para desarrollar ciertos componentes de la aplicación y
ensamblarlos junto con otros proyectos desarrollados por otro grupo de trabajo
utilizando un lenguaje distinto.
• Independencia de la plataforma (hardware/software): la plataforma .NET de
Microsoft permite desarrollar aplicaciones independientes de hardware pero no
totalmente independientes con respecto al software, esto se debe a que la librería de
clases base (BCL) del .NET Framework de Microsoft sólo fue implementada para
ejecutarse bajo los sistemas operativos Windows, es decir, las aplicaciones
desarrolladas pueden ejecutarse en Pcs, NoteBooks, PDAs, Pocket Pcs, Smart
Phone’s, XBox, Tablet PCs, Hand Helds, etc., sólo si estos equipos cuentan con los
sistemas operativos de Microsoft (Windows 9x, Windows CE, Windows Mobile,
Windows ME, Windows XP, Windows NT, Windows 2000, Windows 2003, etcétera).
Existe un proyecto Open Source denominado MONO 1 que posee herramientas libres
similares a las de .NET de Microsoft, entre las características de MONO V 1.2 están:
o Un entorno común de ejecución CLR parecido al de .NET Framework de
Microsoft, con recolector de basura, un cargador de clases y un compilador JIT
(Just In Time).
1
Para mayor información consulte la página oficial del proyecto http://www.mono-project.com
2 Dirección General de Servicios de Cómputo Académico

o Una librería de clases compatible con la BCL del .NET Framework de Microsoft,
donde destacan los siguientes aspectos:
CLI (Common Language Infraestructure o Infraestructura Común de
Lenguajes): es una especificación que describe el entorno de ejecución para
que los lenguajes de alto nivel del lenguaje se ejecuten en distintas
plataformas sin modificaciones.
ADO .NET: componentes para el acceso a datos y servicios de datos.
ASP.NET: es el lenguaje y un conjunto de tecnologías para el desarrollo de
aplicaciones web.
Windows Forms: componentes para el desarrollo de interfases gráficas en
Windows2.
o Un compilador de C#, MonoBasic (el Visual Basic de Mono), Java y Pyton.
o Mono; cuenta además con las librería gtk# para crear interfases gráficas
ejecutables en ambientes Linux, Windows y OSX sin realizar cambios.
o Permite la ejecución de las aplicaciones desarrolladas en los sistemas
operativos: Linux, BSD, Unix, Mac OS X, Solaris y Windows.
• Integrar los productos de Microsoft: la integración de otros productos de Microsoft con
.NET responde a una necesidad creciente del mercado por contar con plataformas que
integren la infraestructura necesaria para proporcionar distintos servicios a las
aplicaciones, denominadas super-plataformas. La super-plataforma de Microsoft ha
integrado los siguientes productos: SQLServer (Servidor de bases de datos), Exchange
Server (servidor de correo), Biztalk (automatización y gestión de procesos empresariales),
Sharepoint Portal Server (Sistema de Administración de Contenido), con lo anterior
también se logra la colaboración entre distintos ambientes como: arquitecto de software,
probador, desarrollador y administrador de proyectos. Además, se integró la plataforma
de aplicaciones con el sistema operativo subyacente (Windows) logrando la
administración y seguridad necesarias.
• Estandarizar el desarrollo de algunos de los lenguajes de programación de Microsoft:
se estandarizaron los lenguajes de mayor aceptación como Visual Basic, Visual C,
Visual Interdev y todos aquellos servicios que proporcionaba Visual Studio en sus
versiones anteriores.
.NET Framework: es el componente principal de la plataforma .NET; proporciona las
clases necesarias para desarrollar aplicaciones (Librería de clases base, BCL) y permite
ejecutarlas (motor común de ejecución para los lenguajes, CLR).
A diferencia de versiones anteriores de Visual Basic, las aplicaciones ya no se ejecutan
directamente sobre el sistema operativo, se ejecutan sobre la "máquina virtual"
proporcionada por el CLR, que es una capa entre las aplicaciones y el sistema operativo.
2
La implementación de esta librería no es compatible totalmente con la de Microsoft, para mayor
información consulte http://www.mono-project.com/FAQ:_Winforms
3
1.2 Estructura de una aplicación .NET

Conocer la estructura general de una aplicación Visual Basic .NET le servirá como
modelo, debido a que esta estructura es la que deberá seguir. El siguiente ejemplo
muestra el código fuente de una sencilla aplicación de consola que despliega el mensaje
“Hola Mundo”.
Module ModuloHola
Sub Main()
System.Console.WriteLine("Hola Mundo")
End Sub
End Module
El siguiente diagrama muestra la estructura de una aplicación en Visual Basic .NET:
Solución
Proyecto Proyecto
Archivo(s) Archivo(s)
Modulo/Clase/NameSpace Modulo/Clase/NameSpace
Procedimiento(s) Procedimiento(s)
Instrucción(es) Instrucción(es)
Figura 2. Estructura de una aplicación en Visual Basic .NET
• Las instrucciones, por ejemplo System.Console.WriteLine("Hola Mundo")

deben estar dentro de un procedimiento (bloque Sub - End Sub), por ejemplo de Main
(para las aplicaciones de consola, es necesario el método Main ya que es el primero que
se ejecuta).
• Los procedimientos, por ejemplo Main deben estar declarados dentro de una clase
(bloque Class-End Class), Modulo (bloque Module-End Module) o Espacio de Nombres
(bloque Namespace-End Namespace), por ejemplo el módulo ModuloHola.
• Las clases y módulos, por ejemplo ModuloHola deben estar declaradas dentro de
un archivo, por ejemplo HolaMundo.vb.
• Los archivos, por ejemplo HolaMundo.vb, se integran dentro de un proyecto, por
ejemplo HolaMundo.

• Los proyectos, por ejemplo HolaMundo están vinculados a una solución, por
ejemplo HolaMundo.
1.3 El enfoque de construcción de software

Dentro de los modelos más utilizados para el desarrollo del software con .NET está el
modelo en capas, ya que gran parte de las herramientas y tecnologías proporcionadas
por .NET se basan en él. Dentro del modelo en capas existen distintas arquitecturas, por
lo que es importante analizar y elegir la más conveniente dependiendo del tipo de
problema, como se describe a continuación.
Una aplicación de dos capas puede consistir en un programa cliente con una interfaz
gráfica de usuario (presentación) conectada directamente a un servidor de base de datos
(acceso a datos), es decir, sin capas intermedias, esta arquitectura es utilizada en
aplicaciones pequeñas, pero cuando éstas crecen presenta problemas, debido a que
cualquier modificación en las reglas de negocio ocasiona cambios en cada uno de los
clientes, dificultando su mantenimiento y modificación.
Una aplicación de tres capas introduce una capa intermedia entre el cliente y la base de
datos, denominada capa de negocios, con lo que se elimina el problema anterior. A
continuación se describen cada una de estas capas:
• Capa de presentación: es la interfaz de la aplicación hacia los usuarios, por ejemplo
ventanas o páginas web (Windows Forms, formularios ASP o páginas HTML).
• Capa de negocio: contiene la lógica de la aplicación, por ejemplo si el usuario
selecciona en la capa de presentación, visualizar todos los registros de la base de datos
que cumplan con cierto criterio, esta capa se encarga de recoger el criterio seleccionado
en la capa de presentación y crea la cadena de conexión a la base de datos con la
consulta adecuada. Dentro de estas capas también se agrupan herramientas de
administración de procesos, como BizTalk, y servicios como: correo electrónico
(Exchange Server), Servidor Web (IIS), Servicios XML, etc. , lo que permite que la
conexión por parte del usuario pueda realizarse desde cualquier ubicación
independizando los componentes que realizan el acceso a los datos.
• Capa de acceso de datos: está relacionada directamente con el origen de datos, por
ejemplo una base de datos y un sistema manejador como SQL Server.
La arquitectura de N capas se diferencia, en tanto introduce una capa por cada regla de
negocio distinta, esta es la arquitectura más general y más conveniente para aplicaciones
de gran tamaño, pero también requieren de mayor conocimiento por parte de los
desarrolladores, así como más tiempo en el proceso de desarrollo.
Otro modelo muy conocido en la actualidad es MVC (Modelo-Vista-Controlador) que
también es soportado por .NET y existen algunos frameworks que facilitan su
implementación como: Spring .NET 3 , User Interface Process (UIP) Application Block 4 y
3
http://www.springframework.net/
4
http://msdn.microsoft.com/practices/compcat/default.aspx?pull=/library/en-
us/dnpag/html/uipab.asp
5
Maverick .NET5 entre otros. MVC es una arquitectura muy parecida al modelo en capas
que separa los datos de la aplicación en las siguientes partes:
• Modelo: representa el origen de datos y la lógica de los mismos.
• Vista: es la interfaz de la aplicación con el usuario.
• Controlador: es quien recibe las instrucciones a través de la capa de vista y controla
la lógica de la aplicación, accediendo y modificando los datos o regresando los
resultados a la capa de vista para que sean presentados al usuario.
Ahora hablaremos del enfoque que .NET tiene respecto a los distintos tipos de
aplicaciones que puede desarrollar.
Con .NET Framework usted puede desarrollar distintos tipos de aplicaciones.
• Aplicaciones de consola para Windows.
• Aplicaciones gráficas para Windows.
• Aplicaciones gráficas para web.
1.3.1 Aplicaciones de consola

Las aplicaciones de consola se ejecutan en una ventana de DOS que proporciona una
salida basada en texto, por esta razón este tipo de aplicaciones permite iniciar el
aprendizaje de un lenguaje de programación, ya que libera al programador de la
programación de las Interfases Gráficas de Usuarios (IGUs) y centra su atención en los
elementos del lenguaje (clases, métodos, condicionales, ciclos, etcétera).
Figura 3. Aplicación de consola.
1.3.2 Aplicaciones para Windows

Este tipo de aplicaciones se ejecutan en una ventana de Windows; Word y Excel son
ejemplos de este tipo de aplicaciones, las cuales son más complejas que las de consola y
pueden contar con una barra de menús, controles y otros elementos presentes en las
aplicaciones modernas; .NET permite desarrollar este tipo de aplicaciones utilizando los
distintos lenguajes de programación (Visual Basic. NET, C#, C++, entre otros).
Figura 4. Aplicación gráfica para Windows.
5
http://mavnet.sourceforge.net/

1.3.3 Aplicaciones web (ASP.NET)

Una aplicación web es desarrollada en el lenguaje de programación ASP.NET, se ejecuta
en un servidor web y se visualiza a través de un navegador web (IE, Mozilla Firefox,
Netscape, etcétera).
Figura 5. Una aplicación ASP .NET
El software construido mediante .NET puede ser más fácil de emplear y mantener ya que
cuenta con diversos servicios que proporcionan las herramientas de Microsoft.
1.4 Common Language Specification (CLS)

CLS es una especificación y define las reglas que los lenguajes y los desarrolladores deben
cumplir para que las aplicaciones y componentes creados sean compatibles con otros
lenguajes de .NET; el código creado en cualquiera de estos lenguajes es compilado
verificando las reglas del CLS y generando el código MSIL (Microsoft Intermediate Language)
que será compatible con el CLR, lo que permite a los desarrolladores crear aplicaciones
sabiendo que no habrá ninguna incompatibilidad al integrar los diferentes lenguajes .NET.
Para crear componentes compatibles con CLS se requiere lo siguiente:
• Seguir las reglas definidas en la especificación del CLS que se encuentran en la
siguiente liga http://msdn.microsoft.com/netframework/ecma/.
• Marcar el código que se compartirá como compartible a través del atributo
CLSCompliantAttribute.
Solo necesita cumplir estas reglas si desea que los tipos sean accesibles externamente, y
no para los privados. A los componentes que cumplen las reglas de CLS y únicamente
usan características de CLS, se les conoce como componentes compatibles con CLS.
1.5 Common Type System (CTS)

Los tipos comunes son implementaciones de clases, interfases, estructuras, etc. ya sea
que estén incluidas en la BCL o hayan sido creadas por el programador.
El Common Type System (CTS) o Sistema de Tipo Común define los tipos que aceptará el
CLR (Common Language Runtime); aunque cada lenguaje tiene su propia sintaxis para
definir tipos, por ejemplo, una variable entera en C# se declara con int y en Visual Basic
con Integer, existe una sola clase llamada System.Int32 que las interpretará y el código
MSIL resultante debe cumplir las reglas del CTS.
7
Las funciones del CTS son las siguientes:

• Adaptarse automáticamente para integrar el código de distintos lenguajes.
• Optimizar el código en ejecución.
• Proporcionar un modelo de tipos orientado a objetos, que soporta múltiples
lenguajes.
• Especificar las reglas que los lenguajes seguirán para asegurar la intercomunicación.
• Encapsular las estructuras de datos.
• Invocar revisiones de seguridad.
El Sistema de Tipo Común está organizado con base en los tipos que se muestran en el
siguiente diagrama:
Predefinidos
VALOR
Usuario
Enumeraciones
Interfases De usuario
Auto Descriptivos Clases Boxed
REFERENCIA
Arrays Delegados
Punteros
Figura 6. Clasificación de tipos para el .NET Framework.
1.6 Administración de memoria automática

Es uno de los servicios que proporciona el CLR durante la ejecución de un programa a través
del “recolector de basura” que asigna y libera la memoria de forma automática. Cuando el
“recolector de basura” detecta que un objeto ya no será utilizado (es decir, que ya no hay
variables haciendo referencia a él) dentro de un programa, lo elimina y libera la memoria.
La principal ventaja del recolector de basura es evitar al programador la tediosa tarea de
solicitar memoria y liberarla, eliminando los problemas que existían cuando olvidaba
realizar estas tareas, como: pérdida de información o el intento de acceder a un objeto
que ya ha sido liberado.
1.7 Modelo de seguridad

La seguridad en .NET tiene que ver con controlar el acceso a los recursos de la aplicación
como: componentes, datos y hardware, utilizando alguna de las siguientes formas:
• Seguridad de acceso al código (CAS).
• Seguridad basada en roles o funciones (RBS).

Modelo de seguridad de .NET Framework
Seguridad basada en acceso al código Seguridad basada en roles

Code Acces Security (CAS) Role Based Security (RBS)
Figura 7. Modelo de seguridad de .NET Framework.
CAS controla lo que el código puede y no puede hacer basado en los siguientes
esquemas:
• Permisos: el CLR puede permitir o denegar algunos permisos al código, cada permiso
deriva de la clase System.Security.CodeAccessPermission.
• Conjunto de permisos: permisos que son otorgados y manejados como uno solo.
• Grupos de código: es un conjunto de ensamblados que comparten un contexto de
seguridad.
RBS controla lo que los usuarios pueden y no pueden hacer basándose en sus
credenciales, verificando cuáles son las funciones de cada usuario y proporcionándole
los recursos permitidos; CLR proporciona compatibilidad basándose en la autenticación
de una cuenta de Windows o una identidad personalizada.
Los dos esquemas de seguridad anteriores le dan a los administradores de sistemas,
usuarios y desarrolladores de software el control sobre lo que un programa o usuario
puede o no puede hacer, por ejemplo, imagine un programa que escanea el disco duro
en búsqueda de un archivo perdido, este mismo programa podría ser enviado por correo
electrónico y ejecutarse automáticamente en búsqueda de un archivo interesante para el
atacante y ser enviado por correo al mismo; anteriormente este era un problema común
en el desarrollo de aplicaciones Windows en los que no se tenia un acceso restringido
sobre su computadora.
Con .NET cambia esta situación ya que las características de seguridad están
implementadas dentro del CLR y para que el código se ejecute sobre el CLR, el código
requiere evidencia para ejecutarse, esta evidencia puede abarcar políticas de seguridad
creadas por usted junto con el administrador del sistema o el origen del código (su
propia máquina, máquina de la red local o Internet).
1.8 Componentes
El .NET Framework tiene dos componentes principales:
• CLR (Common Language Runtime) o Entorno Común de Ejecución para Lenguajes.
• BCL (Base Class Library) también conocida como FCL (.NET Framework Class Library)
Librería de Clases Base que incluye ASP.NET, ADO.NET y Windows Forms
(Formularios para Windows).
Otros elementos del .NET Framework son:
9
• Los servicios web: permitirán comunicarnos a través de Internet entre diferentes

ordenadores, incluso entre distintos sistemas.
• Remoting: permite tener objetos en computadoras remotas e invocarlos desde otras
computadoras.
• CLS (especificación común de lenguajes) que incluye lenguajes como Visual Basic,
C#, J#, C++, entre otros.
1.8.1 Microsoft Intermediate Language (MSIL)

Cuando un programa escrito en alguno de los lenguajes soportados por .NET (Visual Basic
.NET, C#, etc.) es compilado, el código generado no es código nativo de alguna
arquitectura de hardware específica, ya que de ser así, el programa resultante sólo podría ser
ejecutado por los microprocesadores con dicha arquitectura y con las compatibles. El código
generado está en un lenguaje intermedio (similar al Bytecode de Java) conocido como MSIL
(Microsoft Intermediate Language), que no es independiente de toda arquitectura y no puede
ejecutarse directamente en algún procesador, el código MSIL es interpretado por el CLR
(específicamente el JIT) en tiempo de ejecución, como se muestra en la siguiente figura.
1.8.2 Just-in Time (JIT) Compiler

El JIT es el componente (compilador) del .NET Framework encargado de convertir el
código MSIL en el código de un sistema operativo específico (código nativo) durante la
ejecución, esto mejora el desempeño de los sistemas de programación compilados a
bytecode (MSIL en el caso de .NET).
Como el código MSIL no es ejecutable es compilado por el compilador JIT, el cual es
distinto para cada arquitectura de hardware y genera el código nativo apropiado,
logrando así la independencia de hardware, aunque no de sistema operativo, este
código se almacenará en caché mientras el código MSIL permanezca inalterable.
Código Fuente Con VB 6 el código es

Visual Basic compilado a instrucciones en
código nativo
Compilador de Instrucciones de una

Visual Basic arquitectura (X86)
Antes de ejecutar una

porción de código se
Código Fuente Con VB .NET el código
convierte de MSIL a
Visual Basic .NET es compilado a
instrucciones de código
instrucciones MSIL
nativo mediante el JIT
Compilador de MSIL Interprete Instrucciones de una

Visual Basic .NET MSIL arquitectura (X86)
Figura 8.Comparación del proceso de compilación de .NET y VB 6

1.8.3 CLR (Common Language Runtime)

Es el motor de ejecución de las aplicaciones .NET (lo equivalente a la Máquina Virtual en
Java) que carga las aplicaciones desarrolladas en los distintos lenguajes y se encarga de
ejecutar todo el código de la aplicación .NET.
Las funciones del CLR son las siguientes:
• Ejecutar el código.
• Proporcionar los servicios (por ejemplo, recolector de basura, asignación de
memoria) que facilitan el desarrollo de programas.
La siguiente figura del marco de trabajo .NET muestra que el entorno común para
lenguajes (CLR) funciona como "máquina virtual" entre el sistema operativo y los
programas escritos en los distintos lenguajes de programación contenidos en Visual
Studio .NET, se cuenta con una especificación común para todos los lenguajes así como
una especificación particular para cada uno (VB.NET, C, C#, etc.). Además el CLR da
soporte a la librería de clases (BCL) y otros servicios como los servicios web XML.
Figura 9. Diagrama del marco de trabajo .NET
La siguiente figura muestra a detalle la estructura del CLR.
11
Figura 10. Entorno común de ejecución para lenguajes (CLR)
A continuación se describe el funcionamiento del CLR:

1. La herramienta de desarrollo (Visual Studio .NET en este caso) compila el código
fuente de cualquiera de los lenguajes soportados por .Net en un código intermedio
(MSIL, Microsoft Intermediate Language similar al Bytecode de Java). El compilador
se basa en el Common Language Specification (CLS) para crear ese código MSIL
compatible con el CLR.
2. Este código intermedio no es código de máquina ejecutable, por lo que durante
la ejecución del programa, conforme se invoca cada uno de los métodos, el CLR
pasa el código por el compilador JIT (Just-In-Time) y genera el código máquina
adecuado a la plataforma, posteriormente lo coloca en caché para ser utilizado
en ocasiones posteriores, el cual sólo es recompilado en caso de algún cambio.
El compilador JIT es distinto para cada plataforma de hardware y genera código
máquina apropiado para cada una de ellas, con lo que se obtiene independencia
de hardware, aunque no de sistema operativo.
El procedimiento anteriormente descrito se representa en la siguiente figura:
Figura 11. Diagrama del funcionamiento del CLR.

1.8.4 La biblioteca de clases (.NET Framework Class Library)

La librería de clases base de .NET Framework es un extenso conjunto de clases, tipos de
datos e interfases conocidos en general como tipos, que está unificada e implica una
jerarquía con la cual es posible desarrollar aplicaciones.
La librería de clases de .NET es de las más poderosas, en tanto le brinda acceso a la
funcionalidad del sistema, permitiéndole el manejo de: tipos de datos primitivos,
excepciones, estructuras de datos, entrada y salida, acceso a bases de datos, cadenas y
números, cifrado digital, acceso a redes, etc. Son miles las clases que componen la BCL
(Base Class Library), aunque para desarrollar poderosas aplicaciones le bastará el
dominio de un subconjunto muy pequeño.
Los tipos de BCL cumplen la especificación de lenguaje común (CLS), por lo que puede
utilizarlos en cualquier lenguaje de programación cuyo compilador satisfaga los
requisitos de CLS.
A continuación, se presenta un diagrama de BCL en el que se muestran los elementos
que componen la librería de clases.
Figura 12. Organización de la BCL de .NET Framework6.
Los componentes principales de la biblioteca de clases de .Net Framework son:

• ASP.NET (System.Web): ASP.NET es la parte del .NET Framework dedicada al
desarrollo web. A través del servidor web (IIS) las aplicaciones ASP.NET se ejecutarán
bajo el CLR, con la posibiliadad de usar el conjunto de clases del .NET Framework
para desarrollarlas.
6
Imagen tomada de http://www.desarrolloweb.com/articulos/1328.php
13
• ADO.NET (System.Data y System.Xml): es la versión de .NET de la tecnología ActiveX

Data Objects (ADO) para conectarse y gestionar los orígenes de datos (entre ellos
OLE DB o a través de XML). Entre sus componentes se encuentra todo lo necesario
para conectarse con distintos proveedores de datos, ejecutar comandos sobre éstos y
obtener resultados a través de consultas.
• Windows Forms (System.WinForms): parte del .NET Framework que permite crear
aplicaciones con interfases gráficas basadas en formularios.
1.9 Ensamblados (Assemblies)

Un ensamblado es una unidad lógica de código y recursos que existe físicamente como
un conjunto de archivos .exe o .dll. Dentro del ensamblado (archivo .exe generalmente)
se encuentran contenidos uno o más archivos necesarios para la ejecución de la
aplicación como: archivos con código compilado (MSIL), archivos de imágenes, archivos
de texto, archivos con información para conectar a bases de datos, etc. en otras
palabras, contiene el programa y todos los recursos necesarios para su ejecución.
Un ensamblado contiene también toda la información necesaria de los tipos (no se confunda
con tipos de datos, tipos son los elementos de la librería de clases BCL como se mencionó
anteriormente), debido a que se puede dar que un tipo sea distinto de un lenguaje a otro y
.NET framework debe permitir la interoperabilidad entre los lenguajes, por lo que los
ensamblados contienen el código de lenguaje intermedio de Microsoft MSIL que implementa
estos tipos.
De tal forma, que es posible definir un ensamblado como un conjunto de tipos y recursos
creados para funcionar de manera conjunta y proporcionar la funcionalidad a través del
CLR a las aplicaciones NET. Una ventaja de los ensamblados es evitar registrar los
componentes de la aplicación a consecuencia de que contiene todos los elementos de
registro necesarios para ejecutarla.
Se pueden crear ensamblados de un archivo o de varios archivos; al trabajar con los de
un sólo archivo, éstos contienen:
• Información e implementación del tipo.
• Manifiesto del ensamblado.
Para generar un ensamblado desde el IDE de Visual Studio .NET dé clic en el menú
Generar | Generar Solución (Build | Build Solution), Visual Studio .NET construye
soluciones automáticamente en archivos EXE o DLL para ensamblados de un sólo archivo
generando un archivo .exe en la carpeta bin ubicada dentro de la carpeta en la que creó
su proyecto.
Otra forma menos común de crear un ensamblado de un archivo, es a través de los
compiladores de la línea de comandos, pero para nuestros propósitos bastará con
generarla mediante el IDE de Visual Studio .NET.
Para Visual Basic y Visual Studio .NET sólo se pueden crear ensamblados de un archivo;
si desea crear ensamblados de varios archivos, debe usar compiladores de la línea de
comandos o Visual Studio .NET con las extensiones administradas de C++.

1.10 Espacios de nombres

Los tipos de BCL están organizados de acuerdo a su función en un esquema lógico de
nombres conocido como espacios de nombres (Name Spaces). Los espacios de nombres
agrupan a los tipos relacionados entre sí, de acuerdo a su funcionalidad, de tal forma
que existen namespaces que agrupan los tipos para gráficos (System.Drawing), bases de
datos (System.Data), entrada y salida (System.IO), formularios (System.Windows.Forms),
etcétera.
Por ejemplo, la clase Form (representa un formulario de Windows, es decir, una ventana
de Windows) pertenece al espacio de nombres System.Windows.Forms, por lo que
aparece precedido por este nombre jerárquico separado por puntos
(System.Windows.Forms.Form), como se describe a continuación:
System.Windows.Forms.Form
Espacio de nombres.Tipo
Los dos espacios de nombres con mayor frecuencia se manejan, son:
• System que agrupa los tipos fundamentales de .NET Framework como los tipos de
datos base que utilizan todas las aplicaciones: Object (base de la jerarquía de
herencia), Byte, Char, Array, String, etcétera.
• System.Windows.Forms el espacio de nombres para agrupar los formularios y
controles característicos de las ventanas de Windows que se utilizarán para
desarrollar interfases gráficas.
15
CAPÍTULO
El entorno de desarrollo de Visual Studio .NET
A lo largo de este capítulo se abordará la manera de localizar y utilizar las principales
ventanas y herramientas del entorno de desarrollo Integrado (IDE) de Visual Studio .NET,
así como la creación e identificación de la estructura de una solución y un proyecto, que
son los primeros elementos por definir al momento de desarrollar una aplicación.
Visual Studio .NET es un Entorno de Desarrollo Integrado (IDE, Integrated Development
Enviroment), de Microsoft que cuenta con un conjunto de herramientas para el desarrollo
de aplicaciones .NET entre las que se encuentra el compilador de Visual Basic .NET, así
como compiladores para otros lenguajes (C#, C++, J#). A Visual Studio .NET le puede
agregar componentes a través de módulos, la instalación estándar de Visual Studio .NET
cuenta con los siguientes componentes:
• Visual Basic .NET
• Visual C++
• Visual C#
• Visual J#
Usted puede elegir una instalación personalizada, pero tenga en cuenta que si desea
instalar más componentes requerirá mayor espacio disponible en su disco duro.
A continuación, se presenta una tabla con los requerimientos mínimos para la instalación
de Visual Studio .NET.
Requerimientos mínimos
Procesador Computadora personal (PC) con un procesador Pentium II, 450

megahertz (MHz)
Sistema operativo Microsoft Windows NT® 4.0 o superior
Memoria Windows NT 4.0 Server

Requerimientos mínimos
160 MB de RAM
Windows NT 4.0 Workstation
64 MB de RAM
Windows 2000 Professional
96 MB de RAM
Windows 2000 Server
192 MB de RAM
Microsoft Windows® XP Professional
160 megabytes (MB) de RAM
Disco duro Professional y Enterprise Edition

3.5 GB en la unidad de instalación, que incluye 500 MB en la unidad
de sistema.
Standard Edition
2.5 gigabytes (GB) en la unidad de instalación, que incluye 500 MB en
la unidad de sistema.
Unidades Unidad de CD-ROM o DVD-ROM.
Video Monitor súper VGA (800 x 600) con 256 colores o de alta resolución.
2.1 Estructura de una solución

Dentro de Visual Studio .NET y todos los lenguajes que comprende (C#, Visual C++,
Visual Basic .NET) se denomina solución a un programa en desarrollo, y representa a
todo el sistema que se generará, el cual puede contener varios componentes
independientes llamados proyectos; es decir, que una solución es un contenedor de
proyectos.
Las características de una solución son:
• Punto de inicio para la creación de una aplicación con Visual Studio .NET, por lo que
es lo primero que debe definirse.
• Puede contener uno o más proyectos.
• Contiene información global a todos los proyectos.
• Los archivos de solución tienen extensión .sln.
2.2 Estructura de un proyecto

Un proyecto contiene información específica para una determinada tarea de
programación y se agrupa bajo una solución.
La estructura (de archivos y directorios) de un proyecto depende del tipo de proyecto
(Windows, Web o MSDOS) que se genere; para simplificar el manejo de los archivos
asociados a él, generalmente se almacenan dentro del mismo directorio que la solución.
17
En este texto se manejarán archivos de proyectos de Visual Basic .NET del tipo de una
aplicación para Windows (Windows Forms); los cuales tendrán extensión .vbproj y son un
documento XML que contiene referencias a todos los elementos del proyecto como formularios,
clases y módulos, al igual que referencias del proyecto y las opciones para su compilación. Su
extensión .vbproj permite diferenciarlo de los archivos de proyecto de C# (.csproj).
Posteriormente, mediante el uso del explorador de soluciones se podrá analizar la
estructura de una solución y un proyecto.
A continuación, se describirán las ventanas y herramientas del entorno de desarrollo de
Visual Studio .NET, para lo cual primeramente, deberá ejecutar el programa como se
indica a continuación:
2.2.1 Ejecución de Visual Studio .NET

• Para ejecutar Visual Studio .NET, dé clic en el botón Inicio | Programas | Microsoft
Visual Studio .NET | Microsoft Visual Studio .NET.
A continuación, se presenta una descripción del área de trabajo de Visual Studio .NET.
1
2
3
4
5
6
7 8 9
10
11
12
14 15
13
Figura 7. Ventana de Visual Studio .NET

1. Barra de título.
2. Barra de menús.
3. Barra de herramientas estándar.
4. Barra de herramientas para edición de formularios (alinear, margen, etcétera).
5. Pestañas para cambiar la ventana principal o de trabajo activa (vista de código,
vista de diseño, página inicial, explorador de objetos, etcétera).
6. Fichas para cambiar la sección del cuadro de herramientas activo (datos,
componentes, formulario de Windows).
7. Ventana de cuadro de herramientas.
8. Ventana principal o de trabajo.
9. Explorador de soluciones.
10. Fichas para cambiar entre ventanas (explorador de soluciones, vista de clases, etcétera).
11. Ventana de propiedades.
12. Ventana de lista de tareas.
13. Barra de Estado.
14. Fichas para cambiar entre ventanas (lista de tareas, resultados de búsqueda, etcétera).
15. Fichas para cambiar entre ventanas (propiedades, ayuda dinámica, etcétera).
2.2.2 Creación de una solución y un proyecto

El primer paso para comenzar a trabajar dentro de Visual Studio .NET es crear una nueva
solución o bien un nuevo proyecto; si usted crea un nuevo proyecto automáticamente, se
creará una nueva solución con el mismo nombre a la cual estará asociado.
Para crear un nuevo proyecto, dentro de la ventana de Visual Studio .NET seleccione de
la barra de menús la opción Archivo | Nuevo | Proyecto (File | New Project) con esto se
mostrará el cuadro de diálogo Creación de un nuevo proyecto, como se muestra a
continuación:
Figura 8. Ventana para definir la creación de un nuevo proyecto.
19
Los dos elementos más importantes que se deben definir para este proyecto y que
determinan que el tipo de la aplicación sea el de una aplicación para Windows, son:
• Project Types (tipo de proyecto): en la figura 8 se eligió un proyecto de Visual Basic,
también podría crear otro tipo de proyectos como por ejemplo Visual C#, Visual
C++, entre otros, dependiendo del lenguaje que desee utilizar.
• Templates (plantillas): igualmente, se eligió la plantilla aplicación para Windows
(Windows Application) de tal manera que contará con una interfaz gráfica de usuario
GUI, la cual estará disponible a través de un formulario. Puede utilizar otras plantillas
como ASP.NET Web Application (aplicación web con ASP), Console Application
(aplicación de consola para MS-DOS) entre otras, dependiendo del tipo de
aplicación que desee realizar, ya sea de Windows, Web o MS-DOS respectivamente.
En el ejemplo anterior se especificó el Nombre (Name) del proyecto: HolaMundo que
será el mismo para la solución, y también se eligió guardar la carpeta de la solución en
la Ubicación (Location) C:\CursoVB\Ejercicios.
También pudo haber elegido crear primero una solución en blanco en el menú Archivo |
Nueva | Solución en blanco (File | New | Blank Solution), pero para ahorrar ese paso
generalmente, se creará un proyecto y se dejará que Visual Studio .NET cree la solución
al cual estará vinculado.
2.3 El explorador de soluciones

Una vez que ha creado un proyecto se mostrará la ventana principal de Visual Studio
.NET que se describió anteriormente, esta ventana presenta los elementos generados
junto con el proyecto, los cuales se revisarán mediante el explorador de soluciones.
El explorador de soluciones muestra la solución y los proyectos de manera jerárquica,
incluyendo los elementos de cada proyecto, referencias, formularios, clases, módulos y
cualquier subcarpeta que contenga elementos del proyecto. También le da acceso a los
comandos asociados a cada uno de estos elementos.
Para mostrar el explorador de soluciones lleve a cabo un clic en la barra de menús en la
opción View | Solution Explorer (Ver | Explorador de Soluciones) o presione la
combinación de teclas (CTRL-R).
En caso de tener seleccionado un formulario, se mostrarán dos botones extras (Ver
diseño, Ver código) como se muestra en la siguiente figura.
1 2 3 4 5
Figura 9. Ventana del explorador de soluciones.
1. Refrescar (Refresh): actualiza la lista de elementos en caso de haber agregado un

nuevo archivo o directorio.

2. Mostrar todos los archivos (Show All Files): muestra todas las carpetas y
subcarpetas asociadas al proyecto.
3. Propiedades (Properties): muestra las propiedades asociadas al elemento que
tenga seleccionado.
4. Ver Código (View Code): muestra la vista de código del formulario seleccionado,
y permite editarlo. La vista de código presenta los elementos del lenguaje de
programación Visual Basic .NET (clases procedimientos, variables, etc.) utilizados
por el programador dentro del formulario, así como el código generado de
manera automática por el entorno de desarrollo Visual Studio .NET al momento
de crear el formulario y agregar controles.
5. Ver Diseño (View Designer): muestra el formulario seleccionado en vista de
diseño. La vista de diseño presenta la Intefaz Gráfica de Usuario (IGU) compuesta
por los objetos de la librería Windows.Forms utilizados (formulario, botones, cajas
de texto, etc.) y permite modificar con facilidad el tamaño y la posición de cada
uno de ellos; esta IGU será la vista que tendrá el usuario de nuestra aplicación.
También se utilizarán los menús contextuales que aparecen dando clic con el botón
derecho sobre un elemento del explorador de soluciones.
2.3.1 Estructura de una solución y un proyecto

Dé clic en el botón Mostrar todos los archivos (Show All Files) para mostrar todos los
archivos incluyendo las carpetas dentro del proyecto; esta estructura es la misma que se
crea en su disco duro en la ubicación que haya elegido al momento de crear el proyecto
del explorador de soluciones, como se mostró anteriormente.
Una solución
Un proyecto contiene::
contiene proyectos.
• References: referencias a objetos de la clase System; estas referencias

son necesarias para toda aplicación de Windows.
• bin: carpeta que contiene archivos de soporte y ensamblados generados
al construir la aplicación en el menú Generar (Build). Puede desplegar
una aplicación copiando los archivos de este directorio a la
computadora del usuario y ejecutando el archivo .exe.
• obj: carpeta que contiene a su vez la carpeta Debug para fines de
depuración con archivos intermedios compilados y no optimizados pero
con información para depurarlos o una carpeta Release con archivos
optimizados (depende de la opción seleccionada en el administrador de
configuración en el menú Generar | Administrador de Configuración).
• AssemblyInfo.vb: archivo de texto que provee información sobre el
ensamblado (Assembly) de la aplicación como: título, descripción,
compañía, producto, versión, copyright, compatibilidad CLS.
• Form1.vb: formulario de Windows instancia de la clase
System.Windows.Forms, es la ventana de una interfaz gráfica (creado de
forma automática solo en proyectos del tipo “aplicación para
Windows”).
21
2.3.2 Cuadro de herramientas

El cuadro de herramientas muestra un listado de diversas secciones de código, elementos
de interfaz y otros elementos para que los agregue a sus proyectos. El cuadro de
herramientas muestra siempre las fichas General y Anillo del portapapeles; al abrir un
editor o un diseñador, se muestran otras fichas (Data, Components, Windows Forms).
La función principal de la ficha Windows Forms es permitir agregar controles (etiquetas,
botones, cuadros de Texto, etc.) al formulario para la creación de una interfaz gráfica de
usuario (GUI) y sólo estará disponible encontremos en la vista de diseño del formulario.
Para mostrar el cuadro de herramientas, dé clic en la barra de menús en la opción View |
Toolbox (Ver | Cuadro de Herramientas) o presione la combinación de teclas (CTRL-ALT-X).
Para agregar un control al formulario, dentro del cuadro de herramientas asegúrese de
tener seleccionada la ficha Windows Forms.
1. Seleccione el tipo de control que desea agregar por ejemplo Label.
2. Sin soltar el botón izquierdo del ratón, arrastre el puntero hacia el formulario
hasta colocar el control en la posición deseada.
Figura 10. Agregar controles al formulario mediante el cuadro de herramientas.
2.3.3 Ventana de propiedades

Ahora sabe cómo agregar controles al formulario, los cuales adquieren ciertas
propiedades (tamaño, posición, nombre, entre otras) por default. La ventana de
propiedades le permite ver y cambiar las propiedades de los controles que agregó, así
como las propiedades y eventos en tiempo de diseño del objeto u objetos seleccionados
que están localizados en los editores y/o diseñadores. También puede utilizar la ventana
Propiedades para editar y ver propiedades de archivos, proyectos y soluciones.

Para mostrar la ventana de propiedades, lleve a cabo un clic en la barra de menús en la

opción Ver | Ventana de Propiedades (View | Properties Windows) o presione la tecla F4
Dos de las propiedades que más comúnmente se modifican son texto (Text): el texto
descriptivo que muestra el objeto; y nombre (Name) que es el identificador del objeto.
Por ejemplo, para ver y/o modificar las propiedades de un objeto (control) contenido en
el formulario:
• Seleccione del formulario, el control al cual desea realizar los cambios.
• En la ventana de propiedades se mostrarán las propiedades de dicha etiqueta,
desplácese hasta el nombre de la propiedad que desea modificar, por ejemplo text y
edite el valor, por ejemplo teclee “Hola Mundo” y presione Enter.
Figura 11. Uso de la ventana de propiedades.
2.3.4 El editor de código

El editor de código es la herramienta que muestra y permite editar el código de su
aplicación.
Para mostrar el editor de código, realice alguna de las siguientes acciones:
• Dé clic en la barra de menús en la opción View|Code (Ver|Código).
• Seleccione en el explorador de soluciones el elemento (módulo, formulario, etc.) del
que desea editar el código y dé clic en el botón View Code (Vista de Código).
• Si se encuentra en vista de diseño, dé clic con el botón derecho del ratón sobre el
formulario y elija Ver Código.
23
Figura 12. Editor de código.
Del lado izquierdo se presenta una lista desplegable que le permite seleccionar los nombres
de las clases, y del lado derecho los métodos asociados a cada una de las clases.
2.3.5 Intellisense
IntelliSense es una característica que presenta el editor de código de Visual Studio .NET,
de esta forma no necesitará conocer todos los métodos asociados a un objeto ni la
sintaxis de éstos, ya que al teclear el nombre del objeto correspondiente y el operador
punto (que indica pertenencia en la programación orientada a objetos), aparecerá una
lista con los métodos y propiedades disponibles para ese objeto; si usted selecciona con
un clic aparecerá la descripción del mismo y si da doble clic Intellisense auto-completará
el método o propiedad seleccionado, evitándole escribirlo.
Otra característica es que si tiene un error de sintaxis, éste quedará subrayado en el
editor de código de tal forma, que al pasar el puntero del ratón sobre éste, Intellisense
desplegará una descripción del error, así como la sintaxis correcta.
En la lista que despliega Intellisense para un objeto, las propiedades aparecen con una
imagen parecida a una mano sosteniendo una tarjeta, y los métodos con una especie de
paquete desplazándose que indican un mensaje o comunicación entre objetos.
Figura 13. Intellisense.
2.4 La vista de clases

Para un proyecto o solución existen gran cantidad de clases generadas; la vista de clases
muestra la organización de clases en el proyecto, permitiendo ver la estructura de los
objetos y explorar su código.

Para mostrar la ventana vista de clases, dé clic en la barra de menús en la opción View |
Class View (Ver | Vista de Clases) o bien presione las teclas CTRL+MAYÚS+C.
La vista de clases muestra la organización de las clases dentro del proyecto y permite
acceder a las diversas propiedades y métodos vinculados; dando doble clic en un
elemento de la vista de clases, éste lo llevará a la clase, método, evento, propiedad o
procedimiento, o bien a la definición de la clase dentro del examinador de objetos.
Figura 14. Vista de clases.
En la figura anterior, por ejemplo se despliega la estructura del siguiente espacio de

nombres:
• Solución Hola Mundo
o Proyecto Hola Mundo
Clase FrmHolaMundo
• Procedimiento BtnLimpiar (BtnLimpiar_clic)
Al dar doble clic sobre este último elemento dentro de la vista de clases, se presentará la
vista de código con la definición del mismo.
2.5 El sistema de ayuda

La ayuda dinámica muestra automáticamente enlaces provenientes de la ayuda de Visual
Studio con temas relacionados de la ayuda, dependiendo de dónde se ubique el cursor y
el texto que esté seleccionado; es decir, dependiente del contexto, esto evita que usted
solicite expresamente la ayuda presionando la tecla F1, lo cual es otro tipo de ayuda que
nos proporciona Visual Studio.
Para mostrar la ventana Ayuda dinámica, dé clic en la barra de menús en la opción
Ayuda | Ayuda Dinámica (Help | Dynamic Help) o bien presionando la tecla CTRL+F1.
25
Con esto se mostrará una ventana que cuenta con la característica de que al momento
de seleccionar un elemento dentro de la vista de código, las opciones de ayuda cambian
y dando clic dentro de alguno de estos elementos se mostrará la página con la ayuda, de
acuerdo con el tópico seleccionado.
Por ejemplo, la siguiente figura muestra que al seleccionar la cadena “Hola Mundo”,
dentro de la ventana Ayuda Dinámica (Dynamic Help) se muestran ligas para consultar la
ayuda acerca del tipo de dato String, del operador =, etc., es decir, en función del
elemento seleccionado.
Figura 15. Ventana Vista de código Figura 16. Ventana ayuda dinámica
2.6 Personalización del IDE

Una de las ventajas que presenta el IDE Visual Studio .NET es que usted puede
personalizar muchos aspectos del mismo, como: la forma en que se mostrarán las
ventanas, tipo y tamaño de fuente, entre otras, que se describen a lo largo de este tema,
lo anterior con la finalidad de adaptarla a sus necesidades particulares permitiéndole
trabajar más eficientemente y hacer más agradable su entorno de desarrollo.
La forma más fácil de personalizar el entorno de desarrollo de Visual Studio .NET, es
mediante la configuración de su perfil.
Al ejecutar por primera vez Visual Studio .NET, se mostrará una interfaz tipo página web
que le pide confirmar la configuración del perfil o si desea la barra de menús, seleccione
la opción Ayuda | Mostrar página de inicio (Help | Show Start Page) y dentro de la
página seleccione la opción Mi Perfil (My Profile) con lo que se mostrará una pantalla
como la de la siguiente figura:

Figura 17. Ventana para configurar el perfil de Visual Studio .NET
El perfil es una forma de establecer las preferencias y el comportamiento del IDE de

Visual Studio, las opciones provistas están diseñadas para facilitar la transición de
quienes hayan manejado anteriormente Visual Studio 6 hacia este nuevo entorno. Usted
puede elegir entre los perfiles que se le facilitan.
Es recomendable seleccionar la opción "Programador de Visual Basic" (Visual Basic
Developer).
Esta opción configurará las siguientes opciones:
• Esquema del teclado (Keyboard Scheme): coloca las configuraciones de teclas de
método abreviado que se utilizaban en Visual Basic 6.
• Diseño de Ventana (Window Layout): coloca el diseño de ventana para ocultar el
explorador de servidores y acoplar el cuadro de herramientas a la izquierda, el explorador
de soluciones y la vista de clases a la derecha.
• Filtro de Ayuda (Help Filter): filtra el tipo de ayuda que le presentará MSDN (Microsoft
Developer Network) presentando sólo ayuda de Visual Basic .NET.
• Mostrar Ayuda (Show Help) Interna / Externa: especifica si la ayuda se mostrará
dentro del IDE de Visual Studio o en una ventana externa.
• Al inicio (At Startup): especifica cuál interfaz de usuario aparece al iniciar Visual
Studio .NET.
Otra forma de personalizar Visual Studio .NET, es mediante la opción Herramientas |
Opciones (tools | options) de la barra de menús que se muestra en la siguiente ventana:
27
Figura 18. Ventana para configurar las opciones del IDE de Visual Studio .Net
Del lado izquierdo se muestran las opciones para configurar el ambiente (Enviroment).
• General (General): permite configurar opciones como: cuál será la página que se
muestre al inicio, cómo se mostrarán los documentos abiertos si en ventanas o en
Fichas, entre otras.
• Documentos (Documents): opciones referentes a la edición de los documentos.
• Ayuda Dinámica (Dynamic Help): opciones para configurar las categorías mostradas
en la ayuda, así como el número de ligas que se mostrarán.
• Fuentes y Colores (Fonts and Colors): permite cambiar el tipo y tamaño de la fuente,
así como el color de la letra mostrada al editar el código.
• Ayuda (Help): configura las opciones del lenguaje en que se mostrará la ayuda si se
hará en una ventana externa o interna y el tipo de ayuda que se utilizará.
• Configuración Internacional (Internacional Settings): configura el lenguaje.
• Teclado (Keyboard): coloca las configuraciones de teclas de método abreviado.
• Proyectos y Soluciones (Project and solutions): configura los parámetros para la
ubicación por default que tendrán los proyectos creados, así como las opciones al
construir y ejecutar la solución.
• Lista de tareas (Task List): configura las opciones de la ventana de la lista de tareas.
• Explorador Web (Web Browser): configura las opciones para la página de inicio, de
búsqueda y opciones del navegador Internet Explorer para visualizar los proyectos web.

CAPÍTULO
Sintaxis del lenguaje
A lo largo de este tema, se abordan los elementos del lenguaje de programación como:
clases, variables, operadores, estructuras de control, procedimientos y la sintaxis para
declararlos y utilizarlos.
A continuación, se definirán brevemente las reglas para describir la gramática del
lenguaje de programación Visual Basic .NET.
• = Indican que a continuación va la definición del elemento, es decir, que lo del lado
izquierdo puede ser sustituido por lo del lado derecho dentro de una expresión.
• <elemento> Este elemento debe ser proporcionado obligatoriamente siguiendo
ciertas reglas, por ejemplo para los tipos de acceso <acceso> := public | protected,
indica que sólo podrá especificar tipo de acceso public o bien protected.
• negritas Indica que este elemento (palabra) se tiene que poner tal como se específica,
por ejemplo, para declarar una clase deberá poner class, ya que es una palabra
reservada de Visual Basic .NET.
• [elemento] Indica que el elemento es opcional puede o no proporcionarse en la
declaración, por ejemplo, especificar el acceso de una clase es opcional, en caso de
no hacerlo, por default asumirá public.
• A | B Indica que el elemento sólo podrá tomar uno de los dos valores A o B.
Comentarios
Los comentarios son partes dentro del código del programa que el compilador no tomará en
cuenta y que puede utilizar para describir el funcionamiento del programa, así como algunas
instrucciones en particular con la finalidad de hacer más entendible el programa a la hora de
revisarlo o en caso de que otra persona lo revise y realice modificaciones también puede
utilizarlo para inhabilitar uno o más bloques de código temporalmente en vez de eliminarlos.
Para colocar un comentario en Visual Basic, deberá anteponer el símbolo (‘ ), y los caracteres
posteriores a él hasta el fin de la línea serán un comentario, como se muestra a continuación:
‘ Esto es un comentario y no será tomado en cuenta por el
compilador.
29
3.1 Convenciones del lenguaje

Otro elemento por definirse para la declaración de una clase, es el identificador como se
mencionó en la sintaxis de declaración. El identificador se refiere al nombre de la clase, y es
recomendable usar nombres descriptivos que ayuden a recordar lo que representa la clase.
En los ejemplos que se mencionaron anteriormente, se utilizaron identificadores como:
ClaseParaTodos, ClaseParaMisHijos, FrmHolaMundo, etc, pero no todos son válidos ya
que existen las siguientes normas para nombrar clases y variables:
• Los identificadores de clases y variables deben empezar con una letra a-z A-Z o un
caracter de subrayado seguido de alguna letra para evitar la ambigüedad de la
continuación de línea. Por convención, es preferible que los identificadores de clase
inicien con mayúscula y los identificadores de variables inicien con minúscula.
• Los identificadores de clases y variables no deben coincidir con palabras clave del
lenguaje.
• Los identificadores no distinguen entre mayúsculas y minúsculas, por ejemplo
miVariable y MiVariable son el mismo identificador.
• Los identificadores no deben incluir puntos o un carácter de identificación de tipo
(%,&,!,#,@,$).
• Los identificadores no deben superar los 255 caracteres de longitud.
• Un identificador debe tener un nombre exclusivo dentro del ámbito (alcance) a
excepción de los procedimientos que pueden tener el mismo nombre pero con
distinta lista de argumentos. El ámbito de las clases es el proyecto, el ámbito de las
variables globales es la clase y el ámbito de las variables locales es el método en el
cual fueron declaradas.
• Los identificadores no deben contener espacios en blanco (este es un error muy común).
Notación húngara
Es recomendable como programadores que, además de utilizar nombres descriptivos
como identificadores, indiquemos el tipo de dato que almacenan, es decir, que mediante
el identificador se conozca si almacena un entero, una cadena, un número flotante, etc.
Con este fin se ha creado un sistema estandarizado para nombrar variables conocido
como notación húngara. La notación húngara implica colocar un prefijo en minúsculas al
identificador de una variable; para indicar el tipo de dato almacenado, a continuación se
listan las convenciones que tienen sentido dentro de Visual Basic .NET.
Prefijo Tipo de dato Ejemplo en Visual Basic .NET

b Boolean bIndicador as Boolean
by Byte byEnteroCorto as Byte
c Char cCaracter as Char
i Integer iEntero as Integer
l Long lEnteroLargo as Long

Prefijo Tipo de dato Ejemplo en Visual Basic .NET

s String sCadena as String
d Double dNumeroFlotante as Double
a Arreglos abArregloDeBytes as new Byte(5)
o Objetos en general oAutomovil as new Automovil()
Si lo desea puede utilizar la notación húngara, al igual que puede crear sus propios
prefijos para otros tipos de datos procurando que sean descriptivos; más adelante
cuando generemos interfases gráficas utilizaremos otras convenciones para
identificadores de variables de tipo: etiquetas (Label), cuadros de texto (TextBox), etc.
A continuación, se muestra la sintaxis para declarar una clase:
Public class MiClase
'Aquí irían las declaraciones de variables y procedimientos
End Class
Algunos ejemplos de identificadores para variables son:
Dim 1erEntero As Integer 'Invalido no empieza con una letra
Dim i1erPrimer_Entero As Integer 'Valido
Dim imi Primer Entero% As Integer 'Invalido contiene el caracter
% y varios espacios en blanco.
Para agregar una clase, tendrá que indicárselo a Visual dando clic en la opción de la
barra de menús Proyecto | Agregar Clase (Project | Add Class).
Otra forma de hacer lo anterior, es desde el explorador de soluciones, dar clic con el
botón derecho sobre el elemento proyecto, y seleccionar la opción Agregar Clase (Add
Class) del menú contextual que aparece.
3.2 Variables y tipos de datos

Una variable representa un espacio en memoria, almacena un valor de determinado tipo
(valor, referencia), el cual puede modificarse a lo largo de la ejecución del bloque de
instrucciones donde la variable es accesible. Visual Basic .NET utiliza tipos de datos que
se corresponden directamente con los tipos de datos del sistema de tipos comunes
(Common Type System – CTS), que, como ya se mencionó, define los tipos de datos que
soporta el Common Language Runtime.
Es importante comprender que el CTS es uno de los elementos que hace posible que las
aplicaciones en el .NET Framework tengan la capacidad de ser multilenguaje. A
continuación, se muestra un diagrama de organización del sistema de tipos comunes.
31
Para declarar una variable, se utiliza la palabra reservada Dim, la sintaxis para su
declaración es la siguiente:
Sintaxis:
<declaración de variable>:== [<acceso>] Dim <identificador> [As
<tipo>]
Semántica:
Declara una variable con el acceso y tipo indicados, si no especifica el acceso asume
public de manera automática y si no especifica el tipo asume Object.
Ejemplos:
'Declara dos variables de tipo entero
Dim i1, i2 As Integer
La instrucción anterior es equivalente a las siguientes dos instrucciones:
Dim i1 As Integer
Dim i2 As Integer
A continuación se declara una variable de tipo cadena:
Dim sMiCadena As String 'declara una variable de tipo cadena
llamada miCadena.
Inicialización de variables
De manera predeterminada, una variable contiene un valor cuando se declara. Por
ejemplo una variable de tipo Integer contiene el valor 0, una de tipo Boolean el valor
False. Se puede inicializar una variable para definir un valor inicial como se aprecia a
continuación.
Dim inumVar As Integer 'Declara la variable NumVar de Tipo entero
inumVar = 20 'Inicializa NumVar con el valor 20

En versiones anteriores de Visual Basic no podía inicializarse las variables en la misma

línea en que se declaraba; en Visual Basic .NET es posible, como se muestra a
continuación:
Dim iNumVar As Integer = 20
3.3 Tipos de datos elementales (enteros, no enteros, caracter,

lógico, fecha)
Otro de los elementos que había que especificar en la declaración de una variable era el
tipo de dato, que especifica el tipo de valor que almacenará la variable. Los tipos en
Visual Basic se clasifican en tipos valor o predefinidos y tipos referencia.
• Tipos por valor: son llamados de esta forma debido a que la variable almacena el
valor de forma directa por lo que para acceder al dato basta con referirse a la
variable; las variables de tipos por valor son almacenadas en el stack7, si se realiza
la asignación de una variable a otra, ésta ultima guarda una copia del valor, siendo
estas variables independientes ante una posterior modificación.
• Tipos por referencia: las variables por referencia almacenan la dirección de memoria
que almacena al dato, por lo que para acceder al dato se hará referencia a la
dirección de memoria; estas variables se almacenan en el heap8, si se realiza la
asignación de una variable a otra, esta ultima guarda una copia de la dirección de
memoria, por lo que hacen referencia al mismo valor y cualquier modificación de
una variable afecta a la otra.
Ejemplo:
Dim iContador As Integer 'valor almacena un entero
Dim oCliente As MiObjeto 'referencia almacenará una referencia a
una localidad de memoria de un objeto que es instancia de la
clase MiObjeto.
Si después de las declaraciones del ejemplo intentamos utilizar el valor, la variable
iContador Visual Basic respondería con el valor cero, por el contrario para la variable
oCliente obtendríamos el valor “Nothing”, es decir, que no hace referencia a un
objeto válido debido a que no se ha creado una instancia.
Los tipos valor se clasifican en:
• Primitivos.
• Estructuras.
• Enumeraciones.
Los tipos primitivos se clasifican en:
7
El stack es una estructura que almacena variables locales, funciones y sus parámetros, así como
resultados intermedios, asigna y libera memoria de acuerdo a las operaciones de una pila.
8
El heap es un área de memoria dinámica, asigna (en ocasiones huecos no adyacentes) y libera
memoria al sistema operativo de forma aleatoria.
33
• Enteros (Byte,Short,Integer,Long).
• Reales (Single, Double,Decimal).
• Boolean.
• Char.
• Date.
A continuación, se presenta una tabla con la descripción de los tipos primitivos en Visual
Basic.
Tipo Estructura en CLR Tamaño Descripción
Byte System.Byte 8 bits Datos numéricos de 0 a 255 (sin signo).
Short System.Int16 16 bits Datos numéricos de -32,768 a 32,767.
Integer System.Int32 32 bits Datos numéricos de -2,147,483,648 a

2,147,483,647.
Long System.Int64 64 bits Datos numéricos de -9,223,372,036,854,775,808 a

9,223,372,036,854,775,807.
Single System.Single 32 bits Números de punto flotante de precisión simple de -

3.4028235E+38 a -1.401298E-45 para valores
negativos; 1.401298E-45 a 3.4028235E+38 para
valores positivos.
Double System.Double 64 bits Números de punto flotante de precisión doble de -

1.79769313486231570E+308 a
-4.94065645841246544E-324 para valores negativos;
4.94065645841246544E-324 a
1.79769313486231570E+308 para valores positivos.
Decimal System.Decimal 128 bits Números de punto fijo, correspondientes a enteros

elevados a la décima potencia de 0 a +/-
79,228,162,514,264,337,593,543,950,335 para
valores sin punto decimal; y de
0 a +/-7.9228162514264337593543950335 con 28
dígitos a la derecha del punto decimal; Por ejemplo el
numero mas pequeño distinto de cero es
+/- 0.0000000000000000000000000001 (+/-1E-28).
Boolean System.Boolean 16 bits Almacena datos que pueden tomar valor True o False.
Char System.Char 16 bits Almacena un único carácter 'a','b', etc., pero se

almacena como un entero sin signo de de 16 bits de 0
a 65535.

Tipo Estructura en CLR Tamaño Descripción
Date System.DateTime 64 bits Almacena fechas y horas 0:00:00 de 01/Enero/0001

a 11:59:59 PM 31/Diciembre/9999, los almacena en
una representación de enteros largos de 64 bits.
String System.String Depende De 0 a 2 billones de caracteres unicode

de la aproximadamente.
plataforma
Todos los tipos de datos están asociados a un tipo de la BCL (estructura de datos
asociada por el CLR de .NET), por ejemplo el tipo Single está asociado a System.Single;
de esta manera, estos tipos de datos también son objetos y una consecuencia de esto es
que el tipo Object pueda almacenar valores de cualquiera de estos tipos primitivos,
similar a la función que desempeñaba el tipo Variant en Visual Basic.
Tenga en cuenta los rangos de los valores que es capaz de almacenar cada tipo de
datos, si intenta asignar valores fuera del rango recibirá un mensaje de error por parte de
Visual Basic, por ejemplo si intenta asignar el valor 256 a una variable de tipo Byte
recibirá un error, lo mismo sucederá con los demás tipos de datos.
Una vez que hemos revisado cómo declarar variables de tipo valor, utilizaremos
estructuras que nos permitan manejar conjuntos de variables como los son las
enumeraciones, estructuras y matrices.
3.4 Tipos de datos compuestos (enumeraciones, estructuras y

matrices)
Enumeraciones
Son tipos definidos por el usuario; para crearlos se utiliza la palabra reservada Enum. Las
enumeraciones proporcionan una forma cómoda de trabajar con un conjunto de
constantes relacionadas entre sí y de asociar sus valores con nombres. Por ejemplo, se
puede declarar una enumeración para un conjunto de constantes de tipo entero
asociadas con los días de la semana, y después utilizar los nombres de los días en el
código, en lugar de sus valores enteros, como se muestra en el ejemplo.
'Declara la enumeración día con 7 elementos domingo=0, lunes=1,
etc.
Enum dia
domingo
lunes
martes
miercoles
jueves
viernes
sabado
End Enum 'Marca el fin de la declaración
35
'Declara diaSem, de tipo día y con el valor 6

Dim diaSem As dia = dia.sabado
Estructuras
Tipo de dato compuesto, que a diferencia de las enumeraciones, permiten agrupar
variables de distintos tipos; estas variables conforman los atributos (miembros) de la
estructura, pero además de atributos las estructuras pueden poseer: constructores,
métodos, propiedades, campos constantes y enumeraciones. Por todo lo anterior, son
similares a las clases salvo algunas restricciones, entre sus diferencias se encuentran:
• Son tipos valor y no referencias a objetos.
• No se permite la herencia entre estructuras.
Aun cuando en algunos aspectos son similares a las clases, la principal función de las
estructuras es que permiten crear aplicaciones para implementar un manejador de bases
de datos. Ya que la mayoría de los usuarios no hará eso y sólo creará aplicaciones que
acceden a bases de datos ya conocidas (Access, SQL Server, MySQL, etc.), no las
abordaremos.
Matrices
Ya hemos visto que las variables almacenan datos, pero en ocasiones necesitará trabajar
con múltiples variables para almacenar información similar. Por ejemplo, suponga que
necesita almacenar 50 nombres, podría declarar 50 variables de tipo cadena y
almacenar cada nombre en una variable, o bien, puede declarar una matriz de tipo
cadena que los almacene.
Una matriz es una colección de variables con el mismo tipo de dato. Todas las variables
de una matriz tienen el mismo nombre pero se diferencian por un índice.
Sintaxis:
Dim nombreDeArreglo (Numero de elementos) [As Tipo]
Es necesario colocar los paréntesis para indicar a Visual Basic que se trata de un arreglo y no
de una variable.
[As tipo] Los corchetes indican que la expresión “As tipo” es opcional, si no especifica el tipo
se asume Object.
Ejemplo:
Dim sNombres (49) As String
Esta instrucción es equivalente a:
Dim sNombres As String = new String(49)
Ambas declaran un arreglo de 50 elementos, el motivo por el que tiene 50 elementos y
no 49 como indica el código, es que el índice de las matrices empieza en cero y no en
uno, por esto se tienen índices entre 0 y 49, lo que genera un total de 50 elementos.

Como se ha venido mencionando, un arreglo es una colección de variables por lo que se

tratan de la misma forma, es decir, las puede inicializar, asignarle valores, recuperar
valores, de la misma manera que lo hace con las variables.
Ejemplo:
sNombres(0)="Carlos"
'Asigna la cadena "Carlos a la variable sNombres(0), que
corresponde al primer índice del arreglo.
3.5 Literales y constantes

Constantes
Una constante o literal es el valor de alguno de los tipos expuestos anteriormente. Por
ejemplo:
0, 3.14159, "Hola Mundo", "a"C
Sintaxis (enteros):
{ [+] | - } literal_entero [{ S | I | L }]
Semántica:
El signo + es opcional y el signo - es obligatorio; si el valor es negativo, literal_entero es
el valor entero y S, I, L son opcionales e indican la representación que se utilizará.:
• S: Short
• I: Integer
• L: Long
Si se omite la representación del tipo de dato por utilizar, la constante intentará
representarse mediante el tipo de dato Integer, y si el valor de la constante rebasa la
capacidad de Integer se asignará Long.
Ejemplos:
-1454I 'Constante entera Integer
3426000000 'Constante entera Long
Sintaxis (reales):
{ [+] | - } parte_entera.parte_fraccionaria [{e|E} {[+]|-}
exponente] [{F |R |D }]
Semántica:
El signo + es opcional y el signo - es obligatorio; si el valor de la base es negativo, de
igual forma para el valor del exponente, F, R, D son opcionales e indican la
representación que se utilizará.
• F: Single
• R: Double
37
• D: Decimal
Si se omite el sufijo, el tipo por default es Double.
La letra E o e, es el símbolo para indicar que a continuación se colocará el valor
numérico del exponente, el cual puede constar de uno o más dígitos del 0 al 9.
Ejemplos:
.18e3
27E-3
Sintaxis (caracter):
"x"C
Semántica:
El signo x representa cualquier caracter o espacio en blanco y la C indica que se trata de
un caracter y no de una cadena.
Ejemplos:
"p"C 'Constante caracter p
Sintaxis (cadena):
"MiCadena"
Semántica:
Declara una cadena cuyo valor es la palabra MiCadena..
3.6 Alcance de las variables

El ámbito define el rango de acceso de una variable, es decir, la parte del programa
donde se puede utilizar, y de acuerdo con su alcance, se clasifican en:
• Variables locales: se declaran dentro del cuerpo de un procedimiento y son accesibles
exclusivamente dentro de éste por lo que no se pueden utilizar fuera de él y pierden su
valor al terminar la ejecución del procedimiento en el que fueron declaradas.
• Variables de módulo: se declaran fuera de cualquier procedimiento y dentro del
cuerpo de la clase o módulo, se pueden utilizar dentro de cualquier procedimiento de
la clase ó módulo o aún entre módulos de la aplicación, esto último depende del tipo
de acceso que se le asocie a la variable.
Ejemplos:
public class MiClase
Dim varModulo 'variable de módulo, está declarada fuera de
cualquier procedimiento y dentro de la clase.
Sub MiProcedimiento
Dim varLocal 'variable local, solo es accesible en el
procedimiento.

varModulo = 1 'La variable varModulo es accesible dentro de

la clase.
End Sub
End Class.
3.7 Tipos de acceso (visibilidad de las propiedades)

Como se mencionó anteriormente, las variables de módulo pueden definir su tipo de
acceso, la sintaxis para su declaración es la siguiente:
Sintaxis:
acceso::= Public | Protected | Friend | Protected Friend | Private
Semántica:
Indica el acceso para una variable a nivel de módulo.
public: declara que la variable es accesible dentro del módulo o clase e incluso desde
otros módulos que se encuentren dentro del proyecto, así como desde los módulos de
otros proyectos que hagan referencia al proyecto.
Ejemplo:
Public class ClaseParaTodos
public variablePublica As Integer
End Class
private: declara que la variable es accesible sólo dentro del módulo o clase donde se ha
declarado.
Ejemplo:
private miVariable As Integer
End Class
protected: declara que la variable es accesible dentro de la misma clase o desde una
clase derivada de ésta.
Ejemplo:
protected variableParaMisHijos As Integer 'Variable que
heredaran clases herederas
End Class
Estos son los tipos de acceso más común, existen dos modificadores de acceso más:
Friend declara que la variable será accesible dentro del proyecto, y Protected Friend que
declara que la variable será accesible dentro del proyecto o desde una clase que herede
de la misma clase en donde se declaró.
39
3.8 Conversión entre tipos de datos

En un principio Visual Basic .NET permite convertir implícitamente algunos tipos de datos,
pero esto puede originar pérdidas de información, por ejemplo para convertir una
variable Integer a una de tipo Byte se tendría que truncar la representación en bits, sin
embargo, al revés sí es válido ya que la representación de un Byte cabe en la de Integer.
Para detectar los errores de una conversión implícita con pérdida de información, usted
puede forzar a Visual Studio .NET a que verifique esas conversiones y sólo permita
aquéllas que indique explícitamente el programador; para hacerlo, coloque la opción
Option Strict on en la sección de declaraciones al inicio de su código
De esta manera tenemos conversiones implícitas y explícitas y la siguiente figura indica
precisamente las conversiones implícitas seguras con la flecha que va de izquierda a derecha:
Byte --> Short --> Integer --> Long --> Single--> Double--> Decimal
Option Strict On 'Forza la revisión de conversiones implícitas
Private Sub Main()
Dim rDato as Double=1.34
Dim bDato as Byte
bDato=rDato ‘Marca error y no realiza la conversión implícita, de
lo contrario podría haber perdida de información.
End Sub.
3.9 Funciones de conversión

Si usted activa la verificación de conversiones implícitas mediante Option Strict On y en
un momento dado desea realizar una conversión de manera explícita, puede utilizar las
funciones de conversión, siempre y cuando se asegure de que la expresión esté dentro del
rango del tipo de dato hacia el que desea convertir, de lo contrario se producirá un error. A
continuación, se describen las funciones de conversión existentes en Visual Basic .NET:
Función de
Descripción Ejemplos
conversión
CBool Convierte una expresión numérica o A=5,B=5
de cadena válida y devuelve un valor valor= CBool(A = B) ‘valor=true
de tipo Boolean, cualquier valor C=0
numérico distinto de cero devuelve el
valor = CBool(C) 'valor=False
valor true.
CByte Convierte una expresión numérica o dPi as Double=3.141592
de cadena válida y devuelve un valor bPi as Byte
de tipo, redondea las fracciones, sólo bpi=dpi ‘bpi = 3
acepta rangos de 0 a 255 devolviendo
un valor de tipo Byte.
CChar Convierte una expresión de cadena cLetra=CChar(“ABC”) ‘cLetra = A,
válida, devuelve el primer carácter devuelve el primer carácter
como valor de tipo Char.

Función de
Descripción Ejemplos
conversión
CDate Convierte una expresión válida de Dim sfecha As String = "18/01/2001"
fecha y hora devolviendo un valor de Dim valor As Date
tipo Date. valor = CDate(sfecha) ‘Valor =
18/01/2001
CDbl Convierte una expresión numérica a su Dim dReal As Double
representación en Double. Dim dDecimal As Decimal = 0.01D
dReal = CDbl(dDecimal * 1.0E-27)
'dReal =1E-29
CDec Convierte una expresión numérica a su Dim dReal As Double=0.01D
representación en decimales. Dim dDecimal As Decimal
dDecimal = CDec(dReal * 1.0E-27)
‘dDecimal =0, el número más
pequeño distinto de cero es 1E-28
CInt Convierte una expresión numérica a su Dim dReal As Double=7.64
representación entera de 32 bits Dim iEntero As Integer
redondeando las fracciones. iEntero = CInt(dReal) ‘iEntero=8
CLng Convierte una expresión numérica a su Dim dReal As Double=7.64
representación entera de 64 bits Dim lEntero As Long
redondeando las fracciones. lEntero = CLong(dReal) ‘lEntero =8
CObj Convierte cualquier expresión válida. Dim dReal As Double=7.64

Dim oObjeto As Object
oObjeto = CObj(dReal)'oObjeto
contiene una referencia al valor
asignado.
CShort Convierte una expresión numérica a su Dim dReal As Double=7.64

representación entera de 16 bits Dim sEntero As Short
redondeando las fracciones. sEntero = CShort(dReal) ‘sEntero =8
CSng Convierte una expresión numérica a su Dim dReal As Double = 1.0E-46
representación en Single. Dim sSingle As Single
sSingle = CSng(dReal) ‘sSingle=0, ya
que el número más pequeño distinto de
cero es 1.401298E-45
CStr Convierte cualquier expresión Dim dReal As Double=1.1
numérica de fecha. Dim sCadena As String
sCadena = dReal sCadena= “1.1”
El comportamiento de las funciones de conversión descritas puede ser obtenido también

mediante una función general llamada Ctype, que le permite convertir cualquier
expresión al tipo especificado y cuya sintaxis es la siguiente:
Ctype(expresión, tipo de dato)
41
Como primer argumento recibe la expresión que desea convertir y como segundo
argumento el nombre del tipo de dato hacia el cual lo desea convertir; en caso de recibir
una expresión fuera del rango permitido, se producirá un error. A continuación se
muestra un ejemplo:
Dim dReal As Double = 7.91
Dim iEntero As Integer
iEntero = CType(dReal, Integer) ‘IEntero = 8.
Option Explicit
Option Explicit es una instrucción optativa que se coloca al inicio del archivo (de la
misma forma que Option Strict) y tiene la siguiente sintaxis.
Option Explicit { On | Off }
Si está habilitada (se encuentra habilitada valor por defecto, ya que es recomendable)
forzará al compilador a verificar que todas las variables que intente utilizar dentro del
programa, hayan sido declaradas previamente de manera explícita, produciendo un error
en caso contrario.
Si deshabilita la opción, podrá utilizar variables que no han sido declaradas, las cuales
tendrán por defecto el tipo de dato Object. A continuación, se muestra un ejemplo:
Option Explicit Off 'Permite utilizar variables no declaradas.
Dim iNumero As Integer
iNumero = 10
oVariable = iNumero ‘oVariable es de tipo Object pero contiene
el valor 10.
3.10 Operadores y precedencia

Un operador realiza una operación sobre una o más variables o elementos. A
continuación, se muestra una tabla con los distintos tipos de operadores agrupados por
categorías y ordenados de mayor a menor precedencia de arriba hacia abajo de
izquierda a derecha, por lo que el operador de mayor precedencia es la exponenciación
^, seguido por la negación unaria, etc.; posteriores a los operadores aritméticos y de
concatenación, se encuentran los de comparación, los cuales tienen la misma
precedencia y así sucesivamente.
Categoría Operadores
Exponenciación (^)
Aritméticos y Negación unaria (–)

Concatenación
Multiplicación y división (*, /)

División de número entero (\)
Módulo aritmético (Mod)
Suma y resta (+, –), concatenación de cadenas (+)
Concatenación de cadenas (&)
Desplazamiento de bits aritmético (<<, >>)
=, <>, <, <=, >, >=, Like, Is, TypeOf...Is (Tienen la misma
Comparación
precedencia).
Negación (Not)
Lógicos y bit a bit Conjunción (And, AndAlso)
Disyunción (Or, OrElse, Xor)
Asignación =, ^=, *=, /=, \=, +=, -=, &=
Cuando una expresión combina distintos operadores, ésta se evalúa en un orden

determinado por la precedencia de cada operador, como se muestra en el siguiente
ejemplo, la expresión:
5 + 4 * 3
Visual Basic la evaluará como 17, debido a que realiza primero la multiplicación por
tener mayor precedencia que la suma, reduciendo la expresión a 5 + 12 =17.
Los paréntesis poseen la mayor precedencia, por lo que le permiten agrupar una
subexpresión de tal forma que sea evaluada antes que las demás, por ejemplo, si desea
que Visual Basic realice primero la suma de 5 + 4 puede hacer lo siguiente:
(5 + 4) * 3
La expresión anterior será evaluada a 27, debido a que realiza primero la suma por estar
entre paréntesis, reduciendo la expresión a 9*3=27.
Cuando existen dos o más operadores con la misma precedencia dentro de una
expresión, serán evaluados de izquierda a derecha según su orden de aparición.
3.11 Estructuras de decisión

Cuando es invocado un método dentro de un programa, se van ejecutando las
instrucciones desde el principio hasta el fin del método de manera secuencial, a menos
que se cambie el orden de ejecución con instrucciones de control o mediante ciclos.
Las instrucciones de control permiten regular el flujo de ejecución de un programa. A
continuación se verán algunas instrucciones de control, que le permiten tomar decisiones.
43
Las instrucciones de decisión que se verán a continuación son:

• If...Then
• If...Then...Else
• Select...Case
3.11.1 If...Then…Else
Sintaxis:
If <expresión booleana>Then <Una sola Instrucción>
Semántica:
Si la expresión booleana se evalúa a verdadero (True) entonces (Then) ejecuta la única
instrucción si no continúa con la siguiente instrucción fuera del If, observe que sólo debe
de haber una instrucción; para que acepte más de una instrucción, deberá terminar la
sentencia con End If, como se muestra a continuación:
Sintaxis:
If <expresion booleana> Then
<Una o más Instrucciones>
End If
Semántica:
Si la expresión booleana se evalúa a verdadero (True) entonces (Then) ejecuta todas las
instrucciones después de la palabra Then y así hasta llegar a End If, es decir, ejecuta el
bloque entre Then y End If. También puede requerir que se ejecute otro bloque de
instrucciones en caso de que sea falsa la expresión booleana, como se muestra a continuación:
Sintaxis:
If (expresion booleana) Then
<Una o más Instrucciones ejecutadas en caso de ser verdadera la
expresión booleana>
Else
<Una o más Instrucciones ejecutadas en caso de ser falsa la
expresión booleana>
End If
Semántica:
Si la expresión booleana se evalúa a verdadero (True) entonces (Then), ejecuta todas las
instrucciones después de la palabra Then y así hasta llegar a Else, es decir, ejecuta el
bloque entre Then y Else.
Si la expresión booleana se evalúa como falsa (False) ejecuta todas las instrucciones del
bloque Else - End If.

Ejemplo:
Sub Comparaciones( )
If (3 > 4) Then
MsgBox (" Me ejecuté por que 3 es mayor que 4")
Else
MsgBox (" Me ejecute por que 3 no es mayor que 4")
End If
End Sub
3.11.2 Select...Case
Estructura de decisión que permite ejecutar uno de entre varios bloques de instrucciones,
según los distintos valores a los que se evalué una expresión, es decir, a diferencia de la
Instrucción If-Else-End If utilizada para expresiones que sólo pueden evaluarse
como Falsa o Verdadera, la instrucción Select…Case se utiliza en los casos donde una
expresión puede evaluarse a dos o más valores distintos.
Sintaxis:
Select Case <expresion>
Case <ListaDePosiblesValores>
< instrucciones >
[ Case Else
< instrucciones else>]
End Select
Semántica:
<Expresión> debe evaluarse en uno de los tipos de datos elementales (Boolean, Byte,
Char, Date, Double, Decimal, Integer, Long, Object, Short, Single o String).
<ListaDePosiblesValores> que coinciden con la evaluación de expresión. Las cláusulas
de varias expresiones se separan mediante comas.
Dim Numero As Integer = 8
Select Número 'Evalua el Número.
Case 1 To 5 'Numero esta entre 1 y 5
MsgBox("Esta entre 1 y 5"')
Case 6, 7, 8 'Numero es 6 ó 7 u 8
MsgBox(" El número es entre 6 ó 7 u 8”)
Case 9 To 10 'Si Numero esta entre 9 o 10
MsgBox("Esta entre 9 y 10")
Case Else 'En caso de que no se cumplió ninguno de los
anteriores
MsgBox("El número no esta entre 1 y 10")
End Select.
45
3.12 Estructuras de ciclo

Las estructuras de ciclo permiten ejecutar una o más líneas de código repetitivamente. Un
bloque de instrucciones puede repetirse hasta que una condición sea verdadera o hasta
que sea falsa, o bien, un número de veces especificado. Las estructuras de ciclo que
veremos son:
• While
• Do...Loop
• For...Next
• For Each...Next
3.12.1 While
Se puede utilizar la instrucción While para ejecutar un bloque de instrucciones, un
número de veces indefinido, dependiendo del valor de una condición. La instrucción
While comprueba siempre la condición antes de iniciar el ciclo. La ejecución en ciclo
continúa mientras el valor de la condición sea verdadero.
En el ejemplo siguiente, el procedimiento PruebaWhile comprueba la condición antes
de entrar en el ciclo. Si número se hubiera inicializado en 6 y no en 10, las instrucciones
del ciclo nunca se ejecutarían.
Sub PruebaWhile ( )
Dim iContador As Integer = 0
Dim iNumero As Integer = 10
While iNumero > 6
iNumero = iNumero-1
iContador = iContador + 1
End While
MsgBox("Instruccion ejecutada " & iContador & " veces.")
'Despliega “Instrucción ejecutada 4 veces”.
End Sub.
3.12.2 Do...Loop
Tiene la misma función que While, salvo la diferencia de que las instrucciones dentro
del bloque Do---Loop While se ejecutan al menos una vez, debido a que es al final
del bloque cuando se verifica la condición; en el ejemplo anterior, si la variable número
se hubiera inicializado en 6, las instrucciones del ciclo nunca se ejecutarían, sin embargo,
en el siguiente ejemplo las instrucciones del ciclo si se ejecutan una vez.
Sub PruebaDo ( )
Dim iContador As Integer = 0
Dim iNumero As Integer = 6
Do

iNumero = iNumero – 1
iContador = iContador + 1
Loop While iNumero > 6
MsgBox("Instrucción ejecutada " & iContador & " veces.")
' Despliega “Instrucción ejecutada 1 veces”.
End Sub.
3.12.3 For...Next
Los ciclos Do funcionan bien cuando no se sabe de antemano cuántas veces se necesitan
ejecutar las instrucciones en el ciclo. No obstante, si tiene previsto ejecutar el ciclo un
número específico de veces, un ciclo For...Next es una solución. A diferencia de un
ciclo Do, un ciclo For utiliza una variable denominada Contador, cuyo valor aumenta
o disminuye cada vez que se repite el ciclo. La sintaxis es la siguiente:
Sintaxis:
For <contador> [As datatype] = <valor_inicial> To <valor_limite>
[ Step <incremento> ]
'Bloque de instrucciones
Next [ <contador> ]
Ejemplo:
Sub Suma2 ( )
Dim iContador, iTotal As Integer
‘Inicia contador en 2, incrementa de 2 en 2 hasta llegar a
10
For iContador = 2 To 10 Step 2
iTotal = iTotal + iContador
Next iContador
MsgBox ("El total es" & iTotal)
End Sub.
3.12.4 For each Next

El ciclo For Each...Next tiene la función de iterar sobre una colección (objeto de
tipo Collection) o bien sobre un arreglo ejecutando el bloque de instrucciones por cada
elemento almacenado. La sintaxis es la siguiente:
Sintaxis:
For Each <elemento_de_la_colección> [ As datatype ] In
<nombre_de_la_colección>
'Bloque de instrucciones a ejecutarse por cada elemento de la
colección:
Next [elemento_de_la_colección].
47
Ejemplo:
La funcion Sumador recibe como argumento un arreglo llamado A de enteros, suma
cada elemento del arreglo y devuelve el valor con la suma total.
Function Sumador (ByRef A() As Integer) As Integer
Dim iElem As Integer
Dim iSuma As Integer = 0
For Each iElem In A
iSuma += iElem
Next Elem
Return iSuma
End Function.
3.13 Funciones y procedimientos

A continuación, se describe la manera de crear y utilizar distintos tipos de procedimientos
dentro de Visual Basic.NET. Suponga que tiene que realizar una tarea de forma repetida
por ejemplo, solicitar datos (nombre, dirección y teléfono), generar un nuevo registro y
almacenarlo en la base de datos. Para estos casos, en lugar de escribir repetidamente las
instrucciones, es posible agruparlas en un procedimiento que sea llamado cada vez que
necesite hacerlo, tarea para la que han sido creados los procedimientos.
Un procedimiento es un conjunto de instrucciones agrupadas para realizar una
determinada tarea. Por ejemplo para el caso anterior, usted puede colocar todas las
instrucciones necesarias para solicitar datos, crear el nuevo registro dentro del mismo
procedimiento o refinar la solución haciéndola modular y generar un procedimiento para
solicitar los datos, así como elaborar el nuevo registro y desde ahí invocar otro
procedimiento encargado de agregar registros a la base de datos.
Existen cuatro tipos de procedimientos en Visual Basic .NET, que se describirán posteriormente:
• Procedimientos Sub: realizan tareas específicas.
• Procedimientos Function: realizan tareas específicas y devuelven un valor a la
instrucción de llamada.
• Procedimientos Property: asignan o acceden al valor de un objeto.
• Procedimientos Event-Handling: realizan tareas específicas cuando se produce un
determinado evento.
3.13.1 Crear e invocar procedimientos

Un procedimiento puede ser invocado desde cualquier lugar de la aplicación de la
siguiente manera: se invocan de forma explícita. No puede invocarlos colocando su
nombre en una expresión. Debe pasar todos los argumentos que no sean opcionales al
invocar el método, e incluir la lista de argumentos entre paréntesis.
La instrucción que invoca al procedimiento también se conoce como instrucción de
llamada y su sintaxis es la siguiente:

Sintaxis:
<nombre_procedimiento> ([<declaración de argumentos>])
Semántica:
Se invoca al procedimiento mediante su nombre y pasando la lista de argumentos
(valores necesarios para que el procedimiento realice la tarea correspondiente). A
continuación, se menciona un ejemplo.
Cuando el programa se encuentra en un punto con la instrucción de llamada a un
procedimiento, el compilador se detiene en ese punto y empieza a ejecutar el código que
está dentro del bloque del procedimiento invocado; cuando termina de ejecutar todas las
instrucciones del método invocado, regresa a ejecutar la siguiente instrucción al punto
donde se originó la instrucción de llamada.
Observe que dentro del procedimiento invocado podría suceder que también se realizará
una instrucción de llamada a otro procedimiento distinto; de la misma manera, deberá
de ejecutar todas las instrucciones del último procedimiento invocado y regresar el flujo
de ejecución al punto donde fue invocado.
Procedimientos Sub
Su principal característica es que sólo son utilizados para realizar tareas específicas sin
devolver ningún valor, se pueden declarar dentro de un módulo, clase o estructura.
Cuando se invoca se ejecuta desde la primera instrucción hasta la primera instrucción
End Sub, Exit Sub o Return que se encuentre.
Sintaxis:
[<acceso>] Sub <Nombre_Procedimiento> [(<ListaDeArgumentos>)]
‘Instrucciones que forman el cuerpo del procedimiento
End Sub
Semántica:
Se declara un procedimiento Sub con el acceso y el nombre especificados, a diferencia
de las variables sí puede existir más de un procedimiento con el mismo nombre dentro
del mismo ámbito, siempre y cuando el número de argumentos recibidos y el tipo de
datos de cada argumento no sea igual, lo cual se conoce como sobrecarga de
procedimiento: tema que veremos posteriormente.
Un procedimiento Sub puede tomar argumentos, como constantes, variables o
expresiones, que le pasa el código de llamada. Los argumentos de un procedimiento se
declaran igual que las variables, especificando el nombre y el tipo de datos del argumento.
También puede especificarse el mecanismo que se va a utilizar para pasar el argumento, como
se muestra a continuación:
Sintaxis:
[Optional] [ByVal|ByRef] [ParamArray] <nombreArgumento> As
tipo
49
Semántica:
Se declaran las características de cada elemento dentro de la lista de argumentos:
opcionales (Optional), por Valor (ByVal), por referencia (ByRef) o en caso de que se trate
de un arreglo de parámetros (ParamArray), estas opciones se verán posteriormente.
Ejemplo sobre la declaración de un procedimiento Sub:
Sub CalculaIVA(ByVal dPrecioProducto As Double)
Dim dPrecioIVA as Double =dPrecioProducto*1.15
MessageBox.Show("El precio del producto con IVA es" &
dPrecioIVA & " pesos:" )
End Sub
Procedimientos Function
Un procedimiento Function es una serie de instrucciones que realizan una determinada tarea
y devuelven un valor, por ejemplo, el mismo procedimiento CalculaIVA, pero en lugar de
mostrar un Cuadro de Mensaje devolvería el valor numérico con el cálculo obtenido.
Cuando se invoca se ejecuta desde la primera instrucción hasta la primera instrucción
End Function, Exit Function o Return que se encuentre.
Un procedimiento Function puede tomar argumentos, como constantes, variables o
expresiones, que le pasa el código de llamada.
Sintaxis:
[<acceso>] Function <NombreFuncion>[(<ListaDeArgumentos>)] As
tipo
'[<Instrucciones>]
Return <valor>
End Function
Semántica:
Declara un procedimiento Function con el acceso, nombre y lista de argumentos de la misma
forma que se hacía para los procedimientos Sub, a diferencia de que en los procedimientos
Function se debe especificar el tipo de dato que tendrá el valor que se regresará.
Valores devueltos
Los procedimientos Function pueden devolver un valor de dos formas:
1. Dentro de la función se declara una variable con el mismo nombre de la función,
y al encontrar la instrucción Exit Function o End Function se devuelve el
valor de dicha variable:
Ejemplo:
Function CalculaIVA(ByVal dPrecioProducto As Double) as Double
Dim CalculaIVA as Double =dPrecioProducto*1.15
End Function

2. La función utiliza la instrucción Return para especificar el valor devuelto, e

inmediatamente devuelve el control al programa de llamada.
Ejemplo:
Function CalculaIVA(ByVal dPrecioProducto As Double) as Double
Dim dPrecioIVA as Double =dPrecioProducto*1.15
Return dPrecioIVA
End Function
Procedimientos controladores de eventos

Un evento es una acción o un suceso, por ejemplo, un clic del ratón, una ventana al
mostrarse, etc. el cual devuelve un código de respuesta. Los eventos generalmente se
producen como consecuencia de una acción del usuario o del sistema operativo.
Un procedimiento de control de eventos, o controlador de eventos, es el código que se
escribe para dar respuesta a un evento concreto.
Los controladores de eventos son procedimientos Sub, que se invocan cuando un objeto
detecta que se ha producido un evento por medio del nombre correspondiente al evento.
En este caso no se declararán procedimientos controladores de eventos, ya que la
mayoría y todos los que se utilizarán los crea Visual Basic .NET automáticamente.
3.13.2 Paso de argumentos a procedimientos

Como se mencionó anteriormente, un procedimiento utiliza argumentos y estos valores
pueden ser pasados a un procedimiento Sub o Function de dos distintas formas:
• posición: en el orden en que aparecen en la definición del procedimiento. hay que
especificar el nombre declarado del argumento, seguido de un signo de dos puntos y
un signo igual (:=) y seguido del valor del argumento. Los argumentos que se pasan
por nombre pueden suministrarse en cualquier orden.
• nombre: especificando el nombre sin tener en cuenta la posición.
Por ejemplo, el siguiente procedimiento Sub toma tres argumentos para mostrar la
información de una persona en un cuadro de mensaje:
Sub InformacionPersona(ByVal Nombre As String, Optional ByVal
Edad As Short = 0, Optional ByVal FNac As Date = #1/1/2000#)
MsgBox("Nombre = " & Nombre & "; Edad = " & CStr(Edad) & _
"; Fecha de Nacimiento date = " & CStr(FNac)
End Sub
Por posición
Puede invocar el procedimiento pasándole cada argumento de acuerdo al orden en que
espera recibirlos según su declaración (Nombre,Edad,FNac).
InformacionPersona ("Juan", 22, #12/09/1983#)
51
Por nombre
Puede invocar el procedimiento pasándole cada argumento precedido por el
identificador (identificador:) hacia el cual desea que lo asigne; estos
identificadores deberán coincidir con los declarados por el procedimiento.
InformacionPersona (Edad:=22, FNac:=#12/09/1983#, Nombre:="Juan")
Combinación
Puede invocar el procedimiento pasándole los argumentos mediante una combinación de
paso por nombre y por posición; los argumentos por posición deben preceder al resto ya
que al suministrar un primer argumento por nombre, el resto deberá especificarse
también por nombre.
InformacionPersona ("Juan", 22, FNac:=#9/21/1981#)
Argumentos opcionales
Existen procedimientos en los que no deberá especificar obligatoriamente todos los
argumentos, debido quizás a que no se tiene un valor para un argumento en todos los casos,
por lo cual tendrá que ser declarado opcional (anteponiendo el modificador Optional) y
deberá asignarle un valor por defecto, el cual tomará en caso de que no sea suministrado en
la invocación al procedimiento.
Por ejemplo en el caso anterior, el argumento FNac fue declarado opcional con un
valor por default (#1/1/2000#) desde la definición del procedimiento
InformacionPersona, de esta manera se podrán hacer invocaciones al método
suministrándolo o no, como se muestra a continuación:
InformacionPersona ("Juan", 22)
Paso por valor, por referencia

Además de la forma en que se suministran los argumentos para que sean recibidos por el
procedimiento, se cuenta con la que recibe el contenido de las variables pasadas como
argumento, tal cual se describe a continuación:
• Por valor: si se antepone el modificador ByVal, se toma el valor de la variable (en
realidad crea una copia de la variable con el mismo valor), por lo que cualquier
cambio sobre la variable no afecta a la original.
• Por referencia: si se antepone el modificador ByRef se toma la variable original (la
referencia que apunta a la dirección en memoria), por lo que cualquier cambio se
hace en realidad sobre la misma variable.
Sobrecarga de métodos
Habrá ocasiones en las que no sólo deseará especificar como opcionales algunos
argumentos, sino que deseará crear otro procedimiento, que por estar estrechamente
relacionado, llevará el mismo nombre pero una lista de argumentos distinta, lo cual se
conoce como sobrecarga. Para sobrecargar un procedimiento, deberá realizar lo siguiente:
• Utilizar el mismo nombre del procedimiento que desea sobrecargar.

• Deberá poder distinguir la lista de argumentos de cada procedimiento haciendo una

o más de las siguientes variaciones:
o Especificar un número distinto de argumentos.
o Cambiar el orden de los argumentos.
o Cambiar el tipo de dato de los argumentos.
Al nombre del procedimiento junto con los tipos de datos en la lista de argumentos, se le
conoce como firma del método; y para sobrecargar un método deberá de tener una
firma distinta, por ejemplo, suponga que está escribiendo un procedimiento Sub para
buscar una película, y que puede buscarla por código o por nombre. Para ello, puede
definir dos procedimientos Sub diferentes, como se indica en este ejemplo:
Sub BuscaPorNombre(ByVal NombrePelicula As String, ByVal Precio
As Single)
Sub BuscaPorCodigo(ByVal CodigoPelicula As Integer, ByVal Precio
As Single)
O bien podría sobrecargar un nombre de procedimiento utilizando una firma distinta;
adicionalmente, puede colocar a todos los procedimientos sobrecargados, el modificador
Overloads, como se muestra a continuación.
Overloads Sub Buscar(ByVal NombrePelicula As String, ByVal Precio
As Single)
' Código para acceder al registro de la película por nombre.
End Sub
Overloads Sub Buscar(ByVal CodigoPelicula As Integer, ByVal
Precio As Single)
' Código para acceder al registro de la película por código.
End Sub
En el caso anterior, ambos procedimientos tienen distinta firma, la del primero es
Buscar(String,Single) y la del segundo Buscar(Integer,Single), por lo
que la sobrecarga cumple con las reglas necesarias.
Procedimientos recursivos
Un procedimiento recursivo es aquel que se llama a sí mismo. Por ejemplo, el siguiente
procedimiento utiliza la recursividad para calcular el factorial de su argumento original:
Function Factorial(ByVal N As Integer) As Integer
If N <= 1 Then ' Por definición factorial de N<=1 es uno
Return 1
Else 'Si N>1 entonces habrá que calcular factorial de N-1 y
multiplicar por N
Return N * Factorial(N - 1) 'Llamada recursiva a
factorial
End If
End Function
53
NOTA. Si un procedimiento Function se llama a sí mismo de manera recursiva, su nombre

debe ir seguido de un paréntesis, aunque no exista una lista de argumentos. De lo contrario,
se considerará que el nombre de la función representa al valor devuelto por ésta.
3.14 Colecciones
Al igual que una matriz es un grupo de variables relacionadas, una colección es un
grupo de objetos relacionados. De igual manera, presentan la ventaja de que se puede
iterar (recorrer en ciclo) sobre los miembros de la clase Collection con For
Each...Next y hacer referencia a los mismos mediante un índice.
Visual Basic .NET proporciona una clase Collection, con la que se pueden definir y
crear colecciones propias, como se muestra a continuación.
Public Class Form1
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles MyBase.Load
Dim miColeccion As Collection = New Collection
Dim a, b, c As String
a = "Mi"
b = "Primer"
c = "Coleccion"
'Agregando elementos
miColeccion.Add(a, "Mi")
miColeccion.Add(b, "Primer")
miColeccion.Add(c, "Coleccion")
'Eliminando elementos
miColeccion.Remove(1) ' Elimina el primer elemento de la
colección
miColeccion.Remove("Coleccion") 'Remueve el miembro con
la palabra "Colección"
For Each palabra As String In miColeccion
If palabra = "Primer" Then
MsgBox(palabra) ' Despliega el elemento con la
clave "Primer"
End If
Next
End Sub
End Class

CAPÍTULO
Manejo de excepciones
Es posible que durante la ejecución de una aplicación, ésta llegue a fallar o pueda
presentarse un comportamiento inesperado, como por ejemplo, que no estén disponibles
recursos del sistema operativo, o que la conexión hacia una base de datos externa falle,
a este tipo de errores se les conoce como excepciones. Al lanzarse una excepción, usted
como programador deberá encargarse de darle un buen manejo, es decir, la aplicación
no debería dejar de funcionar abruptamente y originar que todos los cambios realizados
por el usuario se pierdan o que simplemente se cierre la aplicación. Al menos, habrá que
informar al usuario el tipo de error que ha ocurrido y si es un error crítico, entonces sí
liberar los recursos utilizados y posteriormente cerrar la aplicación, o mejor aún, si no es
un error crítico, continuar con la ejecución de la aplicación.
Existen distintos tipos de errores:
• Sintácticos: son aquellos en donde se escribe código que no cumple con las reglas
del lenguaje de programación, y este tipo de errores son generalmente detectados
por el compilador en tiempos de compilación.
• Ejecución: errores que aparecen durante la ejecución, por ejemplo la división por cero.
• Lógicos: son errores que ocasionan el no obtener los resultados esperados en el
programa, por ejemplo, si usted desea aplicar el 15 % de IVA a dos productos con un
precio de $10.00 esto equivale a obtener (10+10)*1.15 = 23, un error lógico que
nos daría un resultado distinto debido a las reglas de precedencia de los operadores,
por tanto debería ponerse 10+10*1.15 = 21.5
4.1 La clase Exception

El control de este tipo de errores se puede hacer mediante excepciones, una excepción
como todo en Visual Basic .NET es un objeto que es instancia de la clase Exception o
de alguna clase heredada de Exception.
La clase Exception se encuentra disponible dentro del espacio de nombres System por lo
que la podremos utilizar sin necesidad de importarla. La clase Exception permite procesar
55
todo tipo de excepciones y cuenta con propiedades y métodos para identificar el punto en el
que se ha generado la excepción, el tipo y el motivo que la originó.
La clase Exception actúa como base, pero existen numerosas clases que derivan de
ésta, como se muestra a continuación:
• System.Exception
o System.ApplicationException
o System.IO.IsolatedStorage.IsolatedStorageException
o System.Runtime.Remoting.MetadataServices.SUDSGeneratorException
o System.Runtime.Remoting.MetadataServices.SUDSParserException
o System.SystemException
o System.Windows.Forms.AxHost.InvalidActiveXStateException
Declarar excepciones
Existen excepciones que son lanzadas por el CLR cuando sucede alguna acción errónea
o inesperada (excepcional), por ejemplo cuando intenta utilizar una variable de tipo
Referencia que no ha sido instanciada mediante el operador new y contiene el valor
Nothing será lanzada la excepcion System.NullReferenceException.
Además de estas excepciones, existen las propias, aquéllas creadas por el programador y
que serán lanzadas ante una situación excepcional dentro del contexto de la aplicación,
por ejemplo, cuando un procedimiento es invocado proporcionando un argumento fuera
del rango permitido.
Para declarar una excepción de aplicación, es recomendable generar una clase que
herede de ApplicationException y no de Exception, ya que esta última se utiliza
solamente para excepciones definidas y lanzadas por el CLR; al heredar de
ApplicationException, puede utilizar todos los procedimientos y atributos
declarados dentro de ella.
En el siguiente ejemplo se declara una excepción que será lanzada cuando invoque al
procedimiento Divide con un divisor igual a cero como argumento.
'Indica que será una Excepción derivada de la clase ApplicationException
Public Class DivisionPorCeroException
Inherits ApplicationException
Public Sub New( ) ‘Constructor vacío de DivisionPorCeroException
MyBase.New( ) ‘Basta con invocar al constructor vacío de la clase
padre
End Sub
‘Constructor que recibe un mensaje descriptivo sobre la excepción
Public Sub New(ByVal mensaje As String)
MyBase.New(mensaje) ‘Basta con invocar al mismo constructor de la
clase padre
End Sub
End Class

4.2 Generación de excepciones

Ya sabe declarar sus propias excepciones, a continuación revisaremos cómo crear una
instancia de ellas para lanzarlas en el momento de detectar un error.
En el siguiente ejemplo, el procedimiento de tipo Function “Divide” crea una
instancia de la clase DivisionPorCeroException y la lanza en caso de recibir un
divisor igual a cero como argumento.
Public Function Divide(ByVal iDivisor as Integer, ByVal iDividendo as Integer)
If (iDivisor = 0) Then
‘Se crea la excepción invocando al constructor que recibe el mensaje descriptivo
Dim NuevaExcepcion as DivisionPorCeroException = new
DivisionPorCeroException ("El argumento divisor es igual a cero")
'Se lanza la excepción mediante la instrucción throw
throw
Else
return iDivisor/iDividendo
End Function
4.3 Try… Catch

Cuando una excepción es lanzada, se detiene el flujo de ejecución y abandona el
método que lanzó la excepción, así comienza la búsqueda de un manejador para la
excepción lanzada dentro de los procedimientos ubicados en la pila de llamadas, es
decir, primero busca dentro del último procedimiento que invocó a aquél que generó la
excepción, si no encuentra un manejador busca a su vez dentro del procedimiento que
invocó a este último y así sucesivamente, hasta encontrar el manejador de la excepción o
bien termina la ejecución de toda la aplicación en caso de no existir.
Para evitar que termine la ejecución al lanzar una excepción, deberá hacer lo siguiente:
1. Si dentro de un procedimiento usted invoca uno o más procedimientos que
puedan lanzar una excepción, coloque las instrucciones de llamada al
procedimiento dentro de un bloque Try.
2. Al final del bloque Try coloque un bloque Catch para manejar la(s) posible(s)
excepción(es) lanzadas por los procedimientos invocados.
3. Al final del bloque Catch, opcionalmente puede agregar un bloque Finally
que se ejecutará siempre (se lance o no una excepción), esto le permitirá cerrar
archivos y conexiones o liberar recursos que esté utilizando.
Try
Divide(x,y)
‘Manejador para la excepción DivisionPorCeroException
Catch excepcionLanzada as DivisionPorCeroException
MsgBox(“No puedo dividir por cero”)
y = InputBox(“Teclea otro numero”)
57
Divide(x,y)
Exit Catch
Finally
‘Aquí irían las instrucciones que se ejecutarán siempre,
ocurra o no una excepcion
MsgBox(“Gracias por utilizar el método divide”)
End Try
Control no estructurado de excepciones

Al manejo de excepciones mediante los bloques Try...Catch se le conoce como
manejo estructurado y es el más recomendable, pero contrario a éste existe el manejo no
estructurado que utiliza la instrucción On error.
Cuando un programa lanza una excepción, el control del programa pasa al argumento
especificado en la instrucción On Error, para el cual existen las siguientes opciones:
• On Error GoTo <línea>
• On Error ResumeNext
• On Error GoTo 0
• On Error GoTo -1
On Error Go To <Línea>, permite especificar el código para resolver la excepción. El
parámetro <línea> indica el inicio de dicho código. Cuando se detecta un error en el
código, posterior a la instrucción On Error GoTo <línea>, el control se pasa hasta el
número de línea especificado por <línea>.
Ejemplo:
Sub MiProcedimiento
On Error GoTo ManejadorDeExcepcion
<Instrucciones a ejecutar>
Exit Sub
ManejadorDeExcepcion:
'Código de resolución de errores
Resume
End Sub
En este caso, el nombre del manejador de errores es ManejadorDeExcepcion, si se

encontrara un error en el código del procedimiento MiProcedimiento, se ejecutarían
las instrucciones que siguen a la etiqueta ManejadorDeExcepcion:
• On Error Go To ResumeNext: esta instrucción intenta pasar por alto el error y continuar
la ejecución del mismo en la línea siguiente al lugar en donde se originó el error.
• On Error Go To 0: esta instrucción deshabilita todos los manejadores de excepciones
del procedimiento actual.

• On Error Go To -1: esta instrucción es igual a la anterior salvo que su uso no es

obligatorio, ya que al terminar la ejecución del procedimiento, se desactivan
automáticamente todos los manejadores de errores del procedimiento.
4.4 Errores lógicos y depuración

Aun cuando ya no existan errores sintácticos en el código (lo cual significa que todo el
código cumple las reglas del lenguaje), que impidan la compilación al momento de
generar el proyecto, pueden existir errores semánticos o lógicos, éstos se producen
cuando la sintaxis del código es correcta, pero los resultados no son los esperados por
que existe algo mal en la lógica del programa, por ejemplo, un ciclo infinito no sería
detectado por el compilador. Sin embargo, usted podría detectar que su programa no
llega a ejecutar cierta instrucción y esto precisamente porque se encuentra ejecutando
infinitamente las instrucciones dentro del ciclo. A continuación, se presenta una tabla
ejemplificando distintos tipos de errores:
Código Descripción Tipo de error
Sub Main()
Dim X As Integer Se declara la variable X y se intenta Sintáctico
imprimir Y. "No se ha declarado la (detectado en la
Console.WriteLine(Y)
variable Y". compilación).
End Sub
Sub Main()
Dim cadena, inversa As String El código anterior intenta obtener
cadena = "hola" la inversa de una cadena pero
inversa = "" marca el error:
'System.IndexOutOfRangeException'
For i As Integer =
cadena.Length To 0 Step -1 ya que se inicializó la variable Semántico
i=cadena.Length, esto es igual a 4, (detectado en la
inversa = inversa +
por lo que en la primera iteración ejecución).
cadena.Chars(i)
del bucle For intenta obtener el
Next i
caracter en el indice 4, el cual no
Console.WriteLine(inversa)
existe ya que los índices de esta
Console.Read() cadena van de 0 a 3.
End Sub
Sub Main()
Dim cadena, inversa As String En este caso, se hace la asignación
cadena = "hola" correcta para que ya no mande el
Semántico
inversa = "" error como en el caso anterior,
(detectado por el
For i As Integer = pero se modificó el decremento de
usuario o el
cadena.Length -1 To 0 Step 1 -1 al contador y ahora se
programador al
inversa = inversa + incrementa 1. Esto ocasiona que se
no obtener los
cadena.Chars(i) caiga en un bucle infinito ya que el
resultados
Next i contador nunca llegará a ser 0, por
esperados).
Console.WriteLine(inversa) lo que no obtiene la cadena
Console.Read() inversa.
End Sub
El entorno de desarrollo le permite depurar su código para detectar estos errores, ya que
durante la ejecución de la aplicación puede detener el programa en algún punto dentro
59
del código e ir ejecutando instrucción por instrucción y en cada momento inspeccionar

los valores de las variables, revisar la memoria, cambiar los valores a las variables para
ver qué consecuencias tiene esto, observar el tráfico de mensajes y así podrá obtener una
visión más detallada y encontrar el origen de los errores.
4.4.1 Ejecución del código paso a paso

En vez de ejecutar todo el programa hasta su finalización, puede elegir ejecutarlo paso a
paso por instrucciones o por procedimientos, lo que permite observar el comportamiento
del programa en cada momento de la ejecución. Para iniciar la depuración de su
aplicación en modo paso a paso por instrucciones seleccione de la barra de menús
Depurar | Paso a Paso por instrucciones o presione la tecla F11, se mostrará la siguiente
pantalla:
Siguiente instrucción
a ejecutar
Ventanas de depuración
(activada variables locales)
Figura 20. Ejecución del código paso a paso por instrucciones.
La flecha amarilla indica la próxima instrucción a ejecutarse usted puede cambiar el

orden arrastrando la flecha hasta la instrucción deseada (aunque esto puede traer
consecuencias inesperadas). También existen diversas ventanas de depuración que puede
mostrar seleccionándolas de la barra de menús Depurar | Ventanas, entre las que se
recomiendan:
• Variables Locales: muestra el nombre, el valor y el tipo de dato de cada variable
local en cada momento de la ejecución, además, permite cambiar el valor de cada
variable dando clic en el campo valor y modificándolo de forma manual.
• Automático: muestra el valor que tienen las variables utilizadas en la línea actual y en
la línea siguiente.

Estas ventanas son muy útiles, por ejemplo, en caso de obtener un error en el que intente
acceder a un índice fuera de los límites de un arreglo desde estas ventanas, puede
verificar cuál es el valor que está produciendo el error, modificarlo de manera manual y
posteriormente corregir el código para evitarlo.
Para seguir ejecutando las siguientes instrucciones, continúe presionando F11.
Para salir del modo de depuración, seleccione de la barra de menús Depurar | Detener
Depuración o presione las teclas Mayus + F5.
4.4.2 Puntos de Interrupción

En la mayoría de las ocasiones no deseará detener la ejecución tras cada instrucción,
sino únicamente en aquellas instrucciones que ha detectado como posibles causantes del
error, para esto usted puede colocar puntos de interrupción que indicarán al depurador
las instrucciones en las que debe detenerse.
Para depurar su aplicación utilizando puntos de interrupción, realice lo siguiente:
1. Desde el editor de código, dé clic en la zona gris que aparece del lado izquierdo
a la altura de la línea en la que desea detener la ejecución, la cual quedará
sombreada, como se muestra en la siguiente pantalla:
Dé clic para colocar el punto de

interrupción en esta línea
Figura 20. Punto de interrupción.
2. Después de haber colocado los puntos de interrupción deseados, inicie la

ejecución del proyecto presionando la tecla F5, con esto se ejecutarán todas las
instrucciones hasta encontrar el primer punto de interrupción para detenerse ahí,
indicado con una flecha amarilla; en ese momento, usted podrá hacer uso de las
ventanas de depuración para verificar y modificar si así lo desea, los valores que
en ese momento tengan cada una de las variables.
4.4.3 Puntos de interrupción condicionales

Además de querer detener la ejecución del proyecto sólo en ciertas instrucciones, puede
necesitar que sólo se detenga en esos puntos si se cumplen determinadas condiciones,
61
por ejemplo, que una variable tenga un cierto valor, para lo cual existen los puntos de
interrupción condicionales.
Para colocar un punto de interrupción condicional, lleve a cabo los siguientes pasos:
1. Coloque el punto de interrupción sobre la línea de código que desee, de la
misma forma en que se describió anteriormente.
2. Dé clic con el botón derecho, sobre el punto de interrupción que desea
condicionar y seleccione la opción Propiedades del punto de interrupción, como
Figura 20. Propiedades del punto de interrupción.
3. Se abrirá una ventana en la que puede ver y definir propiedades del punto de
interrupción; para colocarle una condición, dé clic en el botón Condición, como
Figura 20. Botón para poner una condición al punto de interrupción.
4. Posteriormente, se abrirá una ventana de diálogo en la que puede colocar la

condición que tiene que cumplirse para detener la ejecución, por ejemplo, que cierto

contador i sea igual a cuatro, como se muestra a continuación; al terminar dé clic en

el botón Aceptar de las dos ventanas de diálogo que se encuentran abiertas.
Figura 20. Condición para un punto de interrupción.
Inicie la depuración del proyecto presionando la tecla F5, con lo cual se ejecutarán todas
las instrucciones hasta detenerse en el primer punto de interrupción que encuentre y sólo
si se cumple la condición establecida, en ese momento usted podrá hacer uso de las
ventanas de depuración para verificar y modificar si así lo desea, los valores que en ese
momento tengan cada una de las variables.
Finalmente, para obtener mayor información sobre todos los puntos de interrupción
marcados dentro del código, seleccione la ventana Puntos de interrupción (BreakPoints)
desde el menú Debug | Windows | Breakpoints (Depuración | Ventanas | Puntos de
interrupción), con lo que se mostrará una ventana como la siguiente:
Figura 21. Ventana de puntos de interrupción.
Esta ventana muestra el nombre, la condición y un recuento de las visitas de cada punto
de interrupción y también le permite: crear, deshabilitar, eliminar y consultar
propiedades, entre otras.
Es muy importante hacer un buen manejo del depurador debido a que en varias
ocasiones le salvará de invertir demasiado tiempo en busca de errores lógicos, los cuales
serían difíciles de encontrar.
63
CAPÍTULO
Uso de la programación orientada a objetos
Visual Basic .NET es un lenguaje de programación completamente orientado a objetos,
por lo que soporta las cuatro principales características de ese paradigma: abstracción,
encapsulamiento, herencia y polimorfismo. Esto implica que como desarrollador deberá
realizar el diseño de su aplicación en términos de actores (objetos), sus características
(propiedades) y los servicios (métodos) que deben tener para cooperar a la solución. A lo
largo de este tema, aprenderá a codificar estos elementos dentro del lenguaje de
programación.
5.1 Creación de una clase

Una clase es una plantilla en donde se definen las propiedades y los métodos que
tendrán todos los objetos que sean creados como instancias de la misma; la sintaxis para
su declaración es la siguiente:
Sintaxis:
<Declaración de clase>::=
[<acceso>] class <identificador>
<Declaraciones de propiedades>
<Declaraciones de métodos>
End Class
Semántica:
Se declara una clase con el acceso y el identificador indicado, el cual será utilizado al
momento de crear un nuevo objeto instancia de esta clase.
Las propiedades se utilizan para almacenar el valor de cada uno de los atributos del
objeto y que definen su estado, por ejemplo, las propiedades de la clase Persona podrían
ser: Nombre, Estatura, Peso, Tipo de sangre, etc.

Los métodos corresponden a las acciones que puede realizar un objeto y que definen su
comportamiento, por ejemplo, para la clase Persona algunos métodos podrían ser:
pensar, hablar, caminar, etc.
Usted puede elegir las propiedades y métodos por definir dependiendo de las
características y acciones que le interesa tengan los objetos, para así cooperar con la
solución del problema en cuestión. Más adelante conocerá la forma de declarar
propiedades y métodos de un objeto.
Una clase le permite encapsular la información declarada dentro de ella, por lo que
usted puede definir quiénes tendrán acceso, utilizando la siguiente sintaxis.
Sintaxis:
acceso::= Public | Protected
Semántica:
Se declara quiénes tienen acceso a la clase, según los siguientes modificadores:
• public: desde cualquier otro lugar dentro del mismo proyecto (clase, módulo) o desde
cualquier otro proyecto que le haga referencia.
• Protected: desde una clase derivada o hija (que herede de ésta) y que pertenezca al
mismo proyecto.
Existen más modificadores de acceso (Private, Friend, etc.) pero éstos no son aplicables a
las clases, sólo a propiedades o métodos, temas que veremos posteriormente. Por
ejemplo, declarar acceso private a una clase, implicaría que sólo es accesible dentro de
sí misma, lo cual no tiene sentido.
5.2 Agregar un módulo de clase

Para agregar una clase a un proyecto dentro de Visual Studio .NET, seleccione de la
barra de menús la opción Proyecto | Agregar Clase (Project | Add Class), con lo cual se
mostrará un cuadro de diálogo como el siguiente:
65
Coloque el nombre de la clase (por ejemplo, Persona) y dé clic en el botón Abrir.

Posteriormente se creará una nueva clase conteniendo el siguiente código:
Public Class Persona
End Class
5.3 Definir propiedades de la clase

El primer paso después de agregar una clase al proyecto, es definir las propiedades que
se codifican dentro del lenguaje como variables miembro (field members o campos), las
cuales son globales dentro del ámbito de la clase, ya que se declaran dentro de la clase
(preferentemente al inicio) pero fuera de cualquier procedimiento, por ejemplo para
declarar los campos de la clase Persona.
Private sNombreCompleto As String
Private dateFechaNacimiento As Date
End Class
De esta forma, todos los objetos que usted cree, tendrán los atributos sNombreCompleto
e iEdad, y cada objeto podrá asignarle un valor distinto a cada una de sus propiedades.
5.4 Propiedades compartidas

Existen propiedades denominadas “compartidas“ o “variables de clase”9 que tendrán el
mismo valor para todos los objetos por lo que es inconveniente que se cree una variable
por cada nueva instancia; de esta manera, una sola variable que pertenece a la clase,
será compartida por todos los objetos de la misma clase
Un ejemplo de una propiedad compartida sería el limiteHoras (24 horas) en la clase
Reloj, ya que para todos los relojes tendrá el mismo valor, otro ejemplo lo constituye la
propiedad MaxValue de la clase System.Date que devuelve el mayor valor posible para
este tipo de dato, es decir, aun cuando existan varios objetos instancias de la clase Date,
tendrán el mismo valor para la propiedad compartida MaxValue al no ser un valor que
dependa del objeto particular sino de la clase.
Por ejemplo, para la clase Persona, un ejemplo de propiedad compartida es la especie
de la que provenimos los seres humanos “Homo Sapiens”, que sería codificada de la
siguiente manera:
Private Shared sEspecie As String=“Homo Sapiens”
End Class
9
Algunas ocasiones también son llamadas estáticas, debido a que en el lenguaje de
programación Java se les coloca el modificador static a este tipo de variables.

Un uso muy común de las propiedades Shared es como contador de instancias de una
clase, como se muestra a continuación:
Public Class Elemento
'Declaramos la propiedad compartida (Shared)
Public Shared iContador As Integer = 0
Public Sub New()
iContador += 1 'Cada que se crea un objeto se
incrementa el contador
End Sub
End class
Dim objeto1 As New Elemento() ‘Cuando creamos la primera
instancia el contador se incrementa a 1
Dim objeto2 As New Elemento() ‘Cuando creamos la segunda
instancia el contador se incrementa a 2
5.7 Visibilidad de las propiedades

Una característica de la programación orientada a objetos es el encapsulamiento que
consiste en que cada objeto oculte los detalles de su implementación y sólo permite la
modificación de su estado (conjunto de propiedades) a través de los métodos
correspondientes (procedimientos Property en el caso de Visual Basic .NET). Por lo
anterior, es recomendable que el acceso a las propiedades sea privado (private), para
que sólo puedan ser modificadas dentro de la clase y se proporcione una interfaz pública
que permita su modificación a través de la declaración de procedimientos Property, los
cuales tendrán acceso público (Public). Un procedimiento Property sirve para declarar las
siguientes secciones:
• Get: para devolver el valor de la propiedad.
• Set: para asignar un valor (pasado como argumento) a la propiedad, esto permite
controlar qué valores se pueden asignar a la propiedad (llamado dominio).
A continuación, se presenta la sintaxis para declarar un procedimiento Property:
Sintaxis:
Property <identificador> [(lista de argumentos)] As tipo
Get
Return valor
End Get
Set [(ByVal nuevo As tipo)]
valor = nuevo
End Set
End Property
67
Por ejemplo, para la clase Persona declararíamos un procedimiento Property por cada
una de sus propiedades, como se muestra a continuación:
‘Declaración del procedimiento Property para manipular la
propiedad sNombreCompleto
Public Property NombreCompleto () as String
Get ‘bloque para devolver el valor de la propiedad
Return sNombreCompleto
End Get
‘bloque para asignar el valor de Value a la propiedad
Set(ByVal Value As String)
If Value <> "" Then ‘No asignaremos cadenas vacías
“”
sNombreCompleto = Value
End If
End Set
End Property
...’Se continua declarando los demás procedimientos Property
End Class
Una característica de los procedimientos Property es ofrecer un mayor control sobre su
acceso y modificación como se comentó anteriormente, incluso permite declarar que una
propiedad sea de sólo lectura e impide su modificación, para lo cual únicamente deberá
indicarlo y declarar la sección get, como se muestra a continuación para la clase persona
donde una vez creado el objeto, no se podrá modificar la propiedad sNombreCompleto.
Public ReadOnly Property NombreCompleto () as String
End Get
End Property
Otro ejemplo de la aplicación de la propiedad de sólo lectura la representa MaxValue en
System.Date, que implica el valor más grande para el tipo de dato Date; esta propiedad
además de ser compartida, únicamente puede ser consultada, en tanto es algo que usted
como programador no puede modificar.
También puede declarar propiedades de sólo escritura, en las que únicamente podrá
modificar la propiedad sin poder consultarla por ningún método; un ejemplo para la
clase Persona y la propiedad sNombreCompleto, se muestra a continuación:

Public WriteOnly Property NombreCompleto () as String

“”
End If
End Set
End Property
Si usted desea que las propiedades impliquen tener acceso y puedan ser modificadas
desde cualquier otra clase, puede declararlas con acceso publico (public); si sólo quiere
que aquellas que sean heredadas de esta clase puedan hacerlo, declárelas con acceso
protegido (protected).
5.8 Definición de métodos

Ya sabe cómo declarar propiedades e incluso un tipo de método (property) para
manipularlas, ahora aprenderá a declarar más métodos que tienen como función
principal codificar las acciones que puede llevar a cabo un objeto; un método puede
recibir o no parámetros de entrada para procesarlos y regresar un valor de salida
(Función) o sólo realizar un proceso (procedimiento).
Para la clase Persona, además de definir métodos Property para manipular las
propiedades (métodos considerados de acceso y actualización ya que permiten acceder y
actualizar el valor de las propiedades del objeto), deberá definir métodos de
implementación para que el objeto realice las acciones necesarias.
End Get
“”
End If
End Set
69
End Property
...’Se continua declarando los demás procedimientos Property
‘Declaramos el método de implementación hablar
Public Sub Hablar(ByVal mensaje as String)
MsgBox(“mensaje”)
End Sub
End Class
5.9 Métodos compartidos

De la misma forma que existen propiedades compartidas, hay métodos compartidos por
todas las instancias de una misma clase (métodos estáticos o de clase), y su característica
principal es que sólo podrán acceder a propiedades compartidas de la clase y al igual
que las propiedades, aunque se puede acceder a través de un objeto, se recomienda
utilizar mejor el nombre de la clase, en tanto no es necesario que exista instancia alguna
para invocarlo.
Un ejemplo de método compartido es Now en la clase System.Date que devuelve la
fecha y hora actual del equipo, es decir, aun cuando existan varios objetos instancias de
la clase Date devolverá el mismo valor al invocar a Now, al no ser un método que
dependa de la instancia sino de la clase. Para la declaración de métodos compartidos, es
necesario utilizar el modificador Shared como se muestra a continuación:
Para la clase Persona, podría crear un método compartido que acceda en este caso al
miembro compartido sEspecie, el cual será de sólo lectura como se muestra a
continuación:
End Get
“”
End If
End Set

End Property
...’Se continúa declarando los demás procedimientos Property
‘Declaramos el método de implementación hablar
Public Sub Hablar(ByVal mensaje as String)
MsgBox(“mensaje”)
End Sub
End Class
‘Declaración de métodos compartidos, en este caso se crea la
property compartida para acceder a la propiedad compartida
sEspecie
Public Shared ReadOnly Property Especie() As String
Get 'bloque para devolver el valor de la propiedad
‘Solo puede acceder a propiedades compartidas
Return sEspecie
End Get
End Property
End class
Para el caso de la clase Elemento puede crear un método compartido de acceso a la
propiedad iContador que cuenta el número de instancias como se muestra a
continuación:
Public Class Elemento
'Declara una propiedad compartida
Public Shared iContador As Integer = 0
Public Sub New()
iContador += 1
End Sub
'Declara un método compartido que solo podrá acceder a
propiedades compartidas
Public Shared Sub MetodoCompartido()
MsgBox("El valor del contador es : " & contador)
End Sub
End class
5.10 Definición del constructor

Además de los métodos de actualización, acceso e implementación, existen métodos
constructores que tienen como función fabricar una nueva instancia (objeto) e inicializar
cada una de sus propiedades. Si usted no define algún método constructor Visual Basic
.NET crea un constructor vacío automáticamente que inicializa cada propiedad que no
ha sido inicializada al momento de su declaración, con los valores por defecto de
71
acuerdo a su tipo de dato, de la siguiente forma: numéricos con cero, lógicos (tipo
boolean) con false, fecha con 01/01/2001 12:00 a.m, referencias con Nothing, etc, por
ejemplo para la clase persona tal como se muestra a continuación:
End Class
Al no definir ningún constructor, usted puede invocar al constructor vacío de la siguiente
forma:
Dim nuevaPersona as Persona = new Persona()
La instrucción anterior inicializaría las propiedades de nuevaPersona con los valores por
defecto (sNombreCompleto con cadena vacía “”, dateFechaNacimiento con
#01/01/2001 12:00 a.m#, y sEspecie con “Homo Sapiens”, ya que fue inicializada
desde su declaración.
Lo recomendable es que usted defina sus propios métodos constructores e inicialice las
propiedades del objeto con los valores que le pasan como argumento para su
asignación; en cuanto a aquéllos, de los cuales no le pasan un valor, usted no las
inicialice para que tomen el valor por default o bien usted elija un valor para su
asignación, un ejemplo para la clase Persona se muestra a continuación:
‘Constructor que inicializa ambas propiedades con los
argumentos
Public Sub New(ByVal Nombre as String, ByVal FNac AS Date)
sNombreCompleto=Nombre
dateFechaNacimiento = FNac
End Sub
‘Constructor que solo recibe el nombre y asigna un valor por
defecto a la fecha de nacimiento
Public Sub New(ByVal Nombre as String)
dateFechaNacimiento = #10/21/1983#
End Sub
‘Constructor vacío asigna valores por defecto (definidos por
el programador) a ambas propiedades
Public Sub New()
sNombreCompleto=””

End Sub
End Class
En el caso anterior, se realizó la sobrecarga de métodos constructores, usted podrá
invocar cualquiera de los tres que han sido definidos; es importante mencionar que una
vez que usted defina un constructor, se pierde el constructor vacío que creaba
automáticamente Visual Basic .NET, por eso en el caso anterior, tuvo que declararse
junto con los otros.
5.11 Definición del destructor

De la misma forma que puede definir métodos para construir unas instancias, puede
definir uno para destruirlas, mediante el procedimiento Finalize que no puede ser
sobrecargado, es decir, solamente existe un destructor Finalize en cada clase.
El método Finalize está definido en la clase Object, pero usted deberá sobrescribirlo e
implementarlo para adaptarlo a las necesidades de la clase que lo defina; este método sólo
podrá invocarse desde la clase a la que pertenece o desde clases derivadas (Protected).
Para el ejemplo de la clase Persona y suponiendo ahora que se tiene una propiedad
compartida que cuenta el número de instancias que es incrementada cada vez que se
invoca algún constructor, dentro del método destructor deberá decrementarse, como se
muestra a continuación:
Private Shared numInstancias As Integer=0
‘SE DECLARAN LOS CONSTRUCTORES
‘Constructor que inicializa ambas propiedades con los
argumentos
Public Sub New(ByVal Nombre as String, ByVal FNac AS Date)
dateFechaNacimiento = FNac
End Sub
‘Constructor que solo recibe el nombre y asigna un valor por
defecto a la fecha de nacimiento
Public Sub New(ByVal Nombre as String)
End Sub
‘Constructor vacío asigna valores por default (definidos por
el programador) a ambas propiedades
73
Public Sub New()

sNombreCompleto=””
End Sub
‘SE DECLARAN LOS METODOS PROPERTY (DE ACCESO Y
ACTUALIZACIÓN)
Public Property NombreCompleto() As String
End Get
Set(ByVal Value As String) 'bloque para asignar un valor
If Value <> "" Then 'No asignaremos cadenas vacías “”
End If
End Set
End Property
Public Property FechaNac () As Date
Return dateFechaNacimiento
End Get
Set(ByVal Value As Date) 'bloque para asignar un valor
If Value < Date.Now Then 'Solo fechas menores de la
fecha actual
dateFechaNacimiento = Value
End If
End Set
End Property
‘Método compartido para acceder a la propiedad compartida
sEspecie
Public Shared ReadOnly Property Especie() As String
‘Solo puede acceder a propiedades compartidas.
return sEspecie
End Get
End Property
'METODOS DE IMPLEMENTACION
Public Sub Hablar(ByVal mensaje As String)
MsgBox("mensaje")
End Sub

‘METODO DESTRUCTOR
Protected Overrides Sub Finalize()
‘Aquí irían instrucciones para liberar recursos cerrar
archivos, bases de datos, conexiones, etc., en este caso se
decrementa la propiedad que cuenta las instancias.
numInstancias= numInstancias - 1
End Sub
End Class
El método Finalize no puede invocarse por el programador, sólo el recolector de basura
(GC: Garbage Collector) ejecutará el método una vez que el objeto pase a ser
inaccesible (no existan más variables haciendo referencia al mismo).
Si usted desea poder invocar a un método para la liberación controlada de recursos,
implemente el método Dispose() de la interface IDisposable, que a diferencia de Finalize
puede invocarse de manera manual.
5.12 Objetos basados en clases (referencias)

Ahora que sabe cómo crear sus clases junto con sus propiedades y métodos necesarios,
aprenderá a utilizarlos creando objetos instancias de esa clase, para lo cual es necesario
declarar una variable de tipo referencia, cuyo tipo de dato sea igual al de la clase,
utilizando la siguiente sintaxis:
'declara una variable tipo referencia.
Dim <identificador> As <NombreDeClase>
Semántica:
Se declara una variable (objeto) con el identificador indicado e instancia de la clase
correspondiente.
Hasta este momento, sólo hemos declarado la variable y ésta contiene el valor Nothing
que apunta a una dirección de memoria inválida; para inicializar esta variable será
necesario utilizar el operador New e invocar alguno de los constructores de la clase,
como se muestra en el siguiente ejemplo:
Dim P1 as Persona = new Persona(“Tomás”,#10/21/1983#)
Dim P2 as Persona = new Persona(“Carlos”)
Dim P3 as Persona = new Persona()
Con las instrucciones anteriores tenemos tres objetos con identificadores P1, P2, P3 cada
uno creado invocando a un constructor distinto.
Operador (.)
Hasta ahora sólo ha creado los objetos, por tanto, para poder acceder a sus
propiedades o invocar alguno de sus métodos, tendrá que utilizar el operador ( . ) punto,
como se muestra a continuación:
‘Creamos el objeto
75
Dim P2 as Persona = new Persona(“Carlos”)

‘Asignamos un valor a la propiedad dateFechaNacimiento
(actualmente tiene el valor por defecto #10/21/1983#) mediante el
método property FechaNac invocándolo mediante el uso del operador
(.)
P2.FechaNac=#10/10/1970#
‘No lo asigna ya que la propiedad no admite valores mayores a la
fecha actual:
P2.FechaNac=#10/10/2050#
‘Marcaría error ya que dateFechaNacimiento tiene acceso privado
(private)
P2.dateFechaNacimiento=#10/10/1970#
‘Accedemos al valor de FechaNac y lo mostramos
MsgBox(P2.FechaNac)
‘Invocamos al método hablar pasando como argumento la cadena a
mostrar.<
P2.hablar(“Me llamo ” & P2.NombreCompleto & “ y nací el ” &
P2.FechaNac)
‘Para invocar un método compartido tendrá que hacerlo mediante la
clase y no mediante el objeto.
msgBox(Persona.Especie)
5.13 Vinculación temprana y tardía

La vinculación temprana (early binding) es la asignación de un tipo de dato específico (no
genérico) en la declaración de una variable, lo cual permite a Visual Basic .NET obtener y
mostrar información sobre los miembros del tipo al cual está asociado mediante
Intellisense, y vincular los métodos del objeto a verdaderas direcciones de función en
tiempo de compilación, por ejemplo, en la siguiente declaración se indica que la variable
obj será instancia de la clase Persona.
Dim obj As Persona
La vinculación tardía (late binding) es la asignación de un tipo genérico (Object en
VB.NET, Variant en versiones anteriores) en la declaración de una variable, por lo cual es
posible haga referencia a cualquier objeto, pero Visual Basic no puede tener información
sobre sus miembros e Intellisense no puede mostrarlos, sí como tampoco vincular
ninguna de las propiedades y métodos de la clase en tiempo de compilación; por tanto
es necesario, esperar hasta la ejecución, véase el siguiente ejemplo:
Dim obj As Object
En este caso la variable obj puede hacer referencia a un objeto de cualquier tipo, pero
esto no es recomendable debido a que disminuye el rendimiento.

CAPÍTULO
Herencia
La herencia es una propiedad esencial de la Programación Orientada a Objetos que
consiste en la creación de nuevas clases (subclases) a partir de otras ya existentes, con la
característica de que las subclases tendrán los métodos y propiedades especificados en la
clase base. La herencia permite la reutilización del código ya que si cuenta con una clase
depurada y probada y desea agregar funcionalidad, no necesita modificar su código
fuente, basta con derivar una subclase a partir de ésta y añadir los comportamientos
necesarios disminuyendo así el tiempo y trabajo por parte del desarrollador, e igual
simplificando el mantenimiento de los programas.
6.1 Clase base y subclases

Visual Basic.NET soporta la herencia, por lo que como programador puede definir una
clase base y extender su funcionalidad mediante subclases que deriven de ésta. Las
subclases heredarán todas las propiedades, métodos y eventos declarados en la clase
base, excepto aquellas con acceso privado (private).
Visual Basic .NET soporta sólo la herencia simple, lo que significa que una clase puede
heredar sólo de una clase base, a diferencia de otros lenguajes como C++ en donde se
permite que una clase pueda heredar de múltiples clases; para lograr estos fines en Visual
Basic .NET, puede implementar múltiples interfases, como aprenderá posteriormente.
La clase base contendrá las propiedades y métodos generales a todas las subclases y
conforme desciende por la jerarquía, derivará subclases más refinadas conteniendo
nuevos métodos y propiedades que aplicarán tanto a esa clase como a todas las
subclases de niveles inferiores. A continuación, se muestra un ejemplo para la jerarquía
de clases de transporte.
77
Figura 20. Diagrama de herencia para los medios de trasporte.
Por ejemplo, para la clase Persona podría derivar la subclase Empleado, sólo recuerde
cambiar el acceso Privado (Private) por Protegido (Protected) en aquellas propiedades y
métodos que desea que sean heredadas; observe el diagrama que se muestra a
continuación.
Figura 21. Diagrama de clases mostrando la generalización de Empleado hacia Persona.
La instrucción Inherits
Para indicar que una clase será subclase de otra, en Visual Basic .NET se utiliza la
palabra reservada Inherits, la cual debe colocarse una línea debajo de donde se declara
la clase, como se muestra a continuación:
Sintaxis:
Class <nombre_de_clase_hijo>
Inherits <Nombre_de_clase_padre>

Semántica:
Declara que la clase es subclase de otra.
‘Marcaría error
Class <nombre_de_clase_hijo> Inherits <Nombre_de_clase_padre>
Por ejemplo, para el caso de la subclase Empleado que derivará de la clase Persona,
primero deberá asegurarse de cambiar el acceso privado por el de protegido a las
propiedades y métodos de la clase Persona, para después realizar lo siguiente:
Public class Empleado:
inherits Persona10
Protected dSalario As Decimal
Protected iClave As Integer
Protected dateFechaIngreso As Date
'Declaración del constructor que recibe todos los
parámetros necesarios para crear una nueva instancia:
Public Sub New(ByVal Nombre As String, ByVal FNac As
Date, ByVal Salario As Decimal, ByVal Clave As Integer, ByVal
FechaIngreso As Date)
'Asigna las propiedades de Nombre y Fecha de Nacimiento
invocando al constructor de Persona (Clase Base) mediante la
palabra MyBase:
MyBase.New(Nombre, FNac)
'Posteriormente asigna las propiedades faltantes:
dSalario = Salario
iClave = Clave
dateFechaIngreso = FechaIngreso
End Sub
Public Property Salario() As Decimal
Return dSalario
End Get
Set(ByVal Value As Decimal) 'bloque para asignar un valor
dSalario = Value
End Set
End Property
Public Property Clave() As Integer
Get 'bloque para devolver el valor de la propiedad:
10
Asegurarse de cambiar el acceso privado por protegido a las propiedades y métodos de la
clase Persona para que sean heredados por la clase Empleado.
79
Return iClave
End Get
Set(ByVal Value As Integer) 'bloque para asignar un
valor:
iClave = Value
End Set
End Property
Public Property FechaIng() As Date
Get 'bloque para devolver el valor de la propiedad:
Return dateFechaIngreso
End Get
Set(ByVal Value As Date) 'bloque para asignar un valor:
dSalario = dateFechaIngreso
End Set
End Property
End Class
Con lo anterior indica que la clase Empleado aparte de las propiedades y métodos que
declaró, tendrá acceso a las propiedades y métodos (no privados) de la clase base
Persona, por lo que usted puede hacer lo siguiente:
Dim E1 as Empleado=new Empleado()
E1.NombreCompleto=”Tomás Serrano Escamilla”
Observe como aun cuando en la clase Empleado no definió el método Property
NombreCompleto, sí lo posee y puede utilizarlo por el hecho de ser una subclase de Persona.
Usted puede crear subclases de cualquier clase siempre y cuando ésta no haya sido
marcada con la palabra clave NotInheritable (en Java se utiliza la palabra clave Final), lo
que indica que será una clase de la cual no podrá crear subclases; en otras palabras,
una clase Final en la jerarquía de herencia de la que nada se puede derivar. Por
ejemplo, en el diagrama de medios de transporte si usted desea que la clase bicicleta ya
no pueda ser refinada, así creando subclases como bicicleta de carreras, de montaña,
etc., podría declararla NotInheritable, de esta forma no sería posible derivar subclases.
Un ejemplo de una clase final en Visual Basic .NET es la clase Math, esto implica que
usted no puede declarar subclases a partir de ella.
6.2 Reemplazo de métodos de la clase base

Ahora que sabe cómo extender las capacidades de una clase base agregando métodos y
propiedades en una clase derivada, puede requerir que una propiedad11 o método de la
11
En este caso nos referimos a los métodos Property, no a las variables miembro también
llamadas algunas veces propiedades o atributos.

clase base (heredado) se comporte de forma diferente dentro de la clase derivada. En

otras palabras, deseará reemplazar una propiedad o método en la clase base por otra
propiedad o método con el mismo nombre en la subclase, pero con una implementación
distinta; para esto es importante conocer las palabras clave que Visual Basic .NET utiliza
para indicar desde una clase base restricciones en el reemplazo de sus propiedades y
métodos, como se indica a continuación:
• Overridable: indica que la propiedad o método es reemplazable.
• NotOverridable: indica que la propiedad o método no es reemplazable, lo asume
por defecto y solo es necesario colocarlo cuando esa propiedad o método está
reemplazando a otra definida en la clase base.
• MustOverride: indica que la propiedad o método debe reemplazarse y, por lo tanto,
en la clase base no se implementa sólo se declara, por lo que también se le conoce
como abstracto, si una clase contiene un método MustOverride deberá ser declarado
MustInherit y no se podrán crear instancias de ésta.
En complemento a las palabras clave para indicar qué propiedades y métodos serán
reemplazables, existe una palabra clave utilizada dentro de una clase derivada para
sustituir una propiedad o método de una clase base:
• Overrides: indica que la propiedad o método reemplazará a una propiedad o
método de la clase base, siempre y cuando esté permitido.
A continuación, se ejemplifica el uso de reemplazar métodos de la clase base.
Suponga que define la clase Figura con el método calcularArea(), posteriormente crea las
subclases Círculo y Cuadrado que derivan de la clase Figura; aun cuando ambas
tendrán el método calcularArea(), éste deberá tener distinta implementación debido a que
la formula para calcular el área no es la misma para un cuadrado y para un círculo; en
este caso cada clase deberá reemplazar el método definido en la clase base por otro con
el mismo nombre, pero con distinta implementación.
Enseguida se presenta el diagrama de clases del ejemplo anterior, en el cual se muestran
también otros métodos que ayudarán a explicar cada uno de los casos del reemplazo de
métodos de la clase base.
Figura 22. Diagrama de clases mostrando la generalización de Circulo y Cuadrado hacia Figura
81
Para indicar desde la declaración de una propiedad o un método dentro de una clase
base, que éstas pueden ser reemplazadas en cualquier clase derivada por una propiedad
o un método de nombre idéntico, deberá anteponer el modificador Overridable. Por
ejemplo, para el caso del método despliegaDatos(), debe ser declarado como
Overridable ya que aun cuando la clase Figura despliega los datos mostrando sus
coordenadas x, y la clase Cuadrado puede reemplazarlo para mostrar información sobre
sus lados, es decir, una característica que tienen los cuadrados pero no todas las figuras,
lo mismo sucede para la clase Círculo con el radio. En otras palabras, declare como
Overridable las propiedades o métodos que incluso cuando se implementan en la clase
base, “pueden” ser remplazados en las clases derivadas.
Si no coloca el modificador Overridable, se asume automáticamente el modificador
NotOverridable que indica que la propiedad o método no podrá ser reemplazado en una
clase derivada. Debido a que este es el modificador que asumen por defecto, no hace falta
colocarlo en una clase base, sólo deberá colocarlo a las propiedades o métodos dentro de
una clase derivada que no desea que sean reemplazados en niveles posteriores. Por
ejemplo, el método calculaArea() se define NotOverridable en las clases Círculo y
Cuadrado. Otro ejemplo se encuentra en el caso del método despliegaArea() que asume el
modificador NotOverridable en figura por lo que no podrá ser reemplazado en las clases
derivadas, esto es lógico debido a que ambas clases (Círculo y Cuadrado) tendrán un área
y el método que despliega este dato no cambia su implementación entre una y otra. En
otras palabras declare como NotOverridable las propiedades o métodos que implementa
en la clase y que “no pueden” ser reemplazados en las clases derivadas.
También existirán propiedades o métodos que desee forzar a que todas las clases
derivadas implementen debido a que no se han podido implementar en la clase base,
para lo cual sólo deberá declarar y no implementar el método en la clase base
anteponiendo el modificador MustOverride; en caso de que una clase tenga uno o más
métodos declarados con MustOverride, la clase deberá ser declarada como MustInherit
(véase el ejemplo de la clase Figura). Por ejemplo, para el caso del método calculaArea()
aun cuando todas las figuras deben contar con éste, sólo puede declararlo y no
implementarlo en la clase base ya que no se tienen los datos suficientes para calcular el
área y esto se implementará de forma distinta en la clase Cuadrado y Círculo. En otras
palabras, declare como MustOverride los métodos que “deben” ser implementados en
las clases derivadas y que no pueden ser implementados desde la clase base.
Ahora que sabe cómo indicar desde la clase base, qué propiedades y métodos pueden y
no pueden ser implementados en las clases derivadas, deberá aprender a reemplazarlos
en las clases derivadas, para lo cual será necesario anteponer el modificador Overrides a
la propiedad o método que reemplace a las declaradas en la clase base. Por ejemplo,
para el caso del método calcularArea() dentro de la clase derivada, deberá anteponerle
el modificador Overrides para indicarle a Visual Basic .NET que está reemplazando al
método declarado en la clase base. En otras palabras, declare como Overrides las
propiedades o métodos que reemplacen a una propiedad o método de la clase base.
A continuación, se presenta el código de ejemplo para las clases Figura, Cuadrado y
Círculo.
'Clase que representa una figura, almacenando sus coordenadas x,
y y el área.

'Se utiliza el modificador MustInherit (clase abstracta de la que

no pueden crearse objetos) ya que tiene un método MustOverride
que debe ser implementado forzosamente en cualquier subclase
derivada de ésta.
Public MustInherit Class Figura
Protected dX As Double
Protected dY As Double
Protected dArea As Double
'CONSTRUCTOR: Recibe las coordenadas x, y. El área será
calculada posteriormente ya que depende si es un círculo,
cuadrado, etc.
Public Sub New(ByVal x As Double, ByVal y As Double)
Me.dx = x
Me.dY = y
End Sub
'PROPERTY's
Public Property x() As Double
Get
Return dX
End Get
Set(ByVal value As Double)
Me.dX = value
End Set
End Property
Public Property y() As Double
Get
Return dY
End Get
Me.dY = value
End Set
End Property
Public Property area() As Double
Get
Return dArea
End Get
Me.dArea = value
End Set
83
End Property
'DespliegaArea: Método de implementación, muestra un mensaje
con el valor del área, es notOverridable por defecto por lo que
no podrá ser reemplazado en una subclase.
Public Sub DespliegaArea()
MsgBox("Mi area es : " & area)
End Sub
'DespliegaDatos: Método de implementación, muestra un mensaje
con el valor las coordenadas x,y
'es Overridable por lo que podrá ser reemplazado en una
subclase, por ejemplo,
'para mostrar otros datos como la longitud de los lados de un
cuadrado o el radio de un círculo:
Public Overridable Sub DespliegaDatos()
MsgBox("Mis coordenadas x,y son: " & x & "," & y)
End Sub
'calculaArea: Método de auxiliar, calcula el área de la
figura,
'es MustOverride por lo que forsozamente debe ser reemplazado
e implementado en una subclase.
'solo se declara y no se implementa ya que no es posible
hacerlo a este nivel,
Protected MustOverride Sub calculaArea()
End Class
'SubClase que representa un cuadrado, deriva de figura por lo que

además de almacenar la longitud de los lados, almacenará las
coordenadas x, y, así como el área mediante el uso de los
atributos declarados en la clase base.
'Al ser subclase de Figura debe implementar forzosamente el
método calculaArea
Public Class Cuadrado
Inherits Figura
Protected dLado As Double
'CONSTRUCTOR: Recibe las coordenadas x, y. El área es
calculada tras asignar los atributos correspondientes.
Public Sub New(ByVal x As Double, ByVal y As Double, ByVal
lado As Double):
MyBase.New(x, y)
Me.dLado = lado
calculaArea()
End Sub

'PROPOERTY's
Public Property lado() As Double
Get
Return dLado
End Get
Me.dLado = value
End Set
End Property
figura, es NotOverridable debido a que era MustOverride en la
clase base y deseamos que ya no sea sustituida en subclases
derivadas de Cuadrado también se coloca el modificador Overrides
para indicar que reemplaza al método con el mismo nombre definido
en la clase base:
Protected NotOverridable Overrides Sub calculaArea()
area = lado * lado
End Sub
con el valor las coordenadas x,y y la longitud de cada lado se
coloca el modificador Overrides para indicar que reemplaza al
método con el mismo nombre definido en la clase base:
Public Overrides Sub despliegaDatos()
MsgBox("Mis coordenadas x,y son: " & x & "," & y & "La
longitud de cada lado es: " & lado)
End Sub
End Class
'SubClase que representa un círculo, deriva de figura por lo que

además de almacenar el radio, almacenará las coordenadas x, y,
así como el área, mediante el uso de los atributos declarados en
la clase base.
método calculaArea
Public Class Círculo
Inherits Figura
Protected dRadio As Double
radio As Double)
MyBase.New(x, y)
Me.dRadio = radio
85
calculaArea()
End Sub
'PROPOERTY's
Public Property radio() As Double
Get
Return dRadio
End Get
Me.dRadio = value
End Set
End Property
figura, es NotOverridable debido a que era MustOverride en la
clase base y deseamos que ya no sea sustituida en subclases
derivadas de Círculo; también se coloca el modificador Overrides
para indicar que reemplaza al método con el mismo nombre definido
en la clase base:
Protected NotOverridable Overrides Sub calculaArea()
area = Math.PI * (radio * radio)
End Sub
con el valor las coordenadas x,y y del radio; se coloca el
modificador Overrides para indicar que reemplaza al método con
el mismo nombre definido en la clase base:
MsgBox("Mis coordenadas x,y son: " & x & "," & y & "Mi
radio es: " & radio)
End Sub
End Class
6.3 La palabra clave MyBase

En algún lugar dentro del código de una subclase, puede requerir invocar a una
propiedad o método reemplazado, pero deseando aludir a la propiedad o método en la
clase base; debido a que éste ha quedado “oculto”, deberá utilizar la palabra clave
MyBase. Por ejemplo, para las clases Círculo y Cuadrado del ejemplo anterior dentro de
sus métodos constructores, cada uno invoca al método constructor que recibe los
parámetros x, y de su clase Base mediante MyBase.New(Double, Double).
A continuación, se presenta otro ejemplo en el que la subclase DuplicaPago derivada de
la clase Pago reemplaza el método CalcularPago de la clase base; pero dentro de esta
nueva implementación, se invoca al método de la clase base mediante
MyBase.CalcularPago(), regresando el valor por duplicado de éste.

Class DuplicaPago
Inherits Pago
Public Overrides Function CalcularPago () As Double
' Llama al método de la ClaseBase y retorna el Valor
Return MyBase.CalcularPago() * 2
End Function
End Class
Obsérvese que aun cuando MyBase hace referencia a la clase base inmediata y a sus
miembros heredados, no se puede utilizar para invocar a métodos que utilizaron el
modificador MustOverride, debido a que esto implica que no fueron implementados.
6.4 La palabra clave MyClass

Otro caso dentro del reemplazo de propiedades y métodos, es en el que usted desea
asegurarse de invocar a la propiedad o método declarado en la clase en la que se
encuentra, es decir, asegurarse de que no se invocará a un método en la clase base o en
subclases derivadas de ésta, para lo cual puede utilizar la palabra clave MyClass.
Por ejemplo, en el caso de la clases Figura, Círculo y Cuadrado y estando dentro de la
clase Figura desea asegurarse de invocar al método desplegarDatos declarado como
parte de esa clase, y no a los declarados dentro de las clases Círculo o Cuadrado, podrá
realizar lo siguiente:
‘Solo se ha agregado el método Prueba al final de la clase
Protected dArea As Double
Me.dx = x
Me.dY = y
End Sub
'PROPERTY's
Get
Return dX
End Get
Me.dX = value
End Set
End Property
87

Get
Return dY
End Get
Me.dY = value
End Set
End Property
Public Property area() As Double
Get
Return dArea
End Get
Me.dArea = value
End Set
End Property
Public Sub DespliegaArea()
End Sub
End Sub
Protected MustOverride Sub calculaArea()
Public Sub Prueba()
'Uso de MyClass para llamar al método declarado en
esta clase:
DespliegaDatos()
End Sub
End Class
En este caso en que se colocó la palabra clave MyClass, realizar lo siguiente:

Dim c As Círculo = New Círculo(1, 2, 3)
c.Prueba()
Se desplegará un cuadro de diálogo con el texto “Mis coordenadas x,y son: 1,2 ”.
Contrario a esto, si usted no coloca la palabra clave MyClass el texto será “Mis
coordenadas x, y son: 1,2 y Mi Radio es 3”.

Herencia visual
Es muy común que desee crear un formulario base que sirva como plantilla para la creación
de formularios derivados que hereden los controles, pero a los que también podrá agregar
controles nuevos, a esto se le conoce como herencia visual. El formulario base será un
objeto que herede sus características de la clase System.Windows.Forms.Form, y el
formulario derivado a su vez, heredará sus características del formulario base, como se
ilustra a continuación:
Formulario Base
Class FormBase
Inherits System.Windows.Forms.Form
Formulario Derivado
Class FormDerivado
Inherits FormBase
Figura 23. Ejemplo de herencia visual.
La herencia visual permite que a partir de un formulario base se puedan representar un

tamaño estándar de objetos, como botones, cajas de texto y otros controles contenidos
dentro del mismo. Por lo que cualquier formulario derivado de un mismo formulario
base, tendrá las mismas formas de controles y tamaños. Para agregar un formulario
derivado en Visual Studio, seleccione la opción Proyecto | Agregar Formulario Heredado
(Project | Add Inherited Form).
Figura 22 Agregar un formulario derivado.
89
En caso de que no se haya generado la solución previamente ya sea mediante la opción

de la barra de menús Generar | Generar Solución o el menú Depurar | Iniciar, podrá
aparecer una ventana de advertencia indicándole que aun no se ha generado el
ensamblado, por lo que no puede heredar de algún elemento. Una vez que ha generado
la solución, podrá tener disponible los elementos para heredar, con lo que se presentará
la pantalla en donde deberá confirmar que desea agregar un formulario heredado y
podrá colocar el nombre que desee al nuevo formulario; para continuar dé clic en el
botón Abrir.
Aparecerá una ventana solicitándole que seleccione el elemento dentro del proyecto del
cual desea heredar, en donde deberá seleccionar el formulario base y dar clic en el
botón Aceptar para finalizar, como se muestra a continuación:
Figura 24 Selector de herencia.
Con esto generará un nuevo formulario con la misma apariencia que el formulario base,
pero al cual podrá agregar nuevos controles.

6.5 Interfases
Una interfaz es una especie de clase que sólo puede contener atributos y métodos
abstractos, es decir, métodos que no han sido implementados y sirven para obligar a las
clases derivadas a implementarlos, de esta manera en ocasiones son considerados
“contratos” que las clases que implementan la interfaz, se obligan a cumplir.
Las interfases permiten “simular” la herencia múltiple en tanto una clase puede
implementar más de una interfaz, pero a diferencia de la herencia no se adquiere
funcionalidad, ya que en una interfaz no implementa ningún método, sólo se adquiere la
obligación de implementarlos.
Para el ejemplo de la clase Figura, ésta contiene el método abstracto calcularArea(), pero
en un sentido más estricto, una Figura es cualquier conjunto de puntos; y el método
calcularArea es característico sólo de las superficies, por lo que podríamos declarar una
interfaz llamada superficie, conteniendo el método calcularArea y despliegaArea.
Declarar interfases
Para declarar una interfaz, deberá utilizar la palabra clave Interfase y se recomienda
colocar como prefijo la letra mayúscula “I” al nombre de la interfaz. Los métodos
declarados en una interfaz no contienen cuerpos y son públicos implícitamente.
Interfase Isuperficie:
Sub calculaArea()
Sub DespliegaArea()
Property area() As Double
End Interfase.
Implementación de la interfaz
Una vez que ha declarado la interfaz, podrá implementarla dentro de una clase, cabe
recordar que una clase sólo puede heredar de una clase base, pero puede implementar
más de una interfaz, permitiendo simular la herencia múltiple; a su vez, una interfaz
también puede heredar sólo de otra interfaz.
Por ejemplo, a continuación se muestra la forma en que se ve modificada la clase Figura,
al existir ahora la interface ISuperficie, Figura no contendrá el atributo área, ni los
métodos calcularArea y DespliegaArea; también se muestra la clase Cuadrado que
deriva de la clase Figura e implementa la interfaz ISuperficie, por lo que se obliga a
implementar los métodos CalcularArea y DespliegaArea.
'Clase que representa una figura, almacenando sus coordenadas x,
y y el área.
'Se utiliza el modificador MustInherit debido a que tiene un
método MustOverride que debe ser:
'implementado forsozamente en cualquier subclase derivada de esta
91
'CONSTRUCTOR: Recibe las coordenadas x, y. El área será

calculada posteriormente ya que depende:
'de si es un círculo, cuadrado, etc.
Me.dx = x
Me.dY = y
End Sub
'PROPERTY's
Get
Return dX
End Get
Me.dX = value
End Set
End Property
Get
Return dY
End Get
Me.dY = value
End Set
End Property

con el valor las coordenadas x,y,
'es Overridable por lo que podrá ser reemplazado en una
subclase, por ejemplo,
'para mostrar otros datos como la longitud de los lados de un
cuadrado o el radio de un círculo:
End Sub
Public Sub Prueba()
'Uso de MyClass para llamar al método declarado en esta
clase
DespliegaDatos()
End Sub
End Class

'SubClase que representa un cuadrado, deriva de figura por lo que

además de almacenar la longitud de los lados,
'almacenará las coordenadas x, y y el área mediante el uso de los
atributos declarados en la clase base.
método calculaArea,
Public Class Cuadrado
Inherits Figura
Implements ISuperficie
Protected dLado As Double
Protected darea As Double
lado As Double)
MyBase.New(x, y)
Me.dLado = lado
calculaArea()
End Sub
'PROPOERTY's
Public Property lado() As Double
Get
Return dLado
End Get
Me.dLado = value
End Set
End Property
Public Property area() As Double Implements ISuperficie.area
Get
Return darea
End Get
Me.darea = value
End Set
End Property
figura,
'es NotOverridable debido a que era MustOverride en la clase
base y deseamos que ya no
93
'sea substituida en subclases derivadas de Cuadrado también

se coloca el modificador Overrides
'para indicar que reemplaza al método con el mismo nombre
definido en la clase base:
Protected Sub calculaArea() Implements
ISuperficie.calculaArea
area = lado * lado
End Sub
'DespliegaArea: Método de implementación, muestra un mensaje
con el valor del área,
'es notOverridable por defecto por lo que no podrá ser
reemplazado en una subclase.
Public Sub DespliegaArea() Implements
ISuperficie.DespliegaArea
End Sub
con el valor las coordenadas x,y así como la longitud de cada
lado,
'se coloca el modificador Overrides para indicar que
reemplaza al método,
'con el mismo nombre definido en la clase base:
MsgBox("Mis coordenadas x,y son: " & x & "," & y & "La
longitud de cada lado es: " & lado)
End Sub
End Class

CAPÍTULO
Polimorfismo
El polimorfismo es una característica de la programación orientada a objetos y hace
referencia a la capacidad de un objeto para “adoptar distintas formas”, ya que puede
responder de forma diferente a un mismo método dependiendo del contexto en el que
sea utilizado. A lo largo de este capítulo se presenta la forma de realizar polimorfismo
mediante herencia y mediante interfases, complementando en gran parte el tema 5.2
“reemplazo de métodos en la clase base” y 5.3 “interfases” del capítulo anterior.
7.1 Polimorfismo mediante herencia

El polimorfismo mediante herencia hace alusión a la capacidad que se tiene en la
porgramación orientada a objetos, en la que puede declarar una clase base que contenga
un método X, posteriormente derivar varias clases a partir de ella, de tal forma que el método
X definido en la clase base existirá con el mismo nombre en todas ellas, pero cada una podrá
implementarlo de distinta forma y responder con su código particular.
Utilizando el ejemplo de la interfaz Isuperficie y las clases Figura, Cuadrado y Círculo,
ahora suponga que declaramos un Módulo de prueba llamado FiguraTest, como se
muestra a continuación:
Public Module FiguraTest
Private Sub Main()
probador(c)
Dim cu As Cuadrado= New Cuadrado(1, 2, 3)
probador(cu)
End Sub
Public Sub probador(ByVal fig As Figura)
fig.DespliegaDatos()
End Sub
End Module
95
El ejemplo anterior crea un objeto de tipo Círculo que pasa como parámetro al método
probador (ByVal fig as Figura), el cual recibe una figura e invoca al método
DespliegaDatos() de dicha figura, que en este caso mostrará el texto “Mis coordenadas
x,y son 1,2 y mi radio es 3”. Posteriormente crea un objeto de tipo Cuadrado y realiza lo
mismo, para este caso mostrará el texto “Mis coordenadas x, y son 1,2 y la longitud de
cada lado es 3”.
Como podrá darse cuenta, aun cuando el método probador recibe como parámetro un
objeto de tipo Figura, no ejecuta el código del método despliegaDatos declarado en la
clase Figura, sino más bien el del método despliegaDatos declarado en cada una de las
clases correspondientes al objeto que pasaron como parámetro, Círculo y Cuadrado
respectivamente, logrando el polimorfismo mediante la herencia a partir de una clase base.
7.2 Polimorfismo mediante interfases

Las interfases proporcionan otro método de conseguir el polimorfismo en Visual Basic .NET.
Para conseguir el polimorfismo mediante interfases, se declara una interfaz conteniendo
un método X, posteriormente diversas clases pueden poner en operación dicha interfaz y
responder a la invocación del método con su implementación particular.
Continuando con el ejemplo de la interfaz Isuperficie y las clases Figura, Círculo y
Cuadrado, observe el siguiente módulo de prueba ejemplificando el uso del polimorfismo
mediante herencia.
Public Module FiguraTest
Private Sub Main()
probador(c)
Dim cu As Cuadrado= New Cuadrado(1, 2, 3)
probador(cu)
End Sub
Public Sub probador(ByVal fig As ISuperficie)
fig.calculaArea()
fig.DespliegaArea()
End Sub
End Module
En este caso al igual que en el anterior, crea un círculo y posteriormente un cuadrado que
pasa como parámetros al método probador (ByVal fig As ISuperficie) mostrando el texto “Mi
área es: 28.274” y “Mi área es: 9” para el círculo y el cuadrado respectivamente.
Observe de nueva cuenta que aun cuando el método probador recibe como parámetro
un objeto de tipo Isuperficie, ejecuta el método correspondiente a cada uno de los
objetos que se le pasan como parámetro, para lorar así el polimorfismo mediante una
interfaz.

CAPÍTULO
System Windows Forms
Visual Studio .NET permite desarrollar interfases gráficas de usuario de una manera
sencilla, las cuales pueden contar con diversos controles: Barras de Menú, Barras de
Estado, Cuadros de Texto, Ventanas de Diálogo, entre otros controles disponibles en el
espacio de nombres System.Windows.Forms. El desarrollo de una interfaz gráfica se lleva
a cabo utilizando principalmente el diseñador de Windows Forms, así como el cuadro de
herramientas que contiene los objetos (controles) que conformarán la interfaz gráfica.
8.1 System.Windows.Forms.Form
Un formulario es la base de nuestra interfaz gráfica y será el contenedor para todos los
controles; de esta forma cada ventana que se muestre al ejecutar la aplicación será un
formulario.
Un formulario es un objeto que hereda sus características de la clase
System.Windows.Forms.Form, que representa la plantilla a partir de la cual serán creados
los nuevos formularios, aunque Visual Basic .NET también le da la posibilidad de crear
un nuevo formulario que herede de un formulario previamente creado.
Para agregar un formulario al proyecto que herede de Form, realice un clic en el menú
Proyecto | Agregar Windows Forms; si desea agregar un formulario que herede de otro
formulario creado previamente, dé clic en el menú Proyecto | Agregar Formulario Heredado.
Para el caso en que haya elegido agregar un nuevo formulario Windows Forms, obtendrá
un formulario similar al de la siguiente figura:
Barra de Botón Cerrar
título
Botón Maximizar
Botón Minimizar
97
En dicho formulario se pueden agregar elementos como etiquetas, cajas de texto y

botones entre otros, por ejemplo, para la aplicación de Compuventa descrita al final del
tema (PARECE QUE NO SE HA DESCRITO ESTA APLICACIÓN DE COMPUVENTA), se
utilizará un formulario por cada pantalla (menú, registro clientes, registro productos,
pedidos, etcétera). Entre sus propiedades más representativas se encuentran:
• Name: indica el nombre para identificar el objeto dentro del código.
• AcceptButton: permite establecer un botón Aceptar que será activado cuando el
usuario presione la tecla Enter.
• BackColor: color de fondo utilizado para mostrar texto y gráficos en el control.
• BackGroundImage: imagen de fondo utilizada para el control.
• CancelButton: permite establecer un botón Cancelar que será activado cuando el
usuario presione la tecla Esc.
• Enabled: indica si el control está habilitado, es decir, si puede ser editado.
• Font: fuente utilizada para mostrar texto en el control.
• Fore Color: color de primer plano utilizado para mostrar texto y gráficos en el control.
• Location: posición de la esquina superior izquierda del control respecto del contenedor.
• Locked: determina si se puede mover o cambiar el tamaño del control en vista de diseño.
• Size: tamaño del control en pixeles.
• Text: indica el texto asociado al formulario en la barra de título.
Entre sus métodos más representativos se encuentran:
• Show(): muestra el control al usuario.
• Activate(): activa el formulario y le otorga el foco.
• Close(): cierra el formulario.
• Focus(): establece el foco de entrada en el control.
• Evento Load: se invoca al cargar el formulario, es útil para introducir instrucciones
que deseamos que se ejecuten antes de que se muestre el formulario.
8.2 Label
Las etiquetas son elementos que nos permiten mostrar texto dentro del formulario de
nuestra interfaz de usuario, se utilizan para mostrar texto descriptivo acerca de un control.
Usted puede elegir cambiar el tipo de fuente, el color y el tamaño de la misma; entre
otras propiedades o bien puede escoger la librería de clases de Windows Forms que nos
provee estos controles mediante la clase System.Windows.Forms.Label. Por ejemplo, para
el caso de la aplicación descrita al final del tema se utilizan controles Label para
mostrarlos, y para que el usuario capture los datos correspondientes al producto. Entre
sus propiedades más representativas se encuentran:


• Text: indica el texto contenido dentro del control.
• Visible: determina si el control está visible u oculto.
8.3 TextBox
Las cajas de texto presentan un campo de entrada dentro del formulario, para que el usuario
introduzca datos, los cuales son almacenados en una variabe de tipo Texto correspondiente a
la propiedad Text del objeto TextBox; la librería de clases Windows.Forms nos provee de
estos controles mediante la clase System.Windows.Forms.TextBox. Por ejemplo, para el
caso de la aplicación descrita al final del tema se utilizan controles TextBox dentro de un
formulario (FrmProductos por ejemplo), para que el usuario capture los datos
correspondientes. Entre sus propiedades más representativas se encuentran:
• CausesValidation: indica si este control causa y genera eventos de validación.
• MaxLength: especifica el número máximo de caracteres que se pueden teclear dentro
del control.
• Password Char: indica el caracter que se debe mostrar, asumiendo que se introducirá
una contraseña en el control.
• TabIndex: indica el orden de tabulación que ocupará este control, cuando usted
presione la tecla tab estando dentro del control, se moverá al indice siguiente.
• Text: Indica el texto contenido dentro del control.
• Visible: Determina si el control está visible u oculto.
• AppendText (texto as String): anexa texto al texto contenido dentro del control.
• Clear(): borra todo el texto del control.
• Focus(): establece el foco de entrada en el control.
• Evento TextChanged: se invoca cuando el texto dentro del control ha cambiado.
99
• Evento Validating: se invoca al abandonar el control para validar el texto introducido,

solo en caso de que la propiedad CausesValidation sea true.
8.4 Button
Seguramente conoce los botones de comando de Windows que generalmente se utilizan
para desencadenar una acción (evento) o aceptar/cancelar las opciones que se le
presentan al usuario en un cuadro de diálogo. El botón de comando de Windows está
representado en la clase System.Windows.Forms.Button. Por ejemplo, para el caso de la
aplicación compuventa descrita al final del tema, se utilizan controles Button para que el
usuario acepte o cancele una acción para limpiar formularios y para indicar el tipo de
búsqueda que desea realizar (por clave o por tipo). Entre sus propiedades más
representativas se encuentran:
• BackColor: color de fondo utilizado para mostrar texto y gráficos en el control
presione la tecla tab estando dentro del control se moverá al índice siguiente.
• Text: indica el texto contenido dentro del control.
• Evento Click(): se invoca al dar clic sobre el control.
8.5 GroupBox
Los GroupBox o Grupo de Cajas nos permiten agrupar controles, sirven como
contenedor y de esta forma facilitan el diseño de la interfaz gráfica, ya que al cambiar la
posición o eliminar este contenedor, estas acciones afectarán a todos los elementos que
contiene la librería de clases de Windows Forms, la cual nos proporciona estos controles
mediante la clase System.Windows.Forms.GroupBox. Por ejemplo, para el caso de la
aplicación Compuventa descrita al final del tema, se utilizan controles GroupBox para
agrupar las opciones de sexo (controles RadioButton) en las que sólo puede estar
seleccionada una de las dos opciones a la vez; un grupo de opciones independiente
debe estar contenido dentro de un control GroupBox, de lo contrario pertenecerá al
contenedor del formulario y no será independiente. Entre sus propiedades más


• Property Controls(): obtiene la colección de controles que contiene el control.
8.6 RadioButton
Los botones de selección nos permiten mostrar elementos para su selección que son
excluibles entre sí, es decir, sólo nos da una opción de entre un grupo de ellas; dentro
del formulario de nuestra interfaz de usuario, la librería de clases de Windows Forms
provee estos controles mediante la clase System.Windows.Forms.RadioButton. Por
ejemplo, para el caso de la aplicación compuventa descrita al final del tema se utilizan
controles RadioButton para las opciones de sexo; es imporatante que cada grupo de
opciones independiente, quede contenido dentro de un control GroupBox, de lo contrario
pertenecerá al contenedor del formulario y no será independiente. Entre sus propiedades
más representativas se encuentran:
• Checked: indica si el botón de opción esta activado o no.
• Locked: determina si se puede mover o cambiar el tamaño del control en vista de
diseño.
presione la tecla tab estando dentro del control, se moverá al índice siguiente.
• Text: indica que se mostrara junto al control.
8.7 CheckBox
Los botones de verificación CheckBox son utilizados para marcar múltiples opciones y la
librería de clases de Windows Forms nos provee estos controles mediante la clase
System.Windows.Forms.CheckBox. Por ejemplo, para el caso de la aplicación
compuventa descrita al final del tema, se utilizan controles CheckBox para las opciones
de tarjetas bancarias, debido a que puede tener múltiples. Entre sus propiedades más
representativas se encuentran.
• Checked: indica si el botón de opción está activado o no.
101
• Enabled: indica si el control esta habilitado, es decir, si puede ser editado.

• Location: posición de la esquina superior izquierda del control respecto del
contenedor.
• Locked: determina si se puede mover o cambiar el tamaño del control en vista de
diseño.
• Text: indica que se mostrará junto al control.
• ThreeState: indica si permitira tres estados en lugar de dos.
• Evento CheckedChanged: se invoca cuando cambia de estado.
8.8 ComboBox
Los cuadros combinados son utilizados para seleccionar uno o más elementos de una
lista desplegable, y la librería de clases de Windows.Forms nos provee estos controles
mediante la clase System.Windows.Forms.ComboBox. Por ejemplo, para el caso de la
aplicación compuventa descrita al final del tema, se utilizan controles ComboBox para
que el usuario seleccione de una lista el estado en el que vive. Entre sus propiedades más
representativas se encuentran.
• Data Source: indica la lista que el control utiliza para obtener sus elementos.
• Enabled: indica si el control esta habilitado, es decir si puede ser editado.
• Sorted: especifica si están ordenados los elementos del cuadro combinado.
• Ítems: colección conteniendo los elementos del cuadro combinado.
• Property SelectedIndex: obtiene o establece el índice que especifica el elemento
seleccionado actualmente.
• Property SelectedItem: obtiene o establece el elemento seleccionado actualmente.
• Property SelectedText: obtiene o establece el texto seleccionado en un comboBox que
se puede editar.
• Evento SelectedIndexChanged: se invoca cuando cambia de estado.

8.9 ListBox
Los controles de cajas de lista nos permiten mostrar una lista de opciones dentro para
que el usuario pueda seleccionar una o más de ellas; la librería de clases de Windows
Forms nos provee estos controles mediante la clase System.Windows.Forms.ListBox. Entre
sus propiedades más representativas se encuentran:
• Data Source: indica la lista que el control utiliza para obtener sus elementos.
• Selection Mode: indica si el cuadro de lista será de selección simple, multiple o no
seleccionable.
• Sorted: especifica si están ordenados los elementos del cuadro de lista.
• Ítems: colección conteniendo los elementos del cuadro de lista.
• Property de solo lectura SelectedIndices: obtiene una colección con los índices
seleccionados actualmente.
• Property de solo lectura SelectedItems: obtiene una colección con los elementos
8.10 Panel
Un Panel es una región bien limitada dentro de una ventana que puede contener a otros
controles; su principal función es agrupar los controles de manera similar a como lo hace
GroupBox, de tal manera que si se deshabilita el panel, se deshabilitarán todos los
controles que estén contenidos en él.
El control Panel no muestra ningún título. Si necesita un control similar a Panel que puede
mostrar un título, utilice el control GroupBox. Entre sus propiedades más representativas
se encuentran:
103
8.11 LinkLabel
El control LinkLabel es un control de tipo Label, con la característica de que puede mostrar
uno o más hipervínculos. Cada hipervínculo que se muestra en el control LinkLabel es de tipo
LinkLabel.Link. Entre sus propiedades más representativas se encuentran.
• DisabledLinkColor: determina el color del hipervínculo cuando está deshabilitado.
• LinkArea: parte del texto de la etiqueta que se procesa como hipervínculo.
• LinkBehavior: comportamiento del subrayado de un hipervínculo.
• LinkColor: color del hipervínculo en forma predeterminada.
• VisitedLinkColor: determina el color del hipervínculo cuando la propiedad link visited
es true.
• Evento LinkClicked: se invoca al dar un clic sobre el link.
• Property Links: obtiene la colección de vínculos que contiene el control.
8.12 CheckedListBox
Es una caja que presenta una lista de controles tipo CheckBox, pudiendo marcar una o
más casillas de verificación. El objeto CheckedListBox admite tres estados a través de la
enumeración CheckState: Checked, Indeterminate y Unchecked, cuyos valores son:
verificado, indeterminado y no verificado respectivamente. Entre sus propiedades más
• Check On Click: indica si la casilla debe cambiar su estado al hacer clic por primera
vez en el elemento.
• Sorted: especifica si están ordenados los elementos del cuadro de lista.
• Ítems: colección conteniendo los elementos del cuadro de lista.

• Property de solo lectura SelectedIndices: obtiene una colección con los índices
• Property de solo lectura Selectedtems: obtiene una colección con los elementos
8.13 PictureBox
Permite mostrar imágenes (BMP, íconos, JPEG, GIF o PNG) dentro de una interfaz
gráfica. Puede especificar la ruta al archivo que se mostrará en el objeto Image que
desea mostrar, ya sea en tiempo de diseño o en tiempo de ejecución. Entre sus
propiedades más representativas se encuentran:
• ErrorImage: imagen que se carga cuando falla la carga de otra imagen.
• Image: imagen mostrada en el control PictureBox.
• InitialImage: imagen que se muestra mientras se carga otra imagen.
• Enabled: indica si el control está habilitado, es decir si puede ser editado.
• SizeMode: controla la forma en que se tratará la ubicación y el tamaño de las
imágenes.
• WaitOnLoad: controla si el proceso se detendrá hasta que la imagen se cargue.
8.14 Timer
Permite lanzar eventos en cada cierto intervalo establecido por el usuario, utilizando el
evento Tick. Esta clase proporciona métodos para establecer el intervalo y para iniciar y
detener el temporizador. Entre sus propiedades más representativas se encuentran.
• Enabled: habilita la generación de eventos Elapsed.
• Interval: frecuencia de los eventos Elapsed.
8.15 TabControl
Control que permite mostrar ventanas con múltiples fichas, incluye el conjunto de fichas
asociadas a él. Entre sus propiedades más representativas se encuentran:
• Aligment: determina la posición de las fichas.
105
• TabPages: la colección de fichas dentro del control.

• Property Controls: obtiene la colección de controles que contiene el control.
8.16 Trackbar
Control que funciona como un deslizador en donde se pueden configurar los intervalos
entre los que se podrá desplazar una barra de seguimiento. Entre sus propiedades más
• SmallChange: número de posiciones que se moverá el control, al utilizar las teclas de
direccionamiento del teclado.
• TickFrecuency: número de posiciones entre marcas de paso.
• Orientation: establece la orientación del control (horizontal o vertical)
• Evento Scroll(): se invoca al deslizar el control.
8.17 ProgressBar
Sirve para para indicar de forma visual el progreso de un proceso de alguna de las
siguientes formas:
Entre sus propiedades más representativas se encuentran.
• MarqueeAnimationSpeed: velocidad de la animación de la marquesina en
milisegundos.
• Maximum: límite superior
• Minimum: límite inferior
• Step: cantidad por la que debe aumentar el valor actual al invocar al método
PerformStep.
• Style: Estilo de progress Bar (bloque, barra continua o marquesina).
• Método PerformStep(): método que puede invocar para avanzar la cantidad indicada
por Step.
8.18 MainMenu (MenuStrip VB.NET 2005)

Muestra los comandos y las opciones de la aplicación agrupados por funcionalidad, es el
control que generalmente existe en todas las ventanas de Windows y representa la
estructura de menú que se muestra en la parte superior, cada menú por objetos que son
instancia de la clase MenuItem (ToolStripMenu en VB.NET 2005) que representan los

comandos de menú individuales de la estructura de menú. Entre sus propiedades más

• Ítems: colección de controles que se van a mostrar en ToolStrip.
8.19 ToolBar (ToolStrip VB.NET 2005)

Es un control contenedor que representa las barras de herramientas de Windows. El tipo
de controles contenidos en él son instancias de la clase ToolBarButton que pueden
aparecer como un botón estándar, un botón de alternar o un botón desplegable al igual
que se pueden asignar imágenes a los botones, así como el texto que aparecerá debajo
o a la derecha de la imagen.
8.20 StatusBar(StatusStrip VB.NET 2005)

Representa un control en la barra de estado de Windows que generalmente contiene
objetos que son instancias de las clases StatusBarPanel, cada uno de los cuales muestra
texto y/o un ícono.
8.21 InputBox y MsgBox

El control InputBox muestra una ventana de diálogo a la espera de que el usuario escriba
un texto o haga clic en un botón, y devuelve una cadena que contiene el texto tecleado
por el usuario. Por ejemplo, la siguiente instrucción despliega una ventana con el
mensaje “Teclea un valor” y almacena la respuesta en la variable valorTecleado.
ValorTecleado = InputBox( “Teclea un valor”)
El control MsgBox muestra una ventana de diálogo con un mensaje al usuario y dos
botones Aceptar y Cancelar, a la espera de que el usuario dé clic en algún botón
devolviendo un entero que indica el botón que escogió.
botonEscogido=MsgBox(“Elige Aceptar o Cancelar”)
Para el desarrollo de este tema y del siguiente, se plantea una aplicación que deberá
desarrollar, generando la interfaz gráfica con los controles necesarios.
Una empresa que vende equipo de cómputo ha detectado que sus ventas han ido
disminuyendo notablemente y tras realizar un estudio de mercado, han encontrado que la
causa principal es la falta de automatización en los procesos para la búsqueda de
productos y levantamiento de pedidos.
Para solucionar el problema, es necesario crear un sistema de cómputo con las siguientes
características:
• Una pantalla para dar de alta clientes.
• Una pantalla de autenticación para los clientes registrados previamente, después de
validarlos podrá realizar pedidos y el sistema les hará el cargo correspondiente.
107
• Una pantalla de pedidos en donde podrán realizar búsquedas de los productos por
Tipo y por clave, desplegará una lista con el resultado de los productos cumpliendo
los criterios de búsqueda y permitirá seleccionar productos a partir de esta lista y
agregarlos al pedido.
• Una pantalla para dar de alta productos.
A continuación, se muestran los elementos de la interfaz gráfica de la aplicación,
asegurese de colocar la propiedad nombre (name) con el valor indicado en la tabla,
para facilitar su identificación al momento de ser programados.
• Formulario Menu Principal: Muestra la barra de menus que accionan los
ventanas de la aplicación.
Control Propiedad Valor
Formulario Name FrmPrincipal
• Formulario Ayuda: muestra información acerca del programa.
Formulario Name FrmAyuda
• Formulario de Autenticación: el usuario deberá teclear la clave y le solicitará la

contraseña, en caso de no estar registrado, podrá abrir la ventana para hacerlo.

FrmBienvenida Name FrmBienvenida
TxtClave Name TxtClave
BtnEnviar Name BtnEnviar
BtnRegistrarme Name BtnRegistrarme
BtnCerrar Name BtnCerrar
• Formulario para el registro de productos: permite capturar los datos de un

producto y registrarlo en la base de datos.
FrmProductos Name FrmProductos
TxtTipo Name TxtTipo
TxtDescripcion Name TxtDescripcion
TxtPrecio Name TxtPrecio
TxtExistencias Name TxtExistencias
BtnRegistrar Name BtnRegistrar
BtnLimpiar Name BtnLimpiar
BtnCancelar Name BtnCancelar
109
• Formulario para el registro de clientes: permite capturar los datos de un cliente

y registrarlo en la base de datos.
FrmClientes Name FrmClientes
TxtLogin Name TxtLogin
TxtPassword Name TxtPassword
TxtNombre Name TxtNombre
TxtApellidos Name TxtApellidos
CmbAnio Name CmbAnio
CmbMes Name CmbMes
CmbDia Name CmbDia
RbtMasculino Name RbtMasculino
RbtFemenino Name RbtFemenino
TxtDireccion Name TxtDireccion
TxtCiudad Name TxtCiudad
CmbEstado Name CmbEstado
TxtCorreo Name TxtCorreo
TxtTelefono Name TxtTelefono0
TxtNumTarjeta Name TxtNumTarjeta
ChkBanMex Name ChkBanMex
ChkBanSur Name ChkBanSur
ChkBancoMex Name ChkBancoMex
BtnRegistrar Name BtnRegistrar
BtnLimpiar Name BtnLimpiar

• Formulario de Búsqueda y Pedidos: permitirá buscar por tipo o clave,

desplegará los resultados y permitirá agregar productos al pedido; dando clic
al botón Terminar, se finalizará la compra.
FrmPedidos Name FrmPedidos
CmbTipo Name CmbTipo

BtnBuscarTipo Name BtnBuscarTipo
BtnBuscarClave Name BtnBuscarClave

LvwBusqueda Name LvwBusqueda
BtnComprar Name BtnComprar

LvwPedido Name LvwPedido
TxtMonto Name TxtMonto
BtnTerminar Name BtnTerminar
BtnSalir Name BtnSalir
111
CAPÍTULO
Desarrollo de un proyecto en Visual Basic .NET
En el tema anterior, se han planteado los requisistos de la aplicación CompuVenta y se
ha llevado a cabo el diseño de alto nivel, que consiste en el diseño de la interfaz gráfica
de usuario, ahora utilizando los elementos del lenguaje de programación Visual Basic
.NET, agregará el código necesario a cada una de las pantallas y módulos necesarios
para el funcionamiento de la aplicación.
9.1 Clases: Cliente, Producto, Pedido y Venta

El primer paso será realizar una especie de diseño de la base de datos relacional, ya que
en nuestro caso utilizaremos objetos para representar cada una de las relaciones (tablas),
debido a que el manejo de bases de datos queda fuera del alcance de estas notas.
Aunque posteriormente podrá realizar fácilmente un mapeo Objeto/Relacion ya sea
creando por su cuenta las tablas en algún manejador de bases de datos o empleando
alguna de las herramientas ORM (Object/Relational Mapping) disponibles para Visual
Basic .NET.
A continuación, se presentan los diagramas de clases para la aplicación CompuVenta.
A partir del diagrama de clases mediante un mapeo Objeto/relación, obtenemos el

siguiente diagrama relacional, el cual puede implementarse en cualquier manejador de
bases de datos:

Del diagrama de clases así como del diagrama relacional, podemos concluir lo
siguiente:
• Un objeto cliente almacenará todos los datos correspondientes al cliente y contará
con una clave única IdCliente.
• Un objeto producto almacenará todos los datos correspondientes al producto y
contará con una clave única IdProducto.
• Un cliente podrá realizar un pedido, para el cual se asignará una clave única;
también se almacenará la clave única del cliente (IdCliente) que realiza el pedido, la
fecha en que se realiza y el monto total, de tal forma que un pedido estará
conformado de una o más ventas.
• Para cada venta se asignará una clave única (Idventa), también se almacenará la
clave única del pedido (IdPedido) al que pertenece, la clave única del producto
(IdProducto) vendido y la cantidad de unidades vendidas de ese producto.
A continuación, se presenta el código para las clases Cliente, Producto, Pedido y Venta,
ponga atención a los comentarios dentro del código.
'Clase que representa a un Cliente
Public Class Cliente
'Es recomendable que el acceso a los atributos de cada clase sea
privado solo pudiendo verse y modificarse mediante los métodos
Property correspondientes:
Private clave As String
Private contrasenia As String
Private nombre As String
Private apellidos As String
Private fecha As Date
113
Private sexo As Boolean 'El sexo lo almacenamos como un Boolean

True =Masculino, False =Femenino
Private direccion As String
Private ciudad As String
Private estado As Byte 'El estado lo almacenamos como un Byte
1=Aguascaliente,2=Baja california, etc.
Private correo As String
Private telefono As String
Private tarjeta As String
Private bancos(2) As Boolean 'El arreglo de checkboxes de bancos
lo almacenamos como un arreglo de Boolean's 0 si no tiene la
tarjeta, 1 si la tiene.
'Declaración del constructor que recibe todos los parametros y

los asigna a las propiedades del objeto (Uso de Me para referirse a
las propiedades del objeto actual).
Sub New(ByVal clave As String, ByVal contrasenia As String,
ByVal nombre As String, ByVal apellidos As String, ByVal fecha As
Date, ByVal sexo As Boolean, ByVal direccion As String, ByVal ciudad
As String, ByVal estado As Byte, ByVal correo As String, ByVal
telefono As String, ByVal tarjeta As String, ByVal bancos() As
Boolean).
Me.clave = clave
Me.contrasenia = contrasenia
Me.nombre = nombre
Me.apellidos = apellidos
Me.fecha = fecha
Me.sexo = sexo
Me.direccion = direccion
Me.ciudad = ciudad
Me.estado = estado
Me.correo = correo
Me.telefono = telefono
Me.tarjeta = tarjeta
Me.bancos = bancos
End Sub
'Declaración de las Property método que nos permiten regresar
(get) y colocar el valor (set) de cada atributo dándonos un mayor
control, aquí podemos elegir que valores son válidos (dominio),
podemos elegir si un atributo es de solo lectura, solo escritura o
ambas. En estos casos no hay restricciones:
Property clavep() As String
Get
Return clave
End Get
Set(ByVal clave As String)

Me.clave = clave
End Set
End Property
Property contraseniap() As String
Get
Return contrasenia
End Get
Set(ByVal contrasenia As String)
Me.contrasenia = contrasenia
End Set
End Property
Property nombrep() As String
Get
Return nombre
End Get
Set(ByVal nombre As String)
Me.nombre = nombre
End Set
End Property
Property apellidosp() As String
Get
Return apellidos
End Get
Set(ByVal apellidos As String)
Me.apellidos = apellidos
End Set
End Property
Property fechap() As Date
Get
Return fecha
End Get
Set(ByVal fecha As Date)
Me.fecha = fecha
End Set
End Property
Property sexop() As Boolean
Get
Return sexo
End Get
Set(ByVal sexo As Boolean)
Me.sexo = sexo
End Set
End Property
115
Property direccionp() As String

Get
Return direccion
End Get
Set(ByVal direccion As String)
Me.direccion = direccion
End Set
End Property
Property ciudadp() As String
Get
Return ciudad
End Get
Set(ByVal ciudad As String)
Me.ciudad = ciudad
End Set
End Property
Property estadop() As Byte
Get
Return estado
End Get
Set(ByVal estado As Byte)
Me.estado = estado
End Set
End Property
Property correop() As String
Get
Return correo
End Get
Set(ByVal correo As String)
Me.correo = correo
End Set
End Property
Property telefonop() As String
Get
Return telefono
End Get
Set(ByVal telefono As String)
Me.telefono = telefono
End Set
End Property
Property tarjetap() As String
Get
Return tarjeta

End Get
Set(ByVal tarjeta As String)
Me.tarjeta = tarjeta
End Set
End Property
Property bancosp() As Boolean()
Get
Return bancos
End Get
Set(ByVal bancos As Boolean())
Me.bancos = bancos
End Set
End Property
End Class.
'Clase que representa un Producto.

Public Class Producto.
Property correspondientes:
Private clave As Integer
Private tipo As String
Private descripcion As String
Private existencias As Integer
Private precio As Double.
'Declaración del constructor que recibe todos los parámetros y
Sub New(ByVal clave As Integer, ByVal tipo As String, ByVal
descripcion As String, ByVal existencias As Integer, ByVal precio As
Double).
Me.clave = clave
Me.tipo = tipo
Me.descripcion = descripcion
Me.existencias = existencias
Me.precio = precio
End Sub
control, aquí podemos elegir qué valores son válidos (dominio),
Property clavep() As Integer
Get
117
Return clave
End Get
Set(ByVal clave As Integer)
Me.clave = clave
End Set
End Property
Property tipop() As String
Get
Return tipo
End Get
Set(ByVal tipo As String)
Me.tipo = tipo
End Set
End Property
Property descripcionp() As String
Get
Return descripcion
End Get
Set(ByVal descripcion As String)
Me.descripcion = descripcion
End Set
End Property
Property existenciasp() As String
Get
Return existencias
End Get
Set(ByVal existencias As String)
Me.existencias = existencias
End Set
End Property
Property preciop() As String
Get
Return precio
End Get
Set(ByVal valor5 As String)
Me.precio = precio
End Set
End Property
End Class
'Clase para representar un pedido

Public Class Pedido

Private idPedido As Integer

Private idCliente As String
Private DateFecha As Date 'Fecha en que se realizó el pedido
Private CurMonto As Decimal
'Declaración del constructor que recibe todos los parametros y
los asigna a las
'propiedades del objeto (Uso de Me para referirse a las
propiedades del objeto actual).
Sub New(ByVal idPedido As Integer, ByVal idCliente As String,
ByVal DateFecha As Date, ByVal CurMonto As Decimal).
Me.idPedido = idPedido
Me.idCliente = idCliente
Me.DateFecha = DateFecha
Me.CurMonto = CurMonto
End Sub

(get) y colocar el valor (set) de cada atributo,
'dándonos un mayor control, aquí podemos elegir qué valores son
válidos (dominio), podemos elegir si un atributo
'es de solo lectura, solo escritura o ambas. En estos casos no
hay restricciones.
Property idPedidop() As Integer
Get
Return idPedido
End Get
Set(ByVal idPedido As Integer)
Me.idPedido = idPedido
End Set
End Property
Property idClientep() As String

Get
Return idCliente
End Get
Set(ByVal idCliente As String)
Me.idCliente = idCliente
End Set
End Property
Property DateFechap() As Date
Get
Return DateFecha
End Get
Set(ByVal DateFecha As Date)
119
Me.DateFecha = DateFecha
End Set
End Property
Property CurMontop() As Decimal
Get
Return CurMonto
End Get
Set(ByVal CurMonto As Decimal)
Me.CurMonto = CurMonto
End Set
End Property
End Class.
'Clase para representar cada venta que forma parte de un pedido, por
ejemplo si hicieron un pedido de
'3ratón, 4 teclados, etc. En esta clase se representa cada ítem una
instancia para los tres ratones con la información de:
'el idVenta, IdPedido (a que pedido pertenecen), IdProducto,
IdCantidad,
Public Class Venta.
Property correspondientes: Private IdVenta As Integer
Private IdPedido As Integer
Private IdProducto As Integer
Private IntCantidad As Integer
'Declaración del constructor que recibe todos los parámetros y

Sub New(ByVal IdVenta As Integer, ByVal IdPedido As Integer,
ByVal IdProducto As Integer, ByVal IntCantidad As Integer).
Me.IdVenta = IdVenta
Me.IdPedido = IdPedido
Me.IdProducto = IdProducto
Me.IntCantidad = IntCantidad
End Sub.
control, aquí podemos elegir qué valores son válidos (dominio),
Property IdVentap() As Integer
Get
Return IdVenta

End Get
Set(ByVal IdVenta As Integer)
Me.IdVenta = IdVenta
End Set
End Property
Property IdPedidop() As Integer
Get
Return IdPedido
End Get
Set(ByVal IdPedido As Integer)
Me.IdPedido = IdPedido
End Set
End Property
Property IdProductop() As Integer
Get
Return IdProducto
End Get
Set(ByVal IdProducto As Integer)
Me.IdProducto = IdProducto
End Set
End Property
Property IntCantidadp() As Integer
Get
Return IntCantidad
End Get
Set(ByVal IntCantidad As Integer)
Me.IntCantidad = IntCantidad
End Set
End Property
End Class
9.2 Módulo con las colecciones de clientes, productos, pedidos

y ventas
Una vez que ha codificado las clases de las que se instanciarán cada uno de los distintos
objetos por emplearse dentro de la aplicación, se preguntará en dónde serán almacenados
esos objetos; en este caso, utilizaremos los objetos de tipo Collection que usted ya conoce,
de tal forma que habrá una colección para almacenar los clientes, una para almacenar los
productos, una para almacenar los pedidos y otra más para almacenar las ventas.
Algunas de estas colecciones serán utilizadas desde distintas clases, por ejemplo la colección
de productos será utilizada desde la pantalla de registro de productos y en la pantalla de
pedidos, es decir, éstás deberán ser accesibles desde distintas clases; por lo que es
121
conveniente declararlas dentro de un módulo y en el proyecto que sea accesible a las demás
clases, como se muestra a continuación:
Module Module1
Public CClientes As New Collection
Public CProductos As New Collection
Public CPedidos As New Collection
Public CVentas As New Collection
End Module.
Ahora es momento de agregar la funcionalidad a cada una de las pantallas, de modo
que empezaremos por el formulario principal.
9.3 Funcionalidad del formulario principal

El formulario principal tiene como función mostrar la barra de menús y cuando el usuario
dé clic sobre algún comando dentro de esta barra, deberá mostrar la ventana
correspondiente; de esta manera, almacena una variable de tipo referencia hacia cada
formulario, luego crea una instancia y la muestra, también guarda en una variable, la
clave del usuario (login) que indica si el usuario ha sido autenticado.
Public Class FrmPrincipal
'Declaramos las siguientes variables globales
'Variables para hacer referencia a cada uno de los Formularios
Public FormBienvenido As FrmBienvenido
Public FormAyuda As FrmAyuda
Public FormClientes As FrmClientes
Public FormPedidos As FrmPedidos
Public FormProductos As FrmProductos
Public Shared IdLogin As String = "" 'Guarda el Login que

autenticará al usuario para que al generar pedidos sepa a quien
hacer los cargos.
Private Sub MenuItem2_click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles MenuItem2.Clic.
'En caso de dar clic al submenú Login crea el formulario y
lo muestra:
FormBienvenido = New FrmBienvenido
FormBienvenido.Show()
End Sub.
e As System.EventArgs) Handles MenuItem7.Click.
'En caso de dar clic al submenú Registrar (Cliente)crea el
formulario y lo muestra:
FormClientes = New FrmClientes
FormClientes.Show()

End Sub
Private Sub MenuItem12_click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles MenuItem12.Click.
'En caso de dar clic al submenú Realizar Pedido crea el
FormPedidos = New FrmPedidos
FormPedidos.Show()
End Sub.

'En caso de dar clic al submenú Exit Termina la ejecución
End
End Sub.

'En caso de dar clic al submenú Ayuda crea el formulario y
lo muestra:
FormAyuda = New FrmAyuda
FormAyuda.Show()
End Sub.

'En caso de dar clic al submenú Registrar Producto crea el
FormProductos = New FrmProductos
FormProductos.Show()
End Sub.

'En caso de dar clic al submenú Registrar (Cliente)crea el
FormClientes.Show()
End Sub
End Class
9.4 Funcionalidad del formulario registro de clientes

El formulario para el registro de clientes presenta una pantalla en donde el usuario
tecleará los datos correspondientes, cuenta con los botones: Limpiar, el cual dejará todos
123
los controles con sus valores por defecto; Cancelar que cerrará el formulario y regresará
al formulario principal; y Enviar que creará un nuevo objeto del tipo Cliente con los datos
capturados, para después agregarlo a la colección cClientes.
Imports WindowsApplication5.Module1
Public Class FrmClientes
Private Sub BtnLimpiar_clic(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles BtnLimpiar.Click.
'En caso de dar clic en el botón Limpiar, invocamos al
procedimiento correspondiente:
LimpiarControles()
End Sub.
Private Sub BtnEnviar_clic(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles BtnEnviar.Click.
'En caso de dar clic en el botón Enviar se recuperan los
datos capturados se crea un objeto de tipo Cliente.
'Se agrega el nuevo objeto a la colección Clientes y se
restablecen los controles del formulario.
'Los valores de las 3 casillas de verificación (Check Box)

guardan en un
'arreglo de Boolean (true si tiene la tarjeta del banco,
false de otra forma).
Dim bancos(2) As Boolean
bancos(0) = ChkBanMex.Checked
bancos(1) = ChkBanSur.Checked
bancos(2) = ChkBancoMex.Checked
'Se invoca al constructor (vea la firma del constructor) de

Cliente.
'La fecha de nacimiento se guarda en un objeto
Date(YYYY,MM,DD).
'El sexo se guarda como un valor booleano 0=True=Masculino.
'Para el Estado en el que vive solo se pasa el indice
0=Aguascalientes,1=BajaCalifornia,etc.
CClientes.Add(New Cliente(TxtLogin.Text(),
TxtPassword.Text(), TxtNombre.Text(), TxtApellidos.Text(), New
Date(CmbAnio.SelectedItem, CmbMes.SelectedIndex,
CmbDia.SelectedIndex), RbtMasculino.Checked, TxtDireccion.Text(),
TxtCiudad.Text(), CmbEstado.SelectedIndex(), TxtCorreo.Text(),
TxtTelefono.Text(), TxtNumTarjeta.Text(), bancos))

'Al terminar se limpian los controles:

LimpiarControles()
End Sub
Private Sub Form2_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
'Al momento de cargarse el formulario Clientes (el método
Load se invoca automáticamente al crear el formulario).
'Mediante dos ciclos se agregan los elementos (ítems) de los
combos de Año y Día:
Dim Anio As Integer
Dim Dia As Integer
For Anio = 1930 To 2005
CmbAnio.Items.Add(Anio)
Next
For Dia = 1 To 31
CmbDia.Items.Add(Dia)
Next
End Sub
Private Sub BtnCancelar_clic(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles BtnCancelar.Click.
'En caso de dar clic en el botón Cancelar se cierra el
formulario Actual.
ActiveForm.Close()
End Sub
'Procedimiento para reestablecer y limpiar todos los controles
del formulario:
Sub LimpiarControles()
TxtLogin.Clear()
TxtPassword.Clear()
TxtNombre.Clear()
TxtApellidos.Clear()
CmbAnio.SelectedIndex = 1
CmbMes.SelectedIndex = 1
CmbDia.SelectedIndex = 1
RbtMasculino.Checked = False
RbtFemenino.Checked = False
TxtDireccion.Clear()
125
TxtCiudad.Clear()
CmbEstado.SelectedIndex = 1
TxtCorreo.Clear()
TxtTelefono.Clear()
TxtNumTarjeta.Clear()
ChkBanMex.Checked = False
ChkBanSur.Checked = False
ChkBancoMex.Checked = False
End Sub
End Class
9.5 Funcionalidad del formulario de registro de productos

El formulario para el registro de productos presenta una pantalla en donde el usuario
tecleará los datos correspondientes, cuenta con los botones: Limpiar, el cual dejará todos
los controles con sus valores por defecto; Cancelar que cerrará el formulario y regresará
al formulario principal; y Enviar que creará un nuevo objeto del tipo Producto con los
datos capturados, para después agregarlo a la colección cProductos.
Public Class FrmProductos:
Inherits System.Windows.Forms.Form.
Private Sub BtnCancelar_clic(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles BtnCancelar.Click.
'En caso de dar clic en el botón Cancelar se cierra el
formulario Actual:
ActiveForm.Close()
End Sub.
Private Sub BtnLimpiar_clic(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles BtnLimpiar.Clic.
'En caso de dar clic en el botón Limpiar, invocamos al
procedimiento correspondiente:
LimpiarControles()
End Sub.
Private Sub BtnRegistrar_clic(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles BtnRegistrar.Click.
'En caso de dar clic en el botón Registrar se recuperan los
datos capturados, se crea un objeto de de tipo Producto.
'Se agrega el nuevo objeto a la colección CProductos y se
restablecen los controles del formulario.

'Se invoca al constructor (vea la firma del constructor) de

Producto:
Dim nProducto As New Producto(TxtClave.Text,
CmbTipo.SelectedItem, TxtDescripcion.Text, TxtPrecio.Text,
TxtExistencias.Text)
'Se agrega el nuevo objeto nProducto a la colección
CProductos.Add(nProducto)
LimpiarControles()
End Sub
'Procedimiento para reestablecer y limpiar todos los controles
del formulario:
Sub LimpiarControles()
TxtClave.Clear()
TxtDescripcion.Clear()
TxtPrecio.Clear()
TxtExistencias.Clear()
CmbTipo.SelectedIndex = 0
End Sub
End Class
9.6 Funcionalidad del formulario de bienvenida (Autenticación)

El formulario de bienvenida presenta una pantalla en donde el usuario tecleará su clave y
su contraseña y al dar clic en el botón Enviar, empezará el proceso de validación, para
después buscarse en la colección cClientes por dicha clave; al momento de encontrarla
solicita la contraseña y la valida, en caso de estar correcta asigna la variable de sesión
en el formulario principal, con lo cual se autentica el usuario y se le muestra el formulario
desde el que podrá realizar un pedido, en caso de no ser correcta la contraseña, informa
al usuario de este hecho.
Imports WindowsApplication5.Module1.
Public Class FrmBienvenido.
Inherits System.Windows.Forms.Form.
'Declaramos las siguientes variables globales que hacen
referencia a los Formularios
Public FormPedidos As FrmPedidos
Public FormClientes As FrmClientes
Public FormPrincipal As FrmPrincipal
Private Sub BtnEnviar_click(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles BtnEnviar.Click.
127
'En caso de dar clic en el botón Enviar se validará la clave

del usuario,
'si encuentra su clave solicitará la contraseña para
validarla.
'Si no teclea la clave entonces..muestra un mensaje de

advertencia:
If TxtClave.Text = "" Then
MsgBox("Debes Teclear tu nombre de usuario")
Else
Dim i As Integer
Dim password As String
Dim encontrado As Boolean 'Bandera para saber si fue
encontrada la clave de usuario.
Dim nCliente As Cliente 'Declaración del objeto nCliente
del tipo CLiente que nos servirá como apuntador dentro de la
colección.
For Each nCliente In CClientes 'Bloque para buscar la
clave tecleada dentro de la colección.
If TxtClave.Text = nCliente.clavep Then 'Si la clave
tecleada es igual a la propiedad clave del objeto actual
encontrado = True
'Solicita el password, si coincide entonces..
If (InputBox("Inserta tu password", "Password",
"") = nCliente.contraseniap) Then.
'Coloca la variable de "sesion" Login con el
valor de la clave:
FrmPrincipal.IdLogin = TxtClave.Text.
'Cierra el formulario actual, Crea el
formulario pedidos y lo muestra:
Me.Close()
FormPedidos = New FrmPedidos
FormPedidos.Show()
Exit For
Else.
'Si la contraseña no coincide, muestra un
mensaje de advertencia y sale del bloque de búsqueda:
MsgBox("Contraseña incorrecta")
Exit For
End If

End If
Next.
'Si termina el bloque de búsqueda y no encontró la clave
del usuario, muestra un mensaje de advertencia:
If encontrado <> True Then
MsgBox("La clave de usuario no existe")
End If
End If
End Sub.
Private Sub BtnCerrar_click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles BtnCerrar.Click.
'En caso de dar clic en el botón Cerrar se cierra el
formulario Actual:
ActiveForm.Close()
End Sub.
Private Sub BtnRegistrarme_click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles BtnRegistrarme.Clic.
'En caso de dar clic en el botón Registrarme se cierra el
formulario actual yrecuperan los datos capturados, se crea un objeto
de tipo Cliente,
'se crea y muestra el formulario para el registro de
clientes:
ActiveForm.Close()
FormClientes.Show()
FormClientes.Activate()
End Sub
End Class
9.7 Funcionalidad del formulario de pedidos

El formulario de pedidos presenta una pantalla en donde el usuario una vez que ha sido
autentificado, podrá buscar productos por clave o por tipo (teclado, ratón, etc.); de tal
forma que al dar clic al botón Buscar, realizará la búsqueda sobre los objetos
almacenados en la colección cProductos, mostrándose los resultados en el control
ListView LvwBusqueda, del cual el usuario podrá seleccionar los que desea adquirir. Al
dar clic en el botón Comprar se agregarán al pedido y se visualizarán en el control
ListView LvwPedido; por último, al dar clic en el botón Terminar, se agregará cada una de
las ventas a la colección cVentas y el pedido a la colección cPedidos.
Public Class FrmPedidos
129
Private Sub BtnTipo_Click(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles BtnTipo.Click.
'En caso de dar clic,
'limpiamos los resultados de búsquedas anteriores:
LvwBusqueda.Items.Clear()
'Colocamos la bandera encontrado = false
Dim encontrado As Boolean = False
'Declaración del objeto nProducto del tipo Producto que nos
servirá como apuntador dentro de la colección:
Dim nProducto As Producto
'Bloque para iniciar la búsqueda por tipo de producto
seleccionado dentro de la colección Cproductos
For Each nProducto In Cproductos.
'Si el tipo de producto seleccionado es igual a la
propiedad tipo del objeto actual:
If CmbTipo.SelectedItem = nProducto.tipop Then
encontrado = True 'Cambiamos la bandera por que ya
se encontró.
'Creamos un arreglo de tipo String con el valor de
las propiedades del objeto encontrado,
'estas se mostrarán en el ListViewItem un objeto por
renglón y cada propiedad en una columna:
Dim ProductoEncontrado(2) As String
ProductoEncontrado(0) = nProducto.clavep
ProductoEncontrado(1) = nProducto.descripcionp
ProductoEncontrado(2) = nProducto.preciop
LvwBusqueda.Items.Add(New
ListViewItem(ProductoEncontrado))
End If
Next
If Not encontrado Then
MsgBox("Producto no encontrado")
End If
End Sub.
Private Sub BtnClave_Click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles BtnClave.Click.
'Limpiamos los resultados de búsquedas anteriores:
LvwBusqueda.Items.Clear()

'Colocamos la bandera encontrado = false

Dim encontrado As Boolean = False
'Declaración del objeto nProducto del tipo Producto que nos
servirá como apuntador dentro de la colección:
Dim nProducto As Producto
'Bloque para iniciar la búsqueda por tipo de producto
seleccionado dentro de la coleccion Cproductos:
For Each nProducto In CProductos
'Si la clave del producto tecleada es igual a la
propiedad clave del objeto actual:
If TxtClave.Text = nProducto.clavep Then
encontrado = True 'Cambiamos la bandera porque ya se
encontró.
'Creamos un arreglo de tipo String con el valor de
las propiedades del objeto encontrado,
'éstas se mostrarán en el ListViewItem un objeto por
renglón y cada propiedad en una columna:
Dim ProductoEncontrado(2) As String
ProductoEncontrado(0) = nProducto.clavep
ProductoEncontrado(1) = nProducto.descripcionp
ProductoEncontrado(2) = nProducto.preciop
LvwBusqueda.Items.Add(New
ListViewItem(ProductoEncontrado).
End If
Next
If Not encontrado Then
MsgBox("Producto no encontrado")
End If
End Sub
Private Sub FrmPedidos_Load(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles MyBase.Load.
'En caso de que no haya tecleado su usuario y contraseña
previamente:
If FrmPrincipal.IdLogin = "" Then
MsgBox("No has sido registrado")
Me.Close()
End If
131
End Sub
Private Sub BtnCancelar_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles BtnCancelar.Click
ActiveForm.Close()
End Sub
Private Sub BtnComprar_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles BtnComprar.Click.
'Objetos que representan un renglón del ListView con todas
sus columnas:
Dim elemento, elementoClonado As ListViewItem
Dim cantidad As String 'Guardar la cantidad que el usuario
desee del producto comprado.
Dim subtotal As Decimal 'Guarda el subtotal
precioproducto*cantidad.
'Por cada elemento seleccionado para ser comprado.
For Each elemento In LvwBusqueda.SelectedItems.
'1.-Clona el elemento en la lista de buscados ya que
solo así se puede agregar una copia
'identica a la lista de los comprados (LvwPedido)
elementoClonado = elemento.Clone.
'2.-Pregunta la cantidad que desea, por default muestra 1a
cantidad = InputBox("Cantidad", "Cantidad", "1").
'3.-Agrega el elemento clonado pero le pega al final la
cantidad que eligió el usuario.
LvwPedido.Items.Add(elementoClonado).SubItems().Add(cantidad).
'4.-Calcula el subtotal precioproducto*cantidad
subtotal = CDbl(elementoClonado.SubItems(2).Text()) *
CInt(elementoClonado.SubItems(3).Text).
'Actualiza el MontoTotal.
TxtMonto.Text = CInt(TxtMonto.Text) + subtotal
Next
End Sub
Private Sub BtnTerminar_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles BtnTerminar.Click.
Dim vendidoLista As ListViewItem 'Representa el elemento
vendido en la lista ListViewItem.
Dim vendidoVenta As Venta 'Representa el elemento vendido
como un objeto instancia de la clave Venta.

'El idUltimaVenta se incrementa de 1 en 1

Dim idUltimaVenta As Integer
'El idUltimoPedido se incrementa de 1 en 1
Dim idUltimoPedido As Integer = CPedidos.Count + 1
'Por cada elemento en la lista de vendidos que forman parte
del pedido Total
For Each vendidoLista In LvwPedido.Items
'1.-Calcula el id de esa venta
idUltimaVenta = CVentas.Count + 1
'2.-Crea el objeto Venta que su idVenta,IdPedido,
idProducto,Cantidad),
vendidoVenta = New Venta(idUltimaVenta, idUltimoPedido,
CInt(vendidoLista.SubItems(0).Text),
CInt(vendidoLista.SubItems(3).Text)).
'3.-Agrega la venta a la colección correspondiente
CVentas.Add(vendidoVenta)
Next.
'Crea el objeto Pedido con el idUltimoPedido,IdLogin con el
que se autentificó el usuario.
'DateFecha pedido igual a Date.Now (esta propiedad es
SHARED) hora y fecha actual del sistema.
'CurMonto el calculado en el cuadro de texto TxtMonto por
ser texto habrá que convertirlo a valor Decimal.
Dim pedido As Pedido = New Pedido(idUltimoPedido,
FrmPrincipal.IdLogin, Date.Now, CDec(TxtMonto.Text).
'Lo agrega a la colección
CPedidos.Add(pedido)
End Sub
End Class
133
Bibliografía
• Arnold y Gosling, 1997] Ken Arnold y James Gosling. Addison-Wesley/Domo.
El lenguaje de Programación Java.
Wesley Iberoamericana. 1997. 334 páginas.
(Muy básico, escrito por el desarrollador del lenguaje).
• [Liberty 2002] Liberty Jesse.
Learning Visual Basic .NET.
O’ Reylli. 2002.
• [Bembey. Kuiljit 2002] Bembey Pooja y Kaur Kuljit.
Proyectos Profesionales con Visual Basic .NET.
Anaya Multimedia.

UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO
DR. JOSÉ NARRO ROBLES
Rector
DR. SERGIO M. ALCOCER MARTÍNEZ DE CASTRO

Secretario General
MTRO. JOSÉ PÉREZ CASTAÑEDA

Secretario Administrativo
DRA. ROSAURA RUIZ GUTIÉRREZ

Secretaria de Desarrollo Institucional
MC. RAMIRO JESÚS SANDOVAL

Secretario de Servicios a la Comunidad
LIC. LUIS RAÚL GONZÁLEZ PÉREZ

Abogado General
DIRECCIÓN GENERAL DE SERVICIOS DE CÓMPUTO

ACADÉMICO
DR. IGNACIO DE JESÚS ANIA BRISEÑO
Director General
MAT. CARMEN BRAVO CHAVESTE

Directora de Cómputo para la Docencia
ACT. FABIÁN ROMO ZAMUDIO

Subdirector de Tecnología para la Educación
MTRO. JESÚS DÍAZ BARRIGA ARCEO

Subdirector de Planeación Académica
MTRA. HORTENSIA CANO GRANADOS

Coordinadora de Producción Académica
MTRA. ALEJANDRINA SAN JUAN REYES

Coordinadora del Centro de Extensión en
Cómputo y Telecomunicaciones Nuevo León
ING. SERGIO ALVA ARGUINZONIZ

Coordinador del Centro Mascarones
LIC. JOSÉ LUIS MEDINA FLORES

Coordinador del Centro Coapa de Extensión
en Cómputo y Telecomunicaciones
LIC. PATRICIA ROMERO ELÍAS

Coordinadora del Centro Educativo
Multidisciplinario Polanco
MTRA. ALMA IBARRA OBANDO

Coordinadora del Centro San Agustín
LIC. REBECA SÁNCHEZ ZALDIVAR

Responsable de los cursos de Cómputo
del Palacio de la Autonomía, Fundación UNAM
ING. PABLO DE LA O CRUZ

Coordinador del Centro Tlatelolco
DG TOÑA ZIMERMAN SONABEND

Jefa del Departamento de Diseño
Guías y Textos de Cómputo

Abril, 2008
Guías y Textos de Cómputo.
Fue editada por la Dirección General de Servicios
de Cómputo Académico y se terminó de imprimir en
abril de 2008, en los talleres de Impresos Azteca,
calle José T. Cuéllar 79 A, local A, Col. Obrera,
Cuauhtémoc, CP 06800, DF.
El cuidado de la edición estuvo a cargo

del Departamento de Diseño de la DGSCA, UNAM.
Se utilizaron tipos Futura Lt BT de 10/12, 8/10,

11/13 pts. y papel Bond de 90 grs. en interiores y
las portadas en cartulina Couché de 200 gr.
El tiraje consta de ¿??? ejemplares.

Lenguaje de Programacion Con Visual Basic NET

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Lenguaje de Programacion Con Visual Basic NET

Încărcat de

Drepturi de autor:

Formate disponibile

Rector

José Narro Robles

Guías y Textos de Cómputo. Lenguaje de programación Visual Basic .NET

DIRECCIÓN GENERAL DE SERVICIOS DE CÓMPUTO ACADÉMICO

1ª. edición 2008

Impreso y hecho en México

1. El .NET Framework .............................................................................................. 1

2. El entorno de desarrollo de Visual Studio .NET ..................................................... 16

2.3.3. Ventana de propiedades ....................................................................22

3. Sintaxis del lenguaje ...........................................................................................29

5. Uso de la programación orientada a objetos ........................................................64

II Dirección General de Servicios de Cómputo Académico

5.1. Creación de una clase................................................................................ 64

8. System Windows Forms ...................................................................................... 97

8.18. MainMenu (MenuStrip VB.NET 2005) .......................................................106

9. Desarrollo de un proyecto en Visual Basic.NET....................................................112

IV Dirección General de Servicios de Cómputo Académico

1.1 Conceptos generales

Aplicaciones del usuario

Marco de trabajo (.NET Framework)

Servidores .NET (.NET Enterprise Servers)

Figura 1. Elementos que conforman la plataforma .NET

Los objetivos de la plataforma .NET son:

2 Dirección General de Servicios de Cómputo Académico

1.2 Estructura de una aplicación .NET

Figura 2. Estructura de una aplicación en Visual Basic .NET

• Las instrucciones, por ejemplo System.Console.WriteLine("Hola Mundo")

4 Dirección General de Servicios de Cómputo Académico

1.3 El enfoque de construcción de software

1.3.1 Aplicaciones de consola

Figura 3. Aplicación de consola.

1.3.2 Aplicaciones para Windows

Figura 4. Aplicación gráfica para Windows.

6 Dirección General de Servicios de Cómputo Académico

1.3.3 Aplicaciones web (ASP.NET)

Figura 5. Una aplicación ASP .NET

1.4 Common Language Specification (CLS)

1.5 Common Type System (CTS)

Las funciones del CTS son las siguientes:

Figura 6. Clasificación de tipos para el .NET Framework.

1.6 Administración de memoria automática

1.7 Modelo de seguridad

8 Dirección General de Servicios de Cómputo Académico

Modelo de seguridad de .NET Framework

Seguridad basada en acceso al código Seguridad basada en roles

Figura 7. Modelo de seguridad de .NET Framework.

• Los servicios web: permitirán comunicarnos a través de Internet entre diferentes

1.8.1 Microsoft Intermediate Language (MSIL)

1.8.2 Just-in Time (JIT) Compiler

Código Fuente Con VB 6 el código es

Compilador de Instrucciones de una

Antes de ejecutar una

Compilador de MSIL Interprete Instrucciones de una

Figura 8.Comparación del proceso de compilación de .NET y VB 6

10 Dirección General de Servicios de Cómputo Académico

1.8.3 CLR (Common Language Runtime)

Figura 9. Diagrama del marco de trabajo .NET

La siguiente figura muestra a detalle la estructura del CLR.

Figura 10. Entorno común de ejecución para lenguajes (CLR)

A continuación se describe el funcionamiento del CLR:

Figura 11. Diagrama del funcionamiento del CLR.

12 Dirección General de Servicios de Cómputo Académico

1.8.4 La biblioteca de clases (.NET Framework Class Library)