Visualbasic Tomo i

GUÍA DEL CURSO

Microsoft Visual Basic.NET 2005®

Microsoft Visual Basic.NET 2005

CONTENIDO

INTRODUCCIÓN A VISUAL BASIC.NET 2005 ____________________ 5

Introducción ____________________________________________ 6

Historia y presentación ___________________________________ 6

.NET Framework ________________________________________ 7

Características de Common Languaje Runtime ______________ 8Biblioteca de clase de .NET Framework___________________ 10Desarrollo de aplicaciones cliente ________________________11Desarrollo de aplicaciones de servidor____________________ 12

CONOCIENDO VISUAL BASIC.NET 2005 ______________________ 15

La pantalla de inicio _____________________________________ 16

Iniciar un nuevo proyecto _________________________________17

El entorno_____________________________________________ 18

El diseñador de formularios____________________________ 18El cuadro de herramientas ____________________________ 19El explorador de soluciones____________________________ 20La ventana de propiedades____________________________ 20La ventana de código ________________________________ 22

CONTROLES _______________________________________________ 29

Controles _____________________________________________ 30

Consideraciones comunes _____________________________ 30Button ___________________________________________ 31CheckBox_________________________________________ 31CheckListBox ______________________________________ 31ComboBox ________________________________________ 32DateTimePicker ____________________________________ 33Label ____________________________________________ 33LinkLabel _________________________________________ 33ListBox ___________________________________________ 34MaskedTextBox ____________________________________ 35MonthCalendar ____________________________________ 35NotifyIcon ________________________________________ 36NumericUpDown ___________________________________ 36PictureBox ________________________________________ 36ProgressBar _______________________________________ 37RadioButton _______________________________________ 37RichTextBox _______________________________________ 38TextBox __________________________________________ 39ToolTip___________________________________________ 40Treeview__________________________________________ 40WebBrowser_______________________________________ 40Formulario ________________________________________ 41

Contenido


CONTENIDO

Contenido

ELEMENTOS DEL LENGUAJE _________________________________ 47

Variables ______________________________________________ 48

Declarando variables ________________________________ 49Ámbito de variables___________________________ 49

Tipos de variables___________________________________ 50Boolean ____________________________________ 52Byte _______________________________________ 52Char _______________________________________ 52Date _______________________________________ 53Decimal ____________________________________ 54Double _____________________________________ 55Integer _____________________________________ 55Long _______________________________________ 56Object _____________________________________ 56String ______________________________________ 57

Conversión de tipo de datos ___________________________ 57Operadores ___________________________________________ 58

Tipos de operadores _________________________________ 58Operadores de concatenación/aritméticos ________ 58Operadores de comparación ___________________ 58Operadores lógicos/bit a bit ____________________ 59Operador mod_______________________________ 59

Prioridad de los operadores____________________________ 60Mensajes ______________________________________________ 60

MsgBox __________________________________________ 60ImputBox _________________________________________ 63

ELEMENTOS DEL LENGUAJE 2 ________________________________ 65

Estructuras de decisión __________________________________ 66

If...Then __________________________________________ 66If...Then...Else ______________________________________ 67Select Case________________________________________ 68

Estructuras de bucle_____________________________________ 69

While____________________________________________ 69Do Loop__________________________________________ 70For...Next _________________________________________ 72For Each...Next_____________________________________ 74

Salir de un procedimiento ________________________________ 75

Realizar acciones con métodos ____________________________ 76

•

••••••••••

••••


CONTENIDO

CONTENIDOS

Matrices ______________________________________________ 77

Matrices multidimensionales___________________________ 77Para crear una matriz dinámica ________________________ 78

Para declarar una variable unidimensional _________ 78Cambiar el tamaño de matrices ________________________ 80Crear matrices de objeto______________________________ 80

Procedimientos Sub _____________________________________ 81

Declaración de argumentos____________________________ 81Sintaxis de llamada__________________________________ 81

Procedimientos Function _________________________________ 82

Valores devueltos ___________________________________ 83Sintaxis de llamada__________________________________ 84

Cómo tratar errores ____________________________________ 84

POO. PROGRAMACIÓN ORIENTADA A OBJETOS_______________ 87

Introducción ___________________________________________ 88

Definición _____________________________________________ 88

Herencia _________________________________________ 89Encapsulación______________________________________ 90Polimorfismo_______________________________________ 90

Trabajando con clases ___________________________________ 91

Definiendo nuestra clase _________________________________ 93

Propiedades ___________________________________________ 93

Métodos _____________________________________________ 102

Constructores ________________________________________ 103

Sobrecargas __________________________________________ 104

Herencia ______________________________________________110

•

INTRODUCCIÓN A VISUAL BASIC.NET 2005

Os presentamos la versión 2005 del Visual Studio.Conocerermos su pilar principal, las .NET Framework

IntroducciónHistoria y presentación

.NET Framework

w OleDb.

incidencias.m

w DataTable

= “SELECT T _ Incidenc

as.Descripcion, T _ Incidenc

_ cliente, T _ Incidencias.F _ c

s ON Ta _ Operarios.Id _ Operario = T

s.nombre=’” & lstOperarios.SelectedItem.T

comando = New OleDb.OleDbCommand(que

conexion.Open()

lector = comando.ExecuteReader

If lector.HasRows Then

‘tabla.Load(lector, LoadOption.Overwri

For contador = 0 To lector.FieldCount

Dim columna As New DataColumn

GetFieldType(contador))

tabla.Columns.Add(columna)

Next

While lector.Read

fila = tabla.NewRow

For contador = 0

fila(cont

Next

tabla.R

End Whilconexe

visual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic.NET 2005 visNET 2005 visual Basic.NET 20Basic.NET 2005 visual Basic.Nvisual Basic.NET 2005 visual Ba2005 visual Basic NET 2005 vis

1


6

Introducción a Visual Basic.NET 2005

INTRODUCCIÓN A VISUAL BASIC.NET 2005Introducción

Bienvenidos a Visual Studio .NET 2005 a lo largo de las siguientes páginas nos familiarizaremos con el que, tal vez, sea uno de los lenguajes de progra-mación más completos y a la par sencillos de utilizar de los últimos años.

Desde las primeras versiones de Basic, allá por los años 70, han sido innu-merables los cambios sufridos por este lenguaje. Hoy en día Visual Basic .NET 2005 ofrece nuevas funcionalidades tales como ADO, .NET, POO, IntelliSense, las cuales nos facilitan crear aplicaciones potentes y seguras en pocos minutos. Pero hablaremos de estas más adelante

Microsoft, en su afán de ofrecer un producto potente y polivalente, ofre-ce en esta versión un producto lleno de nuevas funcionalidades, que harán las delicias de los programadores experimentados y suavizarán la curva de aprendizaje a aquellos que esto de la programación les pille de nuevas.

Éste manual nace con la idea de aprender a programar en Visual Basic .NET 2005 sin tener conocimientos previos de programación, por lo que si es nuevo en esto no se apure. Sin embargo al final del mismo “y si todo ha ido bien” será capaz de crear aplicaciones útiles y seguras capaces de satisfacer todas sus necesidades, y por qué no , las de sus clientes.

Historia y presentación

Estoy seguro que si lo que le apasiona es la historia y no la programación, este apartado no va a ser uno de sus favoritos pero, aun así, me veo en la obligación de hablar brevemente de los antecedentes de Visual Basic .NET 2005.

BASIC “Begginers All-Purpose Symbolic Instruction Code” nace en 1964 con la clara idea de convertirse en un lenguaje de referencia para la industria, a la par que un lenguaje claro y sencillo de aprender. Trascurridos unos años, en 1975, Microsoft, por aquel entonces una pequeña compañía de “2 integran-tes”, lanza su primera versión de este lenguaje.

Tras numerosas versiones, BASIC alcanza uno de sus momentos de gloria con la versión Visual Basic 6.0. Esta versión se hizo con un gran trozo del pastel de los programas empresariales y aun hoy son innumerables las apli-caciones funcionando que fueron hechas con esta versión y que están espe-rando ser actualizadas a Microsoft Visual Basic .NET 2005, también llamado Visual Basic 8.0.

¿Pero qué es Visual Basic .NET 2005?

Visual Basic .NET 2005 es una aplicación “programa” que nos permite pro-gramar (hacer otros programas) de una manera cómoda y sencilla gracias al uso de las .NET Framework. Visual Basic .NET 2005 es a su vez parte de Visual Studio 2005, que es una suite de programación que consta de varios programas siendo “el Basic” uno de ellos.


7


El que usted decida programar con Basic, C# o J# lo dejo a su elección, ya que debe saber que todo lo que puede hacer con Visual Basic .NET 2005 lo podrá hacer también con Visual C#.NET 2005 por ejemplo, sin otro proble-ma que conocer la sintaxis adecuada.

.NET Framework

Información general y conceptual sobre .NET Framework

.NET Framework es un componente integral de Windows que admite la creación y ejecución de la siguiente generación de aplicaciones y servicios Web XML. El diseño de .NET Framework está enfocado a cumplir los obje-tivos siguientes:

Proporcionar un entorno coherente de programación orienta-da a objetos, en el que el código de los objetos se pueda alma-cenar y ejecutar de forma local, ejecutar de forma local pero distribuida en Internet o ejecutar de forma remota.Proporcionar un entorno de ejecución de código que reduzca lo máximo posible la implementación de software y los conflic-tos de versiones.Ofrecer un entorno de ejecución de código que fomente la eje-cución segura del mismo, incluso del creado por terceras per-sonas desconocidas o que no son de plena confianza.Proporcionar un entorno de ejecución de código que elimine los problemas de rendimiento de los entornos en los que se utilizan secuencias de comandos o intérpretes de comandos.Ofrecer al programador una experiencia coherente entre tipos de aplicaciones muy diferentes, como las basadas en Windows o en el Web.Basar toda la comunicación en estándares del sector para ase-gurar que el código de .NET Framework se puede integrar con otros tipos de código.

.NET Framework contiene dos componentes principales: Common Langua-ge Runtime y la biblioteca de clases de .NET Framework. Common Language Runtime es el fundamento de la tecnología. El motor en tiempo de ejecución se puede considerar como un agente que administra el código en tiempo de ejecución y proporciona servicios centrales, como la administración de me-moria, la administración de subprocesos y la interacción remota, al tiempo que aplica una seguridad estricta a los tipos y otras formas de especificación del código que fomentan su seguridad y solidez. De hecho, el concepto de administración de código es un principio básico del motor en tiempo de eje-cución. El código destinado al motor en tiempo de ejecución se denomina código administrado, a diferencia del resto de código, que se conoce como código no administrado. La biblioteca de clases, el otro componente princi-pal de .NET Framework, es una completa colección orientada a objetos de tipos reutilizables que se pueden emplear para desarrollar aplicaciones que abarcan desde las tradicionales herramientas de interfaz gráfica de usuario (GUI) o de línea de comandos hasta las aplicaciones basadas en las innova-ciones más recientes proporcionadas por ASP.NET, como los formularios Web Forms y los servicios Web XML.

•

•

•

•

•

•


8


.NET Framework puede alojarse en componentes no administrados que car-gan Common Language Runtime en sus procesos e inician la ejecución de código administrado, con lo que se crea un entorno de software en el que se pueden utilizar características administradas y no administradas. En .NET Framework no sólo se ofrecen varios hosts de motor en tiempo de ejecu-ción, sino que también se admite el desarrollo de estos hosts por parte de terceros.

Por ejemplo, ASP.NET aloja el motor en tiempo de ejecución para pro-porcionar un entorno de servidor escalable para el código administrado. ASP.NET trabaja directamente con el motor en tiempo de ejecución para habilitar aplicaciones de ASP.NET y servicios Web XML, que se tratan más adelante en este tema.

Internet Explorer es un ejemplo de aplicación no administrada que aloja el motor en tiempo de ejecución (en forma de una extensión de tipo MIME). Al usar Internet Explorer para alojar el motor en tiempo de ejecución, pue-de incrustar componentes administrados o controles de Windows Forms en documentos HTML. Al alojar el motor en tiempo de ejecución de esta manera se hace posible el uso de código móvil administrado (similar a los controles de Microsoft® ActiveX®), pero con mejoras significativas, que sólo el código administrado puede ofrecer, como la ejecución con confianza parcial y el almacenamiento aislado de archivos.

En la ilustración siguiente se muestra la relación de Common Language Run-time y la biblioteca de clases con las aplicaciones y el sistema en su conjunto. En la ilustración se representa igualmente cómo funciona el código adminis-trado dentro de una arquitectura mayor.

.NET Framework en contexto

En las secciones siguientes se describen con más detalle los componentes y características principales de .NET Framework.

Características de Common Language Runtime

Common Language Runtime administra la memoria, ejecución de subproce-sos, ejecución de código, comprobación de la seguridad del código, compila-ción y demás servicios del sistema. Estas características son intrínsecas del código administrado que se ejecuta en Common Language Runtime.


9


Con respecto a la seguridad, los componentes administrados reciben grados de confianza diferentes, en función de una serie de factores entre los que se incluye su origen (como Internet, red empresarial o equipo local). Esto significa que un componente administrado puede ser capaz, o no, de realizar operaciones de acceso a archivos, operaciones de acceso al Registro y otras funciones delicadas, incluso si se está utilizando en la misma aplicación activa.

El motor en tiempo de ejecución impone seguridad en el acceso al código. Por ejemplo, los usuarios pueden confiar en que un archivo ejecutable in-crustado en una página Web puede reproducir una animación en la pantalla o entonar una canción, pero no puede tener acceso a sus datos personales, sistema de archivos o red. Por ello, las características de seguridad del mo-tor en tiempo de ejecución permiten que el software legítimo implementado en Internet sea excepcionalmente variado.

Además, el motor en tiempo de ejecución impone la solidez del código me-diante la implementación de una infraestructura estricta de comprobación de tipos y código denominada CTS (Common Type System, Sistema de tipos común). CTS garantiza que todo el código administrado es autodescriptivo. Los diferentes compiladores de lenguajes de Microsoft y de terceros gene-ran código administrado que se ajusta a CTS. Esto significa que el código administrado puede usar otros tipos e instancias administrados, al tiempo que se aplica inflexiblemente la fidelidad y seguridad de los tipos.

Además, el entorno administrado del motor en tiempo de ejecución elimina muchos problemas de software comunes. Por ejemplo, el motor en tiem-po de ejecución controla automáticamente la disposición de los objetos, administra las referencias a éstos y los libera cuando ya no se utilizan. Esta administración automática de la memoria soluciona los dos errores más co-munes de las aplicaciones: la pérdida de memoria y las referencias no válidas a la memoria.

Además, el motor en tiempo de ejecución aumenta la productividad del programador. Por ejemplo, los desarrolladores pueden crear aplicaciones en el lenguaje que prefieran y seguir sacando todo el provecho del motor en tiempo de ejecución, la biblioteca de clases y los componentes escritos en otros lenguajes por otros colegas. El proveedor de un compilador pue-de elegir destinarlo al motor en tiempo de ejecución. Los compiladores de lenguajes que se destinan a .NET Framework hacen que las características de .NET Framework estén disponibles para el código existente escrito en dicho lenguaje, lo que facilita enormemente el proceso de migración de las aplicaciones existentes.

Aunque el motor en tiempo de ejecución está diseñado para el software del futuro, también es compatible con el software actual y el software antiguo. La interoperabilidad entre el código administrado y no administrado permite que los desarrolladores continúen utilizando los componentes COM y las DLL que necesiten.

El motor en tiempo de ejecución está diseñado para mejorar el rendimiento. Aunque Common Language Runtime proporciona muchos servicios están-


10


dar de motor en tiempo de ejecución, el código administrado nunca se inter-preta. Una característica denominada compilación JIT (Just-In-Time) permite ejecutar todo el código administrado en el lenguaje máquina nativo del siste-ma en el que se ejecuta. Mientras tanto, el administrador de memoria evita que la memoria se pueda fragmentar y aumenta la zona de referencia de la memoria para mejorar aún más el rendimiento.

Por último, el motor en tiempo de ejecución se puede alojar en aplicaciones de servidor de gran rendimiento, como Microsoft® SQL Server™ e IIS (Ser-vicios de Internet Information Server). Esta infraestructura permite utilizar código administrado para escribir lógica empresarial, al tiempo que se dis-fruta del superior rendimiento de los mejores servidores empresariales del sector que puedan alojar el motor en tiempo de ejecución.

Biblioteca de clases de .NET Framework

La biblioteca de clases de .NET Framework es una colección de tipos reuti-lizables que se integran estrechamente con Common Language Runtime. La biblioteca de clases está orientada a objetos, lo que proporciona tipos de los que su propio código administrado puede derivar funciones. Esto oca-siona que los tipos de .NET Framework sean sencillos de utilizar y reduce el tiempo asociado con el aprendizaje de las nuevas características de .NET Framework. Además, los componentes de terceros se pueden integrar sin dificultades con las clases de .NET Framework.

Por ejemplo, las clases de colección de .NET Framework implementan un conjunto de interfaces que puede usar para desarrollar sus propias clases de colección. Éstas se combinarán fácilmente con las clases de .NET Fra-mework.

Como en cualquier biblioteca de clases orientada a objetos, los tipos de .NET Framework permiten realizar diversas tareas de programación comu-nes, como son la administración de cadenas, recopilación de datos, conecti-vidad de bases de datos y acceso a archivos. Además de estas tareas habitua-les, la biblioteca de clases incluye tipos adecuados para diversos escenarios de desarrollo especializados. Por ejemplo, puede utilizar .NET Framework para desarrollar los siguientes tipos de aplicaciones y servicios:

Aplicaciones de consolaAplicaciones GUI de Windows (formularios Windows Forms)Aplicaciones de ASP.NETServicios Web XMLServicios de Windows

Por ejemplo, las clases de formularios Windows Forms son un conjunto completo de tipos reutilizables que simplifican enormemente el desarrollo de interfaces GUI para Windows. Si escribe una aplicación Web Form de ASP.NET, puede utilizar las clases de formularios Web Forms.

•••••


11


Desarrollo de aplicaciones cliente

Las aplicaciones cliente constituyen lo más parecido a una aplicación de es-tilo tradicional en la programación basada en Windows. En este tipo de apli-caciones se muestran ventanas o formularios en el escritorio, lo que permite al usuario realizar una tarea. Entre las aplicaciones cliente se incluyen los procesadores de texto y las hojas de cálculo, además de aplicaciones empre-sariales, como herramientas de entrada de datos, de informes, etcétera. En las aplicaciones cliente se suelen emplear ventanas, menús, botones y otros elementos de la interfaz gráfica de usuario, y suelen tener acceso a recursos locales como el sistema de archivos y a dispositivos periféricos como las impresoras.

Otro tipo de aplicación cliente es el tradicional control ActiveX (reempla-zado ahora por el control de Windows Forms) implementado en Internet como una página Web. Esta aplicación es muy parecida a otras aplicaciones cliente: se ejecuta de forma nativa, tiene acceso a los recursos locales e in-cluye elementos gráficos.

En el pasado, los desarrolladores creaban esas aplicaciones mediante C o C++ en combinación con MFC (Microsoft Foundation Classes) o con un entorno RAD (Rapid Application Development, desarrollo rápido de aplica-ciones) como Microsoft® Visual Basic®. En .NET Framework se incorporan aspectos de estos productos, que siguen existiendo, en un único entorno de desarrollo coherente que simplifica de forma espectacular el desarrollo de las aplicaciones cliente.

Las clases de formularios Windows Forms contenidas en .NET Framework están diseñadas para utilizarse en el desarrollo de GUI. Puede crear venta-nas, botones, menús, barras de herramientas y demás elementos de pantalla fácilmente con la flexibilidad requerida para adaptarse a la evolución de las necesidades de su empresa.

Por ejemplo, .NET Framework proporciona propiedades simples para ajus-tar los atributos visuales asociados con los formularios. En determinadas circunstancias, el sistema operativo subyacente no permite cambiar estos atributos directamente y, entonces, .NET Framework vuelve a crear los for-mularios de forma automática. Ésta es una de las múltiples maneras en que .NET Framework integra la interfaz del programador, con lo que la creación de código resulta más sencilla y más coherente.

A diferencia de los controles ActiveX, los controles de Windows Forms tie-nen acceso con una confianza parcial al equipo de un usuario. Esto significa que el código binario, o que se ejecuta de forma nativa, puede tener acceso a algunos de los recursos del sistema del usuario (como elementos de la GUI y acceso limitado a los archivos) sin tener acceso ni comprometer los demás recursos. Debido a la seguridad de acceso a código, muchas aplicaciones que antes era necesario instalar en el sistema de un usuario, ahora se pueden implementar a través del Web. Las aplicaciones pueden implementar las ca-racterísticas de una aplicación local a la vez que se implementan como una página Web.


12


Desarrollo de aplicaciones de servidor

Las aplicaciones de servidor en entornos administrados se implementan me-diante hosts de motor en tiempo de ejecución. Las aplicaciones no adminis-tradas alojan Common Language Runtime, que permite al código administra-do personalizado controlar el comportamiento del servidor. Este modelo proporciona todas las características de Common Language Runtime y la biblioteca de clases, además de obtener el rendimiento y la escalabilidad del servidor host.

En la ilustración siguiente se muestra un esquema de red básico donde se ejecuta código administrado en diferentes entornos de servidor. Los servi-dores como IIS y SQL Server pueden realizar operaciones estándar mientras la lógica de la aplicación se ejecuta en el código administrador.

Código administrado en el servidor

ASP.NET es el entorno host que permite a los desarrolladores utilizar .NET Framework con las aplicaciones para el Web. Sin embargo, ASP.NET no es sólo un host de motor en tiempo de ejecución: se trata de una comple-ta arquitectura para el desarrollo de sitios Web y objetos distribuidos en Internet mediante código administrado. Los formularios Web Forms y los servicios Web XML utilizan IIS y ASP.NET como mecanismos de publicación de las aplicaciones y ambos disponen de una colección de clases compatibles en .NET Framework.

Los servicios Web XML, que constituyen una evolución importante de la tecnología basada en el Web, son componentes distribuidos de aplicaciones de servidor similares a los sitios Web comunes. Sin embargo, a diferencia de las aplicaciones basadas en el Web, los componentes de servicios Web XML no tienen interfaz de usuario y no están orientados a exploradores como Internet Explorer y Netscape Navigator. En su lugar, los servicios Web XML constan de componentes de software reutilizables diseñados para que los utilicen otras aplicaciones, como aplicaciones cliente tradicional, aplicacio-nes basadas en el Web o, incluso, otros servicios Web XML. Como resul-tado, la tecnología de servicios Web XML está desplazando rápidamente el desarrollo y la implementación de aplicaciones hacia el entorno altamente distribuido de Internet.


13


Si ha utilizado versiones anteriores de la tecnología ASP, apreciará de inme-diato las mejoras que ofrecen ASP.NET y formularios Web Forms. Por ejem-plo, puede desarrollar páginas de formularios Web Forms en cualquier len-guaje compatible con .NET Framework. Además, ya no es necesario que el código comparta el mismo archivo con el texto HTTP (aunque puede seguir haciéndolo, si lo prefiere). Las páginas de formularios Web Forms se ejecu-tan en lenguaje máquina nativo porque, al igual que todas las aplicaciones administradas, sacan todo el provecho del motor en tiempo de ejecución. En cambio, las páginas ASP no administradas siempre utilizan secuencias de comandos e intérpretes de comandos. El desarrollo de páginas de ASP.NET es más rápido, más funcional y más sencillo que el desarrollo de páginas ASP no administradas, porque interactúan con el motor en tiempo de ejecución como una aplicación administrada.

.NET Framework proporciona también una colección de clases y herramien-tas para ayudar al desarrollo y uso de las aplicaciones de servicios Web XML. Los servicios Web XML se basan en estándares como SOAP (un pro-tocolo de llamadas a procedimientos remotos), XML (un formato de datos extensible) y WSDL (el Lenguaje de descripción de servicios Web). En .NET Framework se utilizan estos estándares para fomentar la interoperabilidad con soluciones que no son de Microsoft.

Por ejemplo, la herramienta Lenguaje de descripción de servicios Web in-cluida en .NET Framework (SDK) puede consultar un servicio Web XML publicado en el Web, analizar su descripción de WSDL y producir código fuente, de C# o Visual Basic, que la aplicación puede utilizar para conver-tirse en cliente del servicio Web XML en cuestión. El código fuente puede crear clases derivadas de las clases de la biblioteca de clases que controlan completamente la comunicación subyacente mediante SOAP y análisis de XML. Aunque puede utilizar la biblioteca de clases para usar los servicios Web XML directamente, la herramienta Lenguaje de descripción de servi-cios Web y las demás herramientas incluidas en el SDK facilitan el trabajo de desarrollo con .NET Framework.

Si desarrolla y publica su propio servicio Web XML, .NET Framework pro-porciona un conjunto de clases que cumplen todos los estándares de co-municación subyacentes, como SOAP, WSDL y XML. El uso de esas clases le permite centrarse en la lógica del servicio, sin preocuparse de la infraes-tructura de comunicaciones que se requiere en el desarrollo de software distribuido.

Por último, al igual que las páginas de formularios Web Forms en un entorno administrado, el servicio Web XML se ejecutará con la velocidad del lengua-je máquina nativo mediante la comunicación escalable de IIS.

Visual Basic.NET 2005 trabaja con versión 2.0 de las Framework, por lo que cuando distribuya sus aplicaciones deberá asegurarse que dicha versión está instalada, o su aplicación no funcionará.

CONOCIENDO VISUAL BASIC.NET 2005

Primeros pasos con Visual Basic.NET.Conoceremos su interface y la manera de crear un programa

La pantalla de inicio

Iniciar un nuevo proyecto

El entorno

w OleDb.

incidencias.m

w DataTable







conexion.Open()








Next

While lector.Read

fila = tabla.NewRow

For contador = 0

fila(cont

Next

tabla.R

End Whilconexe


2


16

Conociendo Visual Basic.NET 2005

CONOCIENDO VISUAL BASIC.NET 2005En esta sección aprenderemos a familiarizarnos con el entorno de Visual Basic .NET 2005: conoceremos su interface, sus tipos de proyectos, carac-terísticas y opciones de configuración.

Antes de nada me gustaría aclarar que las capturas y código de este manual han sido realizados con Microsoft Visual Studio 2005 Versión 8.0.50727.867 bajo las .NET Framework Versión 2.0.50727.

La página de inicio

La primera vez que habrá Visual Basic .NET se le pedirá que seleccione el tipo de proyectos en los que piensa trabajar. Suponiendo que ha elegido proyectos Visual Basic, la siguiente ventana que aparecerá será similar a la aquí expuesta. En ella podemos definir las siguientes áreas.

Proyectos recientes: en esta sección aparecerán los últimos proyectos con los que hemos estado trabajando, dándonos la posibilidad de abrirlos pinchando en ellos. También podemos abrir otros proyectos o generar nuevos.MSDN: es una ventana de navegador que nos ofrece distintos enlaces a artículos de Microsoft relacionados con el producto.Introducción: esta sección contiene enlaces a tareas básicas de programación.

Microsoft se ha dado cuenta de lo importante que es que el usuario no se sienta solo ante su programa y para evitar que este se desespere hallan-do soluciones ha creado MSDN. La página web de MSDN es un bastión de información en el que podemos encontrar todo tipo de información, ayuda, tutoriales, artículos técnicos, etc. Les recomiendo que le echen un vistazo.

•

•

•


17


Iniciar un nuevo proyecto

Para iniciar un nuevo proyecto tenemos distintas vías: podemos hacer clic en Crear proyecto dentro del área proyectos recientes, desplegar el menú Archivo y elegir Nuevo Proyecto o simplemente presionar la combinación de teclas Ctrl +N.

En esta ventana se nos solicita el nombre de nuestro proyecto y el tipo de este. Existen numerosos tipos de proyecto pero por ahora no centraremos en los del tipo Aplicación para Windows. Seleccionamos este y le damos el nombre, en mi caso Mi primera aplicación.


18


El entorno

El entorno o “interface” que utiliza Visual Studio .NET 2005 es uno de los más completos que podemos encontrar hoy en día. Nos brinda la posibili-dad de tener aquellas herramientas que queramos al alcance de un solo clic, gracias a una gran capacidad de personalización. Dicha capacidad hace que cada programador personalice la aplicación a su antojo. No obstante existen unas áreas bien definidas.

Diseñador de formularios

Es el área principal del entorno, en ella configuraremos la apariencia de nuestro formulario, dándole un tamaño y aspecto determinado y agregando los distintos controles que conformarán nuestra aplicación.

Para cambiar el aspecto de nuestro formulario, modificaremos su tamaño situando el cursor en la esquina de este, haciendo clic con el ratón y dejando presionado el botón. Del mismo modo podemos establecer su ancho y alto a mano alterando su propiedad Width y Height respectivamente. Si queremos renombrarlo no tendremos mas que modificar su propiedad Text.


19


Cuadro de herramientas

En esta sección tenemos los distintos controles y objetos que utilizaremos en nuestras aplicaciones. Por defecto los distintos controles están organiza-dos por categorías. Comenzaremos con los controles situados en la catego-ría de Controles comunes pero más adelante veremos otros.

Es necesario mencionar que en la barra de herramientas no están todas la herramientas que nos brinda Visual Basic .NET, sino sólo aquellas que la gen-te de Microsoft han pensado importantes. Si queremos agregar alguna de las muchas herramientas que no están visibles pero si disponibles, deberemos de hacer clic con el botón derecho y seleccionar Elegir elementos.

Si queremos añadir un control a nuestro formulario podemos hacerlo de varias maneras:

Haciendo clic en el control elegido y dibujarlo en el formularioClickear dos veces, con lo cual se posicionara un control en la esquina superior izquierda del formularioDejando presionado el botón izquierdo del ratón sobre el con-trol elegido y arrastrando el mismo hacia la ubicación elegida en el formulario.

Una de las nuevas funcionalidades que incorpora Visual Basic .NET en su versión 2005 y que más han aplaudido los programadores son las líneas guía o líneas de ayuda al posicionamiento de controles. Estas líneas no ayudan a alinear controles entre si, centrar estos, o posicionarlos en una distancia estándar frente a un lateral del formulario.

••

•


20


Explorador de soluciones

Una solución puede constar de varios formularios, clases y soluciones; pues bien, el explorador de soluciones es el lugar donde vemos y administra-mos las distintas partes de nuestra aplicación. Por defecto Visual Basic .NET 2005 no nos muestra toda la información de nuestra solución quedando oculta por ejemplo las referencias de nuestro proyecto así como el código autogenerado.

Es aún pronto para entender todo esto, pero si quieren ir investigando “con cuidado” presionen el botón Mostrar todos los archivos para ver de qué les hablo.

La ventana de propiedades


21


Desde la ventana de propiedades podremos ver y modificar las distintas propiedades de cada control o formulario de nuestra aplicación.

La ventana de propiedades cambiara su contenido dependiendo del control que tengamos seleccionado.

En la parte superior de la ventana de propiedades nos aparecerá un desple-gable que nos permitirá seleccionar los distintos controles que tengamos en el formulario actual. Aparecerá el nombre del control y el tipo o clase a la que pertenece.

Las propiedades de los objetos están, por defecto, ordenadas por categorías (apariencia, diseño, comportamiento…) y tal vez para comenzar prefieran este método al orden alfabético.

Como pueden apreciar en la figura, la ventana de propiedades también se nos permite ver los eventos del control o formulario seleccionado y los procedimientos, si los hay, asociados a dicho evento. Si esto de eventos y procedimientos le suena a chino, no se preocupe en absoluto pues son con-ceptos que aclararemos más adelante.

Las propiedades pueden ser modificadas en esta ventana, nos podremos encontrar con propiedades que puedan tomar cualquier valor de cadena de texto, como la propiedad text, otras que tan sólo permitan dos opciones como la propiedad Visible, y otras que nos obliguen a seleccionar alguna de las opciones que nos propone como la propiedad TextAlign.

No se deje impresionar por el gran número de propiedades, pues muchas de ellas son comunes a la mayor parte de los controles y las iremos conociendo juntos en las próximas páginas.

Para ir abriendo boca, nos centraremos en una propiedad que merece mi atención, la propiedad Name.


22


La propiedad Name nos permitirá identificar nuestros controles tanto en la ventana de propiedades como dentro de la ventana de código. Le reco-miendo que lo primero que haga una vez que haya agregado un control a su formulario, sea nombrarlo con un nombre que lo identifique de manera clara e inequívoca, por ejemplo “BtnAceptar” nos recuerda que el objeto seleccionado es del tipo botón y que es el Aceptar no el cancelar o la etiqueta que acompaña al nombre. Del mismo modo nombrando nuestros controles nada más agregarlos al formulario evitamos que el Visual Basic olvide cambiar el código autogenerado.

En la parte inferior de la ventana de propiedades está el panel de descripción, en él se nos mostrara una breve descripción de la propiedad seleccionada en ese momento. No pierda de vista este panel pues ahora que estamos empezando le será de mucha utilidad, y más tarde cuando creemos nuestros propios controles, podremos utilizar este área para informar a otros progra-madores y compañeros de la utilidad de nuevas propiedades que nosotros mismos hemos creado.

La ventana de código

Para acceder a la ventana de código tenemos varias formas, podremos se-leccionar un control, hacer clic con el botón derecho y marcar Ventana de código, seleccionar la pestaña o simplemente presionar F7.

Estoy seguro de que hasta ahora ha encontrado apasionante las ventanas de propiedades, explorador de soluciones, etc… pero seguro que echaba en falta un montón de sentencias de código, instrucciones extrañas y comen-tarios. ¿Dónde programo? Pues en este área, Visual Basic .NET 2005 nos brinda un entorno de programación impensable hace unos años. Olvídese recordar de manera exacta cada método o propiedad pues el Visual nos va ayudar, y mucho.


23


Pero vayamos por orden.

En la parte superior de la ventana de código tenemos dos desplegables, el de la izquierda nos permite seleccionar el objeto sobre el cual queremos trabajar y el de la derecha nos muestra los distintos eventos de ese objeto. Los objetos en Visual Basic .NET 2005 están vivos, es decir, son capaces de reaccionar a estímulos. De hecho, básicamente, lo que haremos como pro-gramadores, será programar las acciones que nuestros controles llevarán a cabo cuando reacciones a esos estímulos o eventos.

Le invito a crear su primera aplicación para que la explicación tome forma y entienda como programaremos en Visual Studio .NET 2005

Cree un nuevo proyecto y asígnele el original nombre de “Mi primer pro-yecto”. Agregue al formulario una etiqueta, una caja de texto y un botón, y modifique sus propiedades como en la tabla siguiente:

Nombre Propiedad “Text” TipolblNombre Nombre LabeltxtNombre Pepe TextboxbtnSaludar Saludar Button


24


Vamos a programar el evento click del objeto btnSaludar, para ello abrimos la ventana de código, y en el desplegable de arriba a la izquierda selecciona-mos el objeto btnSaludar y en el de la derecha buscamos el evento click. Al hacer esto se creará automáticamente el código necesario, es pronto para entender ese galimatías, por ahora nos centraremos en decir que aquéllo que queramos que se lleve a cabo al hacer click en nuestro botón deberá ir ahí dentro.

En nuestro caso queremos hacer un sencillo programa que nos salude, para ello escribiremos el siguiente código

MsgBox(“Hola” & txtNombre.Text)

Este código mostrará un pequeño mensaje en pantalla, pero vayamos poco a poco conociendo las bondades que nos brinda el interface. Imagine que no recuerda el nombre exacto para invocar a estos “mensajitos”. Escriba “Msg” y presione la combinación de teclas Ctrl + Espacio o Ctrl + J,el Intellisense nos ofrece una ventana emergente con las instrucciones que comienzan por “Msg” y podemos ver fácilmente el comando Msgbox acom-pañado de un cartel descriptivo de su utilidad y sintaxis.


25


Si ese es el que queremos utilizar lo seleccionaremos con la tecla tabulador, una vez escrito el comando, el Intellisense, de nuevo, nos recuerda la sintaxis del comando, los parámetros que necesita y el tipo de estos. En este caso vemos que Msgbox tiene tres parámetros: prompt, buttons y title. Los paráme-tros opcionales en este caso buttons y title van encerrados entre corchetes.

Si queremos ejecutar nuestra aplicación tan sólo tendremos que presionar F5 o darle al botón Play de nuestra barra de herramientas.

El resultado de la aplicación es el esperado, pero…¿qué pasaría si el usuario no escribe su nombre en la casilla adecuada? Mostraríamos un “Hola” sin más.


26


Vamos a ir enriqueciendo nuestro sencillo programa a la par que seguimos familiarizándonos con la generación de código. Antes de mostrar nuestro mensaje nos aseguraremos que el usuario ha añadido texto al objeto txt-Nombre, esto lo haremos con una estructura de decisión que estudiaremos más adelante

If txtNombre.Text <> ““ ThenMsgBox(“Hola “ & txtNombre.Text)

End If

Con esta simple estructura nos estamos asegurando de que tan sólo mos-traremos nuestro saludo al usuario si este ha introducido algo en la caja de texto, o lo que es lo mismo, si su propiedad text es distinta de nada.

Ahora haga clic en el margen de la ventana de código a la altura de la primera línea. Con ello introduciremos en nuestro código un punto de interrupción, tal como muestra la figura.

Esto hará que nuestro programa se detenga al llegar a esa línea y podamos examinar el flujo de nuestro código, los valores de las propiedades e incluso modificar el código en tiempo de ejecución.

Ejecute su aplicación, introduzca un nombre y presione el botón, verá que su aplicación se detiene abriendo la sección de código donde introdujo el punto de interrupción como muestra la figura.

La flecha amarilla nos indica que esa es la próxima línea que se va a leer. Si pasamos el ratón por encima de la propiedad text veremos que el GUI nos muestra el valor de esta propiedad. Si queremos que la línea se ejecute podremos darle al botón “Paso a paso por instrucción” o bien presionar la tecla F8


27


Viendo el funcionamiento de nuestro programa vemos que ya va siendo un poco mas conciso, pero, ¿qué pasaría si el usuario introduce en la caja de texto espacios en blanco? Pues que se habría saltado nuestro pequeño con-trol de errores pues en programación una cadena de espacios en blanco no es lo mismo que la ausencia de caracteres. Vamos a corregirlo haciendo uso de las ventajas del Visual Basic .NET 2005.

Con nuestro programa detenido en el punto de interrupción modificamos la condición de la expresión haciendo uso de la función Trim que elimina de una cadena de texto los espacios en blanco tanto por delante como por detrás, como muestra la figura.


28


Una vez hecha la modificación continuamos con la ejecución, botón Playde nuevo o F5 y vemos como el cambio en la sentencia ha modificado el funcionamiento de nuestra aplicación sin necesidad de detenerla y volverla a ejecutar.

Ahora detenga su programa y sitúe el cursor sobre la palabra trim y presione F1 de nuevo, el Visual Basic .NET 2005 nos ayuda lanzando la Ayuda MSDN con la página que nos brinda una descripción del comando, así como un ejemplo y enlaces de interés. Si quiere disponer del mejor libro de Visual Basic .NET 2005 he de decirle que este es la ayuda MSDN.

Algo que hay que tener en cuenta cuando estamos programando es que nuestro código puede ser visto por terceras personas (compañeros de de-partamento, analistas, etc…); también tenemos que pensar que aquel código que hicimos hace unos meses, puede ser que necesitemos abrirlo hoy para corregirlo o añadirle funcionalidad. Pero ¿qué ocurre si abrimos un progra-ma nuestro o ajeno y no entendemos el código? Para poner solución a este problema tenemos los comentarios. Los comentarios acompañan a nuestro código de tal modo que sea fácil entender el funcionamiento de cada proce-dimiento sin entorpecer o mermar el rendimiento de nuestra aplicación.

Para introducir un comentario no tenemos más que empezar la línea con el carácter comilla simple, o bien seleccionar el fragmento de código que queremos comentar y presionar el botón comentar.

CONTROLES

Conoceremos los controles principales de Windows,sus características, eventos y comportamientos.

Controles

w OleDb.

incidencias.m

w DataTable







conexion.Open()








Next

While lector.Read

fila = tabla.NewRow

For contador = 0

fila(cont

Next

tabla.R

End Whilconexe


3


30

CONTROLES

CONTROLES

Tal y como vimos en el capítulo 2, Visual Basic. NET 2005 pone a nuestra disposición un elevado número de controles que harán posible nuestro tra-bajo. Tenemos controles sencillos con apenas unas pocas propiedades como el control timer, y otros mucho más complejos con decenas de propiedades y métodos como el potentísimo oledbadapter.

La mayor parte de los controles comparten innumerables propiedades por lo que no estimo necesario llenar páginas con todas las propiedades de cada control, ya que creo que para eso ya tenemos la ayuda del propio Visual Studio 2005. Considero mejor el abarcar cada control de una manera más personalizada comentando para que se utilizan y aquéllas propiedades, mé-todos y eventos más comunes de programar.

Tenemos a nuestra disposición controles de todo tipo, algunos llenarán nuestros formularios como el control TextBox y otros nos brindarás su fun-cionalidad sin ser vistos como el objeto DataSet.

Las múltiples funcionalidades de los controles que se nos brindan son mucho más fáciles de entender y aprender con la práctica, por lo que si queda algu-na duda con el manejo de los controles espero que estas sean disipadas con los ejercicios que acompañan a este manual.

Consideraciones comunes

Casi todos los controles tienen una serie de características o propiedades comunes que afectan sobre todo a su diseño. Propiedades:

Name: podríamos decir que es la propiedad más importante de todo obje-to ya que mediante ella referenciamos al mismo. Os aconsejo nombrar los objetos en cuanto los agreguemos al formulario y que el nombre identifique la función del control y el tipo. Ej: lblNombre, txtEdad, btnCancelar, etc…

Location: estable la x y la y del objeto, es decir la distancia horizontal y vertical en pixeles del objeto respecto al lado izquierdo y superior de su contenedor.

Size: establece el height y width del objeto es decir su tamaño en pixeles.

Anchor: define a qué bordes del contenedor está anclado control, por de-fecto los controles están anclados al lado izquierdo y superior. Si queremos modificar este comportamiento no tenemos más que modificar esta pro-piedad.

Dock: la propiedad dock hace que el control en cuestión se acople a uno de los laterales del contenedor o formulario.

Text: la propiedad text es el texto que mostrará el control. La propiedad text sustituye a la antigua propiedad caption.


31

CONTROLES

Enabled: la propiedad enabled establece si un control estará activado o des-activado. Si un control está desactivado el usuario no podrá interactuar con él, sin embargo sí podemos modificar y acceder a sus propiedades y eventos desde código.

Button

El control “botón” sustituye al antiguo CommandButton. Permite al usuario hacer clic en él para llevar a cabo una acción. El texto que muestra es su propiedad text.

Un objeto button que esté en un formulario invocado como cuadro de diá-logo mediante el método showdialog, puede retornar un valor de la colección dialogresult modificando su propiedad dialogresult.Es decir, si posicionamos un objeto button en un formulario llamado me-diante frmAuxiliar.showdialog y modificamos su propiedad dialogresult a OK, el botón devolverá esa respuesta y cerrará el for-mulario automáticamente.

CheckBox

El control CheckBox es la representación gráfica de una variable boolean. Su propiedad más importante es checked; dicha propiedad podrá tener el valor true o false.

El control CheckBox es por lo tanto ideal para dar al usuario la posibilidad de elegir entre dos opciones, por ejemplo la típica casilla de verificación de los acuerdos de licencia, es un control CheckBox.

CheckedListbox

El control CheckedListbox es un control combinado a raíz de un control ListBox y un control CheckedListbox. Nos permite ofrecer al usuario elegir múltiples opciones, como los ingredientes de una pizza sin recurrir al uso de varios controles CheckBox.

Las propiedades principales de este control:

Checkeditems que nos devuelve una colección con los ítems seleccionados.

Checkindices que nos devuelve una colección con los índices de los ele-mentos seleccionados.

Items que nos permite acceder a cada uno de los elementos del control, pasándole el índice en base 0 del elemento al cual queremos acceder. Por ejemplo el siquiente código nos devolvería Sandías.


32

CONTROLES

CheckedListBox1.Items(2).ToString

El evento principal del control CheckedListbox es SelectedIndexChangedy se produce cada vez que se activa o desactiva cualquier item. El CheckedListboxes muy similar al control ListBox del cual hablaré en detalle más adelante.

ComboBox

El ComboBox en un control compuesto de un TextBox, un ListBox y un button.Nos permite dar al usuario la posibilidad de elegir una opción.

Las selecciones que aparecen en el ComboBox son las distintas entradas de su propiedad ítems y el ítem seleccionado es el selecteditem.

El control ComboBox permite autocompletarse según escribimos, modificando para ello sus propiedades autocompletmode y autocompletsource.

Al igual que el CheckedListBox, el control ComboBox hereda gran parte de la funcionalidad del control ListBox que veremos más adelante.

El evento principal de este control es SelectedIndexChanged que su-cede cuando cambia el índice del objeto seleccionado.


33

CONTROLES

DateTimePicker

Este control tiene como funcionalidad el permitir al usuario seleccionar una fecha de una manera gráfica. La propiedad más importante del control DateTimePicker es su propiedad value que nos devuelve un tipo date con la fecha seleccionada.

El formato de la fecha devuelta puede modificarse en la propiedad format.

Si queremos evitar que el usuario seleccione una fecha incorrecta, dema-siado antigua o demasiado adelantada, podremos acotar las fechas válidas modificando las propiedades Mindate (fecha mínima) y Maxdate (fecha máxima)

Label

El control label o etiqueta es un control sencillo y de obligado uso en cual-quier formulario Windows. El control label tiene como cometido el mostrar un texto al usuario; acompañará por tanto a cajas de texto, paneles, etc.

La propiedad principal es su propiedad text. La etiqueta se utiliza por lo tanto para mensajes de salida ya que su propiedad text no puede ser modificada por el usuario.

LinkLabel

El objeto LinkLabel hereda toda la funcionalidad del objeto link y le agrega la posibilidad de reaccionar al evento LinkClicked. Sera por tanto dentro de este evento dónde escribiremos el código necesario para realizar la aper-tura de un formulario, página web, etc.

Ej:

Private Sub lnk1 _ linkclicked(ByVal sender As System.Ob-ject, ByVal e As System.Windows.Forms.LinkLabelLinkClicke-dEventArgs) Handles lblAuxiliar.LinkClicked

Form2.Show()lblAuxiliar.LinkVisited = True

End Sub


34

CONTROLES

ListBox

Un control ListBox muestra una lista de elementos entre los que el usuario pue-de seleccionar uno o más dependiendo de su propiedad selectionmode.Si el número total de elementos supera el número que se puede mostrar, se agrega automáticamente una barra de desplazamiento al control ListBox.

El control ListBox expone en su propiedad items una colección de elemen-tos objects. A los cuales se puede acceder mediante un índice en base 0. El siguiente código daría el resultado que muestra la figura

Ej: MsgBox(ListBox1.Items(1).ToString).

Para agregar elementos a un ListBox lo podemos hacer a través de la ventana de propiedades o por código mediante la función add.

ListBox1.Items.Add(“Alicante”)

Si queremos eliminar un objeto lo haremos mediante el método remove.

ListBox1.Items.Remove(“Alicante”)

La sentencia anterior eliminaría “Alicante” de la colección de items en caso de que lo encontrara; si hubiera más de una coincidencia, sólo eliminaría la primera por lo que el método remove se utilizará en contadas ocasiones siendo preferible el método removeat, que espera como argumento el índice del elemento a eliminar.

ListBox1.Items.RemoveAt(2)

Si queremos eliminar todos los elementos lo haremos mediante el método clear

Listbox1.Items.Clear


35

CONTROLES

Un elemento ListBox nos proporciona además las siquientes propiedades

Propiedad Descripción

SectedItemNos devuelve el elemento seleccionado. Sólo es útil si la propiedad selectionmode=one

SelectedIndexNos devuelve el índice del elemento se-leccionado. Solo es útil si la propiedad selectionmode=one

SelectItemsSubcolección con los elementos seleccio-nados. Para acceder a ellos utilizaremos un índice en base 0

SelectedIndicesSubcolección con los índices de los elementos seleccionados. Para acceder a ellos utilizare-mos un índice en base 0

Si queremos buscar un elemento dentro del ListBox utilizaremos el método indexof que nos devolverá el índice dónde encontró el elemento en caso de que lo encontrara y -1 si no fuera así.

ListBox1.Items.IndexOf(“alicante”)

MaskedTextBox

Este control que hereda toda la funcionalidad del TextBox nos permite aco-tar la entrada de texto a un formato concreto. La maskedtextbox es por tanto el control ideal para recopilar fechas, matriculas, etc…Para ello deberemos configurar su propiedad mask estableciendo esta en una de las máscaras propuestas o crear la nuestra propia.

Si queremos informar al usuario de que el carácter que está tratando de intro-ducir no es válido podemos establecer a true la propiedad Beeponerror.

Si queremos validar que se ha introducido en el control el texto requerido podemos comprobar su propiedad maskfull

If MaskedTextBox1.MaskFull ThenValidar _ usuario(MaskedTextBox1.Text)

End If

MonthCalendar

El control MonthCalendar muestra una intuitiva interfaz gráfica de usuario para que los usuarios vean y establezcan información relativa a fechas. El control muestra un calendario: una cuadrícula que contiene el número de días del mes, ordenado en columnas, debajo de los días de la semana con el intervalo de fechas seleccionado resaltado. Para seleccionar un mes diferen-te, puede hacer clic en los botones de fecha a los lados del título del mes. A diferencia del control DateTimePicker, puede seleccionar más de una fecha con este control con las propiedades SelectionStart y SelectionEnd

MonthCalendar1.SelectionStart = CDate(“01/03/2008”)MonthCalendar1.SelectionEnd = CDate(“06/03/2008”)


36

CONTROLES

NotifyIcon

El componente NotifyIcon se usa normalmente para mostrar iconos en los procesos que se ejecutan en segundo plano y que, por tanto, no muestran una interfaz de usuario la mayor parte del tiempo. Un ejemplo sería un pro-grama de protección antivirus al que se puede tener acceso si se hace clic en un icono situado en el área de notificación de estado de la barra de tareas.

Como propiedades interesantes tenemos la propiedad icon que establece el icono que mostrará y el evento que programaremos normalmente será el asociado al doble click.

NumericUpDown

El control NumericUpDown es similar a una combinación de un cuadro de texto y un par de flechas en las que el usuario puede hacer clic para ajustar un valor. El control muestra y establece un valor numérico único a partir de una lista de opciones de valor numérico fijo. Para incrementar y reducir el número, el usuario puede hacer clic en los botones hacia arriba y hacia abajo, presionar las teclas FLECHA ARRIBA y FLECHA ABAJO, o escribir un número en la parte del cuadro de texto del control. Al presionar la tecla FLECHA ARRIBA, el número se mueve hacia arriba hacia el valor máximo; al presionar la tecla FLECHA ABAJO, el número se mueve hacia el mínimo.

Debido a su versátil funcionalidad, este control es una elección obvia, por ejemplo, si desea crear un control de volumen para una aplicación de repro-ducción de música. El control NumericUpDown se utiliza en muchas aplicacio-nes del Panel de control de Windows.

La propiedad que nos dice el número selecionado es su propiedad value y limitaremos el número mayor y menor del rango con la propiedad Maximum y Minimum respectivamente.

PictureBox

El control PictureBox se utiliza para mostrar gráficos en formato de mapa de bits, GIF, JPEG, metarchivo o icono. Se puede cargar la imagen en el control en tiempo de diseño gracias a su propiedad image o mediante código en tiempo de ejecución.

PictureBox1.Image = Image.FromFile(“d:\fotos\coche\DSC00053.JPG”)


37

CONTROLES

El modo en el que se mostrará la imagén se configura mediante la propiedad SizeMode la cual puede tomar los siguientes valores.

Valor Descripción

NormalLa imagen se coloca en la esquina superior izquier-da de PictureBox. La imagen se recorta si es más grande que el objeto PictureBox que la contiene.

StretchImageLa imagen situada dentro de PictureBox se estira o se encoge para ajustarse al tamaño de PictureBox.

AutoSizeEl tamaño de PictureBox es igual al de la imagen que contiene.

CenterImage

La imagen se muestra en el centro si PictureBoxes más grande que la imagen. Si la imagen es más grande que PictureBox, se coloca en el centro de PictureBox y se recortan los bordes exteriores.

ZoomSe aumenta el tamaño de la imagen o se disminu-ye, manteniendo la proporción de tamaño.

ProgressBar

El control ProgressBar indica el progreso de un proceso, mediante la pre-sentación de un número adecuado de rectángulos dispuestos en una barra horizontal. Cuando se completa el proceso, la barra se llena. Las barras de progreso suelen utilizarse para dar al usuario una idea de cuánto deberá esperar hasta que se complete un proceso como, por ejemplo, la carga de un archivo grande.

Sus propiedades principales son el Value, Minimum y Maximum.

RadioButton

Los controles RadioButton presentan al usuario un conjunto de dos o más opciones excluyentes entre sí. Aunque puede parecer que los botones de opción y las casillas de verificación funcionan de forma parecida, existe una diferencia importante: cuando un usuario selecciona un botón de opción, no puede seleccionar ninguno de los otros botones de opción del mismo grupo


38

CONTROLES

sin perder la selección de este botón. En cambio, es posible activar tantas casillas de verificación como se desee. Al definir un grupo de botones de opción, se indica al usuario que “tiene este conjunto de opciones entre las que puede elegir una y solamente una”.

Para definir distintos grupos de opciones debemos introducir los objetos RadioButton en algún objeto contenedor tales como GroupBox o panels.

La propiedad que indica si un RadioButton está marcado o no es su propiedad checked.

RichTextBox

El control RichTextBox se utiliza para mostrar, escribir y manipular texto con formato. El control RichTextBox hace todo lo que realiza el control TextBox,pero además puede efectuar las siguientes operaciones: mostrar fuentes, colores y vínculos; cargar texto e imágenes incrustadas desde un archivo; y buscar caracteres especificados. El control RichTextBox suele utilizarse para manipular texto y proporcionar funciones de presentación similares a las de aplicaciones de procesador de textos tales como Microsoft Word. Al igual que el control TextBox, el control RichTextBox puede mostrar barras de des-plazamiento; sin embargo, a diferencia del control TextBox, su configuración predeterminada es mostrar tanto barras de desplazamiento horizontales como verticales según se precise, y posee configuraciones adicionales para las barras de desplazamiento.

Para cargar un archivo de texto o salvar el contenido de este en un fichero podemos utilizar los métodos loadfile y savefile

Sub cargar _ archivo()RichTextBox1.LoadFile(“C:\cv.doc”)

End Sub

Sub salvar _ archivo()RichTextBox1.SaveFile(“C:\cv.doc”)

End Sub

Si queremos trabajar con el texto seleccionado en el objeto RichTextBox nos serviremos de la propiedad selectedtext.

Si queremos hacer una selección por código utilizaremos el método selecto las propiedad selectionstart y selectionlength

RichTextBox1.Select(posicion _ inicial, tamaño _ de _ la _ seleccion)

RichTextBox1.SelectionStart = posicion _ inicialRichTextBox1.SelectionLength = tamaño _ de _ la _ seleccion

La propiedad selectionlegth será mayor que 0 sólo cuando haya un texto seleccionado, sin embargo la propiedad selectionstart guardará la posicón del cursor haya o no selección.


39

CONTROLES

Si deseamos buscar una cadena de texto dentro de un TextBox utilizaremos el método indexof, que nos devolverá la posición donde hayó la cadena buscada o un cero en caso de que no se encuentre.

‘Posicion donde se encuentra la palabra

Dim a As Integer

a=RTB1.Text.IndexOf(“hola”, 0, StringComparison.OrdinalIgnoreCase)

TextBox

Los cuadros de texto se utilizan para obtener entradas del usuario o para mostrar texto. El control TextBox se utiliza generalmente para el texto que se puede editar, aunque también puede configurarse como control de sólo lectura. Los cuadros de texto pueden mostrar varias líneas, ajustar el texto al tamaño del control y agregar formato básico. El control TextBox propor-ciona a diferencia del RichTextBox un único estilo de formato para el texto mostrado o escrito en el control.

Si queremos limitar el tamaño máximo a introducir en un control textbox modificaremos su propiedad maxlegth.

La propiedad booleana multiline establecida por defecto a False nos per-mite que el control TextBox muestre varias líneas de texto.

Para permitir que el control TextBox reciba saltos de línea o tabulados, debe-remos establecer a true sus propiedades AcceptsReturn y AcceptsTabsrespectivamente.

Si estamos utilizando el control para solicitar un password al usuario no ten-dremos que implementar una tediosa rutina para substituir los caracteres presionados por asteriscos u algún otro símbolo. Bastará con modificar su propiedad PasswordChar

Los eventos mas habituales de programar son los eventos de pulsación de teclas, el evento textchanged se produce siempre que cambien el conte-nido de la propiedad text del control.

Los eventos keydown, keypress y keyup nos permiten evaluar y modi-ficar el normal funcionamiento del control TextBox al recibir una pulsación de una tecla. El código de ejemplo siguiente impide que el control TextBox1acepte algún carácter fuera del rango de la “a” a la “z”

Private Sub TextBox1 _ KeyPress(ByVal sender As Object, _ByVal e As System.Windows.Forms.KeyPressEventArgs)

Handles TextBox1.KeyPressSelect Case e.KeyChar

Case “a”c To “z”c ‘No hago nada. La letra se escribe normalmente Case Else ‘Cancelo la pulsación de la tecla e.Handled = True

End SelectEnd Sub


40

CONTROLES

ToolTip

El ToolTip es un control que nos permite añadir un cartelito de información a otros controles windows. Una vez añadido un control ToolTip al formulario los controles reciven una nueva propiedad llamada “tooltip en tooltip1” que será el texto que se muestre automáticamente al dejar posado el cursor sobre el control.

TreeView

Con el control TreeView, puede mostrar una jerarquía de nodos a usuarios, del modo en que se muestran los archivos y carpetas en el panel izquierdo de la característica Explorador de Windows del sistema operativo Windows.Cada nodo de la vista de árbol podría contener otros nodos, llamados nodossecundarios. Puede mostrar nodos primarios o nodos que contienen nodos se-cundarios, como expandidos o contraídos.

Para agregar nuevos nodos al control TreeView nos serviremos del método add tal como ilustra el siguiente ejemplo

Dim nuevo _ nodo As TreeNodenuevo _ nodo = New TreeNode(“Archivos de programa”)TreeView1.Nodes.Add(nuevo _ nodo)

El evento mas programado en los controles TreeView es AfterSelect que nos permite actuar ante las selecciones de nodo realizadas.

WebBrowser

El control WebBrowser proporciona un contenedor administrado para el control ActiveX WebBrowser. El contenedor administrado permite mostrar páginas Web en las aplicaciones cliente de los formularios Windows Forms.Se puede utilizar el control WebBrowser para duplicar la funcionalidad de ex-ploración Web de Internet Explorer en la aplicación o se puede deshabilitar la funcionalidad predeterminada de Internet Explorer y utilizar el control como visor simple de documentos HTML. También se puede utilizar el con-trol para agregar elementos de la interfaz de usuario basados en DHTML al formulario y no mostrar el hecho de que se alojan en el control WebBrowser.Este enfoque permite combinar sin problemas controles Web con controles de formularios Windows Forms en una sola aplicación.


41

CONTROLES

Si queremos cargar una página en nuestro pequeño navegador lo haremos mediante el método nagivate

WebBrowser1.Navigate(“http://www.microsoft.com”)

La figura muestra un formulario con un control WebBrowser con su propie-dad Dock establecida a Fill

Formulario

Los formularios de Visual Basic .NET tienen como noble objetivo ser el esqueleto de nuestras aplicaciones. Las aplicaciones pueden constar de uno o varios formularios y estos a su vez engloban o albergan al resto de los controles.

Para agregar un formulario a nuestra aplicación debemos actuar de manera distinta que en el resto de controles. En el explorador de soluciones selec-cionamos el proyecto con el queremos trabajar, hacemos clic con el botón derecho, menu agregar, Windows Form o bien en el Menu Proyecto selecio-namos agregar formulario.


42

CONTROLES

Una vez hecho esto aparecerá una ventana como la siquiente en la que elegi-remos el tipo de formulario, en este caso Windows Form y se nos pide darle un nombre al formulario.

Ahora ya tenemos un nuevo formulario en nuestro proyecto, si queremos que este se convierta en el formulario de inicio procederemos como sigue:

En el Explorador de Soluciones seleccionamos nuestro proyecto y hacemos clic con el botón derecho y luego Propiedades.


43

CONTROLES

Se nos deplegará la siguiente ventana:

Seleccionamos el desplegable Formulario de Inicio donde se nos dará la opción de elegir entre todos los formularios que forman nuestra aplicación. Cerra-mos guardamos y listo.

El objeto Form es un objeto con muchas propiedades. Trataré de definir aquellas más importantes.

AcceptButton: esta propiedad permite al formulario escuchar la pulsación de la tecla Enter, invocando al botón deseado sin escribir una sola línea de código. Al desplegar la propiedad nos aparecerán los distintos controles del tipo Button que hay actualmente sobre nuestro formulario dándonos la posibilidad de elegir uno.

Backcolor: nos permite cambiar el color de fondo de nuestro formulario.

BackgroundImage: nos permite establecer una imagen como fondo de nuestro formulario.

BackgroundImageLayout: nos permite modificar el comportamiento de la imagen cargada en la propiedad BackgroundImage


44

CONTROLES

CancelButton: funciona de manera análoga al AcceptButton, solo que en este caso la tecla encargada de invocar al botón es Esc.

ContextMenuStrip: nos permite seleccionar el menú contextual que mostrara nuestro formulario al presionar sobre con el botón derecho o con la tecla de menú contextual de nuestro teclado.

ControlBox: si la propiedad ControlBox se establece en true, el cuadro de control se muestra en el ángulo superior izquierdo de la barra de título.

ForeColor: nos permite modificar el color de primer plano de todos los objetos que haya situado en mi formulario.

FormBorderStyle: permite modificar el aspecto de nuestro formulario eligiendo si tendrá un borde redimensionable o no, o si ni tendrá borde.

Aspecto de un formulario windows con su formborderstyle establecido a None y su propiedad forecolor a Red

Icon: nos permite cambiar el icono que lucirá nuestro formulario.

IsMdiContainer: si queremos que nuestro formulario actúe como un con-tenedor de formulario, deberemos establecer esta propiedad booleana a true.La ventana principal del Microsoft Excell © es un formulario contenedor de formularios MDI “Multiple Document Interface”

KeyPreview: cuando esta propiedad se establece en true, el formulario re-cibe todos los eventos KeyPress, KeyDown y KeyUp. Una vez que los controladores de eventos del formulario han terminado de procesar la pre-sión de tecla, dicha presión se asigna al control con el foco. Por ejemplo, si la propiedad KeyPreview se establece en true y el control seleccionado actualmente es un TextBox, una vez que los controladores de eventos del for-mulario hayan procesado la presión de tecla, se asignará al control TextBoxla tecla que se presionó.

MainMenuStrip: nos permite seleccionar el menú que utilizará nuestro formulario.

Formulario Windows con un objeto MenuStrip asociado.

ShowinTaskbar: esta propiedad permite que el formulario en cuestión no cree una nueva instancia en la barra de tareas. Es útil que tan sólo el formu-lario principal tenga establecida esta propiedad a true.


45

CONTROLES

StartPosition: nos permite establecer la posición inicial de nuestro formu-lario, centrarlo en la pantalla, centrarlo referente a su mdiparent o posicio-narlo en la ubicación por defecto que establece el sistema operativo.

Text: es el título que mostrara el formulario en un barra de menú.

TopMost: nos permite que el formulario permanezca por encima de otros formularios. No confundir con un formulario llamado mediante el método showdialog.

WindowsState: nos permite hacer que nuestro formulario esté maximiza-do, minimizado o normal.

Ahora que conocemos las principales propiedades de un formulario hablaré sobre algunos de sus eventos:

Load: se produce antes de que se muestre un formulario por primera vez. Es un buen lugar donde inicializar conexiones de acceso a datos o inicializar ciertos valores.

Closing: el evento se lanzará cuando tratemos de cerrar nuestro formu-lario, ya sea mediante Alt + F4 o con el aspa. Es un buen momento para dar la opción de guardar cambios o escribir los datos a disco.

Si queremos mostrar un formulario, lo haremos mediante los métodos showy showdialog. Dependiendo de si queremos que el formulario en cuestión se comporte como un formulario normal o un cuadro de dialogo modal.

Form1.showdialogForm1.show

ELEMENTOS DEL LENGUAJE

Elementos básicos de Visual Basic.NET 2005.Uso y definición de variables.

Manejo de mensajes de entrada y salida.

Variables

Operadores

Mensajes

w OleDb.

incidencias.m

w DataTable







conexion.Open()








Next

While lector.Read

fila = tabla.NewRow

For contador = 0

fila(cont

Next

tabla.R

End Whilconexe


4


48



Variables

¿Qué es una variable? Pues como su propio nombre indica es algo que puede variar. Visual Basic .NET 2005 como todos los lenguajes se sirve del uso de variables para hacer la vida más fácil a sus programadores.

Imaginen que soy el encargado de hacer un programa que va calculando con-tinuamente los intereses generados por los distintos clientes de bolsa.

Debería de calcular cientos de valores dependiendo de distintos índices bur-sátiles, si los estos variaran (y varían) cada día me vería en la obligación de ir cambiando a través de innumerables líneas de código los valores aplicados, lo cual sería imposible si no existieran las variables. Haciendo uso de las va-riable, tan sólo tendría que cambiar el valor de esta en un sólo sitio y todos mis datos que utilizaran dicha variable se recalcularían automáticamente.

Si vemos la definición oficial de la RAE puede que vayamos definiendo un poco más el termino. Variable: “Magnitud que puede tener un valor cualquiera de los comprendidos en un conjunto”; según esto ya vemos que debemos acotar los posibles valores.

Por lo tanto, para crear una variable tenemos que pensar en un nombre y en el tipo de valores que vamos a utilizar. Lógicamente no será lo mismo una variable que se va a encargar de guardar el estado de una bombilla que otra que almacene una conexión con una base de datos ¿verdad?

Una variable se declara para especificar su nombre y sus características. La instrucción de declaración para variables es Instrucción Dim seguida del nombre de la variable, seguida de la clausa as “como”, seguida del tipo de valor que vaya a almacenar mi variable.

Dim edad As Byte

Al escribir esta línea de código le estamos diciendo en realidad al Visual Basic .NET 2005 que nos reserve un espacio en memoria (cuanto ya lo veremos) para que podamos almacenar un valor del tipo byte, y que para dirigirme a ese espacio de memoria, ya sea para leer o escribir, voy a utilizar el nombre edad.

Para almacenar un valor en una variable utilizaremos el operador =

edad =27

Almacena el valor 27 en la variable edad.


49


Si queremos incrementar el valor de la variable lo podremos hacer como sigue:

edad = edad + 7

O utilizando la forma abreviada

edad += 7

Si queremos por el contrario leer el valor de una variable ubicaremos a la derecha del operador de asignación.

txtEdad.text=edad

Leería el valor almacenado en la variable edad y lo escribiría en la propiedad text del control txtEdad

Declarando variables

Si necesitamos declarar dos o más variables de un mismo tipo podemos hacerlo así:

Dim nombre As StringDim apellido As StringDim direccion As String

O hacerlo en una sola linea, separando los nombres de las variables por comas.

Dim nombre, apellido, direccion As String

Por defecto el lenguaje inicializa las variables una vez declaradas, pero puede ser que queramos inicializarlas nosotros para cambiar los valores por omi-sión.

Para ello podemos optar por la declaración e inicialización en dos pasos.

Dim nota As ByteNota = 6

O ahorrarnos una línea con:

Dim nota As Byte = 7

ÁMBITO DE VARIABLES

El ámbito indica en qué lugar de la aplicación se desea utilizar la variable y puede ser una de las siguientes palabras claves: Dim, Static, Private o Public.

Dim: se puede utilizar a nivel de procedimiento y a nivel del formulario. Si se declara una variable a nivel de procedimiento con la palabra Dim, Visual Basic reinicializa (borra su contenido) la variable cada vez que ejecuta el procedimiento.

Dim nota As Byte

•


50


Static: Se utiliza sólo a nivel del procedimiento. Cuando una variable se declara con la palabra Static, Visual Basic no reinicializa la variable cada vez que se ejecuta el procedimiento, sólo lo hace la primera vez. Esto quiere decir que la variable conserva su valor entre una llamada al procedimiento y otra.

Static nota As Byte

Private: Se utiliza solo a nivel del módulo e indica que la variable es pri-vada; es decir, sólo va a ser reconocida dentro del módulo donde ha sido declarada.

Private nombre As String

Tipos de variables

Como ya hemos comentado, dependiendo de los valores que vayamos a almacenar en las variables, deberemos declarar nuestras variables de un tipo u otro. Una buena elección en el tipo de las variables redunda en una menor posibilidad de errores en el código y una mejora del rendimiento.

Tipos de datos de Visual Basic.NET y su equivalente en el Common Langua-ge Runtime (CLR)

Tipo deVisual Basic

Estructura de tipo Common

LanguageRuntime

Asignación dealmacenamiento

nominal Intervalo de valores

Boolean Boolean

En función de la

plataforma deimplementación

True o False

Byte Byte 1 byte 0 a 255 (sin signo)

Char

(carácter

individual)

Char 2 bytes 0 a 65535 (sin signo)

Date DateTime 8 bytes0:00:00 (medianoche) del 1 de enero de 0001 a 11:59:59 p.m. del 31 de diciembre de 9999.

Decimal Decimal 16 bytes

0 a +/-79.228.162.514.264.337.593.543.950.335 (+/-7,9... E+28) † sin separador decimal; 0 a +/-7,9228162514264337593543950335 con 28 posi-ciones a la derecha del decimal;

el número distinto de cero más pequeño es +/-0,0000000000000000000000000001 (+/-1E-28)


51


Double

(punto

flotante de

precisión

doble)

Double 8 bytes

-1,79769313486231570E+308 a-4,94065645841246544E-324 † para los valores negativos;

4,94065645841246544E-324 a 1,79769313486231570E+308 † para los valores positivos

Integer Int32 4 bytes -2.147.483.648 a 2.147.483.647 (con signo)

Long

(entero

largo)

Int64 8 bytes-9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 (9,2...E+18 †) (con signo)

Object Object (clase)

4 bytes en plataforma de

32 bits

8 bytes en plataforma de

64 bits

Cualquier tipo puede almacenarse en una variable de tipo Object

SByte SByte 1 byte -128 a 127 (con signo)

Short

(entero cor-

to)

Int16 2 bytes -32.768 a 32.767 (con signo)

Single (pun-

to flotante

de precisión

simple)

Single 4 bytes

-3,4028235E+38 a -1,401298E-45 † para los valo-res negativos;

1,401298E-45 a 3,4028235E+38 † para los valores positivos

String (lon-

gitud varia-

ble)

String (clase)

En función de la


0 a 2.000 millones de caracteres Unicode aprox.

UInteger UInt32 4 bytes 0 a 4.294.967.295 (sin signo)

ULong UInt64 8 bytes0 a 18.446.744.073.709.551.615 (1,8...E+19 †)(sin signo)

User-Defi-

ned

(estructura)

(hereda de ValueType)

En función de la


Cada miembro de la estructura tiene un interva-lo de valores determinado por su tipo de datos y es independiente de los intervalos de valores correspondientes a los demás miembros.

UShort UInt16 2 bytes 0 a 65.535 (sin signo)


52


BOOLEAN

Contiene valores que pueden ser sólo True o False. Las palabras clave True y False corresponden a los dos estados de las variables Boolean.

Utilice el tipo de datos Boolean para contener valores de dos estados como verdadero/falso, sí/no o activado/desactivado.

El valor predeterminado de Boolean es False.

Conversiones de tipo

Cuando Visual Basic convierte los valores de tipos de datos numéricos en Boolean, 0 pasa a ser False y todos los otros valores, True. Cuando Visual Basic convierte los valores Boolean en tipos numéricos, False pasa a ser 0 y True, -1.

Ejemplo de código que utiliza una variable boolean:

Dim terceraedad As BooleanIf CInt(txtEdad.text) > 65 Then

terceraedad = TrueEnd If

BYTE

Contiene enteros de 8 bits sin signo (1 bytes) que se sitúan en el intervalo entre 0 y 255.

El valor predeterminado de Byte es 0.

El tipo de datos Byte se amplía a Short, UShort, Integer, UInteger, Long, ULong, Decimal, Single y Double. Esto significa que se puede convertir Byte en cual-quiera de estos tipos sin encontrar un error de desbordamiento.

Ejemplo de código con una variable byte:

Dim edad As ByteIf CDbl(txtEdad.Text) > 0 AndAlso CDbl(txtEdad.Text) < 200 Thenedad = CByte(txtEdad.Text)

End If

CHAR

Contiene puntos de código de 16 bits (2 bytes) sin signo comprendidos entre 0 y 65535. Cada punto de código o código de carácter representa un único carácter Unicode.

Utilice el tipo de datos Char cuando necesite albergar únicamente un carácter individual y no necesite la sobrecarga de String. En algunos casos, puede utili-zar Char(), una matriz de elementos Char, para albergar varios caracteres.

El valor predeterminado de Char es el carácter con el punto de código 0.

•

•

•


53


Caracteres Unicode

Los primeros 128 puntos de código (0–127) Unicode corresponden a las le-tras y símbolos de un teclado estándar de EE.UU. Estos primeros 128 puntos de código son los mismos que los definidos por el conjunto de caracteres ASCII. Los siguientes 128 puntos de código (128–255) representan caracte-res especiales, como letras de alfabetos latinos, acentos, símbolos de mone-da y fracciones. Unicode utiliza los puntos de código restantes (256-65535) para albergar una amplia variedad de símbolos, incluidos caracteres de texto de todo el mundo, signos diacríticos y símbolos técnicos y matemáticos.

Puede utilizar métodos como IsDigit y IsPunctuation en una variable Char para determinar su clasificación Unicode.

Visual Basic no realiza conversiones directas entre el tipo Char y los tipos numéricos. Puede utilizar Asc, AscW (Funciones) para convertir un valor Char a un tipo Integer que represente su punto de código. Puede utilizar Chr, ChrW (Funciones) para convertir un valor Integer a un tipo Char que tenga ese punto de código.

Si el modificador de comprobación de tipos (Option Strict (Instruc-ción)) está habilitado, debe agregar el carácter de tipo de literal a un literal de cadena de un solo carácter para identificarlo como el tipo de datos Char.Esto se ilustra en el siguiente ejemplo:

Option Strict OnDim caracter As Charcaracter = “r”c

DATE

Contiene valores IEEE de 64 bits (8 bytes) que representan fechas compren-didas entre el 1 de enero del año 0001 y el 31 de diciembre de 9999, y horas comprendidas entre las 0:00:00 (medianoche) y las 11:59:59. Cada incremen-to representa 100 nanosegundos de tiempo transcurrido desde el comienzo del 1 de enero del año 1 del calendario gregoriano. El valor máximo repre-senta 100 nanosegundos antes del comienzo del 1 de enero del año 10000.

Utilice el tipo de datos Date para albergar valores de fecha, valores de tiem-po o valores de fecha y hora.

El valor predeterminado de Date es 0:00:00 (medianoche) del 1 de enero de 0001.

Requisitos de formato

Debe incluir un literal Date dentro de los signos de número (# #). Debe es-pecificar el valor de fecha en el formato M/d/yyyy, por ejemplo #5/31/1993#.Este requisito es independiente de la configuración regional y de la configu-ración de formato de fecha y hora del equipo.

El motivo de esta restricción es que el significado del código nunca debe cambiar en función de la configuración regional en que se ejecuta la aplica-

•


54


ción. Suponga que asigna un literal Date de #3/4/1998# para representar 4 de marzo de 1998. En una configuración regional que utilice el formato mm/dd/yyyy, 3/4/1998 se compila como desee. Pero suponga que implementa la aplicación en varios países. En una configuración regional que utilice el for-mato dd/mm/yyyy, el literal incluido en el código se compilará como Abril 3, 1998. En una configuración local que utilice el formato yyyy/mm/dd, el literal podría no ser válido (Abril 1998, 0003) y generar un error de compilación.

Para convertir un literal de tipo Date al formato de la configuración regional o a un formato personalizado, proporcione el literal a la función Format(Función) especificando formatos de fecha y hora predefinidos o formatos de fecha y hora definidos por el usuario. En el siguiente ejemplo se muestra esta operación.

MsgBox(“F. formateada es” & Format(#5/31/1993#, “dddd, d MMM yyyy”))

DECIMAL

Contiene valores de 128 bits con signo (16 bytes) que representan números enteros de 96 bits (12 bytes) que se ajustan a una potencia variable de 10. El factor de ajuste especifica el número de dígitos a la derecha del separador decimal; comprendidos entre 0 y 28. Con un ajuste de 0 (sin decimales), el valor más grande posible es +/-79,228,162,514,264,337,593,543,950,335 (+/-7.9228162514264337593543950335E+28). Con 28 posiciones decima-les, el valor más grande es +/-7.9228162514264337593543950335 y el valor más pequeño distinto de cero es +/-0.0000000000000000000000000001(+/-1E-28).

El tipo de datos Decimal proporciona el número máximo de dígitos significa-tivos para un número. Admite hasta 29 dígitos significativos y puede repre-sentar valores que superan 7.9228 x 10^28. Es especialmente cómodo para cálculos, por ejemplo, financieros, que requieren un gran número de dígitos pero no puede tolerar errores del redondeo.

El valor predeterminado de Decimal es 0.

Precisión: Decimal no es un tipo de datos de punto flotante. La estructura Decimal contiene un valor entero binario, junto con un bit de signo y un factor de ajuste de entero que especifica qué parte del valor es una fracción decimal. Debido a esto, los números Decimal tienen una representación más precisa en la memoria que los tipos de punto flotante (Single y Double).

Rendimiento: El tipo de datos Decimal es el más lento de todos los tipos numéricos. Debe considerar la importancia de la precisión frente al rendi-miento antes de elegir un tipo de datos.

Ampliación: El tipo de datos Decimal se amplía a Single o Double. Esto signi-fica que se puede convertir Decimal a cualquiera de estos tipos sin encontrar un error de desbordamiento.

•


55


Ceros finales: Visual Basic no almacena los ceros finales en un literal Decimal. Sin embargo, una variable Decimal conserva cualquier cero final adquirido de forma computacional. Esto se ilustra en el siguiente ejemplo:

Dim d1, d2, d3, d4 As Decimald1 = 2.375Dd2 = 1.625Dd3 = d1 + d2d4 = 4DMsgBox(“d1 = “ & CStr(d1) & “, d2 = “ & CStr(d2) & “, d3 = “ & CStr(d3) & “, d4 = “ & CStr(d4))

El resultado de MsgBox en el ejemplo anterior es el siguiente:

d1 = 2.375, d2 = 1.625, d3 = 4.000, d4 = 4

DOUBLE

Contiene números IEEE de punto flotante de doble precisión de 64 bits (8 bytes) con valores de –1,79769313486231570E+308 a –4,94065645841246544E-324 para números negativos y de 4,94065645841246544E-324 a 1,79769313486231570E+308 para números positivos. Los números de doble precisión almacenan aproximaciones de números reales.

El tipo de datos Double proporciona las magnitudes más grandes y más pe-queñas posibles para un número.

El valor predeterminado de Double es 0.

Cuando trabaje con números de punto flotante, tenga presente que no siempre tienen una representación precisa en memoria. Esto podría provo-car unos resultados inesperados en ciertas operaciones, como comparación de valor y el operador Mod. Para obtener más información, vea Solucionar

problemas de tipos de datos.

Los tipos de datos de punto flotante no tienen ninguna representación in-terna de caracteres 0 finales. Por ejemplo, no distinguen entre 4,2000 y 4,2. Por consiguiente, los caracteres 0 finales no aparecen al mostrar o imprimir valores de punto flotante.

INTEGER

Contiene enteros de 32 bits con signo (4 bytes) que se sitúan en el intervalo entre -2.147.483.648 y 2.147.483.647.

El tipo de datos Integer proporciona rendimiento óptimo en un procesador de 32 bits. Los demás tipos integrales son más lentos para cargarse y alma-cenarse en la memoria.

El valor predeterminado de Integer es 0.

Ampliación: El tipo de datos Integer se amplía a Long, Decimal, Single o Double. Esto significa que se puede convertir Integer en cualquiera de estos tipos sin encontrar un error de desbordamiento

•

•


56


Si intenta asignar a una variable de un tipo integral un número que esté fuera del intervalo correspondiente a este tipo, se produce un error. Si intenta establecerlo en una fracción, el número se redondea. Ejemplo:

Dim nota As Integernota = CInt(5.9)MsgBox(nota)

Este código mostraría el valor 6

LONG

Contiene enteros de 64 bits (8 bytes) con signo cuyo valor se sitúa entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807 (9,2... E+18).

Utilice el tipo de datos Long para incluir números enteros demasiado gran-des para ajustarse en el tipo de datos Integer.

El valor predeterminado de Long es 0.

OBJECT

Contiene direcciones de 32 bits (4 bytes) que hacen referencia a objetos. Se puede asignar cualquier tipo de referencia (cadena, matriz, clase o interfaz) a una variable Object. Una variable Object también puede hacer referencia a datos de cualquier tipo de valor (numérico, Boolean, Char, Date, estructura o enumeración).

El tipo de datos Object puede señalar a datos de cualquier tipo, incluso cual-quier instancia de objeto que su aplicación reconozca. Utilice Object cuando en tiempo de compilación no conoce a qué tipo de datos puede señalar la variable.

El valor predeterminado de Object es Nothing (una referencia nula).

Independientemente del tipo de datos al que haga referencia, una variable Object no contiene el valor de datos en sí, sino un puntero al valor. Siempre utiliza cuatro bytes en la memoria del sistema, pero sin incluir el almace-namiento para los datos que representan el valor de la variable. Debido al código que el puntero utiliza para buscar los datos, las variables Object que contienen tipos de valor son de acceso un poco más lento que las variables que tienen un tipo explícito.

Rendimiento: Una variable que declara con el tipo Object es bastante flexi-ble para contener una referencia a cualquier objeto. Sin embargo, cuando invoca un método o propiedad en este tipo de variable, se produce siempre el enlace en tiempo de ejecución. Para forzar el enlace en tiempo de compilacióny un mejor rendimiento, declare la variable con un nombre de clase especí-fico o conviértala en el tipo de datos específico.

Cuando declara una variable de objeto, intente utilizar la clase más específica disponible, como TextBox en lugar de Control, así podrá tener acceso a sus propiedades y métodos.

•

•


57


Ampliación: Todos los tipos de datos y todos los tipos de referencia se am-plían al tipo de datos Object. Esto significa que se puede convertir cualquier tipo a Object sin encontrar un error de desbordamiento.

STRING

Contiene secuencias de puntos de código de 16 bits sin signo (2 bytes) que van de un valor de 0 a 65535. Cada punto de código, o código de carácter, representa un carácter Unicode único. Una cadena puede contener de 0 a 2.000 millones (2^31) de caracteres Unicode aproximadamente.

Para asignar un valor a una variable de cadena, este debe in entre comillas dobles.

Dim nombre As Stringnombre = “Jose Gutiérrez”

Si queremos que la variable contenga algo entrecomillado debemos escribir dos pares de comillas. Ejemplo:

Dim comentario As Stringcomentario = “Dijo “”no acordarse de nada”” y se marcho”MsgBox(comentario)

Conversion de tipo de datos

Si queremos evitar fallos en nuestro código y/o la sentencia option strict está activada, debemos usar funciones de conversión. Las funciones de conversión nos devuelven un dato especifíco convertido (si pueden) al tipo dado.

La función de conversión es CType(expresión, tipo) pero existen funciones reducidas para casi todos los tipos.

•

Nombre de la función

Tipo de datos

devuelto Intervalo de valores del argumento expression

CBool Boolean Cualquier expresión numérica, Char o String válida.

CByte Byte 0 a 255 (sin signo); las partes fraccionarias se redondean.1

CChar CharCualquier expresión Char o String válida; sólo se convierte el primer carácter de String; el valor puede estar comprendido entre 0 y 65535 (sin signo).

CDate Date Cualquier representación válida de fecha y hora.

CDbl Double de -1,79769313486231570E+308 a -4,94065645841246544E-324 para valores negativos; de 4,94065645841246544E-324 a 1,79769313486231570E+308 para valores positivos.


58


Operadores

Tipos de operadores

OPERADORES DE CONCATENACIÓN/ARITMÉTICOS

Exponenciación (^)

Negación (–)

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

División de número entero (\)

Módulo aritmético (Mod)

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

Concatenación de cadenas (&)

OPERADORES DE COMPARACIÓN

Los operadores relacionales comparan valores entre sí. Todos los operado-res relacionales dan como resultado un valor Boolean.

Los operadores relacionales tienen el siguiente significado general:

El operador = comprueba si dos operandos son iguales.

El operador <> comprueba si dos operandos no son iguales.

•

•

CDec Decimal

+/-79.228.162.514.264.337.593.543.950.335 para números a partir de cero, es decir, números sin decimales. Para números con 28 posiciones decimales, el intervalo es +/-7,9228162514264337593543950335. El menor número posible distinto de cero es 0,0000000000000000000000000001 (+/-1E-28).

CInt Integer de -2.147.483.648 a 2.147.483.647; las partes fraccionarias se redondean.

CLng Long de -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807; las partes fraccionarias se redondean.

CObj Object Cualquier expresión válida.

CSByte SByte de -128 a 127; las partes fraccionarias se redondean.

CShort Short de -32.768 a 32.767; las partes fraccionarias se redondean.

CSng Single De -3,402823E+38 a –1,401298E-45 para valores negativos; de 1,401298E-45 a 3,402823E+38 para valores positivos.

CStr String Los valores devueltos para CStr dependen del argumento expression.

CUInt UInteger de 0 a 4.294.967.295 (sin signo); las partes fraccionarias se redondean.

CULng ULong de 0 a 18.446.744.073.709.551.615 (sin signo); las partes fraccionarias se redondean.


59


El operador < comprueba si el primer operando es menor al segundo.

El operador > comprueba si el primer operando es mayor que el segundo.

El operador <= comprueba si el primer operando es menor o igual que el segundo.

El operador >= comprueba si el primer operando es mayor o igual que el segundo.

El operador Like lo utilizaremos para comparar que una cadena cumple un formato de expresión dado.

El operador TypeOf...Is Lo utilizaremos para hacer comprobaciones de tipo. Ejemplo:

Dim objeto1 As Control = txtEdadIf TypeOf objeto1 Is System.Windows.Forms.TextBox ThenMsgBox(“El objeto1 es un del tipo textbox”)

End If

OPERADORES LÓGICOS/BIT A BIT

Negación (Not)

Conjunción (And, AndAlso)

Disyunción (Or, OrElse, Xor)

Cuando aparecen la multiplicación y la división juntas en una expresión, se evalúa cada operación según aparece de izquierda a derecha. Cuando apa-recen la suma y la resta juntas en una expresión, cada operación se evalúa en orden de aparición de izquierda a derecha. Puede utilizar paréntesis para pasar por alto el orden de prioridad y obligar a evaluar algunas partes de una expresión antes que otras. Las operaciones entre paréntesis se realizan siempre antes que las de fuera del paréntesis. Sin embargo, entre paréntesis se mantiene la prioridad de los operadores.

El operador de concatenación de cadenas (&) no es un operador aritmético, pero, por prioridad, va después de todos los operadores aritméticos y antes de todos los operadores de comparación.

OPERADOR MOD

Divide dos números y devuelve sólo el resto.

Dim resto As Integerresto = 12 Mod 5MsgBox(resto)

El cuadro de mensaje mostraría un “2”.

•

•


60


Prioridad de los operadores

Cuando una expresión contiene varios operadores, la prioridad de los ope-radores controla el orden de evaluación de las expresiones. Por ejemplo, la expresión x + y * z se evalúa como x + (y * z) porque el operador * tiene una prioridad más alta que el operador +. La tabla siguiente muestra todos los operadores en orden descendente de prioridad. Los operadores dentro de una misma fila tienen la misma prioridad y se evalúan en el orden, de izquierda a derecha, que aparecen en una expresión:

Categoría Operadores

Principal Todas las expresiones de no operador

Exponenciación ^

Negación unaria +, -

Multiplicativo *, /

División de número entero \

Módulo Mod

Aditiva +, -

Concatenación &

Relacionales =, <>, <, >, <=, >=, Like, Is, TypeOf...Is

Condicional NOT Not

Condicional AND And, AndAlso

O condicional Or, OrElse

Condicional XOR Xor

Cuando un operando se encuentra entre dos operadores de la misma prio-ridad, la asociatividad de los operadores controla el orden en que se eje-cutan las operaciones. Todos los operadores binarios son asociativos por la izquierda, lo que significa que las operaciones se realizan de izquierda a derecha. La prioridad y asociatividad pueden y deben controlarse mediante el uso de expresiones entre paréntesis.

Mensajes

Es habitual en programación el tener un método para mostrar cierta infor-mación al usuario o bien solicitársela. Para ello disponemos de los mensajes, msgbox e inputbox.

Msgbox

Muestra un mensaje en un cuadro de diálogo, espera a que el usuario haga clic en un botón y devuelve un entero que indica el botón utilizado.


61


Public Function MsgBox( _ ByVal Prompt As Object, _ Optional ByVal Buttons As MsgBoxStyle = MsgBoxStyle.OKOnly, _ Optional ByVal Title As Object = Nothing _) As MsgBoxResult

PARÁMETROS

Prompt: Obligatorio. Expresión de tipo String que se muestra como mensa-je en el cuadro de diálogo. La longitud máxima de Prompt es de aproximada-mente 1024 caracteres, según el ancho de los caracteres utilizados. Si Promptconsta de más de una línea, puede separar las líneas mediante un carácter de retorno de carro (Chr(13)), un carácter de avance de línea (Chr(10)) o una combinación de caracteres de retorno de carro/avance de línea (Chr(13) y Chr(10)) entre cada línea.

Buttons: Opcional. Expresión numérica que corresponde a la suma de los valores que especifican el número y tipo de botones que se han de mostrar, el estilo de icono que se va a usar, la identificación del botón predetermi-nado y la modalidad del cuadro de mensaje. Si se omite Buttons, el valor predeterminado será cero.

Title: Opcional. Expresión de tipo String que se muestra en la barra de títu-lo del cuadro de diálogo. Si se omite Title, en la barra de título aparecerá el nombre de la aplicación.

En la siguiente tabla se incluyen los valores de enumeración de MsgBoxStyle:

•

Miembro Valor Descripción

OKOnly 0 Muestra sólo el botón Aceptar.

OKCancel 1 Muestra los botones Aceptar y Cancelar.

AbortRetryIgnore 2 Muestra los botones Anular, Reintentar y Omitir.

YesNoCancel 3 Muestra los botones Sí, No y Cancelar.

YesNo 4 Muestra los botones Sí y No.

RetryCancel 5 Muestra los botones Reintentar y Cancelar.

Critical 16 Muestra el icono Mensaje crítico.

Question 32 Muestra el icono Consulta de advertencia.

Exclamation 48 Muestra el icono Mensaje de advertencia.

Information 64 Muestra el icono Mensaje de información.

DefaultButton1 0 El primer botón es el predeterminado.

Miembro Valor Descripción

OKOnly 0 Muestra sólo el botón Aceptar.

OKCancel 1 Muestra los botones Aceptar y Cancelar.

AbortRetryIgnore 2 Muestra los botones Anular, Reintentar y Omitir.

YesNoCancel 3 Muestra los botones Sí, No y Cancelar.

YesNo 4 Muestra los botones Sí y No.

RetryCancel 5 Muestra los botones Reintentar y Cancelar.

Critical 16 Muestra el icono Mensaje crítico.

Question 32 Muestra el icono Consulta de advertencia.

Exclamation 48 Muestra el icono Mensaje de advertencia.

Information 64 Muestra el icono Mensaje de información.

DefaultButton1 0 El primer botón es el predeterminado.


62


El primer grupo de valores (0-5) describe el número y tipo de botones mos-trados en el cuadro de diálogo. El segundo grupo (16, 32, 48, 64) describe el estilo de icono. El tercer grupo (0, 256, 512) determina qué botón es el valor predeterminado. El cuarto grupo (0, 4096) determina la modalidad del cua-dro de mensaje y el quinto grupo especifica si el cuadro de mensaje es la ventana de primer plano, junto con la alineación y la dirección del texto. A la hora de sumar números para crear el valor final del argumento Buttons, se deberá utilizar únicamente un número de cada grupo. Podremos mostrar por ejemplo un mensaje con el icono de critical y el texto alineado a la dere-cha sumando sus valores. Ejemplo:MsgBox(“Problema con la conexion”, _CType(16 + 524288, MsgBoxStyle), “Error de conexion”)

O lo que es lo mismo

MsgBox(“Problema con la conexion”, _CType(MsgBoxStyle.Critical + MsgBoxStyle.MsgBoxRight, _MsgBoxStyle), “Error de conexion”)

El Msgbox da un valor de respuesta de la colección MsgBoxResult

Constante Valor

OK 1

Cancel 2

Abort 3

Retry 4

Ignore 5

Yes 6

No 7

DefaultButton2 256 El segundo botón es el predeterminado.

DefaultButton3 512 El tercer botón es el predeterminado.

ApplicationModal 0Aplicación modal: el usuario debe responder al cuadro de mensaje antes de continuar trabajando en la aplicación actual.

SystemModal 4096Sistema modal: se suspenden todas las aplicaciones hasta que el usuario responda al cuadro de mensaje.

MsgBoxSetForeground 65536Especifica la ventana del cuadro de mensaje como ventana de primer plano.

MsgBoxRight 524288 Texto alineado a la derecha.

MsgBoxRtlReading 1048576Especifica que el texto debe aparecer para ser leído de derecha a izquierda en los sistemas árabe y hebreo.

DefaultButton2 256 El segundo botón es el predeterminado.

DefaultButton3 512 El tercer botón es el predeterminado.

ApplicationModal 0Aplicación modal: el usuario debe responder al cuadro de mensaje antes de continuar trabajando en la aplicación actual.

SystemModal 4096Sistema modal: se suspenden todas las aplicaciones hasta que el usuario responda al cuadro de mensaje.

MsgBoxSetForeground 65536Especifica la ventana del cuadro de mensaje como ventana de primer plano.

MsgBoxRight 524288 Texto alineado a la derecha.

MsgBoxRtlReading 1048576Especifica que el texto debe aparecer para ser leído de derecha a izquierda en los sistemas árabe y hebreo.


63


Ejemplo:

If MsgBox(“Desea cancelar la conexion”, MsgBoxStyle.YesNo) = MsgBoxResult.Yes Thencancelar _ conexion()

End If

Inputbox

Muestra un mensaje en un cuadro de diálogo, espera a que el usuario escriba un texto o haga clic en un botón y devuelve una cadena con el contenido del cuadro de texto.

Public Function InputBox( _ ByVal Prompt As String, _ Optional ByVal Title As String = “”, _

Optional ByVal DefaultResponse As String = “”, _ Optional ByVal Xpos As Integer = -1, _ Optional ByVal YPos As Integer = -1 _) As String

PARÁMETROS

Prompt: Requerido. Expresión de tipo String que se muestra como mensaje en el cuadro de diálogo. La longitud máxima de Prompt es de aproximada-mente 1024 caracteres, según el ancho de los caracteres utilizados. Si Promptincluye más de una línea, puede separar las líneas mediante un carácter de retorno de carro (Chr(13)), un carácter de salto de línea (Chr(10)) o una combinación de retorno de carro y salto de línea (Chr(13) & Chr(10)) que inserta entre cada línea.

Title: Opcional. Expresión de tipo String que se muestra en la barra de títu-lo del cuadro de diálogo. Si se omite Title, en la barra de título aparecerá el nombre de la aplicación.

DefaultResponse: Opcional. Expresión de tipo String que se muestra en el cuadro de texto como respuesta predeterminada en caso de que no se suministre otra entrada. Si se omite DefaultResponse, el cuadro de texto se mostrará vacío.

XPos: Opcional. Expresión numérica que especifica, en twips, la distancia entre el borde izquierdo del cuadro de diálogo y el borde izquierdo de la pantalla. Si se omite XPos, el cuadro de diálogo quedará centrado horizon-talmente.

YPos: Opcional. Expresión numérica que especifica, en twips, la distancia entre el borde superior del cuadro de diálogo y el borde superior de la pan-talla. Si se omite YPos, el cuadro de diálogo se situará, en sentido vertical, a aproximadamente un tercio del alto total de la pantalla.

•


64


Si el usuario hace clic en Cancelar, se devolverá una cadena de longitud cero.

Si desea especificar más que el primer argumento, deberá utilizar la función InputBox en una expresión. Si omite alguno de los argumentos de posi-ción, deberá conservar el correspondiente delimitador de coma.

ELEMENTOS DEL LENGUAJE 2

Continuamos con las estructuras de programación.Hablaremos de su sintaxis y funcionamiento.

Estructuras de decisión

Estructuras de bucle

Salir de un procedimiento

Realizar acciones con métodos

Matrices

Procedimientos Sub

Procedimientos Function

Cómo tratar errores

w OleDb.

incidencias.m

w DataTable







conexion.Open()








Next

While lector.Read

fila = tabla.NewRow

For contador = 0

fila(cont

Next

tabla.R

End Whilconexe


5


66


ESTUCTURAS DE DECISIÓN

Visual Basic permite probar condiciones y realizar diferentes operaciones en función de los resultados de la prueba. Puede comprobar si una condición es verdadera o falsa, los distintos valores de una expresión o las diferentes excepciones que se generan al ejecutar una serie de instrucciones. Las ins-trucciones de decisión que admite Visual Basic incluyen:

If...Then If...Then...Else Select...Case

If..then

Se pueden utilizar instrucciones If...Then...Else para ejecutar una instruc-ción específica o un bloque de instrucciones dependiendo del valor de tipo Boolean de una condición. Generalmente, la condición es el resultado de comparar dos valores, pero también puede ser cualquier expresión que da como resultado un valor de tipo Boolean (True o False). Esto incluye los valo-res de otros tipos de datos, como los numéricos, que han sido convertidos a valores de tipo Boolean.

Ejecutar instrucciones si una condición es True

Para ejecutar sólo una instrucción cuando una condición es True, se puede utilizar la sintaxis de una sola línea de If...Then...Else omitiendo las instruc-ciones Else y End If, como muestra el ejemplo siguiente:

Sub FixDate() Dim MyDate As Date = #2/13/1973# If MyDate < Now Then MyDate = NowEnd Sub

Para ejecutar más de una línea de código cuando la condición es True se uti-liza la sintaxis de varias líneas, que incluye la instrucción End If. Si no existe código que ejecutar cuando la condición es False, se omite la instrucción Else, como se muestra en el ejemplo siguiente:

Dim AlertLabel As Label ‘ ...Sub AlertUser(ByVal Value As Long) If Value = 0 Then AlertLabel.ForeColor = vbRed AlertLabel.Font.Bold = True AlertLabel.Font.Italic = True End IfEnd Sub

•••


67


Ejecutar algunas instrucciones si una condición es True y otras si

es False

If...then...else

Puede utilizar If...Then...Else con la instrucción Else para definir dos blo-ques de instrucciones ejecutables. Si el valor de la condición es True, se ejecuta un bloque, y si es False, se ejecuta el otro.

Dim AlertLabel As System.Windows.Forms.Label ‘ ...Sub AlertUser(ByVal Value As Long) If Value = 0 Then AlertLabel.ForeColor = vbRed AlertLabel.Font.Bold = True AlertLabel.Font.Italic = True Else AlertLabel.Forecolor = vbBlack AlertLabel.Font.Bold = False AlertLabel.Font.Italic = False End IfEnd Sub

Probar condiciones adicionales si la primera condición es False

Puede agregar una o más instrucciones ElseIf a If...Then...Else para pro-bar condiciones adicionales si la primera condición es False. Por ejemplo, el siguiente procedimiento Function calcula una bonificación en la nómina basándose en el nivel de rendimiento. La instrucción que sigue a la instruc-ción Else sólo se ejecutará si el valor de las condiciones de todas las instruc-ciones If y ElseIf es False.

Function Bonus(ByVal Performance As Single, ByVal Sa-lary As Decimal) _ As Decimal If Performance = 1 Then Return Salary * 0.1 ElseIf Performance = 2 Then Return Salary * 0.09 ElseIf Performance = 3 Then Return Salary * 0.07 Else Return 0 End IfEnd Function

Visual Basic prueba las condiciones en el orden en que aparecen en las prue-bas de las instrucciones If...Then...Else hasta que encuentra una condición True o una instrucción Else, cuando esto ocurre, ejecuta el bloque de ins-trucciones correspondiente. La ejecución realiza entonces una bifurcación al final del bloque If...Then...Else.


68


Puede existir un número arbitrario de instrucciones ElseIf o ninguna. Puede incluirse u omitirse una instrucción Else independientemente de que existan instrucciones ElseIf.

Las instrucciones If...Then...Else se pueden anidar a tantos niveles como sea necesario. No obstante, es posible que en favor de la legibilidad, desee utilizar instrucciones Select...Case en lugar de varios niveles de instruccio-nes If...Then...Else anidadas o muchas instrucciones ElseIf.

Select Case

Cuando compara una misma expresión con varios valores diferentes, puede utilizar las instrucciones Select...Case como alternativa a las instrucciones If...Then...Else. A diferencia de las instrucciones If y ElseIf, que pueden evaluar una expresión diferente en cada instrucción, la instrucción Select

evalúa una única expresión una sola vez y la utiliza para cada comparación.

Visual Basic compara el valor de la expresión con los valores de las instruc-ciones Case en el orden en que éstos aparecen en el bloque Select...Case.Si encuentra una coincidencia o una instrucción Case Else, ejecuta el blo-que de instrucciones correspondiente. En cualquier caso, después ejecuta el código que sigue a la instrucción End Select.

Puede utilizarse cualquier número de instrucciones Case e incluirse u omi-tirse una instrucción Case Else.

En el ejemplo siguiente se usa Select...Case para evaluar el nivel de rendi-miento que se pasa al procedimiento Function. Observe que cada instruc-ción Case puede contener más de un valor, un intervalo de valores o una combinación de valores y operadores de comparación. Cuando una instruc-ción Case contiene más de un valor, el bloque Case se ejecuta si cualquiera de los valores coincide con el valor de la expresión de instrucción Select.

Function Bonus(ByVal Performance As Single, ByVal Salary As Decimal) _ As Decimal Select Performance Case 1 ‘ Performance is 1. Return Salary * 0.1 Case 2, 3 ‘ Performance is 2 or 3. Return Salary * 0.09 Case 5 To 7 ‘ Performance is 5, 6, or 7. Return Salary * 0.07 Case 4, 8 To 10 ‘ Performance is 4, 8, 9, or 10. Return Salary * 0.05 Case Is < 15 ‘ Performance is 11, 12, 13, or 14. Return 100 Case Else ‘ Performance is < 1 or > 14. Return 0 End SelectEnd Function


69


ESTRUCTURAS DE BUCLE

Las estructuras de bucle permiten ejecutar una o más líneas de código re-petitivamente. Una instrucción puede repetirse hasta que una condición sea verdadera, hasta que sea falsa, un número de veces especificado o una vez para cada objeto de una colección. Las estructuras de bucle que admite Vi-sual Basic incluyen:

While Do...Loop For...Next For Each...Next

While

Se puede utilizar la instrucción While para ejecutar un bloque de instruccio-nes, un número de veces indefinido, dependiendo del valor de tipo Booleande una condición. Las instrucciones se repiten mientras la condición sea True.Generalmente, la condición es el resultado de comparar dos valores, pero también puede ser cualquier expresión que da como resultado un valor de tipo Boolean (True o False). Esto incluye los valores de otros tipos de datos, como los numéricos, que han sido convertidos a valores de tipo Boolean.

La instrucción While comprueba siempre la condición antes de iniciar el bucle. La ejecución en bucle continúa mientras el valor de la condición per-manezca en True.

En el ejemplo siguiente, el procedimiento CheckWhile comprueba la con-dición antes de entrar en el bucle. Si Number se hubiera inicializado en 6 y no en 10, las instrucciones del bucle nunca se ejecutarían.

Sub CheckWhile() Dim Counter As Integer = 0 Dim Number As Integer = 10 While Number > 6 Number = Number - 1 Counter = Counter + 1 End While

MsgBox(“The loop ran “ & Counter & “ times.”) ‘ Runs 4 times.End Sub

Puede transferirse el control fuera de una instrucción While mediante la instrucción Exit While. Un uso de esta instrucción consiste en comprobar una condición que pudiera ocasionar un bucle sin fin; es decir, un bucle que pudiera ejecutarse un número extremadamente elevado de veces e incluso infinitamente. Si la condición es True, utilice Exit While para salir. Si la con-dición es False, el bucle continúa ejecutándose.

En el siguiente ejemplo se asigna a Number un valor que podría ocasionar que el bucle se ejecutara más de 2 ^ 31 veces. La instrucción If realiza esta comprobación y sale si existe el valor para evitar un bucle sin fin.

••••


70


Sub ExitWhileExample()Dim Counter As Integer = 0Dim Number As Integer = 8While Number <> 10

If Number < 0 Then Exit While Number = Number - 1 Counter = Counter + 1

End WhileMsgBox(“The loop ran “ & Counter & “ times.”) ‘ Se ejecuta 9 veces.

End Sub

Do loop

Puede utilizar instrucciones Do...Loop para ejecutar un bloque de instruc-ciones un número de veces indefinido dependiendo del valor de tipo Booleande una condición. Las instrucciones pueden repetirse mientras el valor de la condición sea True o hasta que sea True. Generalmente, la condición es el resultado de comparar dos valores, pero también puede ser cualquier ex-presión que da como resultado un valor de tipo Boolean (True o False). Esto incluye los valores de otros tipos de datos, como los numéricos, que han sido convertidos a valores de tipo Boolean.

Repetir instrucciones mientras una condición es True

Hay dos maneras de utilizar la palabra clave While para comprobar una condición en un bucle Do. Puede comprobar la condición antes de entrar en el bucle o comprobarla después de que el bucle se haya ejecutado al menos una vez. La ejecución en bucle continúa mientras el valor de la condición permanezca en True.

En el ejemplo siguiente, el procedimiento CheckWhileFirst comprueba la condición antes de entrar en el bucle. Si Number se hubiera inicializado en 6 y no en 10, las instrucciones del bucle nunca se ejecutarían. En el procedi-miento CheckWhileLast, las instrucciones del bucle se ejecutan una vez antes de comprobar la condición, que es False en la primera prueba.

Sub CheckWhileFirst() Dim Counter As Integer = 0 Dim Number As Integer = 10 Do While Number > 6 Number = Number - 1 Counter = Counter + 1 Loop MsgBox(“The loop ran “ & Counter & “ times.”) ‘ Se ejecuta 4 vecesEnd Sub


71


‘ ...Sub CheckWhileLast() Dim Counter As Integer = 0 Dim Number As Integer = 5 Do Number = Number - 1 Counter = Counter + 1 Loop While Number > 6 MsgBox(“The loop ran “ & Counter & “ times.”) ‘ Se ejecuta 1 vez.End Sub

Repetir instrucciones hasta que una condición sea True

Hay dos maneras de utilizar la palabra clave Until para comprobar una con-dición en un bucle Do. Puede comprobar la condición antes de entrar en el bucle o comprobarla después de que el bucle se haya ejecutado al menos una vez. La ejecución en bucle continúa mientras la condición permanezca en False.

En el ejemplo siguiente, el procedimiento CheckUntilFirst comprueba la condición antes de entrar en el bucle. Si Number se hubiera inicializado en 15 y no en 20, las instrucciones del bucle nunca se ejecutarían. En el procedimiento CheckUntilLast, las instrucciones dentro del bucle se ejecutan una vez antes de comprobar la condición, que es False en la primera prueba.

Sub CheckUntilFirst() Dim Counter As Integer = 0 Dim Number As Integer = 20 Do Until Number = 15 Number = Number - 1 Counter = Counter + 1 Loop MsgBox(“The loop ran “ & Counter & “ times.”) ‘ Se ejecuta 5 veces.End Sub ‘ ...Sub CheckUntilLast() Dim Counter As Integer = 0 Dim Number As Integer = 20 Do Number = Number - 1 Counter = Counter + 1 Loop Until Number = 15 MsgBox(“The loop ran “ & Counter & “ times.”) ‘ Se ejecuta 5 veces.End Sub

Salir de un bucle Do desde dentro del bucle

Puede transferirse el control fuera de un bucle Do mediante la instrucción Exit Do. Un uso de esta instrucción consiste en comprobar una condición que pudiera ocasionar un bucle sin fin; es decir, un bucle que pudiera ejecu-tarse un número extremadamente elevado de veces e incluso infinitamente.


72


Si la condición es True, utilice Exit Do para salir. Si la condición es False, el bucle continúa ejecutándose.

En el siguiente ejemplo se asigna a Number un valor que podría ocasionar que el bucle se ejecutara más de 2 ^ 31 veces. La instrucción If realiza esta comprobación y sale si existe el valor para evitar un bucle sin fin.

Sub ExitDoExample() Dim Counter As Integer = 0 Dim Number As Integer = 8 Do Until Number = 10 If Number < 0 Then Exit Do Number = Number - 1 Counter = Counter + 1 Loop MsgBox(“The loop ran “ & Counter & “ times.”) ‘ Se ejecuta 8 veces.End Sub

La palabra clave Until especifica una condición que finaliza la ejecución de un bucle Do.

For...nextLos bucles Do funcionan bien cuando no se sabe de antemano cuántas veces se necesitan ejecutar las instrucciones en el bucle. No obstante, si tiene pre-visto ejecutar el bucle un número específico de veces, un bucle For…Next es una opción mejor. A diferencia de un bucle Do, un bucle For utiliza una variable denominada counter cuyo valor aumenta o disminuye cada vez que se repite el bucle. La sintaxis es la siguiente:

For counter = start To end [ Step step ] ‘el contador aumenta según el intervalo hasta so-brepasar el fin. Next [ counter ]

La variable counter debe ser un tipo de datos numérico que admita los ope-radores mayor que (>), menor que (<) y suma (+); generalmente es de tipo Integer. Los valores de iteración start, end, y step son expresiones que deben evaluarse como tipos de datos que se amplían al tipo de counter. Normal-mente también son Integer. El valor opcional step puede ser positivo o nega-tivo. Si se omite, se considera que es 1.

Al iniciarse la ejecución del bucle For…Next, Visual Basic evalúa start, endy step. Después asigna start a counter. Antes de ejecutar el bloque de instruc-ciones, compara counter con end. Si counter ya ha superado el valor final, el bucle For finaliza y el control pasa a la instrucción que sigue a Next. En caso contrario, se ejecuta el bloque de instrucciones.

Cada vez que Visual Basic encuentra la instrucción Next, incrementa el contador según el valor de step y vuelve a la instrucción For. Vuelve a com-parar el contador con end, y una vez más ejecuta el bloque o termina el bucle dependiendo del resultado. Este proceso continúa hasta que el contador supera end o se ejecuta una instrucción Exit For.


73


El bucle no termina hasta que counter haya superado el valor final. La compa-ración es mayor que (>) si el valor de incremento es positivo y menor que (<) si el incremento es negativo. Si counter es igual a end, el bucle continúa.

Opcionalmente, puede especificarse counter en la instrucción Next. De este modo mejora la legibilidad del programa. La variable que especifique debe ser igual a la que aparece en la instrucción For.

El procedimiento siguiente preestablece todos los elementos de una matriz en 128. La instrucción For especifica la variable de contador I y sus valores de inicio y fin. La instrucción Next incrementa el contador en 1, porque no se proporciona step.

Sub Preset(ByRef A() As Integer) Dim I As Integer For I = 1 To UBound(A) A(I) = 128 Next IEnd Sub

Los valores de iteración start, end y step sólo se evalúan una vez, antes de iniciarse el bucle. Si en el bloque de instrucciones cambia end o step, estos cambios no afectan a la iteración del bucle. En el ejemplo anterior, la función UBound sólo se invoca cuando la instrucción For se ejecuta por primera vez. Si el bloque de instrucciones hubiera cambiado posteriormente la longi-tud de la matriz A, el bucle For seguiría utilizando la longitud original como valor final, puesto que no vuelve a llamar a la función UBound.

Aumentar y disminuir la variable de contador

Mediante la palabra clave Step, puede aumentar o disminuir el contador en el valor que especifique. En el siguiente ejemplo, la variable de contador Jse incrementa en 2 cada vez que se repite el bucle. Cuando finaliza el bucle, Total es la suma de 2, 4, 6, 8 y 10.

Sub TwosTotal() Dim J, Total As Integer For J = 2 To 10 Step 2 Total = Total + J Next J MsgBox(“The total is “ & Total)End Sub

Para disminuir la variable de contador, utilice un valor negativo para Step.Cuando haga esto, debe especificar un valor final que sea menor que el valor de inicio. En el siguiente ejemplo, la variable de contador N disminuye en 2 cada vez que se repite el bucle. Cuando finaliza el bucle, Total es la suma de 16, 14, 12, 10, 8, 6 y 4.


74


Sub NewTotal() Dim N, Total As Integer For N = 16 To 4 Step -2 Total = Total + N Next N MsgBox(“The total is “ & Total)End Sub

For each...next

El bucle For Each...Next es parecido al bucle For...Next, pero ejecuta el bloque de instrucciones una vez por cada elemento de una colección, en vez de un número de veces especificado. La sintaxis es la siguiente:

For Each elementvariable In collection ‘ Statement block to be executed for each value of ele-mentvariable.Next [ elementvariable ]

Los elementos de collection pueden ser de cualquier tipo de datos. El tipo de datos de elementvariable ha de ser tal que cada elemento de la colección pueda ser convertido al mismo.

Para cada iteración del bucle, Visual Basic establece la variable elementvaria-ble en uno de los elementos de la colección y ejecuta el bloque de instruc-ciones. Cuando todos los elementos de la colección han sido asignados a elementvariable, el bucle For Each finaliza y el control pasa a la instrucción que sigue a Next.

Opcionalmente, puede especificarse la variable de elemento en la instruc-ción Next. De este modo mejora la legibilidad del programa. La variable que especifique debe ser igual a la que aparece en la instrucción For Each.

El siguiente procedimiento acepta un formulario y establece el color de fon-do de cada control del formulario en azul claro:

Sub LightBlueBackground(ByVal ThisForm As System.Win-dows.Forms.Form) Dim ThisControl As System.Windows.Forms.Control For Each ThisControl In ThisForm.Controls ThisControl.BackColor = System.Drawing.Color.LightBlue Next ThisControlEnd Sub

Si el código utilizado depende del recorrido de una colección en un orden concreto, un bucle For Each...Next no es la mejor opción a menos que conozca las características del objeto enumerador que utiliza la colección. Si el código agrega, elimina o reorganiza elementos mientras recorre la co-lección, puede conseguir resultados más fiables mediante un bucle diferente como For...Next o Do...Loop.


75


SALIR DE UN PROCEDIMIENTO

Sale de un procedimiento o bloque y transfiere el control inmediatamente a la instrucción que sigue a la llamada al procedimiento o a la definición del bloque.

Exit { ¡Error! Referencia de hipervínculo no válida. | ¡Error! Referencia de hipervínculo no válida. | ¡Error! Referencia de hipervínculo no válida. | ¡Error! Referencia de hipervínculo no válida. | ¡Error! Referencia de hiper-vínculo no válida. | ¡Error! Referencia de hipervínculo no válida. }

Partes

Do: Sale inmediatamente del bucle Do en el que aparece. La ejecución con-tinúa con la instrucción que sigue a la instrucción Loop Exit Do. Sólo se puede utilizar dentro de un bucle Do. Cuando se utiliza con bucles anidados Do, Exit Do transfiere el control al bucle que está anidado un nivel por encima del bucle donde ocurre Exit Do.

For: Sale inmediatamente del bucle For en el que aparece. La ejecución continúa con la instrucción que sigue a la instrucción Next. Exit For sólo se puede utilizar dentro de un bucle For...Next o For Each...Next. Cuan-do se utiliza con bucles anidados For, Exit For transfiere el control al bucle que está anidado un nivel por encima del bucle donde ocurre Exit For.

Function: Sale inmediatamente del procedimiento Function en el que apa-rece. La ejecución continúa con la instrucción que sigue a la instrucción que llamó al procedimiento Function. Exit Function sólo se puede utilizar dentro de un procedimiento Function.

Select: Sale inmediatamente del procedimiento Select Case en el que aparece. La ejecución continúa con la instrucción que sigue a la instrucción End Select. Exit Select sólo se puede utilizar dentro de una instrucción Select Case.

Sub: Sale inmediatamente del procedimiento Sub en el que aparece. La ejecución continúa con la instrucción que sigue a la instrucción que llamó al procedimiento Sub. Exit Sub sólo se puede utilizar dentro de un procedi-miento Sub.

While: Sale inmediatamente del bucle While en el que aparece. La ejecu-ción continúa con la instrucción que sigue a la instrucción End While. Exit

While sólo se puede utilizar dentro de un bucle While. Cuando se utiliza con bucles anidados While, Exit While transfiere el control al bucle que está anidado un nivel por encima del bucle donde ocurre Exit While.

No confunda las instrucciones Exit con las instrucciones End. La instruc-ción Exit no define dónde termina una instrucción.


76


Ejemplo

En este ejemplo se utiliza la instrucción Exit para salir del bucle For...Next,Do...Loop y de un procedimiento Sub.

Sub ExitStatementDemo()Dim I, MyNum As Integer Do ‘ Bucle infinito. For I = 1 To 1000 ‘ Se ejecuta 1000 veces. MyNum = Int(Rnd * 1000) ‘ Genera números ale-torios. Select Case MyNum ‘ Evaluael número aleato-rio. Case 7: Exit For ‘ If 7, exit For...Next. Case 29: Exit Do ‘ If 29, exit Do...Loop. Case 54: Exit Sub ‘ If 54, exit Sub pro-cedure. End Select Next I LoopEnd Sub

REALIZAR ACCIONES CON MÉTODOS

Los métodos son procedimientos asociados a objetos. Excepto los campos y las propiedades, que representan información que puede almacenar un objeto, los métodos representan acciones que puede realizar un objeto. Los métodos pueden afectar a los valores de las propiedades. Por ejemplo, en el caso de una analogía de radio, se puede emplear un método SetVolumepara cambiar el valor de una propiedad Volume. Asimismo, en Visual Basic .NET, los elementos de los cuadros de lista tienen una propiedad List, que se puede cambiar con los métodos Clear y Add.

Usar métodos en el código

Al utilizar un método en código, la forma de crear la instrucción depende de cuántos argumentos requiere el método y de si devuelve un valor. Gene-ralmente, los métodos se utilizan igual que las subrutinas o las llamadas de función. De forma más específica, los métodos se invocan del mismo modo que los procedimientos de módulos, exceptuando que los métodos se pue-den calificar con una expresión especificando la instancia del objeto a cuyo método debe llamarse. Si no está calificada, la instancia es de forma implícita la variable Me.

Para utilizar un método que no requiera argumentos

Utilice la sintaxis siguiente: object.method()

•


77


En el ejemplo siguiente, el método Refresh vuelve a dibujar el cuadro de imagen:

PictureBox1.Refresh() ‘ Forces a repaint of the control

MATRICES

Las matrices son útiles para trabajar con un conjunto de valores del mismo tipo de datos. Una matriz es una única variable con varios compartimentos para almacenar valores, mientras que una variable escalar (es decir, no ma-tricial) sólo dispone de un compartimento para almacenar un único valor. Se puede hacer referencia a la matriz como un todo si se desea hacer referen-cia a todos los valores que contiene, o bien se puede hacer referencia a sus elementos individuales uno a uno.

Por ejemplo, para almacenar los gastos diarios para cada día del año, se pue-de crear una matriz con 366 elementos, en vez de declarar 366 variables. Cada elemento de la matriz contiene un valor, al cual se obtiene acceso me-diante el índice del elemento. En el siguiente ejemplo se declara la variable de matriz CurExpense, se inicializa de modo que contenga 366 elementos y, a continuación, se asigna a cada elemento el valor inicial 20.

Sub FillArray() Dim CurExpense(365) As Decimal ‘ Matriz de 0 a 365. Dim I As Integer For I = 0 to 365 CurExpense(I) = 20.00 Next I End Sub

Se pueden mezclar distintos tipos de datos en una matriz si se declara del tipo Object. En el siguiente ejemplo se almacena información de empleados en la variable de matriz EmployeeData.

Dim EmployeeData(3) As Object ‘ Matriz de 0 a 3. EmployeeData(0) = “Ron Bendel” EmployeeData(1) = “4242 Maple Blvd” EmployeeData(2) = 48 EmployeeData(3) = “06-09-1953”

Matrices multidimensionales

En Visual Basic, se pueden declarar matrices de hasta 32 dimensiones. Por ejemplo, la siguiente instrucción declara una matriz bidimensional con 5 filas y 10 columnas.

Dim Rectangle(4, 9) As Single ‘ De 0 a 4, 0 a 9.

El número total de elementos es el producto de los tamaños de todas las dimensiones; en este caso, 50.


78


Para crear una matriz dinamica

Las variables de matriz se declaran del mismo modo que otras variables, mediante la instrucción Dim. Se agregan uno o más pares de paréntesis a continuación del nombre de la variable para indicar que es una matriz en vez de un valor escalar (una variable que contiene un solo valor).

Para declarar una variable de matriz unidimensional

En la declaración, agregue un par de paréntesis detrás del nombre de la va-riable, tal y como muestra el siguiente ejemplo:

Dim MySingleArray() As Integer

Se utiliza a nivel de procedimiento para reasignar espacio de almacenamien-to para una variable de matriz.

ReDim [ ¡Error! Referencia de hipervínculo no válida. ]¡Error! Referencia de hipervínculo no válida.[(¡Error! Re-ferencia de hipervínculo no válida.)]

Partes

Preserve: Opcional. Palabra clave utilizada para conservar los datos en una matriz existente cuando sólo se cambia el tamaño de la última dimensión.

Name: Requerido. Nombre de la variable. Debe ser un identificador de Visual Basic válido. Se pueden volver a cambiar tantas variables como desee en la misma instrucción especificando las partes name y boundlist para cada una. Las variables múltiples se separan con comas.

Boundlist: Requerido. Lista de enteros que no sean negativos que repre-sentan los límites superiores de las dimensiones de una matriz que se ha vuelto a definir. Los límites superiores múltiples se separan por comas. El número de dimensiones en boundlist debe coincidir con el rango original de la matriz.

Cada valor en boundlist especifica el límite superior de una dimensión, no la longitud. El límite inferior es siempre cero; por tanto, el subíndice de cada dimensión puede variar desde cero hasta el valor del límite superior.

Es posible utilizar –1 para declarar el límite superior de una dimensión de matriz. Esto significa que la matriz está vacía, pero no es Nothing, una dis-tinción que requieren algunas funciones del Common Language Runtime. No obstante, el código de Visual Basic no tiene un acceso satisfactorio a dicha matriz. Si se intenta obtenerlo, se produce un error IndexOutOfRange-

Exception durante la ejecución.

La instrucción ReDim sólo puede aparecer en el nivel de procedimiento. Esto significa que se puede volver a definir matrices dentro de un procedi-miento pero no en el nivel de clase o módulo.


79


La instrucción ReDim se utiliza para cambiar el tamaño de una o más di-mensiones de una matriz que ya se ha declarado formalmente. ReDim no puede cambiar el rango (el número de dimensiones) de la matriz.

La instrucción ReDim no puede cambiar el tipo de datos de una variable de matriz o proporcionar valores nuevos de inicialización para los elementos de la matriz.

ReDim libera la matriz existente y crea una matriz nueva con el mismo ran-go. Los elementos de la nueva matriz se inicializan al valor predeterminado para su tipo de datos a menos que especifique Preserve.

Si se incluye la palabra clave Preserve, Visual Basic copia los elementos de la matriz existente en la nueva matriz. Si se utiliza Preserve, sólo se puede cambiar el tamaño de la última dimensión de la matriz y, para cada otra dimensión, debe especificar el mismo tamaño que tenga en la matriz existente.

Por ejemplo, si su matriz tiene sólo una dimensión, puede cambiar el tama-ño de dicha dimensión y conservar sin embargo el contenido de la matriz porque es la última y única dimensión. Sin embargo, si su matriz tiene dos o más dimensiones, sólo puede cambiar el tamaño de la última dimensión si utiliza Preserve.

El ejemplo siguiente aumenta el tamaño de la última dimensión de una matriz dinámica sin perder los datos existentes en la matriz y, a continuación, se reduce el tamaño con una pérdida parcial de datos.

Dim IntArray(10, 10, 10) As Integer‘ ...ReDim Preserve IntArray(10, 10, 20)‘ ...ReDim Preserve IntArray(10, 10, 15)

El primer ReDim crea una nueva matriz, copiando todos los elementos de la matriz existente. También agrega más de 10 columnas al final de cada fila de cada capa. Los elementos de estas nuevas columnas se inicializan con el valor predeterminado del tipo de elemento de la matriz.

El segundo ReDim crea otra nueva matriz, copiando todos los elementos que quepan. Sin embargo, se pierden cinco columnas desde el final de cada fila en cada capa. Esto no es un problema si ha terminado de utilizar estas columnas. Si se reduce el tamaño de una matriz de gran tamaño, puede libe-rar memoria que ya no necesite.

Se puede utilizar ReDim en una propiedad que contiene una matriz de valores.


80


Ejemplo

En este ejemplo se utiliza la instrucción ReDim para asignar y reasignar espacio de almacenamiento para variables de matriz.

Dim I, MyArray() As Integer ‘ Declara una variable y una matriz.ReDim MyArray(5) ‘ Redimensiona a 6 elementos.For I = 0 To UBound(MyArray) MyArray(I) = I ‘ Initializa la matriz.Next I

La siguiente instrucción cambia el tamaño de la matriz sin guardar el conte-nido de los elementos.

ReDim MyArray(10) ‘ Redimensiona a 11 elementos.For I = 0 To UBound(MyArray) MyArray(I) = I ‘ Initializa la matriz.Next I

La siguiente instrucción cambia el tamaño de la matriz pero guarda el con-tenido de los elementos.

ReDim Preserve MyArray(15) ‘ Redimensiona a 16 elementos.

Cambiar el tamaño de matrices

Una matriz se puede redimensionar en cualquier momento asignando un objeto matriz diferente a la misma variable de matriz, mediante ReDim o una instrucción de asignación estándar. El nuevo objeto matriz puede tener dimensiones diferentes e incluso distinto rango. Esto ayuda a administrar la memoria de forma más eficaz. Por ejemplo, es posible utilizar una matriz grande durante un tiempo reducido y, después, redimensionarla mediante ReDim a un tamaño menor. De este modo, se libera memoria que ya no se necesita.

Cuando se redimensiona una matriz mediante ReDim, normalmente se pierden los valores existentes. No obstante, se pueden conservar si se in-cluye la palabra clave Preserve en la instrucción ReDim. Por ejemplo, la siguiente instrucción asigna una nueva matriz, inicializa sus elementos a par-tir de los elementos correspondientes de MyArray y asigna la nueva matriz a MyArray.

ReDim Preserve MyArray(10, 20)

Crear matrices de objetos

Para declarar y utilizar matrices de un tipo de objeto se procede del mismo modo que para declarar y utilizar una matriz de cualquier tipo de datos. Los miembros de esta matriz pueden recuperarse mediante su índice y manipu-larse como cualquier otro objeto de este tipo. Las matrices también tienen funcionalidad integrada para buscar y ordenar, a la que se puede tener acce-so a través la variable de matriz.


81


PROCEDIMIENTOS SUB

Un procedimiento Sub consiste en una serie de instrucciones de Visual Basic delimitadas por las instrucciones Sub y End. Cada vez que se llama a un procedimiento, se ejecutan las instrucciones de éste, desde la primera instrucción ejecutable tras la instrucción Sub hasta la primera instrucción End Sub, Exit Sub o Return que se encuentre.

Un procedimiento Sub ejecuta acciones, pero no devuelve ningún valor. Puede tomar argumentos, como constantes, variables o expresiones, que le pasa el código de llamada.

La sintaxis para declarar un procedimiento Sub es la siguiente:

[accessibility] Sub subname[(argumentlist)] ‘ Statements of the Sub procedure go here.End Sub

La accesibilidad puede ser Public, Protected, Friend, Protected Friend o Private.

Los procedimientos Sub pueden definirse en módulos, clases y estructuras. Son Public de forma predeterminada, lo que significa que se les puede lla-mar desde cualquier parte de una aplicación.

Declaración de argumentos

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, así como si se trata de un argumento opcional.

La sintaxis de los argumentos en una lista de argumentos es la siguiente:

[Optional] [ByVal|ByRef] [ParamArray] argumentname As datatype

Si el argumento es opcional, la declaración de éste debe contener también un valor predeterminado, como se muestra a continuación:

Optional [ByVal|ByRef] argumentname As datatype = de-faultvalue

Sintaxis de llamada

Los procedimientos Sub se invocan de forma explícita, con una instrucción de llamada independiente. No se les puede llamar utilizando su nombre en una expresión. La instrucción de llamada debe suministrar el valor de todos los argumentos que no sean opcionales, y debe incluir la lista de argumentos entre paréntesis. Si no se proporcionan argumentos, se puede omitir el pa-réntesis. El uso de la palabra clave Call también es opcional.


82


La sintaxis para llamar a un procedimiento Sub es la siguiente:

[Call] subname[(argumentlist)]

El procedimiento Sub que aparece a continuación notifica al usuario del equipo la tarea que está a punto de realizar la aplicación, y también mues-tra una marca de tiempo. En lugar de duplicar este fragmento de código al principio de cada tarea, la aplicación simplemente llama a TellOperator desde varios lugares. Cada llamada pasa una cadena al argumento Task que identifi-ca la tarea que se va a iniciar.

Sub TellOperator(ByVal Task As String) Dim Stamp As Date ‘ Stamp is local to TellO-perator. Stamp = TimeOfDay() ‘ Get current time for time stamp. ‘ Use MessageBox class of System.Windows.Forms na-mespace. MessageBox.Show(“Starting “ & Task & “ at “ & CStr(Stamp))End Sub

Una llamada típica a TellOperator tendría esta forma:

Call TellOperator(“file update”)

PROCEDIMIENTOS FUNCTION

Un procedimiento Function consiste en una serie de instrucciones de Vi-sual Basic delimitadas por las instrucciones Function y End Function.Cada vez que se llama a un procedimiento de este tipo, se ejecutan las ins-trucciones de éste, desde la primera instrucción ejecutable tras la instruc-ción Function hasta la primera instrucción End Function, Exit Function

o Return que se encuentre.

Un procedimiento Function es similar a un procedimiento Sub, pero ade-más devuelve un valor al programa que realiza la llamada al procedimiento. Un procedimiento Function puede tomar argumentos, como constantes, variables o expresiones, que le pasa el código de llamada.

La sintaxis para declarar un procedimiento Function es la siguiente:

[accessibility] Function functionname[(argumentlist)] As datatype ‘ Statements of the Function procedure.End Function

La accesibilidad puede ser Public, Protected, Friend, Protected Friend o Private.


83


Los procedimientos Function pueden definirse en módulos, clases y es-tructuras. Son Public de forma predeterminada, lo que significa que se les puede llamar desde cualquier parte de una aplicación.

Los argumentos se declaran del mismo modo que en un procedimiento Sub.

Valores devueltos

El valor que un procedimiento Function devuelve al programa que realiza la llamada se denomina valor devuelto. La función puede devolver dicho valor de dos maneras:

La función asigna un valor a su propio nombre de función en una o más instrucciones del procedimiento. No se devuelve el control al programa que realiza la llamada hasta que se ejecuta una instrucción Exit Function o End Function, como en el siguiente ejemplo:

Function functionname[(argumentlist)] As datatype ‘ ... functionname = expression ‘Control remains within the function. ‘ ...End Function

La función utiliza la instrucción Return para especificar el valor devuelto, e inmediatamente devuelve el control al programa de llamada, como en el siguiente ejemplo:

Function functionname[(argumentlist)] As datatype ‘ ... Return expression ‘Control is returned imme-diately. ‘ ...End Function

La ventaja de asignar el valor devuelto al nombre de la función es que el control permanece en la función hasta que el programa encuentra una ins-trucción Exit Function o End Función, lo que permite asignar un valor previo y, si es necesario, se puede ajustar después.

Si la función devuelve datos de tipo matricial, el acceso a los elementos individuales de la matriz no es posible dentro de la función. Si se intentara hacerlo, el compilador lo interpretará como una llamada a la función. En el siguiente ejemplo se genera un error de compilación:

Function AllOnes(ByVal N As Integer) As Integer()For I = 1 To N - 1 ‘ Assume N has a valid value.

AllOnes(I) = 1 ‘ Compiler error: call with wrong data type. Next I Return AllOnes()End Function

•

•


84


Todos los procedimientos Function tienen un tipo de datos, al igual que las variables. La cláusula As de la instrucción Function especifica el tipo de datos, y determina el tipo del valor devuelto. En las siguientes declaraciones de ejemplo se ilustra esto último:

Function Yesterday As DateFunction Sqrt(ByVal Number As Single) As Single

Sintaxis de llamada

Para llamar a un procedimiento Function, hay que incluir el nombre y los argumentos de éste en la parte derecha de una asignación o en una expre-sión. Esto último se ilustra en los siguientes ejemplos de llamada:

lvalue = functionname[(argumentlist)]If ((functionname[(argumentlist)] / 3) <= expression)Then ...

El siguiente procedimiento Function calcula la hipotenusa de un triángulo rectángulo a partir de los valores de los catetos:

Function Hypotenuse (ByVal Side1 As Single, ByVal Side2 As Single) As Single Return Sqrt((Side1 ^ 2) + (Side2 ^ 2))End Function

Son llamadas habituales a Hypotenuse las siguientes:

TestHypotenuse = Hypotenuse(TestLength, 10.7)Area = TriangleArea(X, Y, Hypotenuse(X, Y))

Common Language Runtime proporciona multitud de funciones, que se encuentran en el espacio de nombres Microsoft.VisualBasic. Entre las funciones más comunes se encuentran, por ejemplo, Beep, MsgBox y Str-

Comp. Puede llamar a estas funciones de la misma manera que llama a los procedimientos Function que ha creado usted mismo.

Cuando se llama a un procedimiento Function, no es necesario utilizar su valor devuelto, en cuyo caso se ejecutan todas las acciones de la función, pero el valor devuelto se omite. Las llamadas a MsgBox suelen hacerse de esta manera.

COMO TRATAR ERRORES

Instrucción Try...Catch...Finally (Visual Basic)

Esta instrucción proporciona una manera de controlar algunos o todos los errores posibles que pueden ocurrir en un bloque de código determinado mientras se ejecuta el código.


85


Try [ tryStatements ] [ Exit Try ][ Catch [ exception [ As type ] ] [ When expression ] [ catchStatements ] [ Exit Try ] ][ Catch ... ][ Finally [ finallyStatements ] ]End Try

tryStatementsOpcional. Instrucciones en las que puede ocurrir un error. Puede ser una instrucción compuesta.

catchOpcional. Se permite utilizar varios bloques Catch. Si tiene lugar una excep-ción mientras se procesa el bloque Try, cada instrucción Catch se examina en orden textual para determinar si controla la excepción; el parámetro exception representa la excepción que se ha producido.

exceptionOpcional. Cualquier nombre de variable. El valor inicial de exception es el valor del error producido. Se utiliza con Catch para especificar la captura del error. Si se omite, la instrucción Catch detecta cualquier excepción.

typeOpcional. Especifica el tipo de filtro de clase. Si el valor de exception es del tipo especificado en type o de un tipo derivado, el identificador queda enla-zado al objeto de excepción.

whenOpcional. Una instrucción Catch con una cláusula When sólo detecta las excepciones cuando expression se evalúa como True. Una cláusula When

sólo se aplica después de comprobar el tipo de la excepción y expression puede hacer referencia al identificador que representa la excepción.

expressionOpcional. Debe ser convertible implícitamente a Boolean. Cualquier ex-presión que describe un filtro genérico. Se utiliza normalmente para filtrar por número de error. Se utiliza con la palabra clave When para especificar las circunstancias bajo las que se captura el error.

catchStatementsOpcional. Instrucciones para controlar los errores que se producen en el bloque Try. Puede ser una instrucción compuesta.

Exit Try Opcional. Palabra clave que interrumpe la ejecución de la estructura Try...

Catch...Finally. La ejecución se reanuda con el código que sigue inmediata-mente a la instrucción End Try. Se ejecutará la instrucción Finally todavía. No se permite en bloques Finally.


86


FinallyOpcional. Siempre se ejecuta un bloque Finally cuando la ejecución sale de cualquier parte de la instrucción Try.

finallyStatementsOpcional. Instrucciones que se ejecutan después de las demás operaciones de procesamiento de error.

End Try Finaliza la estructura Try...Catch...Finally.

Las variables locales de un bloque Try no se encuentran disponibles en un bloque Catch porque se trata de bloques independientes. Si se desea utili-zar una variable en más de un bloque, se debe declarar la variable fuera de la estructura Try...Catch...Finally.

Las variables locales de un bloque Try no se encuentran disponibles en un bloque Catch porque se trata de bloques independientes. Si se desea utilizar una variable en más de un bloque, se debe declarar la variable fuera de la estructura Try...Catch...Finally.

El bloque Try contiene código donde puede producirse un error, mien-tras que el bloque Catch contiene el código para controlar cualquier error que tenga lugar. Si se produce un error en el bloque Try, el control del programa pasa a la instrucción Catch apropiada para su procesa-miento. El argumento exception es una instancia de la clase Exception

o una clase que se deriva de la clase Exception. La instancia de la cla-se Exception corresponde al error que se produjo en el bloque Try.La instancia contiene información acerca del error, como el número de error y el mensaje.

Si una instrucción Catch no especifica un argumento exception, de-tectará cualquier tipo de excepción del sistema o de la aplicación. Esta variación debe utilizarse siempre como el último bloque Catch en la estructura Try...Catch...Finally, después de detectar todas las excep-ciones específicas anticipadas. El flujo de control nunca puede alcanzar un bloque Catch situado detrás de Catch sin un argumento exception.

Las variables locales de un bloque Try no se encuentran disponibles en un bloque Catch porque se trata de bloques independientes. Si se desea utilizar una variable en más de un bloque, se debe declarar la variable fuera de la estructura Try...Catch...Finally.

El bloque Try contiene código donde puede producirse un error, mien-tras que el bloque Catch contiene el código para controlar cualquier error que tenga lugar. Si se produce un error en el bloque Try, el control del programa pasa a la instrucción Catch apropiada para su procesa-miento. El argumento exception es una instancia de la clase Exception

o una clase que se deriva de la clase Exception. La instancia de la cla-se Exception corresponde al error que se produjo en el bloque Try.La instancia contiene información acerca del error, como el número de error y el mensaje.

Si una instrucción Catch no especifica un argumento exception, de-tectará cualquier tipo de excepción del sistema o de la aplicación. Esta variación debe utilizarse siempre como el último bloque Catch en la estructura Try...Catch...Finally, después de detectar todas las excep-ciones específicas anticipadas. El flujo de control nunca puede alcanzar un bloque Catch situado detrás de Catch sin un argumento exception.

POO. PROGRAMACIÓN

ORIENTADA A OBJETOS

Aprenderemos que es la POO.Confeccionaremos una clase, creando los atributos,

propiedades y métodos que la definen.Crearemos una DLL que nos permita explotar su funcionalidad

en cualquier programa.Haremos uso de la herencia de clases.

Introducción

Definición

Trabajando con clases

Definiendo nuestra clase

Propiedades

Métodos

Constructores

Sobrecargas

Herencia

w OleDb.

incidencias.m

w DataTable







conexion.Open()








Next

While lector.Read

fila = tabla.NewRow

For contador = 0

fila(cont

Next

tabla.R

End Whilconexe


6


88

PROGRAMACIÓN ORIENTADA A OBJETOS

POO PROGRAMACIÓN ORIENTADA A OBJETOS

Introducción

Estoy seguro de que en los últimos años ha oído en alguna ocasión el tér-mino POO “programación orientada a objetos” o en su forma inglesaOOP “Object-oriented programming”.

¿Qué es la programación orientada a objetos? ¿ para qué sirve? y ¿porqué debería utilizarla? Son preguntas a las cuales trataré de dar respuesta en las siguientes páginas.

Definición

Antes de nada me gustaría aclarar que no son pocos los que están de acuer-do en afirmar que sería mas propio denominar a la programación orientada a objetos programación orientada a clases, si no entiende esto no se preocupe porque se explicará en estas líneas.

De la programación orientada a objetos se dice que es un paradigma de pro-gramación, es decir una manera de programar.

Empezaré dando una definición técnica, y permítanme que recurra para ello a la MSDN.

Las clases son representaciones simbólicas de objetos; describen las propie-dades, campos, métodos y eventos que forman objetos, de la misma forma que los planos describen los elementos que componen un edificio. Así como un plano puede utilizarse para crear varios edificios, una única clase puede utilizarse para crear tantos objetos como sea necesario.

Imagínese la clase “especie humana”, nosotros somos capaces de realizar una serie de acciones “métodos” tales como hablar, andar, dormir, etc. y tenemos unas propiedades que nos definen, color de piel, altura, color de ojos, longitud del cabello, etc. y somos capaces de reaccionar a una serie de estímulos “eventos”, si me gritas me asusto, si me cortas sangro. La especie humana sería por tanto la clase y cada uno de nosotros, yo, tu, tu compa-ñero de trabajo seríamos entidades tangibles y gestionables, seríamos una instancia de esa clase es decir el objeto.

Si tratamos de definir la programación orientada a objetos de manera un poco más técnica debemos de definir las características imprescindibles que debe cumplir un lenguaje de programación que presuma, como el Visual Basic .NET, de ser orientado a objetos.


89


Herencia

Se trata de la característica más importante de la POO, y establece que partiendo de una clase a la que denominamos clase base, padre o superclase, creamos una nueva clase denominada clase derivada, hija, o subclase. En esta clase derivada dispondremos de todo el código de la clase base, más el nuevo código propio de la clase hija, que escribamos para extender sus funcionalidades.

A su vez podemos tomar una clase derivada, creando una nueva subclase a partir de ella, y así sucesivamente, componiendo lo que se denomina una jerarquía de clases, que explicaremos seguidamente.

Existen dos tipos de herencia: simple y múltiple. La herencia simple es aque-lla en la que creamos una clase derivada a partir de una sola clase base, mientras que la herencia múltiple nos permite crear una clase derivada a partir de varias clases base. El entorno de .NET Framework sólo permite utilizar herencia simple.

Como ejemplo real de herencia, podemos usar la clase Coche como clase base; en ella reconocemos una serie de propiedades como Motor, Ruedas, Volante, etc., y unos métodos como Arrancar, Acelerar, Frenar, etc. Como clase derivada creamos CocheDeportivo, en la cuál, además de todas las características mencionadas para la clase Coche, encontramos propiedades y comportamiento específicos como ABS, Turbo, etc.

Un ejemplo basado en programación consistiría en disponer de la ya conoci-da clase Empleado. Esta clase se ocupa, como ya sabemos, de las operacio-nes de alta de empleados, pago de nóminas, etc.; pero en un momento dado, surge la necesidad de realizar pagos a empleados que no trabajan en la cen-tral de la empresa, ya que se trata de comerciales que pasan la mayor parte del tiempo desplazándose. Para realizar dichos pagos usaremos Internet, ne-cesitando el número de tarjeta de crédito y la dirección email del empleado. Resolveremos esta situación creando la clase derivada CiberEmpleado, que hereda de la clase Empleado, en la que sólo tendríamos que añadir las nuevas propiedades y métodos para las transacciones electrónicas, puesto que las operaciones tradicionales ya las tendríamos disponibles por el mero hecho de haber heredado de Empleado.

La herencia por lo tanto nos sirve para reutilizar código, podríamos imple-mentar una clase cuenta y después la clase cuenta_corriente, cuenta_de_ahorros, etc. que heredase de estas todas sus propiedades y métodos e implementara nuevos/as.


90


Encapsulación

La encapsulación establece la separación entre el interfaz del objeto y su implementación, aportándonos dos ventajas fundamentales.

Por una parte proporciona seguridad al código de la clase, evitando accesos y modificaciones no deseadas; una clase bien encapsulada no debe permitir la modificación directa de una variable, ni ejecutar métodos que sean de uso interno para la clase.

Por otro lado la encapsulación simplifica la utilización de los objetos, ya que un programador que use un objeto, si este está bien diseñado y su código correctamente escrito, no necesitará conocer los detalles de su implemen-tación, se limitará a utilizarlo.

Tomando un ejemplo real, cuando nosotros utilizamos un objeto Coche, al presionar el acelerador, no necesitamos conocer la mecánica interna que hace moverse al coche, sabemos que el método Acelerar del coche es lo que tenemos que utilizar para desplazarnos, y simplemente lo usamos.

Pasando a un ejemplo en programación, si estamos creando un programa de gestión y nos proporcionan un objeto Cliente que tiene el método Alta, y sirve para añadir nuevos clientes a la base de datos, no precisamos conocer el código que contiene dicho método, simplemente lo ejecutamos y damos de alta a los clientes en nuestra aplicación.

El polimorfismo determina que el mismo nombre de método, realizará di-ferentes acciones según el objeto sobre el que sea aplicado. Al igual que sucedía en la encapsulación, el programador que haga uso del objeto, no necesita conocer los detalles de implementación de los métodos, se limita a utilizarlos.

Pasando a un ejemplo real, tomamos dos objetos: Pelota y VasoCristal; si ejecutamos sobre ambos el método Tirar, el resultado en ambos casos será muy diferente; mientras que el objeto Pelota rebotará al llegar al suelo, el objeto VasoCristal se romperá.

En un ejemplo aplicado a la programación, supongamos que disponemos de los objetos Ventana y Fichero; si ejecutamos sobre ambos el método Abrir, el resultado en Ventana será la visualización de una ventana en el monitor del usuario; mientras que en el objeto Fichero, se tomará un fichero en el equipo del usuario y se dejará listo para realizar sobre él operaciones de lectura o escritura.


91


Trabajando con clases

Ya hemos dicho que la clase va a ser el molde a partir del cual crearemos nuestro objeto. Por lo tanto si queremos empezar a trabajar con objetos primeramente tendremos que saber cómo crear e implementar una clase.

En Visual Basic .NET 2005 todo son objetos, es decir todo son instancias de clases. Tal vez no se haya dado cuenta, pero desde el mismo momento en que ha creado una aplicación y ha empezado a programar un formulario en realidad estaba programando una clase, ¿o es que acaso no le suena este código?

¿Cómo creamos entonces una clase? Pues con la sentencia Class seguida del nombre de la clase. Supongamos que nos han encargado un proyecto para un gran banco y que queremos implementar una clase que nos permita tra-bajar con el concepto cuenta.

Para ello abriremos un nuevo proyecto al que llamaremos usando_clases y se-leccionaremos la opción de agregar nueva clase de la barra de herramientas.


92


Y le pondremos el nombre de cuenta.vb

Una vez hecho esto vemos como se ha agregado un nuevo módulo de clase a nuestro proyecto y nos posiciona en la ventana de edición de código de nuestra clase.

Cierre la venta de código y vaya al diseño de nuestro formulario de inicio y agregue un objeto button y nómbrelo btnCrea_cuenta y en el manejador de su evento click agregue el siguiente código.

Dim cuenta01 As New cuentaCon esta sentencia le estamos diciendo que vamos a crear un nuevo objeto del tipo cuenta y que lo referenciaremos mediante el nombre cuenta01.

Soy consciente de que nuestra clase cuenta aun carece de código pero va-mos a ver que por el simple hecho de haber sido creada esta expone ya unos pocos métodos heredados de la clase system.

A continuación escriba el siguiente código

Debug.WriteLine(cuenta01.ToString)El método ToString se hereda de la clase system y nos devuelve por defecto el nombre completo del tipo del objeto.


93


Definiendo nuestra clase

Vamos a empezar a ir dando forma a nuestra clase. Lo primero que tenemos que tener en cuenta cuando nos propongamos a diseñar una clase son los atributos que van a definirla. En el caso que nos ocupa sabemos que toda cuenta tiene por ejemplo un número de cuenta, un titular , un saldo y una fecha de apertura, por citar algunas.

Para implementar estos atributos nos iremos al código de nuestra clase y procederemos a declarar dichos atributos.

Public Class cuenta Dim aNumero _ de _ cuenta As String Dim aTitular As String Dim aSaldo As Double Dim aFecha _ de _ apertura As DateEnd Class

Propiedades

Una vez hecho esto ya le hemos dado a nuestra clase ciertas características que la definen, las cuales no son accesible desde fuera de mi clase, por lo que deberemos darle al usuario un medio para leer y/o escribir en los valores de los atributos es decir un interface para manejar la clase.

Para ello nos serviremos de procedimientos property, escriba a continua-ción el siguiente código

Public Property numero _ de _ cuenta() As String

Una vez escrita esta sentencia al presionar la tecla ENTER el Intellisense re-conoce que estamos creando un procedimiento property y nos autogenera el resto del estructura.

Public Property numero _ de _ cuenta() As String Get End Get Set(ByVal value As String) End SetEnd Property

La estructura consta de dos partes: una encargada de asignar un valor a un atributo Set…End Set conocido como el “setter” y otra encargada de devolver un valor Get…End Get o “getter”. Como habrá podido adivinar la property numero_de_cuenta se va a encargar de leer y escribir en el atribu-to aNumero_de_cuenta. Para ello programamos el property de la siguiente manera:

Public Property numero _ de _ cuenta() As String Get Return aNumero _ de _ cuenta End Get Set(ByVal value As String) aNumero _ de _ cuenta = value End SetEnd Property


94


Con este código cuando alguien que este utilizando un objeto del tipo cuen-ta trate de leer la propiedad numero_de_cuenta se ejecutará el getter y le devolverá el valor del atributo y cuando alguien trate de asignar un valor a la propiedad el setter se encargará de escribir el nuevo valor en esta. Vamos a escribir algunas lineas para comprobar el correcto funcionamiento de nues-tro clase.

Abra el manejador del evento click de nuesto botón btnCrea_cuenta y aña-da el siguiente código

Private Sub btnCrea _ cuenta _ Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles btnCrea _ cuenta.Click Dim cuenta01 As New cuenta cuenta01.numero _ de _ cuenta = “01234567890123456789” MsgBox(cuenta01.numero _ de _ cuenta)End Sub

Ahora agregue un punto de interrupción en la linea 5 y 6 como muestra la figura.

Ejecute la aplicación y haz clic en el boton. El código se detendrá antes de ejecutar la linea 5.


95


Presione la tecla F8 “paso a paso por instrucción” y observe como el código salta al interior de nuestra clase.

Se ejecuta la asignación del value.

Quedando almacenado en el atributo aNumero_de_cuenta.

Presionamos F5 confiando en que nuestro código se detendrá en el 2º punto de interrupción de nuestro código.


96


Está a punto de leerse el valor de la propiedad numero_de_cuenta. Pre-sionamos F8 de nuevo y vemos como nuestro código entra en la clase de nuevo, en esta ocasión en el “getter”.

El getter le devuelve el valor y nuestra aplición muestra el mensaje.

Agreguemos ahora un Property para el campo aTitular

Public Property titular() As String Get Return aTitular End Get Set(ByVal value As String) If value.Trim.Length > 0 Then aTitular = value End If End SetEnd Property


97


Espero que con este ejemplo y con la ayuda de su formador haya entendido el funcionamiento de los métodos property. Estos se encargan básicamente de escribir en los atributos privados de las clases cuando un objeto así lo requiere y leer cuando sea necesario.

Pero, ¿qué pasaría si en vez de tratar de escribir 20 caracteres válidos escri-bimos un galimatías sin sentido o una cadena de texto vacía?. Pues que tal y como hemos implementado nuestros property este guardaría sin problemas el valor en el atributo.

Permitame que refuerze este concepto. Detenga su aplicación, vaya al for-mulario principal y posicione sobre él, un objeto timer. Ahora abra el mane-jador del evento clic del botón btnCrea_cuenta, comente las lineas escritas hasta ahora y escriba esto.

Private Sub btnCrea _ cuenta _ Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnCrea _ cuen-ta.Click Dim intervalo As Integer = 0 Timer1.Interval = intervalo ‘Dim cuenta01 As New cuenta ‘cuenta01.numero _ de _ cuenta = “01234567890123456789” ‘MsgBox(cuenta01.numero _ de _ cuenta)End Sub

Con esto estamos declarando una variable llamada intervalo del tipo integer y la estamos inicializando a 0. Despues le estamos diciendo a la propiedad Interval del tipo Integer de nuestro reloj que va a ser igual a Intervalo, que recordemos vale 0.

Bien, pues si ejecuta la aplicación y presiona el botón obtendremos una ex-cepción tal y como se muestra en la figura.


98


¿Por qué ha ocurrido esto? Pues porque al igual que nosotros con nuestra propiedad numero_de_cuenta el programador de la clase timer quiso evitar que alguien escribiera en la propiedad interval un valor no válido y previno esto lanzando una excepción que el programador pudiera controlar cuando esto sucediera.

Tras esta breve demostración vamos a aprender a operar igual que el pro-gramador de la clase timer para evitar ciertos valores incorrectos en nues-tros atributos.

Elimine su objeto timer y las dos lineas que hemos utilizado para nuesto ejemplo. Ahora abra el código de la clase e introduzca el siguiente código en el property numero_de_cuenta

Public Property numero _ de _ cuenta() As String Get Return aNumero _ de _ cuenta End Get Set(ByVal value As String) If value.Trim.Length = 20 Then Dim contador As Integer For contador = 0 To value.Length - 1 If Not Char.IsDigit(value.Substring(contador, 1)) Then Throw New ArgumentException(“Numero de cuenta inválido”) Exit Property End If Next aNumero _ de _ cuenta = value Exit Property End If Throw New ArgumentException(“Numero de cuenta inválido” & vbCrLf _ & “ Este debe tener 20 caracteres”) End Set End Property

Con este código nos aseguramos de que nuestro numero de cuenta siempre va a tener 20 digitos y en caso contrario, no asignamos el valor y reportamos el fallo al usuario de nuestra clase mediante el uso de una excepción.

La manera general de trabajar de los property es esta. En caso de error po-dríamos haber optado por escribir un numero de cuenta automático, pero es bueno que las clases sean polivalentes y sea el usuario de la clase, no el programador de esta, quien decida que hacer en caso de error.


99


Para probar esto de una manera rápida haremos unos pequeños cambios en nuestra aplicacción, agregaremos una label, una caja de texto y un botón a nuestro formulario, de nombre lblNumeroDeCuenta , txtNumeroDeCuen-ta y btnGrabar tal y como podemos ver en la figura adjunta.

Y modificaremos nuestro código para hacer que el objeto se declare en la zona de declaraciones, se cree o instancie en la carga del formulario y sea el botón el encargado de intentar asignarle un valor a su propiedad nume-ro_de_cuenta.

Public Class Form1

Dim cuenta01 As cuenta

Private Sub Form1 _ Load(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles MyBase.Load cuenta01 = New cuenta End Sub

Private Sub btnGrabar _ Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btnGrabar.Click Try cuenta01.numero _ de _ cuenta = txtNumeroDeCuen-ta.Text MsgBox(“Nº de cuenta asignado correctamente”) Catch ex As Exception MsgBox(“Se produjo un error” & vbCrLf & ex.Message) End Try End SubEnd Class


100


Probemos ahora su correcto funcionamiento. Primero probaremos si todo sigue funcionando correctamente en caso de darle un número de cuenta correcto; es decir 20 dígitos.

Ahora trataremos de darle un número de cuenta con menos de 20 dígitos.

Y por útlimo un número de cuenta con 20 caracteres pero algunos no son dígitos.


101


Ahora que hemos aprendido como realizar métodos de comprobación será fácil implementar procedimientos property que comprueben los datos que nos pasan desde fuera de nuestra clase ¿verdad?.

Implementemos pues un property que nos permita leer y ¿escribir? en el atributo saldo. Estoy seguro de que a muchos nos gustaría cambiar el saldo de nuestra cuenta a nuestro antojo, pero en realidad somos conscientes de que el saldo de una cuenta solo se modifica a base de sacar y meter dinero, ya sea mediante extractos de cajero, retirada de efectivo en ventanilla, reci-vos, transferencias, etc… ¿Quiere decir eso que no podremos modificar el saldo? No, ni mucho menos.

Primero implementemos una propiedad que permita al usuario de nuestra clase el averiguar el saldo actual.

Public ReadOnly Property saldo() As Double Get Return aSaldo End GetEnd Property

Como habrá podido apreciar nuestra property carece de “setter” ya que es de solo lectura, por lo que debemos escribir “ReadOnly”

Implementemos ahora el property de la fecha de apertura. Para ello imple-mentaremos un método property de solo escritura, sé que puede parecer extraño que podamos leer y no escribir en el atributo pero lo habitual es que queramos saber la antigüedad de una cuenta, y esta la calcularemos despues.

Introduzca el siguiente property para la fecha de apertura y confie en mi.

Public WriteOnly Property fecha _ de _ apertura() As DateSet(ByVal value As Date)If value > “01/01/1900” AndAlso value <= Date.Now ThenaFecha _ de _ apertura = value

ElseThrow New ArgumentException(“Fecha no válida”)

End IfEnd Set

End Property


102


Métodos

Continuemos completando nuestra clase, dado que hemos restringido la property Saldo a solo lectura debemos de implementar un método que nos permita modificar el saldo.

Abra su clase y agregue el siguiente código.

Public Sub retirar _ efectivo(ByVal importe As Double) If importe > 0 AndAlso importe <= saldo Then aSaldo -= importe Else Throw New ArgumentException(“Importe nó váli-do”) End IfEnd Sub

Este prodecimiento nos permitira retirar efectivo de nuestra cuenta siem-pre que el importe sea positivo y claro está, siempre que nuestra cuenta disponga de suficiente efectivo.

Creemos ahora un procedimiento análogo para el ingreso de efectivo.

Public Sub ingresar _ efectivo(ByVal importe As Double) If importe > 0 Then aSaldo += importe Else Throw New ArgumentException(“Importe nó váli-do”) End IfEnd Sub

Con estos dos procedimientos ya somos capaces de modificar el valor del atributo aSaldo.

Sigamos completando nuestra clase. Si recuerda el atributo aFecha_de_aper-tura tan solo iba a poder ser leido gracias a una property de solo lectura.

Es habitual en los programas de banca que se hagan estadísticas de la anti-güedad de sus clientes u ofertas especiales para ciertos colectivos, jovenes, 3ª edad, etc. Sería útil pues dar al usuario de nuestra clase un medio de ob-tener la antigüedad de la cuenta.

La antigüedad es el típico ejemplo de campo calculado, es decir no se alma-cena si no que se calcula en tiempo real cuando hace falta.

Vamos a agregar a nuestra clase una función que devuelva al usuario de la clase la antigüedad de la cuenta, calculando la diferencia entre la fecha de apertura y el día de hoy. Abra el código de su clase e implemente el siguiente código.

Public Function antigüedad() As Integer Return (DateDiff(DateInterval.Year, _ aFecha _ de _ apertura, Date.Now))End Function


103


La función datediff nos permite averiguar la diferencia entre dos fechas cualesquiera, el primer argumento es la unidad en la que se nos devolverá el resultado: años, días, etc. el segundo y tercer parámetro son las fechas de las cuales se realizará la diferencia.

Nuestra clase ya dispone por lo tanto de una interface bastante completa, que nos permite modificar algunos de sus campos ya sea mediante proce-dimientos property, o métodos, y leer los atributos mediante los getter de los property.

Constructores

El constructor de un objeto es el método que se ejecuta cuando invocamos la sentencia New de un objeto.

Abra su clase y agregue el siguiente procedimiento.

Public Sub New() MsgBox(“Se acaba de crear un objeto del tipo cuenta”)End Sub

Cuando el usuario introduzca una linea como la siguiente se ejecutará la sentencia anterior y saldrá el mensaje. Es habitual que en el constructor del objeto se inicializen ciertos valores.

¿Recuerda que aun no hemos dispuesto ningún modo de escribir la fecha de apertura…? Seguro que cuando ustéd crea un archivo de texto, o una foto-gráfia no se encarga de escribir en ningún campo cuando la creó. En lugar de ello confia en que la aplicación o el propio sistema operativo la cree por usted ¿verdad?.


104


Sería absurdo obligar al usuario a que cuando cree un objeto cuenta se le pida ¿Cuándo lo creó? El usuario podría maldecir nuestra aplcación alegan-do ”…¿cómo que cuándo estoy creando la cuenta? ¡Pués ahora!!...” Exacto ahora, en el momento en el que se invoca al constructor. Podríamos hechar una mano a nuesto desesperado usuario agregando el siguiente código al constructor del objeto.

Public Sub New() aFecha _ de _ apertura = Date.NowEnd Sub

La propiedad Now de la clase Date nos proporciona un objeto fecha con la fecha de hoy. ¿Práctico, verdad?

Sobrecargas

Una de las ventajas que tiene la POO es la reutilización de código. Si quere-mos que nuestra clase sea utilizada en el mayor número de aplicaciones po-sibles esta debe ser estable y debe ser polivalente, es decir ofrecer distintas maneras de ser utilizada.

¿Se imagina que pasaría si al crear una cuenta el usuario olvidara darnos el numero de cuenta o el titular…? Pues que en caso de que se realizara poste-riormente una lectura de estas propiedades, estas estarían vacias.

cuenta01 = New cuentaMsgBox(cuenta01.numero _ de _ cuenta)MsgBox(cuenta01.titular)

Si queremos obligar al usario a que siempre que cree un objeto nos de unos valores obligatorios, podemos modificar el constructor agregándole pará-metros. De hecho hay un alto número de programadores que opinan que sería obligatorio trabajar así.

Abra el código de su clase y modifique nuestro contructor tal y como sigue.

Public Sub New(ByVal nombre As String, ByVal numero As String) fecha _ de _ apertura = nombre numero _ de _ cuenta = numero aFecha _ de _ apertura = Date.Now End Sub

Con este código estamos modificando nuesto constructor de modo que estemos obligando al usuario a que cuando instancie el objeto me pase di-réctamente el nombre del titular y el numero de cuenta.


105


Sirviéndonos de este constructor, estamos forzando a el usuario de nuestra clase a que siempre que cree un objeto cuenta nos pase los argumentos solicitados. ¿Qué pasaría si el usuario aun no dispone de toda la información necesaria? ¿o simplemente no quiere hacerlo? Pues que dado que hemos modificado el constructor por defecto le sería imposible.

Recuerden que nuestras clases deben de facilitar su uso y para ello, ¿por qué no dar al usuario distintas posibilidades de creación?

Un método que puede ser invocado de dos o mas maneras se dice que está sobrecargado. Cuando tratemos de sobrecargar un método tenemos que recordar que debemos crear las distintas sobrecargas o con distinto numero de parámetros o con distinto tipo de esto, pues si no el GUI sería incapaz de distinga cual estamos utilizando.

No se preocupe si esto no ha quedado demasiado claro, lo aclaramos con el uso de nuesto ejemplo.

Ya hemos visto como configurar el constructor de nuestra clase. Ahora vamos a darle al usuario la posicilidad de crear el objeto cuenta sin paráme-tros, con el número de cuenta, o con el titular y el numero de cuenta.

Abra su clase y agregue los siquientes constructores.

Public Sub New() ‘Constructor sin pametros aFecha _ de _ apertura = Date.NowEnd SubPublic Sub New(ByVal numero As String) ‘Constructor con un parámetro numero _ de _ cuenta = numero aFecha _ de _ apertura = Date.NowEnd SubPublic Sub New(ByVal nombre As String, ByVal numero As String) ‘Construtor con dos parametros fecha _ de _ apertura = nombre numero _ de _ cuenta = numero aFecha _ de _ apertura = Date.NowEnd Sub

Fíjese en que al asignar el valor al atributo no lo hago directamente sino que utilizo los setters de los property oportunos, ya que de no hacerlo el cons-tructor del objeto permitiría escribir valores no válidos en los atributos.

Ahora al tratar de crear un objeto cuenta el usuario se encuentra con alter-nativas y será él, quién elija cual se adecúa mejor a sus necesidades.


106


Podría crear el objeto sin parámetros.

Con el número de cuenta.

O con el número de cuenta y el titular.

Conclusión

Hemos aprendido como crear una clase sencilla con unas cuantos atributos, método, propiedades y varias maneras de ser instanciadas.

En este ejemplo nos hemos servido de un módulo de clase que hemos agre-gado a nuesto proyecto. Pero…¿qué pasaría si quiero utilizar mi clase en otro proyecto? Podría coger el archivo cuenta.vb e incluirlo en el proyecto en cuestión, pero de este modo el programador vería que es lo que hace mi clase y como lo hace rompiendo así el principio de encapsulación.

Imaginemos que mi clase ya está acabada y probada, y decido tratar de su-birla a internet para que cualquier persona pueda hacer uso de ella. Para ello tendría que compilar mi clase en un archivo dll. Vamos a seguir los pasos necesarios.

Visual Basic .NET 2005 nos invita desde el menú de nuevo proyecto a gene-rar las clases con un tipo de proyecto Biblioteca de Clases


107


Pero dado que nuestro proyecto ya está generado voy a enseñarle a con-vertir una aplicación para Windows en una clase ensamblada en un archivo DLL.

Lo primero que deberemos hacer es quitar el formulario de nuestro proyec-to. Esto no es algo verdaderamente necesario, pero este ha sido utilizado solo para probar la funcionalidad de nuestra clase e incluirlo en el ensambla-do no valdrá para nada mas que aumentar su peso, es decir su tamaño.

Para ello en el explorador de soluciones seleccionamos el formulario y le damos a botón derecho excluir.

Ahora seleccionamos la solución y hacemos clic en el botón derecho y se-leccionamos propiedades.


108


Se desplegará la venta de propiedades del proyecto. En ella cambio el tipo de aplicación a biblioteca de clases, el espacio de nombre a mis_clases “ve-remos mas adelante para ques sirve” y el nombre del ensamblado a cuenta. Cerramos la ventana y le decimos que si queremos guardar los cambios.

Ahora debemos generar nuestra DLL para ellos nos vamos al menu Gene-rar/ Generar o bien seleccionamos nuestra solución y hacemos clic con el botón derecho y marcamos la opción generar.

Si todo ha ido bien “Generación satisfactoria” habremos generado un archi-vo DLL con nuestra clase. Para comprobarlo diríjase al directorio del pro-yecto\bin\release y deberá de tener en ese directorio el archivo generado, en nuestro caso cuenta.dll

Ahora solo nos queda comprobar que puedo utilizar nuestra clase en cual-quier proyecto.

Abra una nueva instancia del Visual Basic .NET 2005, cree un proyecto del tipo Aplicación para windows y nombrelo “Usando mi DLL”.


109


Ahora elija el menu agregar referencia del menu proyecto.

Haga click en la pestaña Examinar y navegue por el explorado hasta seleccio-nar la DLL que generamos.

Ahora en el menu explorador de soluciones haga click en el botón Mostrar todos los archivos, desplegue referencias y observe que se ha agregado la referencia a nuestra clase cuenta.

Ahora situe un objeto boton en el formulario y en el manejador del evento de clic agregue el siguiente código.


110


Private Sub Button1 _ Click(ByVal sender As System.Object, _ByVal e As System.EventArgs) Handles Button1.Click Dim nueva _ cuenta As New mis _ clases.cuenta nueva _ cuenta.numero _ de _ cuenta = “01234567890123456789” nueva _ cuenta.ingresar _ efectivo(600) Console.WriteLine(nueva _ cuenta.antigüedad)End Sub

Como puede apreciar, estamos utilizando nuestro objeto nueva_cuenta creado gracias a la clase cuenta que se situa “porque así lo configuramos” en el espacio de nombre “mis_clases”

Herencia

Hasta ahora hemos aprendido como crear una clase, pero ¿qué sucedería si deseo crear una clase que tenga mucho en común con la clase cuenta, pero algunas diferencias…? ¿Tendría que escribir una nueva clase…? Gracias a Dios no. Podremos hacer uso de la herencia.

Imaginemos que queremos crear una nueva clase, llamémosla cuenta nomina que herede de cuenta pero que añada a esta un campo cuantía_nomina.

Podríamos crear una nueva clase del modo que ya conocemos y escribire-mos inherits nombre_de_cuenta.

Public Class cuenta _ nomina Inherits cuenta Dim aCuanía As Double Public Property cuantia() As Double Get Return aCuanía End Get Set(ByVal value As Double) If value > 0 Then aCuanía = cuantia End If End Set End PropertyEnd Class


111


Al utilizar la clase cuenta_nomina tendríamos acceso a todos los métodos y propiedades de la clase cuenta de la que hereda y aquellos declarado en la propia clase cuenta_nomina.

Hemos visto como crear una clase, configurarla, ensamblarla, hacer uso de ella desde otro programa y como reutilizar código gracias a la herencia. El tema de la programación orientada a objetos es realmente apasionante y el número de páginas que hay escritas sobre el no cabrían en este manual.

Espero que con el ejemplo aquí tratado, los ejercicios adjuntos y las expli-caciones de su formador aclare los conceptos principales de la POO con visual Basic .NET 2005 y utilize esta en su día a día como programador. Se sorprenderá.

Documents

Visualbasic Tomo i