lenguaje de programacion con visual basic net

Rector José Narro Robles

Secretario General Sergio M. Alcocer Martínez de Castro

Director General de Servicios de Cómputo Académico Ignacio J. Ania Briseño

Directora de Cómputo para la Docencia Carmen Bravo Chaveste

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

Coordinación de la publicación María Guadalupe Izquierdo Dyrzo

Autor Tomás Gregorio Serrano Escamilla

Revisión técnica Juana Figueroa Reséndiz

Corrección de estilo Gabriela Seoane San Martín Martha Patricia García Morales

Diseño editorial Gabriela Lili Morales Naranjo

Diseño de portada María Cristina Gispert Galván

Editor DR © Universidad Nacional Autónoma de México Ciudad Universitaria, Coyoacán, CP. 04510, México, DF.

DIRECCIÓN GENERAL DE SERVICIOS DE CÓMPUTO ACADÉMICO Circuito exterior s/n, Ciudad Universitaria, Coyoacán, CP. 04510, México DF.

Prohibida la reproducción total o parcial por cualquier medio sin la autorización escrita del titular de los derechos patrimoniales

1ª. edición 2008 ISBN XXXXXXX

Impreso y hecho en México

Lenguaje de programación Visual Basic .NET

I

Contenido

1. El .NET Framework .............................................................................................. 1 1.1. Conceptos generales .................................................................................... 1 1.2. Estructura de una aplicación .NET ................................................................. 4 1.3. El enfoque de construcción de software .......................................................... 5

1.3.1. Aplicaciones de consola...................................................................... 6 1.3.2. Aplicaciones para Windows................................................................. 6 1.3.3. Aplicaciones web (ASP.NET) ................................................................ 7

1.4. Common Language Specification (CLS).......................................................... 7 1.5. Common Type System (CTS).......................................................................... 7 1.6. Administración de memoria automática ......................................................... 8 1.7. Modelo de seguridad ................................................................................... 8 1.8. Componentes .............................................................................................. 9

1.8.1. Microsoft Intermediate Language (MSIL).............................................. 10 1.8.2. Just-in Time (JIT) Compiler................................................................. 10 1.8.3. CLR (Common Language Runtime)..................................................... 11 1.8.4. La biblioteca de clases (.NET Framework Class Library) ........................ 13

1.9. Ensamblados (Assemblies)........................................................................... 14 1.10. Espacios de nombres ................................................................................ 15

2. El entorno de desarrollo de Visual Studio .NET ..................................................... 16 2.1. Estructura de una solución .......................................................................... 17 2.2. Estructura de un proyecto............................................................................ 17

2.2.1. Ejecución de Visual Studio .NET......................................................... 18 2.2.2. Creación de una solución y un proyecto ............................................. 19

2.3. El explorador de soluciones......................................................................... 20 2.3.1. Estructura de una solución y un proyecto ............................................ 21 2.3.2. Cuadro de herramientas ................................................................... 22

Tomás Gregorio Serrano Escamilla

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

2.3.3. Ventana de propiedades ....................................................................22 2.3.4. El editor de código ............................................................................23 2.3.5. Intellisense ........................................................................................24

2.4. La vista de clases.........................................................................................24 2.5. El sistema de ayuda.....................................................................................25 2.6. Personalización del IDE................................................................................26

3. Sintaxis del lenguaje ...........................................................................................29 3.1. Convenciones del lenguaje ..........................................................................30 3.2. Variables y tipos de datos ............................................................................31 3.3. Tipos de datos elementales (enteros, no enteros, caracter, lógico, fecha) .........33 3.4. Tipos de datos compuestos (enumeraciones, estructuras y matrices).................35 3.5. Literales y constantes ...................................................................................37 3.6. Alcance de las variables...............................................................................38 3.7. Tipos de acceso (visibilidad de las propiedades) ............................................39 3.8. Conversión entre tipos de datos....................................................................40 3.9. Funciones de conversión..............................................................................40 3.10. Operadores y precedencia.........................................................................42 3.11. Estructuras de decisión...............................................................................43

3.11.1. If...Then…Else.................................................................................44 3.11.2. Select...Case ...................................................................................45

3.12. Estructuras de ciclo....................................................................................46 3.12.1. While .............................................................................................46 3.12.2. Do...Loop .......................................................................................46 3.12.3. For...Next .......................................................................................47 3.12.4. For each Next .................................................................................47

3.13. Funciones y procedimientos .......................................................................48 3.13.1. Crear e invocar procedimientos ........................................................48 3.13.2. Paso de argumentos a procedimientos ..............................................51

3.14. Colecciones..............................................................................................54

4. Manejo de excepciones.......................................................................................55 4.1. La clase Exception .......................................................................................55 4.2. Generación de excepciones .........................................................................57 4.3. Try… Catch ................................................................................................57 4.4. Errores lógicos y depuración ........................................................................59

4.4.1. Ejecución del código paso a paso.......................................................60 4.4.2. Puntos de Interrupción .......................................................................61 4.4.3 Puntos de interrupción condicionales....................................................61

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


III

5.1. Creación de una clase................................................................................ 64 5.2. Agregar un módulo de clase ....................................................................... 65 5.3. Definir propiedades de la clase. .................................................................. 66 5.4. Propiedades compartidas............................................................................ 66 5.7. Visibilidad de las propiedades ..................................................................... 67 5.8. Definición de métodos ................................................................................ 69 5.9. Métodos compartidos ................................................................................. 70 5.10. Definición del constructor.......................................................................... 71 5.11. Definición del destructor ........................................................................... 73 5.12. Objetos basados en clases (referencias) ..................................................... 75 5.13 Vinculación temprana y tardía .................................................................... 76

6. Herencia ........................................................................................................... 77 6.1. Clase base y subclases ............................................................................... 77 6.2. Reemplazo de métodos de la clase base ...................................................... 80 6.3. La palabra clave MyBase ............................................................................ 86 6.4. La palabra clave MyClass ........................................................................... 87 6.5. Interfases ................................................................................................... 91

7. Polimorfismo ..................................................................................................... 95 7.1. Polimorfismo mediante herencia .................................................................. 95 7.2. Polimorfismo mediante interfases ................................................................. 96

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


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

8.18. MainMenu (MenuStrip VB.NET 2005) .......................................................106 8.19. ToolBar (ToolStrip VB.NET 2005)..............................................................107 8.20. StatusBar(StatusStrip VB.NET 2005) ..........................................................107 8.21. InputBox y MsgBox ..................................................................................107

9. Desarrollo de un proyecto en Visual Basic.NET....................................................112 9.1. Clases: Cliente, Producto, Pedido y Venta ...................................................112 9.2. Módulo con las colecciones de clientes, productos, pedidos y ventas.............121 9.3. Funcionalidad del formulario principal ........................................................122 9.4. Funcionalidad del formulario registro de clientes..........................................123 9.5. Funcionalidad del formulario de registro de productos .................................126 9.6. Funcionalidad del formulario de bienvenida (Autenticación)..........................127 9.7. Funcionalidad del formulario de pedidos ....................................................129

Bibliografía ..........................................................................................................134


1

CAPÍTULO

El .NET Framework

Visual Basic .NET es un lenguaje de programación orientado a objetos diseñado por Microsoft, cuyo antecesor es el Visual Basic que apareció en 1991, el cual fue a su vez una evolución de un lenguaje llamado QuickBasic que nació con la idea de ser un lenguaje muy sencillo de utilizar comparado con sus homólogos de ese entonces. Es un lenguaje ampliamente utilizado para el desarrollo de aplicaciones Windows, que cuenta con características como la herencia, el polimorfismo, control estructurado de excepciones y creación de aplicaciones con múltiples hilos de ejecución, además de tener disponible una amplia librería de objetos para el desarrollo de aplicaciones Windows y de aplicaciones web, así como incorporar servicios web para permitir la interoperabilidad entre diferentes tecnologías.

Visual Basic .NET forma parte de la plataforma .NET de Microsoft. En este capítulo describiremos qué es la plataforma .NET y los elementos que la integran, poniendo especial atención a su principal componente: el marco de trabajo .NET (.NET Framework).

1.1 Conceptos generales

La plataforma .NET es un estándar proporcionado por Microsoft para desarrollar aplicaciones web y para Windows, que permite utilizar diversos lenguajes (Visual Basic .NET, Visual C++, Visual C#, entre otros) para desarrollar una misma aplicación.

La plataforma .NET representa todo un rango de tecnologías y conceptos como se muestra en la siguiente figura.

Aplicaciones del usuario Son las aplicaciones .NET cuyo soporte para su desarrollo y ejecución es proporcionada por el .NET Framework.

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


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

Servidores .NET (.NET Enterprise Servers) Windows, BizTalk, Exchange, SQL, Application Center Diseñados para proveer los servicios básicos para sus aplicaciones .NET (Sistema Operativo, Bases de datos, Correo Electrónico, Servicios XML etcétera).

Dispositivos .NET Dispositivos desde los que se accederá a su aplicación .NET, es la combinación de hardware (PCs, PDAs, Smart Clients, NoteBooks, etc.) y software (Windows 9x, ME, 2000, XP, CE, etcétera).

Componentes de hardware Las aplicaciones .NET se pueden ejecutar en diversas plataformas de hardware sin necesidad de realizarles cambio alguno.

Figura 1. Elementos que conforman la plataforma .NET

Los objetivos de la plataforma .NET son:

• Independencia del lenguaje: la plataforma .NET permite desarrollar soluciones conformadas por proyectos codificados con lenguajes de programación distintos (Visual Basic, C#, Visual C++, entre otros), es decir, con .NET usted puede programar aplicaciones sin depender de un lenguaje y mejor aun puede combinar diversos lenguajes. Una de las ventajas de lo anterior es, que dentro de los equipos de desarrollo, algunos integrantes podrían elegir a Visual Basic .NET como el lenguaje más adecuado para desarrollar ciertos componentes de la aplicación y ensamblarlos junto con otros proyectos desarrollados por otro grupo de trabajo utilizando un lenguaje distinto.

• Independencia de la plataforma (hardware/software): la plataforma .NET de Microsoft permite desarrollar aplicaciones independientes de hardware pero no totalmente independientes con respecto al software, esto se debe a que la librería de clases base (BCL) del .NET Framework de Microsoft sólo fue implementada para ejecutarse bajo los sistemas operativos Windows, es decir, las aplicaciones desarrolladas pueden ejecutarse en Pcs, NoteBooks, PDAs, Pocket Pcs, Smart Phone’s, XBox, Tablet PCs, Hand Helds, etc., sólo si estos equipos cuentan con los sistemas operativos de Microsoft (Windows 9x, Windows CE, Windows Mobile, Windows ME, Windows XP, Windows NT, Windows 2000, Windows 2003, etcétera).

Existe un proyecto Open Source denominado MONO1 que posee herramientas libres similares a las de .NET de Microsoft, entre las características de MONO V 1.2 están:

o Un entorno común de ejecución CLR parecido al de .NET Framework de Microsoft, con recolector de basura, un cargador de clases y un compilador JIT (Just In Time).

1 Para mayor información consulte la página oficial del proyecto http://www.mono-project.com


3

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



1.2 Estructura de una aplicación .NET

Conocer la estructura general de una aplicación Visual Basic .NET le servirá como modelo, debido a que esta estructura es la que deberá seguir. El siguiente ejemplo muestra el código fuente de una sencilla aplicación de consola que despliega el mensaje “Hola Mundo”.

Module ModuloHola

Sub Main()

System.Console.WriteLine("Hola Mundo")

End Sub

End Module

El siguiente diagrama muestra la estructura de una aplicación en Visual Basic .NET:

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

• Las instrucciones, por ejemplo System.Console.WriteLine("Hola Mundo") deben estar dentro de un procedimiento (bloque Sub - End Sub), por ejemplo de Main (para las aplicaciones de consola, es necesario el método Main ya que es el primero que se ejecuta).

• Los procedimientos, por ejemplo Main deben estar declarados dentro de una clase (bloque Class-End Class), Modulo (bloque Module-End Module) o Espacio de Nombres (bloque Namespace-End Namespace), por ejemplo el módulo ModuloHola.

• Las clases y módulos, por ejemplo ModuloHola deben estar declaradas dentro de un archivo, por ejemplo HolaMundo.vb.

• Los archivos, por ejemplo HolaMundo.vb, se integran dentro de un proyecto, por ejemplo HolaMundo.

Solución

Proyecto

Archivo(s)

Modulo/Clase/NameSpace

Procedimiento(s)

Instrucción(es)

Proyecto

Archivo(s)

Modulo/Clase/NameSpace

Procedimiento(s)

Instrucción(es)


5

• Los proyectos, por ejemplo HolaMundo están vinculados a una solución, por ejemplo HolaMundo.

1.3 El enfoque de construcción de software

Dentro de los modelos más utilizados para el desarrollo del software con .NET está el modelo en capas, ya que gran parte de las herramientas y tecnologías proporcionadas por .NET se basan en él. Dentro del modelo en capas existen distintas arquitecturas, por lo que es importante analizar y elegir la más conveniente dependiendo del tipo de problema, como se describe a continuación.

Una aplicación de dos capas puede consistir en un programa cliente con una interfaz gráfica de usuario (presentación) conectada directamente a un servidor de base de datos (acceso a datos), es decir, sin capas intermedias, esta arquitectura es utilizada en aplicaciones pequeñas, pero cuando éstas crecen presenta problemas, debido a que cualquier modificación en las reglas de negocio ocasiona cambios en cada uno de los clientes, dificultando su mantenimiento y modificación.

Una aplicación de tres capas introduce una capa intermedia entre el cliente y la base de datos, denominada capa de negocios, con lo que se elimina el problema anterior. A continuación se describen cada una de estas capas:

• Capa de presentación: es la interfaz de la aplicación hacia los usuarios, por ejemplo ventanas o páginas web (Windows Forms, formularios ASP o páginas HTML).

• Capa de negocio: contiene la lógica de la aplicación, por ejemplo si el usuario selecciona en la capa de presentación, visualizar todos los registros de la base de datos que cumplan con cierto criterio, esta capa se encarga de recoger el criterio seleccionado en la capa de presentación y crea la cadena de conexión a la base de datos con la consulta adecuada. Dentro de estas capas también se agrupan herramientas de administración de procesos, como BizTalk, y servicios como: correo electrónico (Exchange Server), Servidor Web (IIS), Servicios XML, etc. , lo que permite que la conexión por parte del usuario pueda realizarse desde cualquier ubicación independizando los componentes que realizan el acceso a los datos.

• Capa de acceso de datos: está relacionada directamente con el origen de datos, por ejemplo una base de datos y un sistema manejador como SQL Server.

La arquitectura de N capas se diferencia, en tanto introduce una capa por cada regla de negocio distinta, esta es la arquitectura más general y más conveniente para aplicaciones de gran tamaño, pero también requieren de mayor conocimiento por parte de los desarrolladores, así como más tiempo en el proceso de desarrollo.

Otro modelo muy conocido en la actualidad es MVC (Modelo-Vista-Controlador) que también es soportado por .NET y existen algunos frameworks que facilitan su implementación como: Spring .NET3, User Interface Process (UIP) Application Block4 y

3 http://www.springframework.net/ 4 http://msdn.microsoft.com/practices/compcat/default.aspx?pull=/library/en-

us/dnpag/html/uipab.asp



Maverick .NET5 entre otros. MVC es una arquitectura muy parecida al modelo en capas que separa los datos de la aplicación en las siguientes partes:

• Modelo: representa el origen de datos y la lógica de los mismos.

• Vista: es la interfaz de la aplicación con el usuario.

• Controlador: es quien recibe las instrucciones a través de la capa de vista y controla la lógica de la aplicación, accediendo y modificando los datos o regresando los resultados a la capa de vista para que sean presentados al usuario.

Ahora hablaremos del enfoque que .NET tiene respecto a los distintos tipos de aplicaciones que puede desarrollar.

Con .NET Framework usted puede desarrollar distintos tipos de aplicaciones.

• Aplicaciones de consola para Windows.

• Aplicaciones gráficas para Windows.

• Aplicaciones gráficas para web.

1.3.1 Aplicaciones de consola

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

Figura 3. Aplicación de consola.

1.3.2 Aplicaciones para Windows

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

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

5 http://mavnet.sourceforge.net/


7

1.3.3 Aplicaciones web (ASP.NET)

Una aplicación web es desarrollada en el lenguaje de programación ASP.NET, se ejecuta en un servidor web y se visualiza a través de un navegador web (IE, Mozilla Firefox, Netscape, etcétera).

Figura 5. Una aplicación ASP .NET

El software construido mediante .NET puede ser más fácil de emplear y mantener ya que cuenta con diversos servicios que proporcionan las herramientas de Microsoft.

1.4 Common Language Specification (CLS)

CLS es una especificación y define las reglas que los lenguajes y los desarrolladores deben cumplir para que las aplicaciones y componentes creados sean compatibles con otros lenguajes de .NET; el código creado en cualquiera de estos lenguajes es compilado verificando las reglas del CLS y generando el código MSIL (Microsoft Intermediate Language) que será compatible con el CLR, lo que permite a los desarrolladores crear aplicaciones sabiendo que no habrá ninguna incompatibilidad al integrar los diferentes lenguajes .NET.

Para crear componentes compatibles con CLS se requiere lo siguiente:

• Seguir las reglas definidas en la especificación del CLS que se encuentran en la siguiente liga http://msdn.microsoft.com/netframework/ecma/.

• Marcar el código que se compartirá como compartible a través del atributo CLSCompliantAttribute.

Solo necesita cumplir estas reglas si desea que los tipos sean accesibles externamente, y no para los privados. A los componentes que cumplen las reglas de CLS y únicamente usan características de CLS, se les conoce como componentes compatibles con CLS.

1.5 Common Type System (CTS)

Los tipos comunes son implementaciones de clases, interfases, estructuras, etc. ya sea que estén incluidas en la BCL o hayan sido creadas por el programador.

El Common Type System (CTS) o Sistema de Tipo Común define los tipos que aceptará el CLR (Common Language Runtime); aunque cada lenguaje tiene su propia sintaxis para definir tipos, por ejemplo, una variable entera en C# se declara con int y en Visual Basic con Integer, existe una sola clase llamada System.Int32 que las interpretará y el código MSIL resultante debe cumplir las reglas del CTS.



Las funciones del CTS son las siguientes:

• Adaptarse automáticamente para integrar el código de distintos lenguajes.

• Optimizar el código en ejecución.

• Proporcionar un modelo de tipos orientado a objetos, que soporta múltiples lenguajes.

• Especificar las reglas que los lenguajes seguirán para asegurar la intercomunicación.

• Encapsular las estructuras de datos.

• Invocar revisiones de seguridad.

El Sistema de Tipo Común está organizado con base en los tipos que se muestran en el siguiente diagrama:

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

1.6 Administración de memoria automática

Es uno de los servicios que proporciona el CLR durante la ejecución de un programa a través del “recolector de basura” que asigna y libera la memoria de forma automática. Cuando el “recolector de basura” detecta que un objeto ya no será utilizado (es decir, que ya no hay variables haciendo referencia a él) dentro de un programa, lo elimina y libera la memoria.

La principal ventaja del recolector de basura es evitar al programador la tediosa tarea de solicitar memoria y liberarla, eliminando los problemas que existían cuando olvidaba realizar estas tareas, como: pérdida de información o el intento de acceder a un objeto que ya ha sido liberado.

1.7 Modelo de seguridad

La seguridad en .NET tiene que ver con controlar el acceso a los recursos de la aplicación como: componentes, datos y hardware, utilizando alguna de las siguientes formas:

• Seguridad de acceso al código (CAS).

• Seguridad basada en roles o funciones (RBS).

Clases

Arrays

De usuario

Boxed

Delegados

Interfases

Predefinidos

VALOR Usuario

Enumeraciones

REFERENCIA Auto Descriptivos

Punteros


9

Figura 7. Modelo de seguridad de .NET Framework.

CAS controla lo que el código puede y no puede hacer basado en los siguientes esquemas:

• Permisos: el CLR puede permitir o denegar algunos permisos al código, cada permiso deriva de la clase System.Security.CodeAccessPermission.

• Conjunto de permisos: permisos que son otorgados y manejados como uno solo.

• Grupos de código: es un conjunto de ensamblados que comparten un contexto de seguridad.

RBS controla lo que los usuarios pueden y no pueden hacer basándose en sus credenciales, verificando cuáles son las funciones de cada usuario y proporcionándole los recursos permitidos; CLR proporciona compatibilidad basándose en la autenticación de una cuenta de Windows o una identidad personalizada.

Los dos esquemas de seguridad anteriores le dan a los administradores de sistemas, usuarios y desarrolladores de software el control sobre lo que un programa o usuario puede o no puede hacer, por ejemplo, imagine un programa que escanea el disco duro en búsqueda de un archivo perdido, este mismo programa podría ser enviado por correo electrónico y ejecutarse automáticamente en búsqueda de un archivo interesante para el atacante y ser enviado por correo al mismo; anteriormente este era un problema común en el desarrollo de aplicaciones Windows en los que no se tenia un acceso restringido sobre su computadora.

Con .NET cambia esta situación ya que las características de seguridad están implementadas dentro del CLR y para que el código se ejecute sobre el CLR, el código requiere evidencia para ejecutarse, esta evidencia puede abarcar políticas de seguridad creadas por usted junto con el administrador del sistema o el origen del código (su propia máquina, máquina de la red local o Internet).

1.8 Componentes

El .NET Framework tiene dos componentes principales:

• CLR (Common Language Runtime) o Entorno Común de Ejecución para Lenguajes.

• BCL (Base Class Library) también conocida como FCL (.NET Framework Class Library) Librería de Clases Base que incluye ASP.NET, ADO.NET y Windows Forms (Formularios para Windows).

Otros elementos del .NET Framework son:

Modelo de seguridad de .NET Framework

Seguridad basada en acceso al código Code Acces Security (CAS)

Seguridad basada en roles Role Based Security (RBS)



• Los servicios web: permitirán comunicarnos a través de Internet entre diferentes ordenadores, incluso entre distintos sistemas.

• Remoting: permite tener objetos en computadoras remotas e invocarlos desde otras computadoras.

• CLS (especificación común de lenguajes) que incluye lenguajes como Visual Basic, C#, J#, C++, entre otros.

1.8.1 Microsoft Intermediate Language (MSIL)

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

1.8.2 Just-in Time (JIT) Compiler

El JIT es el componente (compilador) del .NET Framework encargado de convertir el código MSIL en el código de un sistema operativo específico (código nativo) durante la ejecución, esto mejora el desempeño de los sistemas de programación compilados a bytecode (MSIL en el caso de .NET).

Como el código MSIL no es ejecutable es compilado por el compilador JIT, el cual es distinto para cada arquitectura de hardware y genera el código nativo apropiado, logrando así la independencia de hardware, aunque no de sistema operativo, este código se almacenará en caché mientras el código MSIL permanezca inalterable.

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

Código Fuente Visual Basic

Compilador de Visual Basic

Instrucciones de una arquitectura (X86)

Código Fuente Visual Basic .NET

Compilador de Visual Basic .NET

MSIL Interprete MSIL

Instrucciones de una arquitectura (X86)

Con VB 6 el código es compilado a instrucciones en código nativo

Con VB .NET el código es compilado a instrucciones MSIL

Antes de ejecutar una porción de código se convierte de MSIL a instrucciones de código nativo mediante el JIT


11

1.8.3 CLR (Common Language Runtime)

Es el motor de ejecución de las aplicaciones .NET (lo equivalente a la Máquina Virtual en Java) que carga las aplicaciones desarrolladas en los distintos lenguajes y se encarga de ejecutar todo el código de la aplicación .NET.

Las funciones del CLR son las siguientes:

• Ejecutar el código.

• Proporcionar los servicios (por ejemplo, recolector de basura, asignación de memoria) que facilitan el desarrollo de programas.

La siguiente figura del marco de trabajo .NET muestra que el entorno común para lenguajes (CLR) funciona como "máquina virtual" entre el sistema operativo y los programas escritos en los distintos lenguajes de programación contenidos en Visual Studio .NET, se cuenta con una especificación común para todos los lenguajes así como una especificación particular para cada uno (VB.NET, C, C#, etc.). Además el CLR da soporte a la librería de clases (BCL) y otros servicios como los servicios web XML.

Figura 9. Diagrama del marco de trabajo .NET

La siguiente figura muestra a detalle la estructura del CLR.



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

A continuación se describe el funcionamiento del CLR:

1. La herramienta de desarrollo (Visual Studio .NET en este caso) compila el código fuente de cualquiera de los lenguajes soportados por .Net en un código intermedio (MSIL, Microsoft Intermediate Language similar al Bytecode de Java). El compilador se basa en el Common Language Specification (CLS) para crear ese código MSIL compatible con el CLR.

2. Este código intermedio no es código de máquina ejecutable, por lo que durante la ejecución del programa, conforme se invoca cada uno de los métodos, el CLR pasa el código por el compilador JIT (Just-In-Time) y genera el código máquina adecuado a la plataforma, posteriormente lo coloca en caché para ser utilizado en ocasiones posteriores, el cual sólo es recompilado en caso de algún cambio. El compilador JIT es distinto para cada plataforma de hardware y genera código máquina apropiado para cada una de ellas, con lo que se obtiene independencia de hardware, aunque no de sistema operativo.

El procedimiento anteriormente descrito se representa en la siguiente figura:

Figura 11. Diagrama del funcionamiento del CLR.


13

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

La librería de clases base de .NET Framework es un extenso conjunto de clases, tipos de datos e interfases conocidos en general como tipos, que está unificada e implica una jerarquía con la cual es posible desarrollar aplicaciones.

La librería de clases de .NET es de las más poderosas, en tanto le brinda acceso a la funcionalidad del sistema, permitiéndole el manejo de: tipos de datos primitivos, excepciones, estructuras de datos, entrada y salida, acceso a bases de datos, cadenas y números, cifrado digital, acceso a redes, etc. Son miles las clases que componen la BCL (Base Class Library), aunque para desarrollar poderosas aplicaciones le bastará el dominio de un subconjunto muy pequeño.

Los tipos de BCL cumplen la especificación de lenguaje común (CLS), por lo que puede utilizarlos en cualquier lenguaje de programación cuyo compilador satisfaga los requisitos de CLS.

A continuación, se presenta un diagrama de BCL en el que se muestran los elementos que componen la librería de clases.

Figura 12. Organización de la BCL de .NET Framework6.

Los componentes principales de la biblioteca de clases de .Net Framework son:

• ASP.NET (System.Web): ASP.NET es la parte del .NET Framework dedicada al desarrollo web. A través del servidor web (IIS) las aplicaciones ASP.NET se ejecutarán bajo el CLR, con la posibiliadad de usar el conjunto de clases del .NET Framework para desarrollarlas.

6 Imagen tomada de http://www.desarrolloweb.com/articulos/1328.php



• ADO.NET (System.Data y System.Xml): es la versión de .NET de la tecnología ActiveX Data Objects (ADO) para conectarse y gestionar los orígenes de datos (entre ellos OLE DB o a través de XML). Entre sus componentes se encuentra todo lo necesario para conectarse con distintos proveedores de datos, ejecutar comandos sobre éstos y obtener resultados a través de consultas.

• Windows Forms (System.WinForms): parte del .NET Framework que permite crear aplicaciones con interfases gráficas basadas en formularios.

1.9 Ensamblados (Assemblies)

Un ensamblado es una unidad lógica de código y recursos que existe físicamente como un conjunto de archivos .exe o .dll. Dentro del ensamblado (archivo .exe generalmente) se encuentran contenidos uno o más archivos necesarios para la ejecución de la aplicación como: archivos con código compilado (MSIL), archivos de imágenes, archivos de texto, archivos con información para conectar a bases de datos, etc. en otras palabras, contiene el programa y todos los recursos necesarios para su ejecución.

Un ensamblado contiene también toda la información necesaria de los tipos (no se confunda con tipos de datos, tipos son los elementos de la librería de clases BCL como se mencionó anteriormente), debido a que se puede dar que un tipo sea distinto de un lenguaje a otro y .NET framework debe permitir la interoperabilidad entre los lenguajes, por lo que los ensamblados contienen el código de lenguaje intermedio de Microsoft MSIL que implementa estos tipos.

De tal forma, que es posible definir un ensamblado como un conjunto de tipos y recursos creados para funcionar de manera conjunta y proporcionar la funcionalidad a través del CLR a las aplicaciones NET. Una ventaja de los ensamblados es evitar registrar los componentes de la aplicación a consecuencia de que contiene todos los elementos de registro necesarios para ejecutarla.

Se pueden crear ensamblados de un archivo o de varios archivos; al trabajar con los de un sólo archivo, éstos contienen:

• Información e implementación del tipo.

• Manifiesto del ensamblado.

Para generar un ensamblado desde el IDE de Visual Studio .NET dé clic en el menú Generar | Generar Solución (Build | Build Solution), Visual Studio .NET construye soluciones automáticamente en archivos EXE o DLL para ensamblados de un sólo archivo generando un archivo .exe en la carpeta bin ubicada dentro de la carpeta en la que creó su proyecto.

Otra forma menos común de crear un ensamblado de un archivo, es a través de los compiladores de la línea de comandos, pero para nuestros propósitos bastará con generarla mediante el IDE de Visual Studio .NET.

Para Visual Basic y Visual Studio .NET sólo se pueden crear ensamblados de un archivo; si desea crear ensamblados de varios archivos, debe usar compiladores de la línea de comandos o Visual Studio .NET con las extensiones administradas de C++.


15

1.10 Espacios de nombres

Los tipos de BCL están organizados de acuerdo a su función en un esquema lógico de nombres conocido como espacios de nombres (Name Spaces). Los espacios de nombres agrupan a los tipos relacionados entre sí, de acuerdo a su funcionalidad, de tal forma que existen namespaces que agrupan los tipos para gráficos (System.Drawing), bases de datos (System.Data), entrada y salida (System.IO), formularios (System.Windows.Forms), etcétera.

Por ejemplo, la clase Form (representa un formulario de Windows, es decir, una ventana de Windows) pertenece al espacio de nombres System.Windows.Forms, por lo que aparece precedido por este nombre jerárquico separado por puntos (System.Windows.Forms.Form), como se describe a continuación:

System.Windows.Forms.Form

Espacio de nombres.Tipo

Los dos espacios de nombres con mayor frecuencia se manejan, son:

• System que agrupa los tipos fundamentales de .NET Framework como los tipos de datos base que utilizan todas las aplicaciones: Object (base de la jerarquía de herencia), Byte, Char, Array, String, etcétera.

• System.Windows.Forms el espacio de nombres para agrupar los formularios y controles característicos de las ventanas de Windows que se utilizarán para desarrollar interfases gráficas.



CAPÍTULO

El entorno de desarrollo de Visual Studio .NET

A lo largo de este capítulo se abordará la manera de localizar y utilizar las principales ventanas y herramientas del entorno de desarrollo Integrado (IDE) de Visual Studio .NET, así como la creación e identificación de la estructura de una solución y un proyecto, que son los primeros elementos por definir al momento de desarrollar una aplicación.

Visual Studio .NET es un Entorno de Desarrollo Integrado (IDE, Integrated Development Enviroment), de Microsoft que cuenta con un conjunto de herramientas para el desarrollo de aplicaciones .NET entre las que se encuentra el compilador de Visual Basic .NET, así como compiladores para otros lenguajes (C#, C++, J#). A Visual Studio .NET le puede agregar componentes a través de módulos, la instalación estándar de Visual Studio .NET cuenta con los siguientes componentes:

• Visual Basic .NET

• Visual C++

• Visual C#

• Visual J#

Usted puede elegir una instalación personalizada, pero tenga en cuenta que si desea instalar más componentes requerirá mayor espacio disponible en su disco duro.

A continuación, se presenta una tabla con los requerimientos mínimos para la instalación de Visual Studio .NET.

Requerimientos mínimos

Procesador Computadora personal (PC) con un procesador Pentium II, 450 megahertz (MHz)

Sistema operativo Microsoft Windows NT® 4.0 o superior

Memoria Windows NT 4.0 Server


17

Requerimientos mínimos

160 MB de RAM Windows NT 4.0 Workstation 64 MB de RAM Windows 2000 Professional 96 MB de RAM Windows 2000 Server 192 MB de RAM Microsoft Windows® XP Professional 160 megabytes (MB) de RAM

Disco duro Professional y Enterprise Edition 3.5 GB en la unidad de instalación, que incluye 500 MB en la unidad de sistema. Standard Edition 2.5 gigabytes (GB) en la unidad de instalación, que incluye 500 MB en la unidad de sistema.

Unidades Unidad de CD-ROM o DVD-ROM.

Video Monitor súper VGA (800 x 600) con 256 colores o de alta resolución.

2.1 Estructura de una solución

Dentro de Visual Studio .NET y todos los lenguajes que comprende (C#, Visual C++, Visual Basic .NET) se denomina solución a un programa en desarrollo, y representa a todo el sistema que se generará, el cual puede contener varios componentes independientes llamados proyectos; es decir, que una solución es un contenedor de proyectos.

Las características de una solución son:

• Punto de inicio para la creación de una aplicación con Visual Studio .NET, por lo que es lo primero que debe definirse.

• Puede contener uno o más proyectos.

• Contiene información global a todos los proyectos.

• Los archivos de solución tienen extensión .sln.

2.2 Estructura de un proyecto

Un proyecto contiene información específica para una determinada tarea de programación y se agrupa bajo una solución.

La estructura (de archivos y directorios) de un proyecto depende del tipo de proyecto (Windows, Web o MSDOS) que se genere; para simplificar el manejo de los archivos asociados a él, generalmente se almacenan dentro del mismo directorio que la solución.



En este texto se manejarán archivos de proyectos de Visual Basic .NET del tipo de una aplicación para Windows (Windows Forms); los cuales tendrán extensión .vbproj y son un documento XML que contiene referencias a todos los elementos del proyecto como formularios, clases y módulos, al igual que referencias del proyecto y las opciones para su compilación. Su extensión .vbproj permite diferenciarlo de los archivos de proyecto de C# (.csproj).

Posteriormente, mediante el uso del explorador de soluciones se podrá analizar la estructura de una solución y un proyecto.

A continuación, se describirán las ventanas y herramientas del entorno de desarrollo de Visual Studio .NET, para lo cual primeramente, deberá ejecutar el programa como se indica a continuación:

2.2.1 Ejecución de Visual Studio .NET

• Para ejecutar Visual Studio .NET, dé clic en el botón Inicio | Programas | Microsoft Visual Studio .NET | Microsoft Visual Studio .NET.

A continuación, se presenta una descripción del área de trabajo de Visual Studio .NET.

Figura 7. Ventana de Visual Studio .NET

2

3 4

5

8 9

11

7

10

15

12

14

13

6

1


19

1. Barra de título.

2. Barra de menús.

3. Barra de herramientas estándar.

4. Barra de herramientas para edición de formularios (alinear, margen, etcétera).

5. Pestañas para cambiar la ventana principal o de trabajo activa (vista de código, vista de diseño, página inicial, explorador de objetos, etcétera).

6. Fichas para cambiar la sección del cuadro de herramientas activo (datos, componentes, formulario de Windows).

7. Ventana de cuadro de herramientas.

8. Ventana principal o de trabajo.

9. Explorador de soluciones.

10. Fichas para cambiar entre ventanas (explorador de soluciones, vista de clases, etcétera).

11. Ventana de propiedades.

12. Ventana de lista de tareas.

13. Barra de Estado.

14. Fichas para cambiar entre ventanas (lista de tareas, resultados de búsqueda, etcétera).

15. Fichas para cambiar entre ventanas (propiedades, ayuda dinámica, etcétera).

2.2.2 Creación de una solución y un proyecto

El primer paso para comenzar a trabajar dentro de Visual Studio .NET es crear una nueva solución o bien un nuevo proyecto; si usted crea un nuevo proyecto automáticamente, se creará una nueva solución con el mismo nombre a la cual estará asociado.

Para crear un nuevo proyecto, dentro de la ventana de Visual Studio .NET seleccione de la barra de menús la opción Archivo | Nuevo | Proyecto (File | New Project) con esto se mostrará el cuadro de diálogo Creación de un nuevo proyecto, como se muestra a continuación:

Figura 8. Ventana para definir la creación de un nuevo proyecto.



Los dos elementos más importantes que se deben definir para este proyecto y que determinan que el tipo de la aplicación sea el de una aplicación para Windows, son:

• Project Types (tipo de proyecto): en la figura 8 se eligió un proyecto de Visual Basic, también podría crear otro tipo de proyectos como por ejemplo Visual C#, Visual C++, entre otros, dependiendo del lenguaje que desee utilizar.

• Templates (plantillas): igualmente, se eligió la plantilla aplicación para Windows (Windows Application) de tal manera que contará con una interfaz gráfica de usuario GUI, la cual estará disponible a través de un formulario. Puede utilizar otras plantillas como ASP.NET Web Application (aplicación web con ASP), Console Application (aplicación de consola para MS-DOS) entre otras, dependiendo del tipo de aplicación que desee realizar, ya sea de Windows, Web o MS-DOS respectivamente.

En el ejemplo anterior se especificó el Nombre (Name) del proyecto: HolaMundo que será el mismo para la solución, y también se eligió guardar la carpeta de la solución en la Ubicación (Location) C:\CursoVB\Ejercicios.

También pudo haber elegido crear primero una solución en blanco en el menú Archivo | Nueva | Solución en blanco (File | New | Blank Solution), pero para ahorrar ese paso generalmente, se creará un proyecto y se dejará que Visual Studio .NET cree la solución al cual estará vinculado.

2.3 El explorador de soluciones

Una vez que ha creado un proyecto se mostrará la ventana principal de Visual Studio .NET que se describió anteriormente, esta ventana presenta los elementos generados junto con el proyecto, los cuales se revisarán mediante el explorador de soluciones.

El explorador de soluciones muestra la solución y los proyectos de manera jerárquica, incluyendo los elementos de cada proyecto, referencias, formularios, clases, módulos y cualquier subcarpeta que contenga elementos del proyecto. También le da acceso a los comandos asociados a cada uno de estos elementos.

Para mostrar el explorador de soluciones lleve a cabo un clic en la barra de menús en la opción View | Solution Explorer (Ver | Explorador de Soluciones) o presione la combinación de teclas (CTRL-R).

En caso de tener seleccionado un formulario, se mostrarán dos botones extras (Ver diseño, Ver código) como se muestra en la siguiente figura.

Figura 9. Ventana del explorador de soluciones.

1. Refrescar (Refresh): actualiza la lista de elementos en caso de haber agregado un nuevo archivo o directorio.

1 2 3 4 5


21

2. Mostrar todos los archivos (Show All Files): muestra todas las carpetas y subcarpetas asociadas al proyecto.

3. Propiedades (Properties): muestra las propiedades asociadas al elemento que tenga seleccionado.

4. Ver Código (View Code): muestra la vista de código del formulario seleccionado, y permite editarlo. La vista de código presenta los elementos del lenguaje de programación Visual Basic .NET (clases procedimientos, variables, etc.) utilizados por el programador dentro del formulario, así como el código generado de manera automática por el entorno de desarrollo Visual Studio .NET al momento de crear el formulario y agregar controles.

5. Ver Diseño (View Designer): muestra el formulario seleccionado en vista de diseño. La vista de diseño presenta la Intefaz Gráfica de Usuario (IGU) compuesta por los objetos de la librería Windows.Forms utilizados (formulario, botones, cajas de texto, etc.) y permite modificar con facilidad el tamaño y la posición de cada uno de ellos; esta IGU será la vista que tendrá el usuario de nuestra aplicación.

También se utilizarán los menús contextuales que aparecen dando clic con el botón derecho sobre un elemento del explorador de soluciones.

2.3.1 Estructura de una solución y un proyecto

Dé clic en el botón Mostrar todos los archivos (Show All Files) para mostrar todos los archivos incluyendo las carpetas dentro del proyecto; esta estructura es la misma que se crea en su disco duro en la ubicación que haya elegido al momento de crear el proyecto del explorador de soluciones, como se mostró anteriormente.

Una solución contiene proyectos.

Un proyecto contiene::

• References: referencias a objetos de la clase System; estas referencias son necesarias para toda aplicación de Windows.

• bin: carpeta que contiene archivos de soporte y ensamblados generados al construir la aplicación en el menú Generar (Build). Puede desplegar una aplicación copiando los archivos de este directorio a la computadora del usuario y ejecutando el archivo .exe.

• obj: carpeta que contiene a su vez la carpeta Debug para fines de depuración con archivos intermedios compilados y no optimizados pero con información para depurarlos o una carpeta Release con archivos optimizados (depende de la opción seleccionada en el administrador de configuración en el menú Generar | Administrador de Configuración).

• AssemblyInfo.vb: archivo de texto que provee información sobre el ensamblado (Assembly) de la aplicación como: título, descripción, compañía, producto, versión, copyright, compatibilidad CLS.

• Form1.vb: formulario de Windows instancia de la clase System.Windows.Forms, es la ventana de una interfaz gráfica (creado de forma automática solo en proyectos del tipo “aplicación para Windows”).



2.3.2 Cuadro de herramientas

El cuadro de herramientas muestra un listado de diversas secciones de código, elementos de interfaz y otros elementos para que los agregue a sus proyectos. El cuadro de herramientas muestra siempre las fichas General y Anillo del portapapeles; al abrir un editor o un diseñador, se muestran otras fichas (Data, Components, Windows Forms).

La función principal de la ficha Windows Forms es permitir agregar controles (etiquetas, botones, cuadros de Texto, etc.) al formulario para la creación de una interfaz gráfica de usuario (GUI) y sólo estará disponible encontremos en la vista de diseño del formulario.

Para mostrar el cuadro de herramientas, dé clic en la barra de menús en la opción View | Toolbox (Ver | Cuadro de Herramientas) o presione la combinación de teclas (CTRL-ALT-X).

Para agregar un control al formulario, dentro del cuadro de herramientas asegúrese de tener seleccionada la ficha Windows Forms.

1. Seleccione el tipo de control que desea agregar por ejemplo Label.

2. Sin soltar el botón izquierdo del ratón, arrastre el puntero hacia el formulario hasta colocar el control en la posición deseada.

Figura 10. Agregar controles al formulario mediante el cuadro de herramientas.

2.3.3 Ventana de propiedades

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


23

Para mostrar la ventana de propiedades, lleve a cabo un clic en la barra de menús en la opción Ver | Ventana de Propiedades (View | Properties Windows) o presione la tecla F4

Dos de las propiedades que más comúnmente se modifican son texto (Text): el texto descriptivo que muestra el objeto; y nombre (Name) que es el identificador del objeto.

Por ejemplo, para ver y/o modificar las propiedades de un objeto (control) contenido en el formulario:

• Seleccione del formulario, el control al cual desea realizar los cambios.

• En la ventana de propiedades se mostrarán las propiedades de dicha etiqueta, desplácese hasta el nombre de la propiedad que desea modificar, por ejemplo text y edite el valor, por ejemplo teclee “Hola Mundo” y presione Enter.

Figura 11. Uso de la ventana de propiedades.

2.3.4 El editor de código

El editor de código es la herramienta que muestra y permite editar el código de su aplicación.

Para mostrar el editor de código, realice alguna de las siguientes acciones:

• Dé clic en la barra de menús en la opción View|Code (Ver|Código).

• Seleccione en el explorador de soluciones el elemento (módulo, formulario, etc.) del que desea editar el código y dé clic en el botón View Code (Vista de Código).

• Si se encuentra en vista de diseño, dé clic con el botón derecho del ratón sobre el formulario y elija Ver Código.



Figura 12. Editor de código.

Del lado izquierdo se presenta una lista desplegable que le permite seleccionar los nombres de las clases, y del lado derecho los métodos asociados a cada una de las clases.

2.3.5 Intellisense

IntelliSense es una característica que presenta el editor de código de Visual Studio .NET, de esta forma no necesitará conocer todos los métodos asociados a un objeto ni la sintaxis de éstos, ya que al teclear el nombre del objeto correspondiente y el operador punto (que indica pertenencia en la programación orientada a objetos), aparecerá una lista con los métodos y propiedades disponibles para ese objeto; si usted selecciona con un clic aparecerá la descripción del mismo y si da doble clic Intellisense auto-completará el método o propiedad seleccionado, evitándole escribirlo.

Otra característica es que si tiene un error de sintaxis, éste quedará subrayado en el editor de código de tal forma, que al pasar el puntero del ratón sobre éste, Intellisense desplegará una descripción del error, así como la sintaxis correcta.

En la lista que despliega Intellisense para un objeto, las propiedades aparecen con una imagen parecida a una mano sosteniendo una tarjeta, y los métodos con una especie de paquete desplazándose que indican un mensaje o comunicación entre objetos.

Figura 13. Intellisense.

2.4 La vista de clases

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


25

Para mostrar la ventana vista de clases, dé clic en la barra de menús en la opción View | Class View (Ver | Vista de Clases) o bien presione las teclas CTRL+MAYÚS+C.

La vista de clases muestra la organización de las clases dentro del proyecto y permite acceder a las diversas propiedades y métodos vinculados; dando doble clic en un elemento de la vista de clases, éste lo llevará a la clase, método, evento, propiedad o procedimiento, o bien a la definición de la clase dentro del examinador de objetos.

Figura 14. Vista de clases.

En la figura anterior, por ejemplo se despliega la estructura del siguiente espacio de nombres:

• Solución Hola Mundo

o Proyecto Hola Mundo

Clase FrmHolaMundo

• Procedimiento BtnLimpiar (BtnLimpiar_clic)

Al dar doble clic sobre este último elemento dentro de la vista de clases, se presentará la vista de código con la definición del mismo.

2.5 El sistema de ayuda

La ayuda dinámica muestra automáticamente enlaces provenientes de la ayuda de Visual Studio con temas relacionados de la ayuda, dependiendo de dónde se ubique el cursor y el texto que esté seleccionado; es decir, dependiente del contexto, esto evita que usted solicite expresamente la ayuda presionando la tecla F1, lo cual es otro tipo de ayuda que nos proporciona Visual Studio.

Para mostrar la ventana Ayuda dinámica, dé clic en la barra de menús en la opción Ayuda | Ayuda Dinámica (Help | Dynamic Help) o bien presionando la tecla CTRL+F1.



Con esto se mostrará una ventana que cuenta con la característica de que al momento de seleccionar un elemento dentro de la vista de código, las opciones de ayuda cambian y dando clic dentro de alguno de estos elementos se mostrará la página con la ayuda, de acuerdo con el tópico seleccionado.

Por ejemplo, la siguiente figura muestra que al seleccionar la cadena “Hola Mundo”, dentro de la ventana Ayuda Dinámica (Dynamic Help) se muestran ligas para consultar la ayuda acerca del tipo de dato String, del operador =, etc., es decir, en función del elemento seleccionado.

Figura 15. Ventana Vista de código Figura 16. Ventana ayuda dinámica

2.6 Personalización del IDE

Una de las ventajas que presenta el IDE Visual Studio .NET es que usted puede personalizar muchos aspectos del mismo, como: la forma en que se mostrarán las ventanas, tipo y tamaño de fuente, entre otras, que se describen a lo largo de este tema, lo anterior con la finalidad de adaptarla a sus necesidades particulares permitiéndole trabajar más eficientemente y hacer más agradable su entorno de desarrollo.

La forma más fácil de personalizar el entorno de desarrollo de Visual Studio .NET, es mediante la configuración de su perfil.

Al ejecutar por primera vez Visual Studio .NET, se mostrará una interfaz tipo página web que le pide confirmar la configuración del perfil o si desea la barra de menús, seleccione la opción Ayuda | Mostrar página de inicio (Help | Show Start Page) y dentro de la página seleccione la opción Mi Perfil (My Profile) con lo que se mostrará una pantalla como la de la siguiente figura:


27

Figura 17. Ventana para configurar el perfil de Visual Studio .NET

El perfil es una forma de establecer las preferencias y el comportamiento del IDE de Visual Studio, las opciones provistas están diseñadas para facilitar la transición de quienes hayan manejado anteriormente Visual Studio 6 hacia este nuevo entorno. Usted puede elegir entre los perfiles que se le facilitan.

Es recomendable seleccionar la opción "Programador de Visual Basic" (Visual Basic Developer).

Esta opción configurará las siguientes opciones:

• Esquema del teclado (Keyboard Scheme): coloca las configuraciones de teclas de método abreviado que se utilizaban en Visual Basic 6.

• Diseño de Ventana (Window Layout): coloca el diseño de ventana para ocultar el explorador de servidores y acoplar el cuadro de herramientas a la izquierda, el explorador de soluciones y la vista de clases a la derecha.

• Filtro de Ayuda (Help Filter): filtra el tipo de ayuda que le presentará MSDN (Microsoft Developer Network) presentando sólo ayuda de Visual Basic .NET.

• Mostrar Ayuda (Show Help) Interna / Externa: especifica si la ayuda se mostrará dentro del IDE de Visual Studio o en una ventana externa.

• Al inicio (At Startup): especifica cuál interfaz de usuario aparece al iniciar Visual Studio .NET.

Otra forma de personalizar Visual Studio .NET, es mediante la opción Herramientas | Opciones (tools | options) de la barra de menús que se muestra en la siguiente ventana:



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.


29

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.



3.1 Convenciones del lenguaje

Otro elemento por definirse para la declaración de una clase, es el identificador como se mencionó en la sintaxis de declaración. El identificador se refiere al nombre de la clase, y es recomendable usar nombres descriptivos que ayuden a recordar lo que representa la clase.

En los ejemplos que se mencionaron anteriormente, se utilizaron identificadores como: ClaseParaTodos, ClaseParaMisHijos, FrmHolaMundo, etc, pero no todos son válidos ya que existen las siguientes normas para nombrar clases y variables:

• Los identificadores de clases y variables deben empezar con una letra a-z A-Z o un caracter de subrayado seguido de alguna letra para evitar la ambigüedad de la continuación de línea. Por convención, es preferible que los identificadores de clase inicien con mayúscula y los identificadores de variables inicien con minúscula.

• Los identificadores de clases y variables no deben coincidir con palabras clave del lenguaje.

• Los identificadores no distinguen entre mayúsculas y minúsculas, por ejemplo miVariable y MiVariable son el mismo identificador.

• Los identificadores no deben incluir puntos o un carácter de identificación de tipo (%,&,!,#,@,$).

• Los identificadores no deben superar los 255 caracteres de longitud.

• Un identificador debe tener un nombre exclusivo dentro del ámbito (alcance) a excepción de los procedimientos que pueden tener el mismo nombre pero con distinta lista de argumentos. El ámbito de las clases es el proyecto, el ámbito de las variables globales es la clase y el ámbito de las variables locales es el método en el cual fueron declaradas.

• Los identificadores no deben contener espacios en blanco (este es un error muy común).

Notación húngara

Es recomendable como programadores que, además de utilizar nombres descriptivos como identificadores, indiquemos el tipo de dato que almacenan, es decir, que mediante el identificador se conozca si almacena un entero, una cadena, un número flotante, etc. Con este fin se ha creado un sistema estandarizado para nombrar variables conocido como notación húngara. La notación húngara implica colocar un prefijo en minúsculas al identificador de una variable; para indicar el tipo de dato almacenado, a continuación se listan las convenciones que tienen sentido dentro de Visual Basic .NET.

Prefijo Tipo de dato Ejemplo en Visual Basic .NET

b Boolean bIndicador as Boolean

by Byte byEnteroCorto as Byte

c Char cCaracter as Char

i Integer iEntero as Integer

l Long lEnteroLargo as Long


31

Prefijo Tipo de dato Ejemplo en Visual Basic .NET

s String sCadena as String

d Double dNumeroFlotante as Double

a Arreglos abArregloDeBytes as new Byte(5)

o Objetos en general oAutomovil as new Automovil()

Si lo desea puede utilizar la notación húngara, al igual que puede crear sus propios prefijos para otros tipos de datos procurando que sean descriptivos; más adelante cuando generemos interfases gráficas utilizaremos otras convenciones para identificadores de variables de tipo: etiquetas (Label), cuadros de texto (TextBox), etc.

A continuación, se muestra la sintaxis para declarar una clase:

Public class MiClase

'Aquí irían las declaraciones de variables y procedimientos

End Class

Algunos ejemplos de identificadores para variables son:

Dim 1erEntero As Integer 'Invalido no empieza con una letra

Dim i1erPrimer_Entero As Integer 'Valido

Dim imi Primer Entero% As Integer 'Invalido contiene el caracter % y varios espacios en blanco.

Para agregar una clase, tendrá que indicárselo a Visual dando clic en la opción de la barra de menús Proyecto | Agregar Clase (Project | Add Class).

Otra forma de hacer lo anterior, es desde el explorador de soluciones, dar clic con el botón derecho sobre el elemento proyecto, y seleccionar la opción Agregar Clase (Add Class) del menú contextual que aparece.

3.2 Variables y tipos de datos

Una variable representa un espacio en memoria, almacena un valor de determinado tipo (valor, referencia), el cual puede modificarse a lo largo de la ejecución del bloque de instrucciones donde la variable es accesible. Visual Basic .NET utiliza tipos de datos que se corresponden directamente con los tipos de datos del sistema de tipos comunes (Common Type System – CTS), que, como ya se mencionó, define los tipos de datos que soporta el Common Language Runtime.

Es importante comprender que el CTS es uno de los elementos que hace posible que las aplicaciones en el .NET Framework tengan la capacidad de ser multilenguaje. A continuación, se muestra un diagrama de organización del sistema de tipos comunes.



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


33

En versiones anteriores de Visual Basic no podía inicializarse las variables en la misma línea en que se declaraba; en Visual Basic .NET es posible, como se muestra a continuación:

Dim iNumVar As Integer = 20

3.3 Tipos de datos elementales (enteros, no enteros, caracter, lógico, fecha)

Otro de los elementos que había que especificar en la declaración de una variable era el tipo de dato, que especifica el tipo de valor que almacenará la variable. Los tipos en Visual Basic se clasifican en tipos valor o predefinidos y tipos referencia.

• Tipos por valor: son llamados de esta forma debido a que la variable almacena el valor de forma directa por lo que para acceder al dato basta con referirse a la variable; las variables de tipos por valor son almacenadas en el stack7, si se realiza la asignación de una variable a otra, ésta ultima guarda una copia del valor, siendo estas variables independientes ante una posterior modificación.

• Tipos por referencia: las variables por referencia almacenan la dirección de memoria que almacena al dato, por lo que para acceder al dato se hará referencia a la dirección de memoria; estas variables se almacenan en el heap8, si se realiza la asignación de una variable a otra, esta ultima guarda una copia de la dirección de memoria, por lo que hacen referencia al mismo valor y cualquier modificación de una variable afecta a la otra.

Ejemplo:

Dim iContador As Integer 'valor almacena un entero

Dim oCliente As MiObjeto 'referencia almacenará una referencia a una localidad de memoria de un objeto que es instancia de la clase MiObjeto.

Si después de las declaraciones del ejemplo intentamos utilizar el valor, la variable iContador Visual Basic respondería con el valor cero, por el contrario para la variable oCliente obtendríamos el valor “Nothing”, es decir, que no hace referencia a un objeto válido debido a que no se ha creado una instancia.

Los tipos valor se clasifican en:

• Primitivos.

• Estructuras.

• Enumeraciones.

Los tipos primitivos se clasifican en:

7 El stack es una estructura que almacena variables locales, funciones y sus parámetros, así como

resultados intermedios, asigna y libera memoria de acuerdo a las operaciones de una pila. 8 El heap es un área de memoria dinámica, asigna (en ocasiones huecos no adyacentes) y libera

memoria al sistema operativo de forma aleatoria.



• Enteros (Byte,Short,Integer,Long).

• Reales (Single, Double,Decimal).

• Boolean.

• Char.

• Date.

A continuación, se presenta una tabla con la descripción de los tipos primitivos en Visual Basic.

Tipo Estructura en CLR Tamaño Descripción

Byte System.Byte 8 bits Datos numéricos de 0 a 255 (sin signo).

Short System.Int16 16 bits Datos numéricos de -32,768 a 32,767.

Integer System.Int32 32 bits Datos numéricos de -2,147,483,648 a 2,147,483,647.

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

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

Double System.Double 64 bits Números de punto flotante de precisión doble de -1.79769313486231570E+308 a -4.94065645841246544E-324 para valores negativos; 4.94065645841246544E-324 a 1.79769313486231570E+308 para valores positivos.

Decimal System.Decimal 128 bits Números de punto fijo, correspondientes a enteros elevados a la décima potencia de 0 a +/-79,228,162,514,264,337,593,543,950,335 para valores sin punto decimal; y de 0 a +/-7.9228162514264337593543950335 con 28 dígitos a la derecha del punto decimal; Por ejemplo el numero mas pequeño distinto de cero es +/- 0.0000000000000000000000000001 (+/-1E-28).

Boolean System.Boolean 16 bits Almacena datos que pueden tomar valor True o False.

Char System.Char 16 bits Almacena un único carácter 'a','b', etc., pero se almacena como un entero sin signo de de 16 bits de 0 a 65535.


35

Tipo Estructura en CLR Tamaño Descripción

Date System.DateTime 64 bits Almacena fechas y horas 0:00:00 de 01/Enero/0001 a 11:59:59 PM 31/Diciembre/9999, los almacena en una representación de enteros largos de 64 bits.

String System.String Depende de la

plataforma

De 0 a 2 billones de caracteres unicode aproximadamente.

Todos los tipos de datos están asociados a un tipo de la BCL (estructura de datos asociada por el CLR de .NET), por ejemplo el tipo Single está asociado a System.Single; de esta manera, estos tipos de datos también son objetos y una consecuencia de esto es que el tipo Object pueda almacenar valores de cualquiera de estos tipos primitivos, similar a la función que desempeñaba el tipo Variant en Visual Basic.

Tenga en cuenta los rangos de los valores que es capaz de almacenar cada tipo de datos, si intenta asignar valores fuera del rango recibirá un mensaje de error por parte de Visual Basic, por ejemplo si intenta asignar el valor 256 a una variable de tipo Byte recibirá un error, lo mismo sucederá con los demás tipos de datos.

Una vez que hemos revisado cómo declarar variables de tipo valor, utilizaremos estructuras que nos permitan manejar conjuntos de variables como los son las enumeraciones, estructuras y matrices.

3.4 Tipos de datos compuestos (enumeraciones, estructuras y matrices)

Enumeraciones

Son tipos definidos por el usuario; para crearlos se utiliza la palabra reservada Enum. Las enumeraciones proporcionan una forma cómoda de trabajar con un conjunto de constantes relacionadas entre sí y de asociar sus valores con nombres. Por ejemplo, se puede declarar una enumeración para un conjunto de constantes de tipo entero asociadas con los días de la semana, y después utilizar los nombres de los días en el código, en lugar de sus valores enteros, como se muestra en el ejemplo.

'Declara la enumeración día con 7 elementos domingo=0, lunes=1, etc. Enum dia domingo lunes martes miercoles jueves viernes sabado End Enum 'Marca el fin de la declaración



'Declara diaSem, de tipo día y con el valor 6 Dim diaSem As dia = dia.sabado

Estructuras

Tipo de dato compuesto, que a diferencia de las enumeraciones, permiten agrupar variables de distintos tipos; estas variables conforman los atributos (miembros) de la estructura, pero además de atributos las estructuras pueden poseer: constructores, métodos, propiedades, campos constantes y enumeraciones. Por todo lo anterior, son similares a las clases salvo algunas restricciones, entre sus diferencias se encuentran:

• Son tipos valor y no referencias a objetos.

• No se permite la herencia entre estructuras.

Aun cuando en algunos aspectos son similares a las clases, la principal función de las estructuras es que permiten crear aplicaciones para implementar un manejador de bases de datos. Ya que la mayoría de los usuarios no hará eso y sólo creará aplicaciones que acceden a bases de datos ya conocidas (Access, SQL Server, MySQL, etc.), no las abordaremos.

Matrices

Ya hemos visto que las variables almacenan datos, pero en ocasiones necesitará trabajar con múltiples variables para almacenar información similar. Por ejemplo, suponga que necesita almacenar 50 nombres, podría declarar 50 variables de tipo cadena y almacenar cada nombre en una variable, o bien, puede declarar una matriz de tipo cadena que los almacene.

Una matriz es una colección de variables con el mismo tipo de dato. Todas las variables de una matriz tienen el mismo nombre pero se diferencian por un índice.

Sintaxis:

Dim nombreDeArreglo (Numero de elementos) [As Tipo]

Es necesario colocar los paréntesis para indicar a Visual Basic que se trata de un arreglo y no de una variable.

[As tipo] Los corchetes indican que la expresión “As tipo” es opcional, si no especifica el tipo se asume Object.

Ejemplo:

Dim sNombres (49) As String

Esta instrucción es equivalente a:

Dim sNombres As String = new String(49)

Ambas declaran un arreglo de 50 elementos, el motivo por el que tiene 50 elementos y no 49 como indica el código, es que el índice de las matrices empieza en cero y no en uno, por esto se tienen índices entre 0 y 49, lo que genera un total de 50 elementos.


37

Como se ha venido mencionando, un arreglo es una colección de variables por lo que se tratan de la misma forma, es decir, las puede inicializar, asignarle valores, recuperar valores, de la misma manera que lo hace con las variables.

Ejemplo:

sNombres(0)="Carlos"

'Asigna la cadena "Carlos a la variable sNombres(0), que corresponde al primer índice del arreglo.

3.5 Literales y constantes

Constantes

Una constante o literal es el valor de alguno de los tipos expuestos anteriormente. Por ejemplo:

0, 3.14159, "Hola Mundo", "a"C

Sintaxis (enteros):

{ [+] | - } literal_entero [{ S | I | L }]

Semántica:

El signo + es opcional y el signo - es obligatorio; si el valor es negativo, literal_entero es el valor entero y S, I, L son opcionales e indican la representación que se utilizará.:

• S: Short

• I: Integer

• L: Long

Si se omite la representación del tipo de dato por utilizar, la constante intentará representarse mediante el tipo de dato Integer, y si el valor de la constante rebasa la capacidad de Integer se asignará Long.

Ejemplos:

-1454I 'Constante entera Integer

3426000000 'Constante entera Long

Sintaxis (reales):

{ [+] | - } parte_entera.parte_fraccionaria [{e|E} {[+]|-} exponente] [{F |R |D }]

Semántica:

El signo + es opcional y el signo - es obligatorio; si el valor de la base es negativo, de igual forma para el valor del exponente, F, R, D son opcionales e indican la representación que se utilizará.

• F: Single

• R: Double



• D: Decimal

Si se omite el sufijo, el tipo por default es Double.

La letra E o e, es el símbolo para indicar que a continuación se colocará el valor numérico del exponente, el cual puede constar de uno o más dígitos del 0 al 9.

Ejemplos:

.18e3

27E-3

Sintaxis (caracter):

"x"C

Semántica:

El signo x representa cualquier caracter o espacio en blanco y la C indica que se trata de un caracter y no de una cadena.

Ejemplos:

"p"C 'Constante caracter p

Sintaxis (cadena):

"MiCadena"

Semántica:

Declara una cadena cuyo valor es la palabra MiCadena..

3.6 Alcance de las variables

El ámbito define el rango de acceso de una variable, es decir, la parte del programa donde se puede utilizar, y de acuerdo con su alcance, se clasifican en:

• Variables locales: se declaran dentro del cuerpo de un procedimiento y son accesibles exclusivamente dentro de éste por lo que no se pueden utilizar fuera de él y pierden su valor al terminar la ejecución del procedimiento en el que fueron declaradas.

• Variables de módulo: se declaran fuera de cualquier procedimiento y dentro del cuerpo de la clase o módulo, se pueden utilizar dentro de cualquier procedimiento de la clase ó módulo o aún entre módulos de la aplicación, esto último depende del tipo de acceso que se le asocie a la variable.

Ejemplos:

public class MiClase

Dim varModulo 'variable de módulo, está declarada fuera de cualquier procedimiento y dentro de la clase.

Sub MiProcedimiento

Dim varLocal 'variable local, solo es accesible en el procedimiento.


39

varModulo = 1 'La variable varModulo es accesible dentro de la clase.

End Sub

End Class.

3.7 Tipos de acceso (visibilidad de las propiedades)

Como se mencionó anteriormente, las variables de módulo pueden definir su tipo de acceso, la sintaxis para su declaración es la siguiente:

Sintaxis:

acceso::= Public | Protected | Friend | Protected Friend | Private

Semántica:

Indica el acceso para una variable a nivel de módulo.

public: declara que la variable es accesible dentro del módulo o clase e incluso desde otros módulos que se encuentren dentro del proyecto, así como desde los módulos de otros proyectos que hagan referencia al proyecto.

Ejemplo:

Public class ClaseParaTodos

public variablePublica As Integer

End Class

private: declara que la variable es accesible sólo dentro del módulo o clase donde se ha declarado.

Ejemplo:


private miVariable As Integer

End Class

protected: declara que la variable es accesible dentro de la misma clase o desde una clase derivada de ésta.

Ejemplo:


protected variableParaMisHijos As Integer 'Variable que heredaran clases herederas

End Class

Estos son los tipos de acceso más común, existen dos modificadores de acceso más: Friend declara que la variable será accesible dentro del proyecto, y Protected Friend que declara que la variable será accesible dentro del proyecto o desde una clase que herede de la misma clase en donde se declaró.



3.8 Conversión entre tipos de datos

En un principio Visual Basic .NET permite convertir implícitamente algunos tipos de datos, pero esto puede originar pérdidas de información, por ejemplo para convertir una variable Integer a una de tipo Byte se tendría que truncar la representación en bits, sin embargo, al revés sí es válido ya que la representación de un Byte cabe en la de Integer.

Para detectar los errores de una conversión implícita con pérdida de información, usted puede forzar a Visual Studio .NET a que verifique esas conversiones y sólo permita aquéllas que indique explícitamente el programador; para hacerlo, coloque la opción Option Strict on en la sección de declaraciones al inicio de su código

De esta manera tenemos conversiones implícitas y explícitas y la siguiente figura indica precisamente las conversiones implícitas seguras con la flecha que va de izquierda a derecha:

Byte --> Short --> Integer --> Long --> Single--> Double--> Decimal

Option Strict On 'Forza la revisión de conversiones implícitas

Private Sub Main()

Dim rDato as Double=1.34

Dim bDato as Byte

bDato=rDato ‘Marca error y no realiza la conversión implícita, de lo contrario podría haber perdida de información.

End Sub.

3.9 Funciones de conversión

Si usted activa la verificación de conversiones implícitas mediante Option Strict On y en un momento dado desea realizar una conversión de manera explícita, puede utilizar las funciones de conversión, siempre y cuando se asegure de que la expresión esté dentro del rango del tipo de dato hacia el que desea convertir, de lo contrario se producirá un error. A continuación, se describen las funciones de conversión existentes en Visual Basic .NET:

Función de conversión Descripción Ejemplos

CBool Convierte una expresión numérica o de cadena válida y devuelve un valor de tipo Boolean, cualquier valor numérico distinto de cero devuelve el valor true.

A=5,B=5 valor= CBool(A = B) ‘valor=true C = 0 valor = CBool(C) 'valor=False

CByte Convierte una expresión numérica o de cadena válida y devuelve un valor de tipo, redondea las fracciones, sólo acepta rangos de 0 a 255 devolviendo un valor de tipo Byte.

dPi as Double=3.141592 bPi as Byte bpi=dpi ‘bpi = 3

CChar Convierte una expresión de cadena válida, devuelve el primer carácter como valor de tipo Char.

cLetra=CChar(“ABC”) ‘cLetra = A, devuelve el primer carácter


41

Función de conversión Descripción Ejemplos

CDate Convierte una expresión válida de fecha y hora devolviendo un valor de tipo Date.

Dim sfecha As String = "18/01/2001" Dim valor As Date valor = CDate(sfecha) ‘Valor = 18/01/2001

CDbl Convierte una expresión numérica a su representación en Double.

Dim dReal As 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 representación en decimales.

Dim dReal As Double=0.01D 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 representación entera de 32 bits redondeando las fracciones.

Dim dReal As Double=7.64 Dim iEntero As Integer iEntero = CInt(dReal) ‘iEntero=8

CLng Convierte una expresión numérica a su representación entera de 64 bits redondeando las fracciones.

Dim dReal As Double=7.64 Dim lEntero As Long lEntero = CLong(dReal) ‘lEntero =8

CObj Convierte cualquier expresión válida. Dim dReal As Double=7.64 Dim oObjeto As Object oObjeto = CObj(dReal)'oObjeto contiene una referencia al valor asignado.

CShort Convierte una expresión numérica a su representación entera de 16 bits redondeando las fracciones.

Dim dReal As Double=7.64 Dim sEntero As Short sEntero = CShort(dReal) ‘sEntero =8

CSng Convierte una expresión numérica a su representación en Single.

Dim dReal As Double = 1.0E-46 Dim sSingle As Single sSingle = CSng(dReal) ‘sSingle=0, ya que el número más pequeño distinto de cero es 1.401298E-45

CStr Convierte cualquier expresión numérica de fecha.

Dim dReal As Double=1.1 Dim sCadena As String sCadena = dReal sCadena= “1.1”

El comportamiento de las funciones de conversión descritas puede ser obtenido también mediante una función general llamada Ctype, que le permite convertir cualquier expresión al tipo especificado y cuya sintaxis es la siguiente:

Ctype(expresión, tipo de dato)



Como primer argumento recibe la expresión que desea convertir y como segundo argumento el nombre del tipo de dato hacia el cual lo desea convertir; en caso de recibir una expresión fuera del rango permitido, se producirá un error. A continuación se muestra un ejemplo:

Dim dReal As Double = 7.91

Dim iEntero As Integer

iEntero = CType(dReal, Integer) ‘IEntero = 8.

Option Explicit

Option Explicit es una instrucción optativa que se coloca al inicio del archivo (de la misma forma que Option Strict) y tiene la siguiente sintaxis.

Option Explicit { On | Off }

Si está habilitada (se encuentra habilitada valor por defecto, ya que es recomendable) forzará al compilador a verificar que todas las variables que intente utilizar dentro del programa, hayan sido declaradas previamente de manera explícita, produciendo un error en caso contrario.

Si deshabilita la opción, podrá utilizar variables que no han sido declaradas, las cuales tendrán por defecto el tipo de dato Object. A continuación, se muestra un ejemplo:

Option Explicit Off 'Permite utilizar variables no declaradas.

Dim iNumero As Integer

iNumero = 10

oVariable = iNumero ‘oVariable es de tipo Object pero contiene el valor 10.

3.10 Operadores y precedencia

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

Categoría Operadores

Aritméticos y Concatenación

Exponenciación (^)

Negación unaria (–)

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


43

División de número entero (\)

Módulo aritmético (Mod)

Suma y resta (+, –), concatenación de cadenas (+)

Concatenación de cadenas (&)

Desplazamiento de bits aritmético (<<, >>)

Comparación =, <>, <, <=, >, >=, Like, Is, TypeOf...Is (Tienen la misma precedencia).

Lógicos y bit a bit

Negación (Not)

Conjunción (And, AndAlso)

Disyunción (Or, OrElse, Xor)

Asignación =, ^=, *=, /=, \=, +=, -=, &=

Cuando una expresión combina distintos operadores, ésta se evalúa en un orden determinado por la precedencia de cada operador, como se muestra en el siguiente ejemplo, la expresión:

5 + 4 * 3

Visual Basic la evaluará como 17, debido a que realiza primero la multiplicación por tener mayor precedencia que la suma, reduciendo la expresión a 5 + 12 =17.

Los paréntesis poseen la mayor precedencia, por lo que le permiten agrupar una subexpresión de tal forma que sea evaluada antes que las demás, por ejemplo, si desea que Visual Basic realice primero la suma de 5 + 4 puede hacer lo siguiente:

(5 + 4) * 3

La expresión anterior será evaluada a 27, debido a que realiza primero la suma por estar entre paréntesis, reduciendo la expresión a 9*3=27.

Cuando existen dos o más operadores con la misma precedencia dentro de una expresión, serán evaluados de izquierda a derecha según su orden de aparición.

3.11 Estructuras de decisión

Cuando es invocado un método dentro de un programa, se van ejecutando las instrucciones desde el principio hasta el fin del método de manera secuencial, a menos que se cambie el orden de ejecución con instrucciones de control o mediante ciclos.

Las instrucciones de control permiten regular el flujo de ejecución de un programa. A continuación se verán algunas instrucciones de control, que le permiten tomar decisiones.



Las instrucciones de decisión que se verán a continuación son:

• If...Then

• If...Then...Else

• Select...Case

3.11.1 If...Then…Else

Sintaxis:

If <expresión booleana>Then <Una sola Instrucción>

Semántica:

Si la expresión booleana se evalúa a verdadero (True) entonces (Then) ejecuta la única instrucción si no continúa con la siguiente instrucción fuera del If, observe que sólo debe de haber una instrucción; para que acepte más de una instrucción, deberá terminar la sentencia con End If, como se muestra a continuación:

Sintaxis:

If <expresion booleana> Then

<Una o más Instrucciones>

End If

Semántica:

Si la expresión booleana se evalúa a verdadero (True) entonces (Then) ejecuta todas las instrucciones después de la palabra Then y así hasta llegar a End If, es decir, ejecuta el bloque entre Then y End If. También puede requerir que se ejecute otro bloque de instrucciones en caso de que sea falsa la expresión booleana, como se muestra a continuación:

Sintaxis:

If (expresion booleana) Then

<Una o más Instrucciones ejecutadas en caso de ser verdadera la expresión booleana>

Else

<Una o más Instrucciones ejecutadas en caso de ser falsa la expresión booleana>

End If

Semántica:

Si la expresión booleana se evalúa a verdadero (True) entonces (Then), ejecuta todas las instrucciones después de la palabra Then y así hasta llegar a Else, es decir, ejecuta el bloque entre Then y Else.

Si la expresión booleana se evalúa como falsa (False) ejecuta todas las instrucciones del bloque Else - End If.


45

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.



3.12 Estructuras de ciclo

Las estructuras de ciclo permiten ejecutar una o más líneas de código repetitivamente. Un bloque de instrucciones puede repetirse hasta que una condición sea verdadera o hasta que sea falsa, o bien, un número de veces especificado. Las estructuras de ciclo que veremos son:

• While

• Do...Loop

• For...Next

• For Each...Next

3.12.1 While

Se puede utilizar la instrucción While para ejecutar un bloque de instrucciones, un número de veces indefinido, dependiendo del valor de una condición. La instrucción While comprueba siempre la condición antes de iniciar el ciclo. La ejecución en ciclo continúa mientras el valor de la condición sea verdadero.

En el ejemplo siguiente, el procedimiento PruebaWhile comprueba la condición antes de entrar en el ciclo. Si número se hubiera inicializado en 6 y no en 10, las instrucciones del ciclo nunca se ejecutarían.

Sub PruebaWhile ( )

Dim iContador As Integer = 0

Dim iNumero As Integer = 10

While iNumero > 6

iNumero = iNumero-1

iContador = iContador + 1

End While

MsgBox("Instruccion ejecutada " & iContador & " veces.")

'Despliega “Instrucción ejecutada 4 veces”.

End Sub.

3.12.2 Do...Loop

Tiene la misma función que While, salvo la diferencia de que las instrucciones dentro del bloque Do---Loop While se ejecutan al menos una vez, debido a que es al final del bloque cuando se verifica la condición; en el ejemplo anterior, si la variable número se hubiera inicializado en 6, las instrucciones del ciclo nunca se ejecutarían, sin embargo, en el siguiente ejemplo las instrucciones del ciclo si se ejecutan una vez.

Sub PruebaDo ( )

Dim iContador As Integer = 0

Dim iNumero As Integer = 6

Do


47

iNumero = iNumero – 1

iContador = iContador + 1

Loop While iNumero > 6

MsgBox("Instrucción ejecutada " & iContador & " veces.")

' Despliega “Instrucción ejecutada 1 veces”.

End Sub.

3.12.3 For...Next

Los ciclos Do funcionan bien cuando no se sabe de antemano cuántas veces se necesitan ejecutar las instrucciones en el ciclo. No obstante, si tiene previsto ejecutar el ciclo un número específico de veces, un ciclo For...Next es una solución. A diferencia de un ciclo Do, un ciclo For utiliza una variable denominada Contador, cuyo valor aumenta o disminuye cada vez que se repite el ciclo. La sintaxis es la siguiente:

Sintaxis:

For <contador> [As datatype] = <valor_inicial> To <valor_limite> [ Step <incremento> ]

'Bloque de instrucciones

Next [ <contador> ]

Ejemplo:

Sub Suma2 ( )

Dim iContador, iTotal As Integer

‘Inicia contador en 2, incrementa de 2 en 2 hasta llegar a 10

For iContador = 2 To 10 Step 2

iTotal = iTotal + iContador

Next iContador

MsgBox ("El total es" & iTotal)

End Sub.

3.12.4 For each Next

El ciclo For Each...Next tiene la función de iterar sobre una colección (objeto de tipo Collection) o bien sobre un arreglo ejecutando el bloque de instrucciones por cada elemento almacenado. La sintaxis es la siguiente:

Sintaxis:

For Each <elemento_de_la_colección> [ As datatype ] In <nombre_de_la_colección>

'Bloque de instrucciones a ejecutarse por cada elemento de la colección:

Next [elemento_de_la_colección].



Ejemplo:

La funcion Sumador recibe como argumento un arreglo llamado A de enteros, suma cada elemento del arreglo y devuelve el valor con la suma total.

Function Sumador (ByRef A() As Integer) As Integer

Dim iElem As Integer

Dim iSuma As Integer = 0

For Each iElem In A

iSuma += iElem

Next Elem

Return iSuma

End Function.

3.13 Funciones y procedimientos

A continuación, se describe la manera de crear y utilizar distintos tipos de procedimientos dentro de Visual Basic.NET. Suponga que tiene que realizar una tarea de forma repetida por ejemplo, solicitar datos (nombre, dirección y teléfono), generar un nuevo registro y almacenarlo en la base de datos. Para estos casos, en lugar de escribir repetidamente las instrucciones, es posible agruparlas en un procedimiento que sea llamado cada vez que necesite hacerlo, tarea para la que han sido creados los procedimientos.

Un procedimiento es un conjunto de instrucciones agrupadas para realizar una determinada tarea. Por ejemplo para el caso anterior, usted puede colocar todas las instrucciones necesarias para solicitar datos, crear el nuevo registro dentro del mismo procedimiento o refinar la solución haciéndola modular y generar un procedimiento para solicitar los datos, así como elaborar el nuevo registro y desde ahí invocar otro procedimiento encargado de agregar registros a la base de datos.

Existen cuatro tipos de procedimientos en Visual Basic .NET, que se describirán posteriormente:

• Procedimientos Sub: realizan tareas específicas.

• Procedimientos Function: realizan tareas específicas y devuelven un valor a la instrucción de llamada.

• Procedimientos Property: asignan o acceden al valor de un objeto.

• Procedimientos Event-Handling: realizan tareas específicas cuando se produce un determinado evento.

3.13.1 Crear e invocar procedimientos

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

La instrucción que invoca al procedimiento también se conoce como instrucción de llamada y su sintaxis es la siguiente:


49

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



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

2. La función utiliza la instrucción Return para especificar el valor devuelto, e inmediatamente devuelve el control al programa de llamada.

Ejemplo:

Function CalculaIVA(ByVal dPrecioProducto As Double) as Double

Dim dPrecioIVA as Double =dPrecioProducto*1.15

Return dPrecioIVA

End Function

Procedimientos controladores de eventos

Un evento es una acción o un suceso, por ejemplo, un clic del ratón, una ventana al mostrarse, etc. el cual devuelve un código de respuesta. Los eventos generalmente se producen como consecuencia de una acción del usuario o del sistema operativo.

Un procedimiento de control de eventos, o controlador de eventos, es el código que se escribe para dar respuesta a un evento concreto.

Los controladores de eventos son procedimientos Sub, que se invocan cuando un objeto detecta que se ha producido un evento por medio del nombre correspondiente al evento.

En este caso no se declararán procedimientos controladores de eventos, ya que la mayoría y todos los que se utilizarán los crea Visual Basic .NET automáticamente.

3.13.2 Paso de argumentos a procedimientos

Como se mencionó anteriormente, un procedimiento utiliza argumentos y estos valores pueden ser pasados a un procedimiento Sub o Function de dos distintas formas:

• posición: en el orden en que aparecen en la definición del procedimiento. hay que especificar el nombre declarado del argumento, seguido de un signo de dos puntos y un signo igual (:=) y seguido del valor del argumento. Los argumentos que se pasan por nombre pueden suministrarse en cualquier orden.

• nombre: especificando el nombre sin tener en cuenta la posición.

Por ejemplo, el siguiente procedimiento Sub toma tres argumentos para mostrar la información de una persona en un cuadro de mensaje:

Sub InformacionPersona(ByVal Nombre As String, Optional ByVal Edad As Short = 0, Optional ByVal FNac As Date = #1/1/2000#)

MsgBox("Nombre = " & Nombre & "; Edad = " & CStr(Edad) & _ "; Fecha de Nacimiento date = " & CStr(FNac)

End Sub

Por posición

Puede invocar el procedimiento pasándole cada argumento de acuerdo al orden en que espera recibirlos según su declaración (Nombre,Edad,FNac).

InformacionPersona ("Juan", 22, #12/09/1983#)



Por nombre

Puede invocar el procedimiento pasándole cada argumento precedido por el identificador (identificador:) hacia el cual desea que lo asigne; estos identificadores deberán coincidir con los declarados por el procedimiento.

InformacionPersona (Edad:=22, FNac:=#12/09/1983#, Nombre:="Juan")

Combinación

Puede invocar el procedimiento pasándole los argumentos mediante una combinación de paso por nombre y por posición; los argumentos por posición deben preceder al resto ya que al suministrar un primer argumento por nombre, el resto deberá especificarse también por nombre.

InformacionPersona ("Juan", 22, FNac:=#9/21/1981#)

Argumentos opcionales

Existen procedimientos en los que no deberá especificar obligatoriamente todos los argumentos, debido quizás a que no se tiene un valor para un argumento en todos los casos, por lo cual tendrá que ser declarado opcional (anteponiendo el modificador Optional) y deberá asignarle un valor por defecto, el cual tomará en caso de que no sea suministrado en la invocación al procedimiento.

Por ejemplo en el caso anterior, el argumento FNac fue declarado opcional con un valor por default (#1/1/2000#) desde la definición del procedimiento InformacionPersona, de esta manera se podrán hacer invocaciones al método suministrándolo o no, como se muestra a continuación:

InformacionPersona ("Juan", 22)

Paso por valor, por referencia

Además de la forma en que se suministran los argumentos para que sean recibidos por el procedimiento, se cuenta con la que recibe el contenido de las variables pasadas como argumento, tal cual se describe a continuación:

• Por valor: si se antepone el modificador ByVal, se toma el valor de la variable (en realidad crea una copia de la variable con el mismo valor), por lo que cualquier cambio sobre la variable no afecta a la original.

• Por referencia: si se antepone el modificador ByRef se toma la variable original (la referencia que apunta a la dirección en memoria), por lo que cualquier cambio se hace en realidad sobre la misma variable.

Sobrecarga de métodos

Habrá ocasiones en las que no sólo deseará especificar como opcionales algunos argumentos, sino que deseará crear otro procedimiento, que por estar estrechamente relacionado, llevará el mismo nombre pero una lista de argumentos distinta, lo cual se conoce como sobrecarga. Para sobrecargar un procedimiento, deberá realizar lo siguiente:

• Utilizar el mismo nombre del procedimiento que desea sobrecargar.


53

• Deberá poder distinguir la lista de argumentos de cada procedimiento haciendo una o más de las siguientes variaciones:

o Especificar un número distinto de argumentos.

o Cambiar el orden de los argumentos.

o Cambiar el tipo de dato de los argumentos.

Al nombre del procedimiento junto con los tipos de datos en la lista de argumentos, se le conoce como firma del método; y para sobrecargar un método deberá de tener una firma distinta, por ejemplo, suponga que está escribiendo un procedimiento Sub para buscar una película, y que puede buscarla por código o por nombre. Para ello, puede definir dos procedimientos Sub diferentes, como se indica en este ejemplo:

Sub BuscaPorNombre(ByVal NombrePelicula As String, ByVal Precio As Single)

Sub BuscaPorCodigo(ByVal CodigoPelicula As Integer, ByVal Precio As Single)

O bien podría sobrecargar un nombre de procedimiento utilizando una firma distinta; adicionalmente, puede colocar a todos los procedimientos sobrecargados, el modificador Overloads, como se muestra a continuación.

Overloads Sub Buscar(ByVal NombrePelicula As String, ByVal Precio As Single)

' Código para acceder al registro de la película por nombre.

End Sub

Overloads Sub Buscar(ByVal CodigoPelicula As Integer, ByVal Precio As Single)

' Código para acceder al registro de la película por código.

End Sub

En el caso anterior, ambos procedimientos tienen distinta firma, la del primero es Buscar(String,Single) y la del segundo Buscar(Integer,Single), por lo que la sobrecarga cumple con las reglas necesarias.

Procedimientos recursivos

Un procedimiento recursivo es aquel que se llama a sí mismo. Por ejemplo, el siguiente procedimiento utiliza la recursividad para calcular el factorial de su argumento original:

Function Factorial(ByVal N As Integer) As Integer If N <= 1 Then ' Por definición factorial de N<=1 es uno Return 1 Else 'Si N>1 entonces habrá que calcular factorial de N-1 y multiplicar por N Return N * Factorial(N - 1) 'Llamada recursiva a factorial End If End Function



NOTA. Si un procedimiento Function se llama a sí mismo de manera recursiva, su nombre debe ir seguido de un paréntesis, aunque no exista una lista de argumentos. De lo contrario, se considerará que el nombre de la función representa al valor devuelto por ésta.

3.14 Colecciones

Al igual que una matriz es un grupo de variables relacionadas, una colección es un grupo de objetos relacionados. De igual manera, presentan la ventaja de que se puede iterar (recorrer en ciclo) sobre los miembros de la clase Collection con For Each...Next y hacer referencia a los mismos mediante un índice.

Visual Basic .NET proporciona una clase Collection, con la que se pueden definir y crear colecciones propias, como se muestra a continuación.

Public Class Form1

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

Dim miColeccion As Collection = New Collection

Dim a, b, c As String

a = "Mi"

b = "Primer"

c = "Coleccion"

'Agregando elementos

miColeccion.Add(a, "Mi")

miColeccion.Add(b, "Primer")

miColeccion.Add(c, "Coleccion")

'Eliminando elementos

miColeccion.Remove(1) ' Elimina el primer elemento de la colección

miColeccion.Remove("Coleccion") 'Remueve el miembro con la palabra "Colección"

For Each palabra As String In miColeccion

If palabra = "Primer" Then

MsgBox(palabra) ' Despliega el elemento con la clave "Primer"

End If

Next

End Sub

End Class


55

CAPÍTULO

Manejo de excepciones

Es posible que durante la ejecución de una aplicación, ésta llegue a fallar o pueda presentarse un comportamiento inesperado, como por ejemplo, que no estén disponibles recursos del sistema operativo, o que la conexión hacia una base de datos externa falle, a este tipo de errores se les conoce como excepciones. Al lanzarse una excepción, usted como programador deberá encargarse de darle un buen manejo, es decir, la aplicación no debería dejar de funcionar abruptamente y originar que todos los cambios realizados por el usuario se pierdan o que simplemente se cierre la aplicación. Al menos, habrá que informar al usuario el tipo de error que ha ocurrido y si es un error crítico, entonces sí liberar los recursos utilizados y posteriormente cerrar la aplicación, o mejor aún, si no es un error crítico, continuar con la ejecución de la aplicación.

Existen distintos tipos de errores:

• Sintácticos: son aquellos en donde se escribe código que no cumple con las reglas del lenguaje de programación, y este tipo de errores son generalmente detectados por el compilador en tiempos de compilación.

• Ejecución: errores que aparecen durante la ejecución, por ejemplo la división por cero.

• Lógicos: son errores que ocasionan el no obtener los resultados esperados en el programa, por ejemplo, si usted desea aplicar el 15 % de IVA a dos productos con un precio de $10.00 esto equivale a obtener (10+10)*1.15 = 23, un error lógico que nos daría un resultado distinto debido a las reglas de precedencia de los operadores, por tanto debería ponerse 10+10*1.15 = 21.5

4.1 La clase Exception

El control de este tipo de errores se puede hacer mediante excepciones, una excepción como todo en Visual Basic .NET es un objeto que es instancia de la clase Exception o de alguna clase heredada de Exception.

La clase Exception se encuentra disponible dentro del espacio de nombres System por lo que la podremos utilizar sin necesidad de importarla. La clase Exception permite procesar



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

4.2 Generación de excepciones

Ya sabe declarar sus propias excepciones, a continuación revisaremos cómo crear una instancia de ellas para lanzarlas en el momento de detectar un error.

En el siguiente ejemplo, el procedimiento de tipo Function “Divide” crea una instancia de la clase DivisionPorCeroException y la lanza en caso de recibir un divisor igual a cero como argumento.

Public Function Divide(ByVal iDivisor as Integer, ByVal iDividendo as Integer)

If (iDivisor = 0) Then

‘Se crea la excepción invocando al constructor que recibe el mensaje descriptivo

Dim NuevaExcepcion as DivisionPorCeroException = new DivisionPorCeroException ("El argumento divisor es igual a cero")

'Se lanza la excepción mediante la instrucción throw

throw

Else

return iDivisor/iDividendo

End Function

4.3 Try… Catch

Cuando una excepción es lanzada, se detiene el flujo de ejecución y abandona el método que lanzó la excepción, así comienza la búsqueda de un manejador para la excepción lanzada dentro de los procedimientos ubicados en la pila de llamadas, es decir, primero busca dentro del último procedimiento que invocó a aquél que generó la excepción, si no encuentra un manejador busca a su vez dentro del procedimiento que invocó a este último y así sucesivamente, hasta encontrar el manejador de la excepción o bien termina la ejecución de toda la aplicación en caso de no existir.

Para evitar que termine la ejecución al lanzar una excepción, deberá hacer lo siguiente:

1. Si dentro de un procedimiento usted invoca uno o más procedimientos que puedan lanzar una excepción, coloque las instrucciones de llamada al procedimiento dentro de un bloque Try.

2. Al final del bloque Try coloque un bloque Catch para manejar la(s) posible(s) excepción(es) lanzadas por los procedimientos invocados.

3. Al final del bloque Catch, opcionalmente puede agregar un bloque Finally que se ejecutará siempre (se lance o no una excepción), esto le permitirá cerrar archivos y conexiones o liberar recursos que esté utilizando.

Try

Divide(x,y)

‘Manejador para la excepción DivisionPorCeroException

Catch excepcionLanzada as DivisionPorCeroException

MsgBox(“No puedo dividir por cero”)

y = InputBox(“Teclea otro numero”)



Divide(x,y)

Exit Catch

Finally

‘Aquí irían las instrucciones que se ejecutarán siempre, ocurra o no una excepcion

MsgBox(“Gracias por utilizar el método divide”)

End Try

Control no estructurado de excepciones

Al manejo de excepciones mediante los bloques Try...Catch se le conoce como manejo estructurado y es el más recomendable, pero contrario a éste existe el manejo no estructurado que utiliza la instrucción On error.

Cuando un programa lanza una excepción, el control del programa pasa al argumento especificado en la instrucción On Error, para el cual existen las siguientes opciones:

• On Error GoTo <línea>

• On Error ResumeNext

• On Error GoTo 0

• On Error GoTo -1

On Error Go To <Línea>, permite especificar el código para resolver la excepción. El parámetro <línea> indica el inicio de dicho código. Cuando se detecta un error en el código, posterior a la instrucción On Error GoTo <línea>, el control se pasa hasta el número de línea especificado por <línea>.

Ejemplo:

Sub MiProcedimiento

On Error GoTo ManejadorDeExcepcion

<Instrucciones a ejecutar>

Exit Sub

ManejadorDeExcepcion:

'Código de resolución de errores

Resume

End Sub

En este caso, el nombre del manejador de errores es ManejadorDeExcepcion, si se encontrara un error en el código del procedimiento MiProcedimiento, se ejecutarían las instrucciones que siguen a la etiqueta ManejadorDeExcepcion:

• On Error Go To ResumeNext: esta instrucción intenta pasar por alto el error y continuar la ejecución del mismo en la línea siguiente al lugar en donde se originó el error.

• On Error Go To 0: esta instrucción deshabilita todos los manejadores de excepciones del procedimiento actual.


59

• On Error Go To -1: esta instrucción es igual a la anterior salvo que su uso no es obligatorio, ya que al terminar la ejecución del procedimiento, se desactivan automáticamente todos los manejadores de errores del procedimiento.

4.4 Errores lógicos y depuración

Aun cuando ya no existan errores sintácticos en el código (lo cual significa que todo el código cumple las reglas del lenguaje), que impidan la compilación al momento de generar el proyecto, pueden existir errores semánticos o lógicos, éstos se producen cuando la sintaxis del código es correcta, pero los resultados no son los esperados por que existe algo mal en la lógica del programa, por ejemplo, un ciclo infinito no sería detectado por el compilador. Sin embargo, usted podría detectar que su programa no llega a ejecutar cierta instrucción y esto precisamente porque se encuentra ejecutando infinitamente las instrucciones dentro del ciclo. A continuación, se presenta una tabla ejemplificando distintos tipos de errores:

Código Descripción Tipo de error

Sub Main() Dim X As Integer Console.WriteLine(Y) End Sub

Se declara la variable X y se intenta imprimir Y. "No se ha declarado la variable Y".

Sintáctico (detectado en la compilación).

Sub Main() Dim cadena, inversa As Stringcadena = "hola" inversa = "" For i As Integer = cadena.Length To 0 Step -1 inversa = inversa + cadena.Chars(i) Next i Console.WriteLine(inversa) Console.Read() End Sub

El código anterior intenta obtener la inversa de una cadena pero marca el error: 'System.IndexOutOfRangeException' ya que se inicializó la variable i=cadena.Length, esto es igual a 4, por lo que en la primera iteración del bucle For intenta obtener el caracter en el indice 4, el cual no existe ya que los índices de esta cadena van de 0 a 3.

Semántico (detectado en la ejecución).

Sub Main() Dim cadena, inversa As Stringcadena = "hola" inversa = "" For i As Integer = cadena.Length -1 To 0 Step 1 inversa = inversa + cadena.Chars(i) Next i Console.WriteLine(inversa) Console.Read() End Sub

En este caso, se hace la asignación correcta para que ya no mande el error como en el caso anterior, pero se modificó el decremento de -1 al contador y ahora se incrementa 1. Esto ocasiona que se caiga en un bucle infinito ya que el contador nunca llegará a ser 0, por lo que no obtiene la cadena inversa.

Semántico (detectado por el usuario o el programador al no obtener los resultados esperados).

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



del código e ir ejecutando instrucción por instrucción y en cada momento inspeccionar los valores de las variables, revisar la memoria, cambiar los valores a las variables para ver qué consecuencias tiene esto, observar el tráfico de mensajes y así podrá obtener una visión más detallada y encontrar el origen de los errores.

4.4.1 Ejecución del código paso a paso

En vez de ejecutar todo el programa hasta su finalización, puede elegir ejecutarlo paso a paso por instrucciones o por procedimientos, lo que permite observar el comportamiento del programa en cada momento de la ejecución. Para iniciar la depuración de su aplicación en modo paso a paso por instrucciones seleccione de la barra de menús Depurar | Paso a Paso por instrucciones o presione la tecla F11, se mostrará la siguiente pantalla:

Figura 20. Ejecución del código paso a paso por instrucciones.

La flecha amarilla indica la próxima instrucción a ejecutarse usted puede cambiar el orden arrastrando la flecha hasta la instrucción deseada (aunque esto puede traer consecuencias inesperadas). También existen diversas ventanas de depuración que puede mostrar seleccionándolas de la barra de menús Depurar | Ventanas, entre las que se recomiendan:

• Variables Locales: muestra el nombre, el valor y el tipo de dato de cada variable local en cada momento de la ejecución, además, permite cambiar el valor de cada variable dando clic en el campo valor y modificándolo de forma manual.

• Automático: muestra el valor que tienen las variables utilizadas en la línea actual y en la línea siguiente.

Siguiente instrucción a ejecutar

Ventanas de depuración (activada variables locales)


61

Estas ventanas son muy útiles, por ejemplo, en caso de obtener un error en el que intente acceder a un índice fuera de los límites de un arreglo desde estas ventanas, puede verificar cuál es el valor que está produciendo el error, modificarlo de manera manual y posteriormente corregir el código para evitarlo.

Para seguir ejecutando las siguientes instrucciones, continúe presionando F11.

Para salir del modo de depuración, seleccione de la barra de menús Depurar | Detener Depuración o presione las teclas Mayus + F5.

4.4.2 Puntos de Interrupción

En la mayoría de las ocasiones no deseará detener la ejecución tras cada instrucción, sino únicamente en aquellas instrucciones que ha detectado como posibles causantes del error, para esto usted puede colocar puntos de interrupción que indicarán al depurador las instrucciones en las que debe detenerse.

Para depurar su aplicación utilizando puntos de interrupción, realice lo siguiente:

1. Desde el editor de código, dé clic en la zona gris que aparece del lado izquierdo a la altura de la línea en la que desea detener la ejecución, la cual quedará sombreada, como se muestra en la siguiente pantalla:

Figura 20. Punto de interrupción.

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

4.4.3 Puntos de interrupción condicionales

Además de querer detener la ejecución del proyecto sólo en ciertas instrucciones, puede necesitar que sólo se detenga en esos puntos si se cumplen determinadas condiciones,

Dé clic para colocar el punto de interrupción en esta línea



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:

Figura 20. Propiedades del punto de interrupción.

3. Se abrirá una ventana en la que puede ver y definir propiedades del punto de interrupción; para colocarle una condición, dé clic en el botón Condición, como se muestra a continuación:

Figura 20. Botón para poner una condición al punto de interrupción.

4. Posteriormente, se abrirá una ventana de diálogo en la que puede colocar la condición que tiene que cumplirse para detener la ejecución, por ejemplo, que cierto


63

contador i sea igual a cuatro, como se muestra a continuación; al terminar dé clic en el botón Aceptar de las dos ventanas de diálogo que se encuentran abiertas.

Figura 20. Condición para un punto de interrupción.

Inicie la depuración del proyecto presionando la tecla F5, con lo cual se ejecutarán todas las instrucciones hasta detenerse en el primer punto de interrupción que encuentre y sólo si se cumple la condición establecida, en ese momento usted podrá hacer uso de las ventanas de depuración para verificar y modificar si así lo desea, los valores que en ese momento tengan cada una de las variables.

Finalmente, para obtener mayor información sobre todos los puntos de interrupción marcados dentro del código, seleccione la ventana Puntos de interrupción (BreakPoints) desde el menú Debug | Windows | Breakpoints (Depuración | Ventanas | Puntos de interrupción), con lo que se mostrará una ventana como la siguiente:

Figura 21. Ventana de puntos de interrupción.

Esta ventana muestra el nombre, la condición y un recuento de las visitas de cada punto de interrupción y también le permite: crear, deshabilitar, eliminar y consultar propiedades, entre otras.

Es muy importante hacer un buen manejo del depurador debido a que en varias ocasiones le salvará de invertir demasiado tiempo en busca de errores lógicos, los cuales serían difíciles de encontrar.



CAPÍTULO

Uso de la programación orientada a objetos

Visual Basic .NET es un lenguaje de programación completamente orientado a objetos, por lo que soporta las cuatro principales características de ese paradigma: abstracción, encapsulamiento, herencia y polimorfismo. Esto implica que como desarrollador deberá realizar el diseño de su aplicación en términos de actores (objetos), sus características (propiedades) y los servicios (métodos) que deben tener para cooperar a la solución. A lo largo de este tema, aprenderá a codificar estos elementos dentro del lenguaje de programación.

5.1 Creación de una clase

Una clase es una plantilla en donde se definen las propiedades y los métodos que tendrán todos los objetos que sean creados como instancias de la misma; la sintaxis para su declaración es la siguiente:

Sintaxis:

<Declaración de clase>::=

[<acceso>] class <identificador>

<Declaraciones de propiedades>

<Declaraciones de métodos>

End Class

Semántica:

Se declara una clase con el acceso y el identificador indicado, el cual será utilizado al momento de crear un nuevo objeto instancia de esta clase.

Las propiedades se utilizan para almacenar el valor de cada uno de los atributos del objeto y que definen su estado, por ejemplo, las propiedades de la clase Persona podrían ser: Nombre, Estatura, Peso, Tipo de sangre, etc.


65

Los métodos corresponden a las acciones que puede realizar un objeto y que definen su comportamiento, por ejemplo, para la clase Persona algunos métodos podrían ser: pensar, hablar, caminar, etc.

Usted puede elegir las propiedades y métodos por definir dependiendo de las características y acciones que le interesa tengan los objetos, para así cooperar con la solución del problema en cuestión. Más adelante conocerá la forma de declarar propiedades y métodos de un objeto.

Una clase le permite encapsular la información declarada dentro de ella, por lo que usted puede definir quiénes tendrán acceso, utilizando la siguiente sintaxis.

Sintaxis:

acceso::= Public | Protected

Semántica:

Se declara quiénes tienen acceso a la clase, según los siguientes modificadores:

• public: desde cualquier otro lugar dentro del mismo proyecto (clase, módulo) o desde cualquier otro proyecto que le haga referencia.

• Protected: desde una clase derivada o hija (que herede de ésta) y que pertenezca al mismo proyecto.

Existen más modificadores de acceso (Private, Friend, etc.) pero éstos no son aplicables a las clases, sólo a propiedades o métodos, temas que veremos posteriormente. Por ejemplo, declarar acceso private a una clase, implicaría que sólo es accesible dentro de sí misma, lo cual no tiene sentido.

5.2 Agregar un módulo de clase

Para agregar una clase a un proyecto dentro de Visual Studio .NET, seleccione de la barra de menús la opción Proyecto | Agregar Clase (Project | Add Class), con lo cual se mostrará un cuadro de diálogo como el siguiente:



Coloque el nombre de la clase (por ejemplo, Persona) y dé clic en el botón Abrir. Posteriormente se creará una nueva clase conteniendo el siguiente código:

Public Class Persona

End Class

5.3 Definir propiedades de la clase

El primer paso después de agregar una clase al proyecto, es definir las propiedades que se codifican dentro del lenguaje como variables miembro (field members o campos), las cuales son globales dentro del ámbito de la clase, ya que se declaran dentro de la clase (preferentemente al inicio) pero fuera de cualquier procedimiento, por ejemplo para declarar los campos de la clase Persona.


Private sNombreCompleto As String

Private dateFechaNacimiento As Date

End Class

De esta forma, todos los objetos que usted cree, tendrán los atributos sNombreCompleto e iEdad, y cada objeto podrá asignarle un valor distinto a cada una de sus propiedades.

5.4 Propiedades compartidas

Existen propiedades denominadas “compartidas“ o “variables de clase”9 que tendrán el mismo valor para todos los objetos por lo que es inconveniente que se cree una variable por cada nueva instancia; de esta manera, una sola variable que pertenece a la clase, será compartida por todos los objetos de la misma clase

Un ejemplo de una propiedad compartida sería el limiteHoras (24 horas) en la clase Reloj, ya que para todos los relojes tendrá el mismo valor, otro ejemplo lo constituye la propiedad MaxValue de la clase System.Date que devuelve el mayor valor posible para este tipo de dato, es decir, aun cuando existan varios objetos instancias de la clase Date, tendrán el mismo valor para la propiedad compartida MaxValue al no ser un valor que dependa del objeto particular sino de la clase.

Por ejemplo, para la clase Persona, un ejemplo de propiedad compartida es la especie de la que provenimos los seres humanos “Homo Sapiens”, que sería codificada de la siguiente manera:




Private Shared sEspecie As String=“Homo Sapiens”

End Class

9 Algunas ocasiones también son llamadas estáticas, debido a que en el lenguaje de

programación Java se les coloca el modificador static a este tipo de variables.


67

Un uso muy común de las propiedades Shared es como contador de instancias de una clase, como se muestra a continuación:

Public Class Elemento

'Declaramos la propiedad compartida (Shared)

Public Shared iContador As Integer = 0

Public Sub New()

iContador += 1 'Cada que se crea un objeto se incrementa el contador

End Sub

End class

Dim objeto1 As New Elemento() ‘Cuando creamos la primera instancia el contador se incrementa a 1

Dim objeto2 As New Elemento() ‘Cuando creamos la segunda instancia el contador se incrementa a 2

5.7 Visibilidad de las propiedades

Una característica de la programación orientada a objetos es el encapsulamiento que consiste en que cada objeto oculte los detalles de su implementación y sólo permite la modificación de su estado (conjunto de propiedades) a través de los métodos correspondientes (procedimientos Property en el caso de Visual Basic .NET). Por lo anterior, es recomendable que el acceso a las propiedades sea privado (private), para que sólo puedan ser modificadas dentro de la clase y se proporcione una interfaz pública que permita su modificación a través de la declaración de procedimientos Property, los cuales tendrán acceso público (Public). Un procedimiento Property sirve para declarar las siguientes secciones:

• Get: para devolver el valor de la propiedad.

• Set: para asignar un valor (pasado como argumento) a la propiedad, esto permite controlar qué valores se pueden asignar a la propiedad (llamado dominio).

A continuación, se presenta la sintaxis para declarar un procedimiento Property:

Sintaxis:

Property <identificador> [(lista de argumentos)] As tipo

Get

Return valor

End Get

Set [(ByVal nuevo As tipo)]

valor = nuevo

End Set

End Property



Por ejemplo, para la clase Persona declararíamos un procedimiento Property por cada una de sus propiedades, como se muestra a continuación:





‘Declaración del procedimiento Property para manipular la propiedad sNombreCompleto

Public Property NombreCompleto () as String

Get ‘bloque para devolver el valor de la propiedad

Return sNombreCompleto

End Get

‘bloque para asignar el valor de Value a la propiedad

Set(ByVal Value As String)

If Value <> "" Then ‘No asignaremos cadenas vacías “”

sNombreCompleto = Value

End If

End Set

End Property

...’Se continua declarando los demás procedimientos Property

End Class

Una característica de los procedimientos Property es ofrecer un mayor control sobre su acceso y modificación como se comentó anteriormente, incluso permite declarar que una propiedad sea de sólo lectura e impide su modificación, para lo cual únicamente deberá indicarlo y declarar la sección get, como se muestra a continuación para la clase persona donde una vez creado el objeto, no se podrá modificar la propiedad sNombreCompleto.

Public ReadOnly Property NombreCompleto () as String



End Get

End Property

Otro ejemplo de la aplicación de la propiedad de sólo lectura la representa MaxValue en System.Date, que implica el valor más grande para el tipo de dato Date; esta propiedad además de ser compartida, únicamente puede ser consultada, en tanto es algo que usted como programador no puede modificar.

También puede declarar propiedades de sólo escritura, en las que únicamente podrá modificar la propiedad sin poder consultarla por ningún método; un ejemplo para la clase Persona y la propiedad sNombreCompleto, se muestra a continuación:


69

Public WriteOnly Property NombreCompleto () as String




End If

End Set

End Property

Si usted desea que las propiedades impliquen tener acceso y puedan ser modificadas desde cualquier otra clase, puede declararlas con acceso publico (public); si sólo quiere que aquellas que sean heredadas de esta clase puedan hacerlo, declárelas con acceso protegido (protected).

5.8 Definición de métodos

Ya sabe cómo declarar propiedades e incluso un tipo de método (property) para manipularlas, ahora aprenderá a declarar más métodos que tienen como función principal codificar las acciones que puede llevar a cabo un objeto; un método puede recibir o no parámetros de entrada para procesarlos y regresar un valor de salida (Función) o sólo realizar un proceso (procedimiento).

Para la clase Persona, además de definir métodos Property para manipular las propiedades (métodos considerados de acceso y actualización ya que permiten acceder y actualizar el valor de las propiedades del objeto), deberá definir métodos de implementación para que el objeto realice las acciones necesarias.









End Get





End If

End Set



End Property

...’Se continua declarando los demás procedimientos Property

‘Declaramos el método de implementación hablar

Public Sub Hablar(ByVal mensaje as String)

MsgBox(“mensaje”)

End Sub

End Class

5.9 Métodos compartidos

De la misma forma que existen propiedades compartidas, hay métodos compartidos por todas las instancias de una misma clase (métodos estáticos o de clase), y su característica principal es que sólo podrán acceder a propiedades compartidas de la clase y al igual que las propiedades, aunque se puede acceder a través de un objeto, se recomienda utilizar mejor el nombre de la clase, en tanto no es necesario que exista instancia alguna para invocarlo.

Un ejemplo de método compartido es Now en la clase System.Date que devuelve la fecha y hora actual del equipo, es decir, aun cuando existan varios objetos instancias de la clase Date devolverá el mismo valor al invocar a Now, al no ser un método que dependa de la instancia sino de la clase. Para la declaración de métodos compartidos, es necesario utilizar el modificador Shared como se muestra a continuación:

Para la clase Persona, podría crear un método compartido que acceda en este caso al miembro compartido sEspecie, el cual será de sólo lectura como se muestra a continuación:









End Get





End If

End Set


71

End Property

...’Se continúa declarando los demás procedimientos Property

‘Declaramos el método de implementación hablar

Public Sub Hablar(ByVal mensaje as String)

MsgBox(“mensaje”)

End Sub

End Class

‘Declaración de métodos compartidos, en este caso se crea la property compartida para acceder a la propiedad compartida sEspecie

Public Shared ReadOnly Property Especie() As String

Get 'bloque para devolver el valor de la propiedad

‘Solo puede acceder a propiedades compartidas

Return sEspecie

End Get

End Property

End class

Para el caso de la clase Elemento puede crear un método compartido de acceso a la propiedad iContador que cuenta el número de instancias como se muestra a continuación:

Public Class Elemento

'Declara una propiedad compartida

Public Shared iContador As Integer = 0

Public Sub New()

iContador += 1

End Sub

'Declara un método compartido que solo podrá acceder a propiedades compartidas

Public Shared Sub MetodoCompartido()

MsgBox("El valor del contador es : " & contador)

End Sub

End class

5.10 Definición del constructor

Además de los métodos de actualización, acceso e implementación, existen métodos constructores que tienen como función fabricar una nueva instancia (objeto) e inicializar cada una de sus propiedades. Si usted no define algún método constructor Visual Basic .NET crea un constructor vacío automáticamente que inicializa cada propiedad que no ha sido inicializada al momento de su declaración, con los valores por defecto de



acuerdo a su tipo de dato, de la siguiente forma: numéricos con cero, lógicos (tipo boolean) con false, fecha con 01/01/2001 12:00 a.m, referencias con Nothing, etc, por ejemplo para la clase persona tal como se muestra a continuación:





End Class

Al no definir ningún constructor, usted puede invocar al constructor vacío de la siguiente forma:

Dim nuevaPersona as Persona = new Persona()

La instrucción anterior inicializaría las propiedades de nuevaPersona con los valores por defecto (sNombreCompleto con cadena vacía “”, dateFechaNacimiento con #01/01/2001 12:00 a.m#, y sEspecie con “Homo Sapiens”, ya que fue inicializada desde su declaración.

Lo recomendable es que usted defina sus propios métodos constructores e inicialice las propiedades del objeto con los valores que le pasan como argumento para su asignación; en cuanto a aquéllos, de los cuales no le pasan un valor, usted no las inicialice para que tomen el valor por default o bien usted elija un valor para su asignación, un ejemplo para la clase Persona se muestra a continuación:





‘Constructor que inicializa ambas propiedades con los argumentos

Public Sub New(ByVal Nombre as String, ByVal FNac AS Date)

sNombreCompleto=Nombre

dateFechaNacimiento = FNac

End Sub

‘Constructor que solo recibe el nombre y asigna un valor por defecto a la fecha de nacimiento

Public Sub New(ByVal Nombre as String)


dateFechaNacimiento = #10/21/1983#

End Sub

‘Constructor vacío asigna valores por defecto (definidos por el programador) a ambas propiedades

Public Sub New()

sNombreCompleto=””


73


End Sub

End Class

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

5.11 Definición del destructor

De la misma forma que puede definir métodos para construir unas instancias, puede definir uno para destruirlas, mediante el procedimiento Finalize que no puede ser sobrecargado, es decir, solamente existe un destructor Finalize en cada clase.

El método Finalize está definido en la clase Object, pero usted deberá sobrescribirlo e implementarlo para adaptarlo a las necesidades de la clase que lo defina; este método sólo podrá invocarse desde la clase a la que pertenece o desde clases derivadas (Protected).

Para el ejemplo de la clase Persona y suponiendo ahora que se tiene una propiedad compartida que cuenta el número de instancias que es incrementada cada vez que se invoca algún constructor, dentro del método destructor deberá decrementarse, como se muestra a continuación:





Private Shared numInstancias As Integer=0

‘SE DECLARAN LOS CONSTRUCTORES

‘Constructor que inicializa ambas propiedades con los argumentos

Public Sub New(ByVal Nombre as String, ByVal FNac AS Date)


dateFechaNacimiento = FNac

End Sub

‘Constructor que solo recibe el nombre y asigna un valor por defecto a la fecha de nacimiento

Public Sub New(ByVal Nombre as String)



End Sub

‘Constructor vacío asigna valores por default (definidos por el programador) a ambas propiedades



Public Sub New()

sNombreCompleto=””


End Sub

‘SE DECLARAN LOS METODOS PROPERTY (DE ACCESO Y ACTUALIZACIÓN)

Public Property NombreCompleto() As String



End Get

Set(ByVal Value As String) 'bloque para asignar un valor

If Value <> "" Then 'No asignaremos cadenas vacías “”


End If

End Set

End Property

Public Property FechaNac () As Date


Return dateFechaNacimiento

End Get

Set(ByVal Value As Date) 'bloque para asignar un valor

If Value < Date.Now Then 'Solo fechas menores de la fecha actual

dateFechaNacimiento = Value

End If

End Set

End Property

‘Método compartido para acceder a la propiedad compartida sEspecie

Public Shared ReadOnly Property Especie() As String


‘Solo puede acceder a propiedades compartidas.

return sEspecie

End Get

End Property

'METODOS DE IMPLEMENTACION

Public Sub Hablar(ByVal mensaje As String)

MsgBox("mensaje")

End Sub


75

‘METODO DESTRUCTOR

Protected Overrides Sub Finalize()

‘Aquí irían instrucciones para liberar recursos cerrar archivos, bases de datos, conexiones, etc., en este caso se decrementa la propiedad que cuenta las instancias.

numInstancias= numInstancias - 1

End Sub

End Class

El método Finalize no puede invocarse por el programador, sólo el recolector de basura (GC: Garbage Collector) ejecutará el método una vez que el objeto pase a ser inaccesible (no existan más variables haciendo referencia al mismo).

Si usted desea poder invocar a un método para la liberación controlada de recursos, implemente el método Dispose() de la interface IDisposable, que a diferencia de Finalize puede invocarse de manera manual.

5.12 Objetos basados en clases (referencias)

Ahora que sabe cómo crear sus clases junto con sus propiedades y métodos necesarios, aprenderá a utilizarlos creando objetos instancias de esa clase, para lo cual es necesario declarar una variable de tipo referencia, cuyo tipo de dato sea igual al de la clase, utilizando la siguiente sintaxis:

'declara una variable tipo referencia.

Dim <identificador> As <NombreDeClase>

Semántica:

Se declara una variable (objeto) con el identificador indicado e instancia de la clase correspondiente.

Hasta este momento, sólo hemos declarado la variable y ésta contiene el valor Nothing que apunta a una dirección de memoria inválida; para inicializar esta variable será necesario utilizar el operador New e invocar alguno de los constructores de la clase, como se muestra en el siguiente ejemplo:

Dim P1 as Persona = new Persona(“Tomás”,#10/21/1983#)

Dim P2 as Persona = new Persona(“Carlos”)

Dim P3 as Persona = new Persona()

Con las instrucciones anteriores tenemos tres objetos con identificadores P1, P2, P3 cada uno creado invocando a un constructor distinto.

Operador (.)

Hasta ahora sólo ha creado los objetos, por tanto, para poder acceder a sus propiedades o invocar alguno de sus métodos, tendrá que utilizar el operador ( . ) punto, como se muestra a continuación:

‘Creamos el objeto



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

5.13 Vinculación temprana y tardía

La vinculación temprana (early binding) es la asignación de un tipo de dato específico (no genérico) en la declaración de una variable, lo cual permite a Visual Basic .NET obtener y mostrar información sobre los miembros del tipo al cual está asociado mediante Intellisense, y vincular los métodos del objeto a verdaderas direcciones de función en tiempo de compilación, por ejemplo, en la siguiente declaración se indica que la variable obj será instancia de la clase Persona.

Dim obj As Persona

La vinculación tardía (late binding) es la asignación de un tipo genérico (Object en VB.NET, Variant en versiones anteriores) en la declaración de una variable, por lo cual es posible haga referencia a cualquier objeto, pero Visual Basic no puede tener información sobre sus miembros e Intellisense no puede mostrarlos, sí como tampoco vincular ninguna de las propiedades y métodos de la clase en tiempo de compilación; por tanto es necesario, esperar hasta la ejecución, véase el siguiente ejemplo:

Dim obj As Object

En este caso la variable obj puede hacer referencia a un objeto de cualquier tipo, pero esto no es recomendable debido a que disminuye el rendimiento.


77

CAPÍTULO

Herencia

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

6.1 Clase base y subclases

Visual Basic.NET soporta la herencia, por lo que como programador puede definir una clase base y extender su funcionalidad mediante subclases que deriven de ésta. Las subclases heredarán todas las propiedades, métodos y eventos declarados en la clase base, excepto aquellas con acceso privado (private).

Visual Basic .NET soporta sólo la herencia simple, lo que significa que una clase puede heredar sólo de una clase base, a diferencia de otros lenguajes como C++ en donde se permite que una clase pueda heredar de múltiples clases; para lograr estos fines en Visual Basic .NET, puede implementar múltiples interfases, como aprenderá posteriormente.

La clase base contendrá las propiedades y métodos generales a todas las subclases y conforme desciende por la jerarquía, derivará subclases más refinadas conteniendo nuevos métodos y propiedades que aplicarán tanto a esa clase como a todas las subclases de niveles inferiores. A continuación, se muestra un ejemplo para la jerarquía de clases de transporte.



Figura 20. Diagrama de herencia para los medios de trasporte.

Por ejemplo, para la clase Persona podría derivar la subclase Empleado, sólo recuerde cambiar el acceso Privado (Private) por Protegido (Protected) en aquellas propiedades y métodos que desea que sean heredadas; observe el diagrama que se muestra a continuación.

Figura 21. Diagrama de clases mostrando la generalización de Empleado hacia Persona.

La instrucción Inherits

Para indicar que una clase será subclase de otra, en Visual Basic .NET se utiliza la palabra reservada Inherits, la cual debe colocarse una línea debajo de donde se declara la clase, como se muestra a continuación:

Sintaxis:

Class <nombre_de_clase_hijo>

Inherits <Nombre_de_clase_padre>


79

Semántica:

Declara que la clase es subclase de otra.

‘Marcaría error

Class <nombre_de_clase_hijo> Inherits <Nombre_de_clase_padre>

Por ejemplo, para el caso de la subclase Empleado que derivará de la clase Persona, primero deberá asegurarse de cambiar el acceso privado por el de protegido a las propiedades y métodos de la clase Persona, para después realizar lo siguiente:

Public class Empleado:

inherits Persona10

Protected dSalario As Decimal

Protected iClave As Integer

Protected dateFechaIngreso As Date

'Declaración del constructor que recibe todos los parámetros necesarios para crear una nueva instancia:

Public Sub New(ByVal Nombre As String, ByVal FNac As Date, ByVal Salario As Decimal, ByVal Clave As Integer, ByVal FechaIngreso As Date)

'Asigna las propiedades de Nombre y Fecha de Nacimiento invocando al constructor de Persona (Clase Base) mediante la palabra MyBase:

MyBase.New(Nombre, FNac)

'Posteriormente asigna las propiedades faltantes:

dSalario = Salario

iClave = Clave

dateFechaIngreso = FechaIngreso

End Sub

Public Property Salario() As Decimal


Return dSalario

End Get

Set(ByVal Value As Decimal) 'bloque para asignar un valor

dSalario = Value

End Set

End Property

Public Property Clave() As Integer

Get 'bloque para devolver el valor de la propiedad:

10 Asegurarse de cambiar el acceso privado por protegido a las propiedades y métodos de la

clase Persona para que sean heredados por la clase Empleado.



Return iClave

End Get

Set(ByVal Value As Integer) 'bloque para asignar un valor:

iClave = Value

End Set

End Property

Public Property FechaIng() As Date

Get 'bloque para devolver el valor de la propiedad:

Return dateFechaIngreso

End Get

Set(ByVal Value As Date) 'bloque para asignar un valor:

dSalario = dateFechaIngreso

End Set

End Property

End Class

Con lo anterior indica que la clase Empleado aparte de las propiedades y métodos que declaró, tendrá acceso a las propiedades y métodos (no privados) de la clase base Persona, por lo que usted puede hacer lo siguiente:

Dim E1 as Empleado=new Empleado()

E1.NombreCompleto=”Tomás Serrano Escamilla”

Observe como aun cuando en la clase Empleado no definió el método Property NombreCompleto, sí lo posee y puede utilizarlo por el hecho de ser una subclase de Persona.

Usted puede crear subclases de cualquier clase siempre y cuando ésta no haya sido marcada con la palabra clave NotInheritable (en Java se utiliza la palabra clave Final), lo que indica que será una clase de la cual no podrá crear subclases; en otras palabras, una clase Final en la jerarquía de herencia de la que nada se puede derivar. Por ejemplo, en el diagrama de medios de transporte si usted desea que la clase bicicleta ya no pueda ser refinada, así creando subclases como bicicleta de carreras, de montaña, etc., podría declararla NotInheritable, de esta forma no sería posible derivar subclases. Un ejemplo de una clase final en Visual Basic .NET es la clase Math, esto implica que usted no puede declarar subclases a partir de ella.

6.2 Reemplazo de métodos de la clase base

Ahora que sabe cómo extender las capacidades de una clase base agregando métodos y propiedades en una clase derivada, puede requerir que una propiedad11 o método de la

11 En este caso nos referimos a los métodos Property, no a las variables miembro también

llamadas algunas veces propiedades o atributos.


81

clase base (heredado) se comporte de forma diferente dentro de la clase derivada. En otras palabras, deseará reemplazar una propiedad o método en la clase base por otra propiedad o método con el mismo nombre en la subclase, pero con una implementación distinta; para esto es importante conocer las palabras clave que Visual Basic .NET utiliza para indicar desde una clase base restricciones en el reemplazo de sus propiedades y métodos, como se indica a continuación:

• Overridable: indica que la propiedad o método es reemplazable.

• NotOverridable: indica que la propiedad o método no es reemplazable, lo asume por defecto y solo es necesario colocarlo cuando esa propiedad o método está reemplazando a otra definida en la clase base.

• MustOverride: indica que la propiedad o método debe reemplazarse y, por lo tanto, en la clase base no se implementa sólo se declara, por lo que también se le conoce como abstracto, si una clase contiene un método MustOverride deberá ser declarado MustInherit y no se podrán crear instancias de ésta.

En complemento a las palabras clave para indicar qué propiedades y métodos serán reemplazables, existe una palabra clave utilizada dentro de una clase derivada para sustituir una propiedad o método de una clase base:

• Overrides: indica que la propiedad o método reemplazará a una propiedad o método de la clase base, siempre y cuando esté permitido.

A continuación, se ejemplifica el uso de reemplazar métodos de la clase base.

Suponga que define la clase Figura con el método calcularArea(), posteriormente crea las subclases Círculo y Cuadrado que derivan de la clase Figura; aun cuando ambas tendrán el método calcularArea(), éste deberá tener distinta implementación debido a que la formula para calcular el área no es la misma para un cuadrado y para un círculo; en este caso cada clase deberá reemplazar el método definido en la clase base por otro con el mismo nombre, pero con distinta implementación.

Enseguida se presenta el diagrama de clases del ejemplo anterior, en el cual se muestran también otros métodos que ayudarán a explicar cada uno de los casos del reemplazo de métodos de la clase base.

Figura 22. Diagrama de clases mostrando la generalización de Circulo y Cuadrado hacia Figura



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

'Se utiliza el modificador MustInherit (clase abstracta de la que no pueden crearse objetos) ya que tiene un método MustOverride que debe ser implementado forzosamente en cualquier subclase derivada de ésta.

Public MustInherit Class Figura

Protected dX As Double

Protected dY As Double

Protected dArea As Double

'CONSTRUCTOR: Recibe las coordenadas x, y. El área será calculada posteriormente ya que depende si es un círculo, cuadrado, etc.

Public Sub New(ByVal x As Double, ByVal y As Double)

Me.dx = x

Me.dY = y

End Sub

'PROPERTY's

Public Property x() As Double

Get

Return dX

End Get

Set(ByVal value As Double)

Me.dX = value

End Set

End Property

Public Property y() As Double

Get

Return dY

End Get


Me.dY = value

End Set

End Property

Public Property area() As Double

Get

Return dArea

End Get


Me.dArea = value

End Set



End Property

'DespliegaArea: Método de implementación, muestra un mensaje con el valor del área, es notOverridable por defecto por lo que no podrá ser reemplazado en una subclase.

Public Sub DespliegaArea()

MsgBox("Mi area es : " & area)

End Sub

'DespliegaDatos: Método de implementación, muestra un mensaje con el valor las coordenadas x,y

'es Overridable por lo que podrá ser reemplazado en una subclase, por ejemplo,

'para mostrar otros datos como la longitud de los lados de un cuadrado o el radio de un círculo:

Public Overridable Sub DespliegaDatos()

MsgBox("Mis coordenadas x,y son: " & x & "," & y)

End Sub

'calculaArea: Método de auxiliar, calcula el área de la figura,

'es MustOverride por lo que forsozamente debe ser reemplazado e implementado en una subclase.

'solo se declara y no se implementa ya que no es posible hacerlo a este nivel,

Protected MustOverride Sub calculaArea()

End Class

'SubClase que representa un cuadrado, deriva de figura por lo que además de almacenar la longitud de los lados, almacenará las coordenadas x, y, así como el área mediante el uso de los atributos declarados en la clase base.

'Al ser subclase de Figura debe implementar forzosamente el método calculaArea

Public Class Cuadrado

Inherits Figura

Protected dLado As Double

'CONSTRUCTOR: Recibe las coordenadas x, y. El área es calculada tras asignar los atributos correspondientes.

Public Sub New(ByVal x As Double, ByVal y As Double, ByVal lado As Double):

MyBase.New(x, y)

Me.dLado = lado

calculaArea()

End Sub


85

'PROPOERTY's

Public Property lado() As Double

Get

Return dLado

End Get


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

'SubClase que representa un círculo, deriva de figura por lo que además de almacenar el radio, almacenará las coordenadas x, y, así como el área, mediante el uso de los atributos declarados en la clase base.

'Al ser subclase de Figura debe implementar forzosamente el método calculaArea

Public Class Círculo

Inherits Figura

Protected dRadio As Double


Public Sub New(ByVal x As Double, ByVal y As Double, ByVal radio As Double)

MyBase.New(x, y)

Me.dRadio = radio



calculaArea()

End Sub

'PROPOERTY's

Public Property radio() As Double

Get

Return dRadio

End Get


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:


MsgBox("Mis coordenadas x,y son: " & x & "," & y & "Mi radio es: " & radio)

End Sub

End Class

6.3 La palabra clave MyBase

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

A continuación, se presenta otro ejemplo en el que la subclase DuplicaPago derivada de la clase Pago reemplaza el método CalcularPago de la clase base; pero dentro de esta nueva implementación, se invoca al método de la clase base mediante MyBase.CalcularPago(), regresando el valor por duplicado de éste.


87

Class DuplicaPago

Inherits Pago

Public Overrides Function CalcularPago () As Double

' Llama al método de la ClaseBase y retorna el Valor

Return MyBase.CalcularPago() * 2

End Function

End Class

Obsérvese que aun cuando MyBase hace referencia a la clase base inmediata y a sus miembros heredados, no se puede utilizar para invocar a métodos que utilizaron el modificador MustOverride, debido a que esto implica que no fueron implementados.

6.4 La palabra clave MyClass Otro caso dentro del reemplazo de propiedades y métodos, es en el que usted desea asegurarse de invocar a la propiedad o método declarado en la clase en la que se encuentra, es decir, asegurarse de que no se invocará a un método en la clase base o en subclases derivadas de ésta, para lo cual puede utilizar la palabra clave MyClass.

Por ejemplo, en el caso de la clases Figura, Círculo y Cuadrado y estando dentro de la clase Figura desea asegurarse de invocar al método desplegarDatos declarado como parte de esa clase, y no a los declarados dentro de las clases Círculo o Cuadrado, podrá realizar lo siguiente:

‘Solo se ha agregado el método Prueba al final de la clase




Protected dArea As Double


Me.dx = x

Me.dY = y

End Sub

'PROPERTY's


Get

Return dX

End Get


Me.dX = value

End Set

End Property




Get

Return dY

End Get


Me.dY = value

End Set

End Property

Public Property area() As Double

Get

Return dArea

End Get


Me.dArea = value

End Set

End Property

Public Sub DespliegaArea()


End Sub



End Sub

Protected MustOverride Sub calculaArea()

Public Sub Prueba()

'Uso de MyClass para llamar al método declarado en esta clase:

DespliegaDatos()

End Sub

End Class

En este caso en que se colocó la palabra clave MyClass, realizar lo siguiente:

Dim c As Círculo = New Círculo(1, 2, 3)

c.Prueba()

Se desplegará un cuadro de diálogo con el texto “Mis coordenadas x,y son: 1,2 ”.

Contrario a esto, si usted no coloca la palabra clave MyClass el texto será “Mis coordenadas x, y son: 1,2 y Mi Radio es 3”.


89

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:

Figura 23. Ejemplo de herencia visual.

La herencia visual permite que a partir de un formulario base se puedan representar un tamaño estándar de objetos, como botones, cajas de texto y otros controles contenidos dentro del mismo. Por lo que cualquier formulario derivado de un mismo formulario base, tendrá las mismas formas de controles y tamaños. Para agregar un formulario derivado en Visual Studio, seleccione la opción Proyecto | Agregar Formulario Heredado (Project | Add Inherited Form).

Figura 22 Agregar un formulario derivado.

Formulario Base

Class FormBase

Inherits System.Windows.Forms.Form

Formulario Derivado

Class FormDerivado

Inherits FormBase



En caso de que no se haya generado la solución previamente ya sea mediante la opción de la barra de menús Generar | Generar Solución o el menú Depurar | Iniciar, podrá aparecer una ventana de advertencia indicándole que aun no se ha generado el ensamblado, por lo que no puede heredar de algún elemento. Una vez que ha generado la solución, podrá tener disponible los elementos para heredar, con lo que se presentará la pantalla en donde deberá confirmar que desea agregar un formulario heredado y podrá colocar el nombre que desee al nuevo formulario; para continuar dé clic en el botón Abrir.

Aparecerá una ventana solicitándole que seleccione el elemento dentro del proyecto del cual desea heredar, en donde deberá seleccionar el formulario base y dar clic en el botón Aceptar para finalizar, como se muestra a continuación:

Figura 24 Selector de herencia.

Con esto generará un nuevo formulario con la misma apariencia que el formulario base, pero al cual podrá agregar nuevos controles.


91

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






'CONSTRUCTOR: Recibe las coordenadas x, y. El área será calculada posteriormente ya que depende:

'de si es un círculo, cuadrado, etc.


Me.dx = x

Me.dY = y

End Sub

'PROPERTY's


Get

Return dX

End Get


Me.dX = value

End Set

End Property


Get

Return dY

End Get


Me.dY = value

End Set

End Property

'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:



End Sub

Public Sub Prueba()

'Uso de MyClass para llamar al método declarado en esta clase

DespliegaDatos()

End Sub

End Class


93

'SubClase que representa un cuadrado, deriva de figura por lo que además de almacenar la longitud de los lados,

'almacenará las coordenadas x, y y el área mediante el uso de los atributos declarados en la clase base.

'Al ser subclase de Figura debe implementar forzosamente el método calculaArea,

Public Class Cuadrado

Inherits Figura

Implements ISuperficie

Protected dLado As Double

Protected darea As Double


Public Sub New(ByVal x As Double, ByVal y As Double, ByVal lado As Double)

MyBase.New(x, y)

Me.dLado = lado

calculaArea()

End Sub

'PROPOERTY's

Public Property lado() As Double

Get

Return dLado

End Get


Me.dLado = value

End Set

End Property

Public Property area() As Double Implements ISuperficie.area

Get

Return darea

End Get


Me.darea = 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 substituida en subclases derivadas de Cuadrado también se coloca el modificador Overrides

'para indicar que reemplaza al método con el mismo nombre definido en la clase base:

Protected Sub calculaArea() Implements ISuperficie.calculaArea

area = lado * lado

End Sub

'DespliegaArea: Método de implementación, muestra un mensaje con el valor del área,

'es notOverridable por defecto por lo que no podrá ser reemplazado en una subclase.

Public Sub DespliegaArea() Implements ISuperficie.DespliegaArea


End Sub

'DespliegaDatos: Método de implementación, muestra un mensaje con el valor las coordenadas x,y así como la longitud de cada lado,

'se coloca el modificador Overrides para indicar que reemplaza al método,

'con el mismo nombre definido en la clase base:


MsgBox("Mis coordenadas x,y son: " & x & "," & y & "La longitud de cada lado es: " & lado)

End Sub

End Class


95

CAPÍTULO

Polimorfismo

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

7.1 Polimorfismo mediante herencia

El polimorfismo mediante herencia hace alusión a la capacidad que se tiene en la porgramación orientada a objetos, en la que puede declarar una clase base que contenga un método X, posteriormente derivar varias clases a partir de ella, de tal forma que el método X definido en la clase base existirá con el mismo nombre en todas ellas, pero cada una podrá implementarlo de distinta forma y responder con su código particular.

Utilizando el ejemplo de la interfaz Isuperficie y las clases Figura, Cuadrado y Círculo, ahora suponga que declaramos un Módulo de prueba llamado FiguraTest, como se muestra a continuación:

Public Module FiguraTest Private Sub Main() Dim c As Círculo = New Círculo(1, 2, 3) probador(c) Dim cu As Cuadrado= New Cuadrado(1, 2, 3) probador(cu) End Sub Public Sub probador(ByVal fig As Figura) fig.DespliegaDatos() End Sub End Module



El ejemplo anterior crea un objeto de tipo Círculo que pasa como parámetro al método probador (ByVal fig as Figura), el cual recibe una figura e invoca al método DespliegaDatos() de dicha figura, que en este caso mostrará el texto “Mis coordenadas x,y son 1,2 y mi radio es 3”. Posteriormente crea un objeto de tipo Cuadrado y realiza lo mismo, para este caso mostrará el texto “Mis coordenadas x, y son 1,2 y la longitud de cada lado es 3”.

Como podrá darse cuenta, aun cuando el método probador recibe como parámetro un objeto de tipo Figura, no ejecuta el código del método despliegaDatos declarado en la clase Figura, sino más bien el del método despliegaDatos declarado en cada una de las clases correspondientes al objeto que pasaron como parámetro, Círculo y Cuadrado respectivamente, logrando el polimorfismo mediante la herencia a partir de una clase base.

7.2 Polimorfismo mediante interfases

Las interfases proporcionan otro método de conseguir el polimorfismo en Visual Basic .NET.

Para conseguir el polimorfismo mediante interfases, se declara una interfaz conteniendo un método X, posteriormente diversas clases pueden poner en operación dicha interfaz y responder a la invocación del método con su implementación particular.

Continuando con el ejemplo de la interfaz Isuperficie y las clases Figura, Círculo y Cuadrado, observe el siguiente módulo de prueba ejemplificando el uso del polimorfismo mediante herencia.

Public Module FiguraTest

Private Sub Main()

Dim c As Círculo = New Círculo(1, 2, 3)

probador(c)

Dim cu As Cuadrado= New Cuadrado(1, 2, 3)

probador(cu)

End Sub

Public Sub probador(ByVal fig As ISuperficie)

fig.calculaArea()

fig.DespliegaArea()

End Sub

End Module

En este caso al igual que en el anterior, crea un círculo y posteriormente un cuadrado que pasa como parámetros al método probador (ByVal fig As ISuperficie) mostrando el texto “Mi área es: 28.274” y “Mi área es: 9” para el círculo y el cuadrado respectivamente.

Observe de nueva cuenta que aun cuando el método probador recibe como parámetro un objeto de tipo Isuperficie, ejecuta el método correspondiente a cada uno de los objetos que se le pasan como parámetro, para lorar así el polimorfismo mediante una interfaz.


97

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:

Botón Cerrar

Botón Maximizar

Barra de título

Botón Minimizar



En dicho formulario se pueden agregar elementos como etiquetas, cajas de texto y botones entre otros, por ejemplo, para la aplicación de Compuventa descrita al final del tema (PARECE QUE NO SE HA DESCRITO ESTA APLICACIÓN DE COMPUVENTA), se utilizará un formulario por cada pantalla (menú, registro clientes, registro productos, pedidos, etcétera). Entre sus propiedades más representativas se encuentran:

• Name: indica el nombre para identificar el objeto dentro del código.

• AcceptButton: permite establecer un botón Aceptar que será activado cuando el usuario presione la tecla Enter.

• BackColor: color de fondo utilizado para mostrar texto y gráficos en el control.

• BackGroundImage: imagen de fondo utilizada para el control.

• CancelButton: permite establecer un botón Cancelar que será activado cuando el usuario presione la tecla Esc.

• Enabled: indica si el control está habilitado, es decir, si puede ser editado.

• Font: fuente utilizada para mostrar texto en el control.

• Fore Color: color de primer plano utilizado para mostrar texto y gráficos en el control.

• Location: posición de la esquina superior izquierda del control respecto del contenedor.

• Locked: determina si se puede mover o cambiar el tamaño del control en vista de diseño.

• Size: tamaño del control en pixeles.

• Text: indica el texto asociado al formulario en la barra de título.

Entre sus métodos más representativos se encuentran:

• Show(): muestra el control al usuario.

• Activate(): activa el formulario y le otorga el foco.

• Close(): cierra el formulario.

• Focus(): establece el foco de entrada en el control.

• Evento Load: se invoca al cargar el formulario, es útil para introducir instrucciones que deseamos que se ejecuten antes de que se muestre el formulario.

8.2 Label

Las etiquetas son elementos que nos permiten mostrar texto dentro del formulario de nuestra interfaz de usuario, se utilizan para mostrar texto descriptivo acerca de un control. Usted puede elegir cambiar el tipo de fuente, el color y el tamaño de la misma; entre otras propiedades o bien puede escoger la librería de clases de Windows Forms que nos provee estos controles mediante la clase System.Windows.Forms.Label. Por ejemplo, para el caso de la aplicación descrita al final del tema se utilizan controles Label para mostrarlos, y para que el usuario capture los datos correspondientes al producto. Entre sus propiedades más representativas se encuentran:




99





• Text: indica el texto contenido dentro del control.

• Visible: determina si el control está visible u oculto.

8.3 TextBox

Las cajas de texto presentan un campo de entrada dentro del formulario, para que el usuario introduzca datos, los cuales son almacenados en una variabe de tipo Texto correspondiente a la propiedad Text del objeto TextBox; la librería de clases Windows.Forms nos provee de estos controles mediante la clase System.Windows.Forms.TextBox. Por ejemplo, para el caso de la aplicación descrita al final del tema se utilizan controles TextBox dentro de un formulario (FrmProductos por ejemplo), para que el usuario capture los datos correspondientes. Entre sus propiedades más representativas se encuentran:



• CausesValidation: indica si este control causa y genera eventos de validación.






• MaxLength: especifica el número máximo de caracteres que se pueden teclear dentro del control.

• Password Char: indica el caracter que se debe mostrar, asumiendo que se introducirá una contraseña en el control.


• TabIndex: indica el orden de tabulación que ocupará este control, cuando usted presione la tecla tab estando dentro del control, se moverá al indice siguiente.

• Text: Indica el texto contenido dentro del control.

• Visible: Determina si el control está visible u oculto.


• AppendText (texto as String): anexa texto al texto contenido dentro del control.

• Clear(): borra todo el texto del control.

• Focus(): establece el foco de entrada en el control.

• Evento TextChanged: se invoca cuando el texto dentro del control ha cambiado.



• Evento Validating: se invoca al abandonar el control para validar el texto introducido, solo en caso de que la propiedad CausesValidation sea true.

8.4 Button

Seguramente conoce los botones de comando de Windows que generalmente se utilizan para desencadenar una acción (evento) o aceptar/cancelar las opciones que se le presentan al usuario en un cuadro de diálogo. El botón de comando de Windows está representado en la clase System.Windows.Forms.Button. Por ejemplo, para el caso de la aplicación compuventa descrita al final del tema, se utilizan controles Button para que el usuario acepte o cancele una acción para limpiar formularios y para indicar el tipo de búsqueda que desea realizar (por clave o por tipo). Entre sus propiedades más representativas se encuentran:


• BackColor: color de fondo utilizado para mostrar texto y gráficos en el control







• 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.



• 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:


101







• Property Controls(): obtiene la colección de controles que contiene el control.

8.6 RadioButton

Los botones de selección nos permiten mostrar elementos para su selección que son excluibles entre sí, es decir, sólo nos da una opción de entre un grupo de ellas; dentro del formulario de nuestra interfaz de usuario, la librería de clases de Windows Forms provee estos controles mediante la clase System.Windows.Forms.RadioButton. Por ejemplo, para el caso de la aplicación compuventa descrita al final del tema se utilizan controles RadioButton para las opciones de sexo; es imporatante que cada grupo de opciones independiente, quede contenido dentro de un control GroupBox, de lo contrario pertenecerá al contenedor del formulario y no será independiente. Entre sus propiedades más representativas se encuentran:


• Checked: indica si el botón de opción esta activado o no.




• 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.



8.7 CheckBox

Los botones de verificación CheckBox son utilizados para marcar múltiples opciones y la librería de clases de Windows Forms nos provee estos controles mediante la clase System.Windows.Forms.CheckBox. Por ejemplo, para el caso de la aplicación compuventa descrita al final del tema, se utilizan controles CheckBox para las opciones de tarjetas bancarias, debido a que puede tener múltiples. Entre sus propiedades más representativas se encuentran.


• Checked: indica si el botón de opción está activado o no.



• Enabled: indica si el control esta habilitado, es decir, si puede ser editado.




• Text: indica que se mostrará junto al control.

• ThreeState: indica si permitira tres estados en lugar de dos.



• Evento CheckedChanged: se invoca cuando cambia de estado.

8.8 ComboBox

Los cuadros combinados son utilizados para seleccionar uno o más elementos de una lista desplegable, y la librería de clases de Windows.Forms nos provee estos controles mediante la clase System.Windows.Forms.ComboBox. Por ejemplo, para el caso de la aplicación compuventa descrita al final del tema, se utilizan controles ComboBox para que el usuario seleccione de una lista el estado en el que vive. Entre sus propiedades más representativas se encuentran.


• Data Source: indica la lista que el control utiliza para obtener sus elementos.

• Enabled: indica si el control esta habilitado, es decir si puede ser editado.



• Sorted: especifica si están ordenados los elementos del cuadro combinado.


• Ítems: colección conteniendo los elementos del cuadro combinado.



• Property SelectedIndex: obtiene o establece el índice que especifica el elemento seleccionado actualmente.

• Property SelectedItem: obtiene o establece el elemento seleccionado actualmente.

• Property SelectedText: obtiene o establece el texto seleccionado en un comboBox que se puede editar.

• Evento SelectedIndexChanged: se invoca cuando cambia de estado.


103

8.9 ListBox

Los controles de cajas de lista nos permiten mostrar una lista de opciones dentro para que el usuario pueda seleccionar una o más de ellas; la librería de clases de Windows Forms nos provee estos controles mediante la clase System.Windows.Forms.ListBox. Entre sus propiedades más representativas se encuentran:


• Data Source: indica la lista que el control utiliza para obtener sus elementos.




• Selection Mode: indica si el cuadro de lista será de selección simple, multiple o no seleccionable.

• Sorted: especifica si están ordenados los elementos del cuadro de lista.


• Ítems: colección conteniendo los elementos del cuadro de lista.




• Property de solo lectura SelectedIndices: obtiene una colección con los índices seleccionados actualmente.


• Property de solo lectura SelectedItems: obtiene una colección con los elementos seleccionados actualmente.


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:







8.11 LinkLabel

El control LinkLabel es un control de tipo Label, con la característica de que puede mostrar uno o más hipervínculos. Cada hipervínculo que se muestra en el control LinkLabel es de tipo LinkLabel.Link. Entre sus propiedades más representativas se encuentran.

• DisabledLinkColor: determina el color del hipervínculo cuando está deshabilitado.

• LinkArea: parte del texto de la etiqueta que se procesa como hipervínculo.

• LinkBehavior: comportamiento del subrayado de un hipervínculo.

• LinkColor: color del hipervínculo en forma predeterminada.

• VisitedLinkColor: determina el color del hipervínculo cuando la propiedad link visited es true.


• Evento LinkClicked: se invoca al dar un clic sobre el link.

• Property Links: obtiene la colección de vínculos que contiene el control.

8.12 CheckedListBox

Es una caja que presenta una lista de controles tipo CheckBox, pudiendo marcar una o más casillas de verificación. El objeto CheckedListBox admite tres estados a través de la enumeración CheckState: Checked, Indeterminate y Unchecked, cuyos valores son: verificado, indeterminado y no verificado respectivamente. Entre sus propiedades más representativas se encuentran:


• Check On Click: indica si la casilla debe cambiar su estado al hacer clic por primera vez en el elemento.




• Sorted: especifica si están ordenados los elementos del cuadro de lista.


• Ítems: colección conteniendo los elementos del cuadro de lista.





105

• Property de solo lectura SelectedIndices: obtiene una colección con los índices seleccionados actualmente.


• Property de solo lectura Selectedtems: obtiene una colección con los elementos seleccionados actualmente.


8.13 PictureBox

Permite mostrar imágenes (BMP, íconos, JPEG, GIF o PNG) dentro de una interfaz gráfica. Puede especificar la ruta al archivo que se mostrará en el objeto Image que desea mostrar, ya sea en tiempo de diseño o en tiempo de ejecución. Entre sus propiedades más representativas se encuentran:


• ErrorImage: imagen que se carga cuando falla la carga de otra imagen.

• Image: imagen mostrada en el control PictureBox.

• InitialImage: imagen que se muestra mientras se carga otra imagen.

• Enabled: indica si el control está habilitado, es decir si puede ser editado.




• SizeMode: controla la forma en que se tratará la ubicación y el tamaño de las imágenes.

• WaitOnLoad: controla si el proceso se detendrá hasta que la imagen se cargue.

8.14 Timer

Permite lanzar eventos en cada cierto intervalo establecido por el usuario, utilizando el evento Tick. Esta clase proporciona métodos para establecer el intervalo y para iniciar y detener el temporizador. Entre sus propiedades más representativas se encuentran.


• Enabled: habilita la generación de eventos Elapsed.

• Interval: frecuencia de los eventos Elapsed.

8.15 TabControl

Control que permite mostrar ventanas con múltiples fichas, incluye el conjunto de fichas asociadas a él. Entre sus propiedades más representativas se encuentran:


• Aligment: determina la posición de las fichas.



• TabPages: la colección de fichas dentro del control.


• Property Controls: obtiene la colección de controles que contiene el control.

8.16 Trackbar

Control que funciona como un deslizador en donde se pueden configurar los intervalos entre los que se podrá desplazar una barra de seguimiento. Entre sus propiedades más representativas se encuentran:


• SmallChange: número de posiciones que se moverá el control, al utilizar las teclas de direccionamiento del teclado.

• TickFrecuency: número de posiciones entre marcas de paso.

• Orientation: establece la orientación del control (horizontal o vertical)


• Evento Scroll(): se invoca al deslizar el control.

8.17 ProgressBar

Sirve para para indicar de forma visual el progreso de un proceso de alguna de las siguientes formas:

Entre sus propiedades más representativas se encuentran.


• MarqueeAnimationSpeed: velocidad de la animación de la marquesina en milisegundos.

• Maximum: límite superior

• Minimum: límite inferior

• Step: cantidad por la que debe aumentar el valor actual al invocar al método PerformStep.

• Style: Estilo de progress Bar (bloque, barra continua o marquesina).


• Método PerformStep(): método que puede invocar para avanzar la cantidad indicada por Step.

8.18 MainMenu (MenuStrip VB.NET 2005)

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


107

comandos de menú individuales de la estructura de menú. Entre sus propiedades más representativas se encuentran:


• Ítems: colección de controles que se van a mostrar en ToolStrip.

8.19 ToolBar (ToolStrip VB.NET 2005)

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

8.20 StatusBar(StatusStrip VB.NET 2005)

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

8.21 InputBox y MsgBox

El control InputBox muestra una ventana de diálogo a la espera de que el usuario escriba un texto o haga clic en un botón, y devuelve una cadena que contiene el texto tecleado por el usuario. Por ejemplo, la siguiente instrucción despliega una ventana con el mensaje “Teclea un valor” y almacena la respuesta en la variable valorTecleado.

ValorTecleado = InputBox( “Teclea un valor”)

El control MsgBox muestra una ventana de diálogo con un mensaje al usuario y dos botones Aceptar y Cancelar, a la espera de que el usuario dé clic en algún botón devolviendo un entero que indica el botón que escogió.

botonEscogido=MsgBox(“Elige Aceptar o Cancelar”)

Para el desarrollo de este tema y del siguiente, se plantea una aplicación que deberá desarrollar, generando la interfaz gráfica con los controles necesarios.

Una empresa que vende equipo de cómputo ha detectado que sus ventas han ido disminuyendo notablemente y tras realizar un estudio de mercado, han encontrado que la causa principal es la falta de automatización en los procesos para la búsqueda de productos y levantamiento de pedidos.

Para solucionar el problema, es necesario crear un sistema de cómputo con las siguientes características:

• Una pantalla para dar de alta clientes.

• Una pantalla de autenticación para los clientes registrados previamente, después de validarlos podrá realizar pedidos y el sistema les hará el cargo correspondiente.



• Una pantalla de pedidos en donde podrán realizar búsquedas de los productos por Tipo y por clave, desplegará una lista con el resultado de los productos cumpliendo los criterios de búsqueda y permitirá seleccionar productos a partir de esta lista y agregarlos al pedido.

• Una pantalla para dar de alta productos.

A continuación, se muestran los elementos de la interfaz gráfica de la aplicación, asegurese de colocar la propiedad nombre (name) con el valor indicado en la tabla, para facilitar su identificación al momento de ser programados.

• Formulario Menu Principal: Muestra la barra de menus que accionan los ventanas de la aplicación.

Control Propiedad Valor

Formulario Name FrmPrincipal

• Formulario Ayuda: muestra información acerca del programa.


Formulario Name FrmAyuda

• Formulario de Autenticación: el usuario deberá teclear la clave y le solicitará la contraseña, en caso de no estar registrado, podrá abrir la ventana para hacerlo.


109


FrmBienvenida Name FrmBienvenida

TxtClave Name TxtClave

BtnEnviar Name BtnEnviar

BtnRegistrarme Name BtnRegistrarme

BtnCerrar Name BtnCerrar

• Formulario para el registro de productos: permite capturar los datos de un producto y registrarlo en la base de datos.


FrmProductos Name FrmProductos


TxtTipo Name TxtTipo

TxtDescripcion Name TxtDescripcion

TxtPrecio Name TxtPrecio

TxtExistencias Name TxtExistencias

BtnRegistrar Name BtnRegistrar

BtnLimpiar Name BtnLimpiar

BtnCancelar Name BtnCancelar



• Formulario para el registro de clientes: permite capturar los datos de un cliente y registrarlo en la base de datos.


FrmClientes Name FrmClientes

TxtLogin Name TxtLogin

TxtPassword Name TxtPassword

TxtNombre Name TxtNombre

TxtApellidos Name TxtApellidos

CmbAnio Name CmbAnio

CmbMes Name CmbMes

CmbDia Name CmbDia

RbtMasculino Name RbtMasculino

RbtFemenino Name RbtFemenino

TxtDireccion Name TxtDireccion

TxtCiudad Name TxtCiudad

CmbEstado Name CmbEstado

TxtCorreo Name TxtCorreo

TxtTelefono Name TxtTelefono0

TxtNumTarjeta Name TxtNumTarjeta

ChkBanMex Name ChkBanMex

ChkBanSur Name ChkBanSur

ChkBancoMex Name ChkBancoMex

BtnRegistrar Name BtnRegistrar

BtnLimpiar Name BtnLimpiar



111

• Formulario de Búsqueda y Pedidos: permitirá buscar por tipo o clave, desplegará los resultados y permitirá agregar productos al pedido; dando clic al botón Terminar, se finalizará la compra.


FrmPedidos Name FrmPedidos

CmbTipo Name CmbTipo

BtnBuscarTipo Name BtnBuscarTipo


BtnBuscarClave Name BtnBuscarClave

LvwBusqueda Name LvwBusqueda

BtnComprar Name BtnComprar


LvwPedido Name LvwPedido

TxtMonto Name TxtMonto

BtnTerminar Name BtnTerminar

BtnSalir Name BtnSalir



CAPÍTULO

Desarrollo de un proyecto en Visual Basic .NET

En el tema anterior, se han planteado los requisistos de la aplicación CompuVenta y se ha llevado a cabo el diseño de alto nivel, que consiste en el diseño de la interfaz gráfica de usuario, ahora utilizando los elementos del lenguaje de programación Visual Basic .NET, agregará el código necesario a cada una de las pantallas y módulos necesarios para el funcionamiento de la aplicación.

9.1 Clases: Cliente, Producto, Pedido y Venta

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

A continuación, se presentan los diagramas de clases para la aplicación CompuVenta.

A partir del diagrama de clases mediante un mapeo Objeto/relación, obtenemos el siguiente diagrama relacional, el cual puede implementarse en cualquier manejador de bases de datos:


113

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



Private sexo As Boolean 'El sexo lo almacenamos como un Boolean True =Masculino, False =Femenino Private direccion As String Private ciudad As String Private estado As Byte 'El estado lo almacenamos como un Byte 1=Aguascaliente,2=Baja california, etc. Private correo As String Private telefono As String Private tarjeta As String Private bancos(2) As Boolean 'El arreglo de checkboxes de bancos lo almacenamos como un arreglo de Boolean's 0 si no tiene la tarjeta, 1 si la tiene. 'Declaración del constructor que recibe todos los parametros y los asigna a las propiedades del objeto (Uso de Me para referirse a las propiedades del objeto actual). Sub New(ByVal clave As String, ByVal contrasenia As String, ByVal nombre As String, ByVal apellidos As String, ByVal fecha As Date, ByVal sexo As Boolean, ByVal direccion As String, ByVal ciudad As String, ByVal estado As Byte, ByVal correo As String, ByVal telefono As String, ByVal tarjeta As String, ByVal bancos() As Boolean). Me.clave = clave Me.contrasenia = contrasenia Me.nombre = nombre Me.apellidos = apellidos Me.fecha = fecha Me.sexo = sexo Me.direccion = direccion Me.ciudad = ciudad Me.estado = estado Me.correo = correo Me.telefono = telefono Me.tarjeta = tarjeta Me.bancos = bancos End Sub 'Declaración de las Property método que nos permiten regresar (get) y colocar el valor (set) de cada atributo dándonos un mayor control, aquí podemos elegir que valores son válidos (dominio), podemos elegir si un atributo es de solo lectura, solo escritura o ambas. En estos casos no hay restricciones: Property clavep() As String Get Return clave End Get Set(ByVal clave As String)


115

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



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


117

End Get Set(ByVal tarjeta As String) Me.tarjeta = tarjeta End Set End Property Property bancosp() As Boolean() Get Return bancos End Get Set(ByVal bancos As Boolean()) Me.bancos = bancos End Set End Property End Class.

'Clase que representa un Producto. Public Class Producto. '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 Integer Private tipo As String Private descripcion As String Private existencias As Integer Private precio As Double. 'Declaración del constructor que recibe todos los parámetros y los asigna a las propiedades del objeto (Uso de Me para referirse a las propiedades del objeto actual). Sub New(ByVal clave As Integer, ByVal tipo As String, ByVal descripcion As String, ByVal existencias As Integer, ByVal precio As Double). Me.clave = clave Me.tipo = tipo Me.descripcion = descripcion Me.existencias = existencias Me.precio = precio End Sub 'Declaración de las Property método que nos permiten regresar (get) y colocar el valor (set) de cada atributo dándonos un mayor control, aquí podemos elegir qué valores son válidos (dominio), podemos elegir si un atributo es de solo lectura, solo escritura o ambas. En estos casos no hay restricciones: Property clavep() As Integer Get



Return clave End Get Set(ByVal clave As Integer) Me.clave = clave End Set End Property Property tipop() As String Get Return tipo End Get Set(ByVal tipo As String) Me.tipo = tipo End Set End Property Property descripcionp() As String Get Return descripcion End Get Set(ByVal descripcion As String) Me.descripcion = descripcion End Set End Property Property existenciasp() As String Get Return existencias End Get Set(ByVal existencias As String) Me.existencias = existencias End Set End Property Property preciop() As String Get Return precio End Get Set(ByVal valor5 As String) Me.precio = precio End Set End Property End Class

'Clase para representar un pedido Public Class Pedido


119

Private idPedido As Integer Private idCliente As String Private DateFecha As Date 'Fecha en que se realizó el pedido Private CurMonto As Decimal 'Declaración del constructor que recibe todos los parametros y los asigna a las 'propiedades del objeto (Uso de Me para referirse a las propiedades del objeto actual). Sub New(ByVal idPedido As Integer, ByVal idCliente As String, ByVal DateFecha As Date, ByVal CurMonto As Decimal). Me.idPedido = idPedido Me.idCliente = idCliente Me.DateFecha = DateFecha Me.CurMonto = CurMonto End Sub 'Declaración de las Property método que nos permiten regresar (get) y colocar el valor (set) de cada atributo, 'dándonos un mayor control, aquí podemos elegir qué valores son válidos (dominio), podemos elegir si un atributo 'es de solo lectura, solo escritura o ambas. En estos casos no hay restricciones. Property idPedidop() As Integer Get Return idPedido End Get Set(ByVal idPedido As Integer) Me.idPedido = idPedido End Set End Property Property idClientep() As String Get Return idCliente End Get Set(ByVal idCliente As String) Me.idCliente = idCliente End Set End Property Property DateFechap() As Date Get Return DateFecha End Get Set(ByVal DateFecha As Date)



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 'Declaración del constructor que recibe todos los parámetros y los asigna a las propiedades del objeto (Uso de Me para referirse a las propiedades del objeto actual). Sub New(ByVal IdVenta As Integer, ByVal IdPedido As Integer, ByVal IdProducto As Integer, ByVal IntCantidad As Integer). Me.IdVenta = IdVenta Me.IdPedido = IdPedido Me.IdProducto = IdProducto Me.IntCantidad = IntCantidad End Sub. 'Declaración de las Property método que nos permiten regresar (get) y colocar el valor (set) de cada atributo dándonos un mayor control, aquí podemos elegir qué valores son válidos (dominio), podemos elegir si un atributo es de solo lectura, solo escritura o ambas. En estos casos no hay restricciones: Property IdVentap() As Integer Get Return IdVenta


121

End Get Set(ByVal IdVenta As Integer) Me.IdVenta = IdVenta End Set End Property Property IdPedidop() As Integer Get Return IdPedido End Get Set(ByVal IdPedido As Integer) Me.IdPedido = IdPedido End Set End Property Property IdProductop() As Integer Get Return IdProducto End Get Set(ByVal IdProducto As Integer) Me.IdProducto = IdProducto End Set End Property Property IntCantidadp() As Integer Get Return IntCantidad End Get Set(ByVal IntCantidad As Integer) Me.IntCantidad = IntCantidad End Set End Property End Class

9.2 Módulo con las colecciones de clientes, productos, pedidos y ventas

Una vez que ha codificado las clases de las que se instanciarán cada uno de los distintos objetos por emplearse dentro de la aplicación, se preguntará en dónde serán almacenados esos objetos; en este caso, utilizaremos los objetos de tipo Collection que usted ya conoce, de tal forma que habrá una colección para almacenar los clientes, una para almacenar los productos, una para almacenar los pedidos y otra más para almacenar las ventas.

Algunas de estas colecciones serán utilizadas desde distintas clases, por ejemplo la colección de productos será utilizada desde la pantalla de registro de productos y en la pantalla de pedidos, es decir, éstás deberán ser accesibles desde distintas clases; por lo que es



conveniente declararlas dentro de un módulo y en el proyecto que sea accesible a las demás clases, como se muestra a continuación:

Module Module1

Public CClientes As New Collection

Public CProductos As New Collection

Public CPedidos As New Collection

Public CVentas As New Collection

End Module.

Ahora es momento de agregar la funcionalidad a cada una de las pantallas, de modo que empezaremos por el formulario principal.

9.3 Funcionalidad del formulario principal

El formulario principal tiene como función mostrar la barra de menús y cuando el usuario dé clic sobre algún comando dentro de esta barra, deberá mostrar la ventana correspondiente; de esta manera, almacena una variable de tipo referencia hacia cada formulario, luego crea una instancia y la muestra, también guarda en una variable, la clave del usuario (login) que indica si el usuario ha sido autenticado.

Public Class FrmPrincipal Inherits System.Windows.Forms.Form 'Declaramos las siguientes variables globales 'Variables para hacer referencia a cada uno de los Formularios Public FormBienvenido As FrmBienvenido Public FormAyuda As FrmAyuda Public FormClientes As FrmClientes Public FormPedidos As FrmPedidos Public FormProductos As FrmProductos Public Shared IdLogin As String = "" 'Guarda el Login que autenticará al usuario para que al generar pedidos sepa a quien hacer los cargos. Private Sub MenuItem2_click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MenuItem2.Clic. 'En caso de dar clic al submenú Login crea el formulario y lo muestra: FormBienvenido = New FrmBienvenido FormBienvenido.Show() End Sub. Private Sub MenuItem7_click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MenuItem7.Click. 'En caso de dar clic al submenú Registrar (Cliente)crea el formulario y lo muestra: FormClientes = New FrmClientes FormClientes.Show()


123

End Sub Private Sub MenuItem12_click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MenuItem12.Click. 'En caso de dar clic al submenú Realizar Pedido crea el formulario y lo muestra: FormPedidos = New FrmPedidos FormPedidos.Show() End Sub. Private Sub MenuItem11_click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MenuItem11.Click. 'En caso de dar clic al submenú Exit Termina la ejecución End End Sub. Private Sub MenuItem10_click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MenuItem10.Click. 'En caso de dar clic al submenú Ayuda crea el formulario y lo muestra: FormAyuda = New FrmAyuda FormAyuda.Show() End Sub. Private Sub MenuItem8_click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MenuItem8.Click. 'En caso de dar clic al submenú Registrar Producto crea el formulario y lo muestra: FormProductos = New FrmProductos FormProductos.Show() End Sub. Private Sub MenuItem9_click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MenuItem9.Click. 'En caso de dar clic al submenú Registrar (Cliente)crea el formulario y lo muestra: FormClientes = New FrmClientes FormClientes.Show() End Sub End Class

9.4 Funcionalidad del formulario registro de clientes

El formulario para el registro de clientes presenta una pantalla en donde el usuario tecleará los datos correspondientes, cuenta con los botones: Limpiar, el cual dejará todos



los controles con sus valores por defecto; Cancelar que cerrará el formulario y regresará al formulario principal; y Enviar que creará un nuevo objeto del tipo Cliente con los datos capturados, para después agregarlo a la colección cClientes.

Imports WindowsApplication5.Module1

Public Class FrmClientes


Private Sub BtnLimpiar_clic(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnLimpiar.Click.

'En caso de dar clic en el botón Limpiar, invocamos al procedimiento correspondiente:

LimpiarControles()

End Sub.

Private Sub BtnEnviar_clic(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnEnviar.Click.

'En caso de dar clic en el botón Enviar se recuperan los datos capturados se crea un objeto de tipo Cliente.

'Se agrega el nuevo objeto a la colección Clientes y se restablecen los controles del formulario.

'Los valores de las 3 casillas de verificación (Check Box) guardan en un

'arreglo de Boolean (true si tiene la tarjeta del banco, false de otra forma).

Dim bancos(2) As Boolean

bancos(0) = ChkBanMex.Checked

bancos(1) = ChkBanSur.Checked

bancos(2) = ChkBancoMex.Checked

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

'La fecha de nacimiento se guarda en un objeto Date(YYYY,MM,DD).

'El sexo se guarda como un valor booleano 0=True=Masculino.

'Para el Estado en el que vive solo se pasa el indice 0=Aguascalientes,1=BajaCalifornia,etc.

CClientes.Add(New Cliente(TxtLogin.Text(), TxtPassword.Text(), TxtNombre.Text(), TxtApellidos.Text(), New Date(CmbAnio.SelectedItem, CmbMes.SelectedIndex, CmbDia.SelectedIndex), RbtMasculino.Checked, TxtDireccion.Text(), TxtCiudad.Text(), CmbEstado.SelectedIndex(), TxtCorreo.Text(), TxtTelefono.Text(), TxtNumTarjeta.Text(), bancos))


125

'Al terminar se limpian los controles:

LimpiarControles()

End Sub

Private Sub Form2_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

'Al momento de cargarse el formulario Clientes (el método Load se invoca automáticamente al crear el formulario).

'Mediante dos ciclos se agregan los elementos (ítems) de los combos de Año y Día:

Dim Anio As Integer

Dim Dia As Integer

For Anio = 1930 To 2005

CmbAnio.Items.Add(Anio)

Next

For Dia = 1 To 31

CmbDia.Items.Add(Dia)

Next

End Sub

Private Sub BtnCancelar_clic(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnCancelar.Click.

'En caso de dar clic en el botón Cancelar se cierra el formulario Actual.

ActiveForm.Close()

End Sub

'Procedimiento para reestablecer y limpiar todos los controles del formulario:

Sub LimpiarControles()

TxtLogin.Clear()

TxtPassword.Clear()

TxtNombre.Clear()

TxtApellidos.Clear()

CmbAnio.SelectedIndex = 1

CmbMes.SelectedIndex = 1

CmbDia.SelectedIndex = 1

RbtMasculino.Checked = False

RbtFemenino.Checked = False

TxtDireccion.Clear()



TxtCiudad.Clear()

CmbEstado.SelectedIndex = 1

TxtCorreo.Clear()

TxtTelefono.Clear()

TxtNumTarjeta.Clear()

ChkBanMex.Checked = False

ChkBanSur.Checked = False

ChkBancoMex.Checked = False

End Sub

End Class

9.5 Funcionalidad del formulario de registro de productos

El formulario para el registro de productos presenta una pantalla en donde el usuario tecleará los datos correspondientes, cuenta con los botones: Limpiar, el cual dejará todos los controles con sus valores por defecto; Cancelar que cerrará el formulario y regresará al formulario principal; y Enviar que creará un nuevo objeto del tipo Producto con los datos capturados, para después agregarlo a la colección cProductos.

Public Class FrmProductos:

Inherits System.Windows.Forms.Form.

Private Sub BtnCancelar_clic(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnCancelar.Click.

'En caso de dar clic en el botón Cancelar se cierra el formulario Actual:

ActiveForm.Close()

End Sub.

Private Sub BtnLimpiar_clic(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnLimpiar.Clic.

'En caso de dar clic en el botón Limpiar, invocamos al procedimiento correspondiente:

LimpiarControles()

End Sub.

Private Sub BtnRegistrar_clic(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnRegistrar.Click.

'En caso de dar clic en el botón Registrar se recuperan los datos capturados, se crea un objeto de de tipo Producto.

'Se agrega el nuevo objeto a la colección CProductos y se restablecen los controles del formulario.


127

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

Dim nProducto As New Producto(TxtClave.Text, CmbTipo.SelectedItem, TxtDescripcion.Text, TxtPrecio.Text, TxtExistencias.Text)

'Se agrega el nuevo objeto nProducto a la colección

CProductos.Add(nProducto)

LimpiarControles()

End Sub

'Procedimiento para reestablecer y limpiar todos los controles del formulario:

Sub LimpiarControles()

TxtClave.Clear()

TxtDescripcion.Clear()

TxtPrecio.Clear()

TxtExistencias.Clear()

CmbTipo.SelectedIndex = 0

End Sub

End Class

9.6 Funcionalidad del formulario de bienvenida (Autenticación)

El formulario de bienvenida presenta una pantalla en donde el usuario tecleará su clave y su contraseña y al dar clic en el botón Enviar, empezará el proceso de validación, para después buscarse en la colección cClientes por dicha clave; al momento de encontrarla solicita la contraseña y la valida, en caso de estar correcta asigna la variable de sesión en el formulario principal, con lo cual se autentica el usuario y se le muestra el formulario desde el que podrá realizar un pedido, en caso de no ser correcta la contraseña, informa al usuario de este hecho.

Imports WindowsApplication5.Module1.

Public Class FrmBienvenido.

Inherits System.Windows.Forms.Form.

'Declaramos las siguientes variables globales que hacen referencia a los Formularios

Public FormPedidos As FrmPedidos

Public FormClientes As FrmClientes

Public FormPrincipal As FrmPrincipal Private Sub BtnEnviar_click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnEnviar.Click.



'En caso de dar clic en el botón Enviar se validará la clave del usuario,

'si encuentra su clave solicitará la contraseña para validarla.

'Si no teclea la clave entonces..muestra un mensaje de advertencia:

If TxtClave.Text = "" Then

MsgBox("Debes Teclear tu nombre de usuario")

Else

Dim i As Integer

Dim password As String

Dim encontrado As Boolean 'Bandera para saber si fue encontrada la clave de usuario.

Dim nCliente As Cliente 'Declaración del objeto nCliente del tipo CLiente que nos servirá como apuntador dentro de la colección.

For Each nCliente In CClientes 'Bloque para buscar la clave tecleada dentro de la colección.

If TxtClave.Text = nCliente.clavep Then 'Si la clave tecleada es igual a la propiedad clave del objeto actual

encontrado = True

'Solicita el password, si coincide entonces..

If (InputBox("Inserta tu password", "Password", "") = nCliente.contraseniap) Then.

'Coloca la variable de "sesion" Login con el valor de la clave:

FrmPrincipal.IdLogin = TxtClave.Text.

'Cierra el formulario actual, Crea el formulario pedidos y lo muestra:

Me.Close()

FormPedidos = New FrmPedidos

FormPedidos.Show()

Exit For

Else.

'Si la contraseña no coincide, muestra un mensaje de advertencia y sale del bloque de búsqueda:

MsgBox("Contraseña incorrecta")

Exit For

End If


129

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

9.7 Funcionalidad del formulario de pedidos

El formulario de pedidos presenta una pantalla en donde el usuario una vez que ha sido autentificado, podrá buscar productos por clave o por tipo (teclado, ratón, etc.); de tal forma que al dar clic al botón Buscar, realizará la búsqueda sobre los objetos almacenados en la colección cProductos, mostrándose los resultados en el control ListView LvwBusqueda, del cual el usuario podrá seleccionar los que desea adquirir. Al dar clic en el botón Comprar se agregarán al pedido y se visualizarán en el control ListView LvwPedido; por último, al dar clic en el botón Terminar, se agregará cada una de las ventas a la colección cVentas y el pedido a la colección cPedidos.

Public Class FrmPedidos




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()


131

'Colocamos la bandera encontrado = false

Dim encontrado As Boolean = False

'Declaración del objeto nProducto del tipo Producto que nos servirá como apuntador dentro de la colección:

Dim nProducto As Producto

'Bloque para iniciar la búsqueda por tipo de producto seleccionado dentro de la coleccion Cproductos:

For Each nProducto In CProductos

'Si la clave del producto tecleada es igual a la propiedad clave del objeto actual:

If TxtClave.Text = nProducto.clavep Then

encontrado = True 'Cambiamos la bandera porque ya se encontró.

'Creamos un arreglo de tipo String con el valor de las propiedades del objeto encontrado,

'éstas se mostrarán en el ListViewItem un objeto por renglón y cada propiedad en una columna:

Dim ProductoEncontrado(2) As String

ProductoEncontrado(0) = nProducto.clavep

ProductoEncontrado(1) = nProducto.descripcionp

ProductoEncontrado(2) = nProducto.preciop

LvwBusqueda.Items.Add(New ListViewItem(ProductoEncontrado).

End If

Next

If Not encontrado Then

MsgBox("Producto no encontrado")

End If

End Sub

Private Sub FrmPedidos_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load.

'En caso de que no haya tecleado su usuario y contraseña previamente:

If FrmPrincipal.IdLogin = "" Then

MsgBox("No has sido registrado")

Me.Close()

End If



End Sub

Private Sub BtnCancelar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnCancelar.Click

ActiveForm.Close()

End Sub

Private Sub BtnComprar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnComprar.Click.

'Objetos que representan un renglón del ListView con todas sus columnas:

Dim elemento, elementoClonado As ListViewItem

Dim cantidad As String 'Guardar la cantidad que el usuario desee del producto comprado.

Dim subtotal As Decimal 'Guarda el subtotal precioproducto*cantidad.

'Por cada elemento seleccionado para ser comprado.

For Each elemento In LvwBusqueda.SelectedItems.

'1.-Clona el elemento en la lista de buscados ya que solo así se puede agregar una copia

'identica a la lista de los comprados (LvwPedido)

elementoClonado = elemento.Clone.

'2.-Pregunta la cantidad que desea, por default muestra 1a

cantidad = InputBox("Cantidad", "Cantidad", "1").

'3.-Agrega el elemento clonado pero le pega al final la cantidad que eligió el usuario.

LvwPedido.Items.Add(elementoClonado).SubItems().Add(cantidad).

'4.-Calcula el subtotal precioproducto*cantidad

subtotal = CDbl(elementoClonado.SubItems(2).Text()) * CInt(elementoClonado.SubItems(3).Text).

'Actualiza el MontoTotal.

TxtMonto.Text = CInt(TxtMonto.Text) + subtotal

Next

End Sub

Private Sub BtnTerminar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnTerminar.Click.

Dim vendidoLista As ListViewItem 'Representa el elemento vendido en la lista ListViewItem.

Dim vendidoVenta As Venta 'Representa el elemento vendido como un objeto instancia de la clave Venta.


133

'El idUltimaVenta se incrementa de 1 en 1

Dim idUltimaVenta As Integer

'El idUltimoPedido se incrementa de 1 en 1

Dim idUltimoPedido As Integer = CPedidos.Count + 1

'Por cada elemento en la lista de vendidos que forman parte del pedido Total

For Each vendidoLista In LvwPedido.Items

'1.-Calcula el id de esa venta

idUltimaVenta = CVentas.Count + 1

'2.-Crea el objeto Venta que su idVenta,IdPedido, idProducto,Cantidad),

vendidoVenta = New Venta(idUltimaVenta, idUltimoPedido, CInt(vendidoLista.SubItems(0).Text), CInt(vendidoLista.SubItems(3).Text)).

'3.-Agrega la venta a la colección correspondiente

CVentas.Add(vendidoVenta)

Next.

'Crea el objeto Pedido con el idUltimoPedido,IdLogin con el que se autentificó el usuario.

'DateFecha pedido igual a Date.Now (esta propiedad es SHARED) hora y fecha actual del sistema.

'CurMonto el calculado en el cuadro de texto TxtMonto por ser texto habrá que convertirlo a valor Decimal.

Dim pedido As Pedido = New Pedido(idUltimoPedido, FrmPrincipal.IdLogin, Date.Now, CDec(TxtMonto.Text).

'Lo agrega a la colección

CPedidos.Add(pedido)

End Sub

End Class



Bibliografía

• Arnold y Gosling, 1997] Ken Arnold y James Gosling. Addison-Wesley/Domo. El lenguaje de Programación Java. Wesley Iberoamericana. 1997. 334 páginas. (Muy básico, escrito por el desarrollador del lenguaje).

• [Liberty 2002] Liberty Jesse. Learning Visual Basic .NET. O’ Reylli. 2002.

• [Bembey. Kuiljit 2002] Bembey Pooja y Kaur Kuljit. Proyectos Profesionales con Visual Basic .NET. Anaya Multimedia.

UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO DR. JOSÉ NARRO ROBLES Rector

DR. SERGIO M. ALCOCER MARTÍNEZ DE CASTRO Secretario General

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

DRA. ROSAURA RUIZ GUTIÉRREZ Secretaria de Desarrollo Institucional

MC. RAMIRO JESÚS SANDOVAL Secretario de Servicios a la Comunidad

LIC. LUIS RAÚL GONZÁLEZ PÉREZ Abogado General

DIRECCIÓN GENERAL DE SERVICIOS DE CÓMPUTO ACADÉMICO DR. IGNACIO DE JESÚS ANIA BRISEÑO Director General

MAT. CARMEN BRAVO CHAVESTE Directora de Cómputo para la Docencia

ACT. FABIÁN ROMO ZAMUDIO Subdirector de Tecnología para la Educación

MTRO. JESÚS DÍAZ BARRIGA ARCEO Subdirector de Planeación Académica

MTRA. HORTENSIA CANO GRANADOS Coordinadora de Producción Académica

MTRA. ALEJANDRINA SAN JUAN REYES Coordinadora del Centro de Extensión en Cómputo y Telecomunicaciones Nuevo León

ING. SERGIO ALVA ARGUINZONIZ Coordinador del Centro Mascarones

LIC. JOSÉ LUIS MEDINA FLORES Coordinador del Centro Coapa de Extensión en Cómputo y Telecomunicaciones

LIC. PATRICIA ROMERO ELÍAS Coordinadora del Centro Educativo Multidisciplinario Polanco

MTRA. ALMA IBARRA OBANDO Coordinadora del Centro San Agustín

LIC. REBECA SÁNCHEZ ZALDIVAR Responsable de los cursos de Cómputo del Palacio de la Autonomía, Fundación UNAM

ING. PABLO DE LA O CRUZ Coordinador del Centro Tlatelolco

DG TOÑA ZIMERMAN SONABEND Jefa del Departamento de Diseño

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

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

Fue editada por la Dirección General de Servicios de Cómputo Académico y se terminó de imprimir en

abril de 2008, en los talleres de Impresos Azteca, calle José T. Cuéllar 79 A, local A, Col. Obrera,

Cuauhtémoc, CP 06800, DF.

El cuidado de la edición estuvo a cargo del Departamento de Diseño de la DGSCA, UNAM.

Se utilizaron tipos Futura Lt BT de 10/12, 8/10, 11/13 pts. y papel Bond de 90 grs. en interiores y

las portadas en cartulina Couché de 200 gr.

El tiraje consta de ¿??? ejemplares.