Professional Documents
Culture Documents
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.
Contenido
I
Tomás Gregorio Serrano Escamilla
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
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
III
Tomás Gregorio Serrano Escamilla
Bibliografía ..........................................................................................................134
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
Tomás Gregorio Serrano Escamilla
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.
1
Para mayor información consulte la página oficial del proyecto http://www.mono-project.com
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
Tomás Gregorio Serrano Escamilla
Solución
Proyecto Proyecto
Archivo(s) Archivo(s)
Modulo/Clase/NameSpace Modulo/Clase/NameSpace
Procedimiento(s) Procedimiento(s)
Instrucción(es) Instrucción(es)
• Los proyectos, por ejemplo HolaMundo están vinculados a una solución, por
ejemplo HolaMundo.
3
http://www.springframework.net/
4
http://msdn.microsoft.com/practices/compcat/default.aspx?pull=/library/en-
us/dnpag/html/uipab.asp
5
Tomás Gregorio Serrano Escamilla
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.
5
http://mavnet.sourceforge.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.
7
Tomás Gregorio Serrano Escamilla
Predefinidos
VALOR
Usuario
Enumeraciones
Interfases De usuario
Auto Descriptivos Clases Boxed
REFERENCIA
Arrays Delegados
Punteros
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
Tomás Gregorio Serrano Escamilla
11
Tomás Gregorio Serrano Escamilla
6
Imagen tomada de http://www.desarrolloweb.com/articulos/1328.php
13
Tomás Gregorio Serrano Escamilla
15
Tomás Gregorio Serrano Escamilla
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
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
Video Monitor súper VGA (800 x 600) con 256 colores o de alta resolución.
17
Tomás Gregorio Serrano Escamilla
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:
1
2
3
4
5
6
7 8 9
10
11
12
14 15
13
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).
19
Tomás Gregorio Serrano Escamilla
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.
1 2 3 4 5
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.
Una solución
Un proyecto contiene::
contiene proyectos.
21
Tomás Gregorio Serrano Escamilla
23
Tomás Gregorio Serrano Escamilla
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.
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.
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.
25
Tomás Gregorio Serrano Escamilla
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
27
Tomás Gregorio Serrano Escamilla
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
Tomás Gregorio Serrano Escamilla
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.
31
Tomás Gregorio Serrano Escamilla
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
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
Tomás Gregorio Serrano Escamilla
• 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.
Boolean System.Boolean 16 bits Almacena datos que pueden tomar valor True o False.
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.
35
Tomás Gregorio Serrano Escamilla
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.
37
Tomás Gregorio Serrano Escamilla
• 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..
39
Tomás Gregorio Serrano Escamilla
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
41
Tomás Gregorio Serrano Escamilla
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.
Categoría Operadores
Exponenciación (^)
=, <>, <, <=, >, >=, Like, Is, TypeOf...Is (Tienen la misma
Comparación
precedencia).
Negación (Not)
43
Tomás Gregorio Serrano Escamilla
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
Tomás Gregorio Serrano Escamilla
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.
47
Tomás Gregorio Serrano Escamilla
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.
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
Tomás Gregorio Serrano Escamilla
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
51
Tomás Gregorio Serrano Escamilla
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)
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
Tomás Gregorio Serrano Escamilla
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
55
Tomás Gregorio Serrano Escamilla
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
57
Tomás Gregorio Serrano Escamilla
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
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
Tomás Gregorio Serrano Escamilla
Siguiente instrucción
a ejecutar
Ventanas de depuración
(activada variables locales)
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.
61
Tomás Gregorio Serrano Escamilla
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
se muestra a continuació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
se muestra a continuació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:
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
Tomás Gregorio Serrano Escamilla
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.
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.
65
Tomás Gregorio Serrano Escamilla
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
67
Tomás Gregorio Serrano Escamilla
Por ejemplo, para la clase Persona declararíamos un procedimiento Property por cada
una de sus propiedades, como se muestra a continuación:
Public Class Persona
Private sNombreCompleto As String
Private dateFechaNacimiento As Date
Private Shared sEspecie As String=“Homo Sapiens”
‘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
Get ‘bloque para devolver el valor de la propiedad
Return sNombreCompleto
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:
69
Tomás Gregorio Serrano Escamilla
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
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
71
Tomás Gregorio Serrano Escamilla
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:
Public Class Persona
Private sNombreCompleto As String
Private dateFechaNacimiento As Date
Private Shared sEspecie As String=“Homo Sapiens”
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:
Public Class Persona
Private sNombreCompleto As String
Private dateFechaNacimiento As Date
Private Shared sEspecie As String=“Homo Sapiens”
‘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)
sNombreCompleto=Nombre
dateFechaNacimiento = #10/21/1983#
End Sub
‘Constructor vacío asigna valores por defecto (definidos por
el programador) a ambas propiedades
Public Sub New()
sNombreCompleto=””
dateFechaNacimiento = #10/21/1983#
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.
73
Tomás Gregorio Serrano Escamilla
‘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.
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
Tomás Gregorio Serrano Escamilla
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.
77
Tomás Gregorio Serrano Escamilla
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.
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
Get 'bloque para devolver el valor de la propiedad
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
Tomás Gregorio Serrano Escamilla
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.
11
En este caso nos referimos a los métodos Property, no a las variables miembro también
llamadas algunas veces propiedades o atributos.
Figura 22. Diagrama de clases mostrando la generalización de Circulo y Cuadrado hacia Figura
81
Tomás Gregorio Serrano Escamilla
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.
83
Tomás Gregorio Serrano Escamilla
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
'PROPOERTY's
Public Property lado() As Double
Get
Return dLado
End Get
Set(ByVal value As Double)
Me.dLado = value
End Set
End Property
'calculaArea: Método de auxiliar, calcula el área de la
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
'DespliegaDatos: Método de implementación, muestra un mensaje
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
85
Tomás Gregorio Serrano Escamilla
calculaArea()
End Sub
'PROPOERTY's
Public Property radio() As Double
Get
Return dRadio
End Get
Set(ByVal value As Double)
Me.dRadio = value
End Set
End Property
'calculaArea: Método de auxiliar, calcula el área de la
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
'DespliegaDatos: Método de implementación, muestra un mensaje
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:
Public Overrides Sub despliegaDatos()
MsgBox("Mis coordenadas x,y son: " & x & "," & y & "Mi
radio es: " & radio)
End Sub
End Class
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.
87
Tomás Gregorio Serrano Escamilla
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
89
Tomás Gregorio Serrano Escamilla
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:
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
Public MustInherit Class Figura
Protected dX As Double
Protected dY As Double
91
Tomás Gregorio Serrano Escamilla
93
Tomás Gregorio Serrano Escamilla
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.
95
Tomás Gregorio Serrano Escamilla
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.
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
Tomás Gregorio Serrano Escamilla
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:
• Name: indica el nombre para identificar el objeto dentro del código.
• BackColor: color de fondo utilizado para mostrar texto y gráficos en el control.
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:
• Name: indica el nombre para identificar el objeto dentro del código.
• BackColor: color de fondo utilizado para mostrar texto y gráficos en el control.
• CausesValidation: indica si este control causa y genera eventos de validación.
• 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.
• 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.
• Size: tamaño del control en pixeles.
• 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.
Entre sus métodos más representativos se encuentran:
• 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
Tomás Gregorio Serrano Escamilla
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:
• Name: indica el nombre para identificar el objeto dentro del código.
• BackColor: color de fondo utilizado para mostrar texto y gráficos en el control
• 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.
• TabIndex: indica el orden de tabulación que ocupará este control, cuando usted
presione la tecla tab estando dentro del control se moverá al índice siguiente.
• Text: indica el texto contenido dentro del control.
• Visible: determina si el control está visible u oculto.
Entre sus métodos más representativos se encuentran:
• 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
representativas se encuentran:
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:
• Name: indica el nombre para identificar el objeto dentro del código.
• Checked: indica si el botón de opción esta activado o no.
• Enabled: indica si el control está 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.
• TabIndex: indica el orden de tabulación que ocupará este control, cuando usted
presione la tecla tab estando dentro del control, se moverá al índice siguiente.
• Text: indica que se mostrara junto al control.
• Visible: determina si el control está visible u oculto.
Entre sus métodos más representativos se encuentran:
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.
• Name: indica el nombre para identificar el objeto dentro del código.
• Checked: indica si el botón de opción está activado o no.
101
Tomás Gregorio Serrano Escamilla
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.
• Name: indica el nombre para identificar el objeto dentro del código.
• 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.
• 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.
• Sorted: especifica si están ordenados los elementos del cuadro combinado.
• TabIndex: indica el orden de tabulación que ocupará este control, cuando usted
presione la tecla tab estando dentro del control, se moverá al índice siguiente.
• Ítems: colección conteniendo los elementos del cuadro combinado.
• Visible: determina si el control está visible u oculto.
Entre sus métodos más representativos se encuentran:
• 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:
• Name: indica el nombre para identificar el objeto dentro del código.
• Data Source: indica la lista que el control utiliza para obtener sus elementos.
• Enabled: indica si el control está 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.
• 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.
• TabIndex: indica el orden de tabulación que ocupará este control, cuando usted
presione la tecla tab estando dentro del control, se moverá al índice siguiente.
• Ítems: colección conteniendo los elementos del cuadro de lista.
• Visible: determina si el control está visible u oculto.
Entre sus métodos más representativos se encuentran:
• Property SelectedIndex: obtiene o establece el índice que especifica el elemento
seleccionado actualmente.
• Property de solo lectura SelectedIndices: obtiene una colección con los índices
seleccionados actualmente.
• Property SelectedItem: obtiene o establece el elemento seleccionado actualmente.
• Property de solo lectura SelectedItems: obtiene una colección con los elementos
seleccionados actualmente.
• Evento SelectedIndexChanged: se invoca cuando cambia de estado.
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:
• Name: indica el nombre para identificar el objeto dentro del código.
• 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.
103
Tomás Gregorio Serrano Escamilla
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.
Entre sus métodos más representativos se encuentran:
• 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
representativas se encuentran:
• Name: indica el nombre para identificar el objeto dentro del código.
• Check On Click: indica si la casilla debe cambiar su estado al hacer clic por primera
vez en el elemento.
• Enabled: indica si el control está 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.
• Sorted: especifica si están ordenados los elementos del cuadro de lista.
• TabIndex: indica el orden de tabulación que ocupará este control, cuando usted
presione la tecla tab estando dentro del control, se moverá al índice siguiente.
• Ítems: colección conteniendo los elementos del cuadro de lista.
• Visible: determina si el control está visible u oculto.
Entre sus métodos más representativos se encuentran:
• Property SelectedIndex: obtiene o establece el índice que especifica el elemento
seleccionado actualmente.
• Property de solo lectura SelectedIndices: obtiene una colección con los índices
seleccionados actualmente.
• Property SelectedItem: obtiene o establece el elemento seleccionado actualmente.
• Property de solo lectura Selectedtems: obtiene una colección con los elementos
seleccionados actualmente.
• Evento SelectedIndexChanged: se invoca cuando cambia de estado.
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:
• Name: indica el nombre para identificar el objeto dentro del código.
• 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.
• Location: posición de la esquina superior izquierda del control respecto del contenedor.
• Visible: determina si el control está visible u oculto.
• Locked: determina si se puede mover o cambiar el tamaño del control en vista de diseño.
• 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.
• Name: indica el nombre para identificar el objeto dentro del código.
• 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:
• Name: indica el nombre para identificar el objeto dentro del código.
• Aligment: determina la posición de las fichas.
105
Tomás Gregorio Serrano Escamilla
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
representativas se encuentran:
• Name: indica el nombre para identificar el objeto dentro del código.
• 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)
Entre sus métodos más representativos se encuentran:
• 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.
• Name: indica el nombre para identificar el objeto dentro del código.
• 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).
Entre sus métodos más representativos se encuentran:
• Método PerformStep(): método que puede invocar para avanzar la cantidad indicada
por Step.
107
Tomás Gregorio Serrano Escamilla
• 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.
109
Tomás Gregorio Serrano Escamilla
111
Tomás Gregorio Serrano Escamilla
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.
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
Tomás Gregorio Serrano Escamilla
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
Tomás Gregorio Serrano Escamilla
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.
117
Tomás Gregorio Serrano Escamilla
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
119
Tomás Gregorio Serrano Escamilla
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.
'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 IdVenta As Integer
Private IdPedido As Integer
Private IdProducto As Integer
Private IntCantidad As Integer
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
121
Tomás Gregorio Serrano Escamilla
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.
End Sub
123
Tomás Gregorio Serrano Escamilla
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
Inherits System.Windows.Forms.Form
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.
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
Tomás Gregorio Serrano Escamilla
TxtCiudad.Clear()
CmbEstado.SelectedIndex = 1
TxtCorreo.Clear()
TxtTelefono.Clear()
TxtNumTarjeta.Clear()
ChkBanMex.Checked = False
ChkBanSur.Checked = False
ChkBancoMex.Checked = False
End Sub
End Class
Inherits System.Windows.Forms.Form.
End Class
127
Tomás Gregorio Serrano Escamilla
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 = New FrmClientes
FormClientes.Show()
FormClientes.Activate()
End Sub
End Class
129
Tomás Gregorio Serrano Escamilla
Inherits System.Windows.Forms.Form
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()
End Sub
131
Tomás Gregorio Serrano Escamilla
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
133
Tomás Gregorio Serrano Escamilla
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.