programación con visualbasic.net parte i con Índice

ILCOMP ALTA TECNOLOGIA A SU ALCANCE

Managua, Nicaragua

ILCOMP INSTITUTO LATINOAMERICANO DE COMPUTACIÓN

VISUAL BASIC.NET CON SQL SERVER PÁGINA 1

INDICE DE CONTENIDO 1 Introducción a Visual Basic .Net .................................................................................. 5

1.1 ¿Qué es .NET? ................................................................................................................... 5 1.2 Información general acerca de .NET Framework .............................................................. 5 1.3 Características de Common Language Runtime ................................................................ 7 1.4 Biblioteca de clases de .NET Framework.......................................................................... 7 1.5 Desarrollo de aplicaciones cliente...................................................................................... 8 1.6 Desarrollo de aplicaciones de servidor .............................................................................. 8 1.7 Entorno Integrado de Desarrollo...................................................................................... 10

1.7.1 Mejoras cosméticas ...................................................................................................................10 1.7.2 Aceleradores del desarrollo .......................................................................................................11

2 Introducción a soluciones, proyectos y elementos .................................................... 12

2.1 Contenedores: soluciones y proyectos ............................................................................. 12 2.2 Elementos: archivos, referencias y conexiones de datos ................................................. 12 2.3 Elementos de la solución ................................................................................................. 12

3 Características gráficas de .NET................................................................................ 13

3.1 Explorador de soluciones ................................................................................................. 13 3.1.1 Iconos de la barra de herramientas ............................................................................................15

3.2 Examinar clases con la Vista de Clases ........................................................................... 16 3.3 Página de inicio................................................................................................................ 17

3.3.1 Mi perfil. ...................................................................................................................................17 3.3.2 Proyectos. ..................................................................................................................................18 3.3.3 Recursos en línea.......................................................................................................................19

3.4 Tipos de proyectos ........................................................................................................... 19 3.4.1 Creando Aplicaciones ...............................................................................................................20 3.4.2 Aplicaciones Windows de Visual Studio ..................................................................................20 3.4.3 Las aplicaciones Windows y Visual Studio ..............................................................................20 3.4.4 Desarrollo de aplicaciones Windows ........................................................................................20 3.4.5 Aplicaciones de servicios de Windows .....................................................................................21 3.4.6 Proyectos Win32 .......................................................................................................................21

4 Controles de formularios Windows ........................................................................... 21

4.1 Cuadro de Mensajes ......................................................................................................... 21 4.1.1 Función InputBox......................................................................................................................21 4.1.2 Función MsgBox.......................................................................................................................22

4.2 Insertar controles en el formulario ................................................................................... 24 4.3 Propiedades controles ...................................................................................................... 24

4.3.1 Editar las propiedades del control .............................................................................................24 4.4 Controles básicos de formularios Windows..................................................................... 24



4.4.1 Label..........................................................................................................................................24 4.4.2 TextBox.....................................................................................................................................25 4.4.3 Button........................................................................................................................................25 4.4.4 Checkbox ..................................................................................................................................26 4.4.5 Groupbox ..................................................................................................................................27 4.4.6 Panel..........................................................................................................................................27 4.4.7 Radiobutton...............................................................................................................................27

4.5 Orden de tabulación ......................................................................................................... 28 4.6 Validar el contenido del control....................................................................................... 29 4.7 Otros Controles ................................................................................................................ 29

4.7.1 LinkLabel ..................................................................................................................................29 4.7.2 Listbox ......................................................................................................................................30 4.7.3 CheckedListBox........................................................................................................................31 4.7.4 ComboBox ................................................................................................................................32 4.7.5 Picturebox .................................................................................................................................32 4.7.6 Timer.........................................................................................................................................33 4.7.7 TabControl ................................................................................................................................33 4.7.8 TrackBar....................................................................................................................................33 4.7.9 ProgressBar ...............................................................................................................................34 4.7.10 ListView ...............................................................................................................................34 4.7.11 TreeView..............................................................................................................................36 4.7.12 DateTimePicker....................................................................................................................37 4.7.13 MonthCalendar.....................................................................................................................38 4.7.14 DomainUpDown ..................................................................................................................38 4.7.15 NumericUpDown .................................................................................................................39 4.7.16 RichTextBox ........................................................................................................................39 4.7.17 ImageList..............................................................................................................................40 4.7.18 HelpProvider ........................................................................................................................41 4.7.19 ToolTip.................................................................................................................................41 4.7.20 StatusBar ..............................................................................................................................42 4.7.21 NotifyIcon ............................................................................................................................43 4.7.22 ErrorProvider........................................................................................................................43

4.8 Creación de controles en tiempo de ejecución................................................................. 43 4.9 Colección de controles ..................................................................................................... 44 4.10 Clase Form....................................................................................................................... 44 4.11 Menús............................................................................................................................... 45

4.11.1 Agregar menús y elementos de menú a formularios Windows Forms .................................45 4.11.2 Agregar funcionalidad a los elementos de menú ..................................................................46

4.12 Barras de Herramientas (Control) .................................................................................... 47 5 Elementos de Programación ....................................................................................... 47

5.1 Tipos de Datos ................................................................................................................. 47 5.1.1 Tipos de valores y tipos de referencia .......................................................................................48 5.1.2 Tipos de datos como clases y estructuras ..................................................................................48 5.1.3 Tipos de datos numéricos..........................................................................................................49



5.1.4 Tipos de datos de caracteres......................................................................................................50 5.1.5 Tipos de datos varios.................................................................................................................50

5.2 Variables .......................................................................................................................... 51 5.2.1 Declaración de variables ...........................................................................................................52 5.2.2 Variables de tipo objecto...........................................................................................................52

5.3 Período de duración, ámbito y accesibilidad de variables ............................................... 53 5.3.1 Período de duración...................................................................................................................53 5.3.2 Ámbito ......................................................................................................................................54 5.3.3 Accesibilidad.............................................................................................................................55

5.4 Constantes y Enumeraciones ........................................................................................... 55 5.4.1 Constantes .................................................................................................................................56 5.4.2 Enumeraciones ..........................................................................................................................57

5.5 Matrices ........................................................................................................................... 58 5.5.1 Matrices como objetos ..............................................................................................................58 5.5.2 Clase de matriz..........................................................................................................................58 5.5.3 Inicializar matrices ....................................................................................................................59 5.5.4 Cambiar el tamaño de matrices .................................................................................................60

5.6 Operadores ....................................................................................................................... 60 5.6.1 Operadores aritméticos..............................................................................................................60 5.6.2 Operadores Concatenación........................................................................................................61 5.6.3 Operadores relacionales o de comparación ...............................................................................61 5.6.4 Operadores lógicos....................................................................................................................63 5.6.5 Combinación eficaz de operadores............................................................................................64

5.7 Flujo de control ................................................................................................................ 64 5.7.1 Estructuras de decisión..............................................................................................................64 5.7.2 Estructuras de bucles.................................................................................................................67 5.7.3 Bucles For...Next más rápidos...................................................................................................71 5.7.4 With...End With (Instrucciones)................................................................................................72 5.7.5 Instrucciones de control anidadas..............................................................................................72 5.7.6 Exit (Instrucción) ......................................................................................................................72

6 Procedimientos............................................................................................................. 73

6.1 Procedimientos Sub ......................................................................................................... 74 6.1.1 Declaración de argumentos .......................................................................................................74 6.1.2 Sintaxis de llamada ...................................................................................................................74

6.2 Procedimientos Function ................................................................................................. 74 6.2.1 Valores devueltos ......................................................................................................................75 6.2.2 Sintaxis de llamada ...................................................................................................................75

6.3 Procedimientos Property .................................................................................................. 76 6.3.1 Declaración de propiedades ......................................................................................................76 6.3.2 Declaración de argumentos .......................................................................................................76 6.3.3 Sintaxis de llamada ...................................................................................................................77

6.4 Argumentos de procedimientos ....................................................................................... 77 6.4.1 Declaración del tipo de datos de un argumento.........................................................................77 6.4.2 Pasar un argumento con ByVal y ByRef...................................................................................77



6.4.3 Argumentos variables y no variables ........................................................................................77 6.4.4 Mecanismo para pasar argumentos ...........................................................................................78 6.4.5 Argumentos opcionales .............................................................................................................79 6.4.6 Llamar a procedimientos con argumentos opcionales...............................................................79 6.4.7 Determinar si un argumento opcional está presente..................................................................79 6.4.8 Matrices de parámetros .............................................................................................................80

7 Funciones de Visual Basic .NET................................................................................. 80

7.1 Manipulación de cadenas ................................................................................................. 80 7.1.1 Tipos de métodos de manipulación de cadenas.........................................................................81 7.1.2 Nothing y cadenas .....................................................................................................................81 7.1.3 Comparar cadenas .....................................................................................................................81 7.1.4 Buscar cadenas dentro de cadenas.............................................................................................81 7.1.5 Crear nuevas cadenas a partir de cadenas existentes .................................................................82

7.2 Analizar cadenas de fecha y hora [Visual Basic]............................................................ 83 7.2.1 Parse ..........................................................................................................................................83 7.2.2 ParseExact .................................................................................................................................84

7.3 Manipulación de fechas y horas. Estructura DateTime. .................................................. 84 7.4 Manipulación de Intervalos de Tiempo. Estructura TimeSpan........................................ 85 7.5 Métodos públicos. ............................................................................................................ 85 7.6 Conversiones implícitas y explícitas................................................................................ 86

7.6.1 La palabra clave CType.............................................................................................................87 7.7 Funciones de comprobación de tipos de datos................................................................. 87

8 Estructura de un programa de Visual Basic ............................................................. 88

8.1 Instrucciones Option ........................................................................................................ 88 8.2 Instrucciones Imports....................................................................................................... 88 8.3 Procedimiento Main......................................................................................................... 88 8.4 Instrucciones Class, Module y Namespace...................................................................... 88 8.5 Instrucciones de compilación condicional ....................................................................... 88



1 Introducción a Visual Basic .Net

1.1 ¿Qué es .NET? Antes que profundicemos en los detalles de

Visual Basic .NET, echemos un vistazo global a todos los cambios y nuevas características. Esta nueva versión es un cambio significativo de la versión anterior. Tomará un poco de esfuerzo acostumbrarse a ella, pero estoy seguro que sentirá que las nuevas características valen la pena. Visual Basic .NET es mucho más que una simple actualización de Visual Basic 6.0. Como esperaría, el Entorno de Desarrollo Integrado (IDE) ha sido mejorado con algunas características nuevas. Ahora todas las herramientas de desarrollo de Visual Studio compartirán el mismo entorno. Por ejemplo, ya no necesitará aprender un IDE diferente al cambiar entre Visual Basic y Visual C++. Se han agregado algunas características buenas que muchos de nosotros hemos estado esperando para facilitar el desarrollo.

Visual Studio .NET se construye basado en el

Framework .NET. Éste será un cambio significativo comparado con Visual Basic 6.0. El Framework .NET hace que el desarrollo de la aplicación vea el Internet como el nuevo sistema operativo. Sus aplicaciones ya no reconocerán el hardware como una limitante. Ésta es una evolución del modelo Windows DNA. Este nuevo Framework se construye sobre los protocolos abiertos de Internet para tener una interoperabilidad estandarizada entre las plataformas y lenguajes de programación. El Framework .NET también permitirá la creación de nuevos tipos de aplicaciones. Ahora las aplicaciones se ejecutarán usando el tiempo de ejecución del Lenguaje Común (CLR). Todas las aplicaciones de .NET usarán este mismo entorno de tiempo de ejecución que permite que sus aplicaciones de Visual Basic se ejecuten en el mismo espacio que otros lenguajes de programación. El CLR le permite a Visual Basic proporcionar la herencia e hilado de ejecución independiente cuya ausencia creó dos limitaciones muy notables en las aplicaciones de Visual Basic. Visual Basic .NET está basado en objetos. Ahora todo es un objeto, y cada objeto se hereda de una clase base estándar. Otro beneficio del CLR es un sistema de tipos comunes lo que significa que todos los lenguajes de programación comparten los mismos tipos de datos. Esto aumenta grandemente la interoperabilidad entre los lenguajes.

El Internet ha entrado en una nueva fase.

Primero, fue usado para desplegar las páginas Web estáticas. Los negocios encontraron pronto que esto no los ayudaba significativamente. Luego, Internet evolucionó al contenido dinámico y permitió el comercio electrónico. El siguiente paso es moverse hacia aplicaciones que se ejecutan completamente en Internet.

Y Visual Basic .NET promueve el desarrollo de estas nuevas aplicaciones para Web. Los servicios Web permiten a los objetos ser localizados en cualquier parte y ser llamados desde cualquier aplicación a través de Internet (ya no hace falta tratar de configurar DCOM). Por supuesto, extender las aplicaciones a través Internet implica un aumento en los riesgos de seguridad. Sin embargo, el Framework .NET tiene incorporadas muchas características de seguridad que le permitirán proteger sus aplicaciones.

La seguridad de tipos es algo obligatorio que se revisa desde el tiempo de diseño. Esto impide al código tener acceso a ubicaciones de la memoria a las que no tiene autorización. Esto también le permite definir cómo se tiene acceso a sus objetos. Antes de que el código se ejecute, se verifica si es seguro a nivel de tipos. Si no es seguro a nivel de tipos, sólo se ejecutará si sus políticas de seguridad lo permiten.

Visual Basic tiene muchos cambios nuevos. En este capítulo le daremos un vistazo de alto nivel a esos cambios arquitectónicos. Este vistazo le ayudará a profundizar en los detalles en los siguientes capítulos teniendo una imagen global.

1.2 Información general acerca de .NET Framework

.NET Framework es una nueva plataforma informática que simplifica el desarrollo de aplicaciones en un entorno altamente distribuido como es Internet. El diseño de .NET Framework está enfocado a cumplir los objetivos siguientes:

• Proporcionar un entorno coherente de programación orientada a objetos, en el que el código de los objetos se pueda almacenar 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 conflictos de versiones.

• Ofrecer un entorno de ejecución de código que garantice la ejecución segura del mismo, incluso del creado por terceras personas 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 asegurar que el código de .NET Framework se puede integrar con otros tipos de código.

.NET Framework contiene dos componentes principales: Common Language Runtime y la biblioteca de clases de .NET Framework. Common Language Runtime es el fundamento de la tecnología. El motor de 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 memoria, 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 garantizan su seguridad y solidez. De hecho, el concepto de administración de código es un principio básico del motor de tiempo de ejecución. El código destinado al motor de 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 principal 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 innovaciones más recientes proporcionadas por ASP.NET, como los formularios Web Forms y los servicios Web XML. .NET Framework puede alojarse en componentes no administrados que cargan 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 de tiempo de ejecución, sino que también se admite el desarrollo de estos hosts por parte de terceros. Por ejemplo, ASP.NET aloja el motor de tiempo de ejecución para proporcionar un entorno de servidor escalable para el código administrado. ASP.NET trabaja directamente con el motor de 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 de tiempo de ejecución (en forma de una extensión de tipo MIME). Al usar Internet Explorer para alojar el motor de tiempo de ejecución, puede incrustar componentes administrados o controles de Windows Forms en documentos HTML. Al alojar el motor de 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 seguros. En la ilustración siguiente se muestra la relación de Common Language Runtime 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 administrado 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.

1.3 Características de Common Language Runtime

Common Language Runtime administra la memoria, ejecución de subprocesos, ejecución de código, comprobación de la seguridad del código, compilación y demás servicios del sistema. Estas características son intrínsecas del código administrado que se ejecuta en Common Language Runtime. 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 de tiempo de ejecución impone seguridad en el acceso al código. Por ejemplo, los usuarios pueden confiar en que un archivo ejecutable incrustado 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 motor de tiempo de ejecución permiten que el software legítimo implementado en Internet sea excepcionalmente variado. Además, el motor de tiempo de ejecución impone la solidez del código mediante 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 generan 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 de tiempo de ejecución elimina muchos problemas de software comunes. Por ejemplo, el motor de tiempo 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 comunes de las aplicaciones: la pérdida de memoria y las referencias no válidas a la memoria.

Además, el motor de tiempo de ejecución aumenta la productividad del programador. Por ejemplo, los programadores pueden crear aplicaciones en el lenguaje que prefieran y seguir sacando todo el provecho del motor de tiempo de ejecución, la biblioteca de clases y los componentes escritos en otros lenguajes por otros colegas. El proveedor de un compilador puede elegir destinarlo al motor de 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 de 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 programadores continúen utilizando los componentes COM y las DLL que necesiten. El motor de tiempo de ejecución está diseñado para mejorar el rendimiento. Aunque Common Language Runtime proporciona muchos servicios estándar de motor de tiempo de ejecución, el código administrado nunca se interpreta. Una característica denominada compilación JIT (Just-In-Time) permite ejecutar todo el código administrado en el lenguaje máquina nativo del sistema 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 de tiempo de ejecución se puede alojar en aplicaciones de servidor de gran rendimiento, como Microsoft® SQL Server™ e IIS (Servicios de Internet Information Server). Esta infraestructura permite utilizar código administrado para escribir lógica empresarial, al tiempo que se disfruta del superior rendimiento de los mejores servidores empresariales del sector que puedan alojar el motor de tiempo de ejecución.

1.4 Biblioteca de clases de .NET Framework

La biblioteca de clases de .NET Framework es una colección de tipos reutilizables 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 ocasiona 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 Framework. Como en cualquier biblioteca de clases orientada a objetos, los tipos de .NET Framework permiten realizar diversas tareas de programación comunes, como son la administración de cadenas, recopilación de datos, conectividad de bases de datos y acceso a archivos. Además de estas tareas habituales, 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 consola • Aplicaciones GUI de Windows (Windows

Forms) • Aplicaciones de ASP.NET • Servicios Web XML • Servicios de Windows

Por ejemplo, las clases de 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 Web Forms.

1.5 Desarrollo de aplicaciones cliente

Las aplicaciones cliente constituyen lo más parecido a una aplicación de estilo tradicional en la programación basada en Windows. En este tipo de aplicaciones 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 empresariales, 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 (reemplazado 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 incluye elementos gráficos. En el pasado, los programadores 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 aplicaciones) 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 Windows Forms contenidas en .NET Framework están diseñadas para utilizarse en el desarrollo de GUI. Puede crear ventanas, 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 ajustar 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 formularios 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 tienen 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 con seguridad a través del Web. Las aplicaciones pueden implementar las características de una aplicación local a la vez que se implementan como una página Web.

1.6 Desarrollo de aplicaciones de servidor

Las aplicaciones de servidor en entornos administrados se implementan mediante hosts de motor de tiempo de ejecución. Las aplicaciones no administradas alojan Common Language Runtime,



que permite al código administrado 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 servidores como IIS y SQL Server pueden realizar operaciones estándar mientras la lógica de la aplicación se ejecuta en el código administrado. Código administrado en el servidor

ASP.NET es el entorno host que permite a los programadores utilizar .NET Framework con las aplicaciones para el Web. Sin embargo, ASP.NET no es sólo un host de motor de tiempo de ejecución: se trata de una completa 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 consta de componentes de software reutilizables diseñados para que los utilicen otras aplicaciones, como aplicaciones cliente tradicionales, aplicaciones basadas en el Web o, incluso, otros servicios Web XML. Como resultado, 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. Si ha utilizado versiones anteriores de la tecnología ASP, apreciará de inmediato las mejoras que ofrecen ASP.NET y Web Forms. Por ejemplo, puede desarrollar páginas de Web Forms en cualquier lenguaje 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 Web Forms se ejecutan en lenguaje máquina nativo porque, al igual que todas las aplicaciones administradas, sacan todo el provecho del motor de 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 de tiempo de ejecución como una aplicación administrada. .NET Framework proporciona también una colección de clases y herramientas 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 protocolo 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 incluida 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 convertirse 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 servicios 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 proporciona un conjunto de clases que cumplen todos los estándares de comunicació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 infraestructura de comunicaciones que se requiere en el desarrollo de software distribuido. Por último, al igual que las páginas de Web Forms en un entorno administrado, el servicio Web XML se ejecutará con la velocidad del lenguaje máquina nativo mediante la comunicación escalable de IIS.



1.7 Entorno Integrado de Desarrollo Sin importar si usted es un desarrollador o un gerente, es muy probable esté más preocupado por saber qué tan difícil será la transición a este nuevo entorno que por cada nueva característica. Microsoft comparte sus preocupaciones. Conforme usted explore lo que VB.NET puede ofrecer, observará una combinación inteligente de versiones anteriores de VB con características adaptadas de otros lenguajes. Y en ninguna otra parte esto más evidente que en el IDE. Microsoft ha agregado nueva funcionalidad significativa para hacer que los desarrolladores trabajen más eficazmente, sin exigirles que aprendan maneras completamente nuevas de hacer sus trabajos. Si usted ha visto versiones anteriores de Visual Basic, la IDE para VB.NET le parecerá muy familiar. Pero si usted también ha trabajado con InterDev en el pasado, la nueva interfaz le resultará aún más familiar. Esto es porque el nuevo IDE usado para VB.NET integra las mejores ideas de ambos entornos para brindar una medio más eficaz de realizar el trabajo. Claro, nada viene sin un costo. Algunos de los problemas involucrados con esta actualización de VB se discuten más adelante en este capítulo y en los capítulos posteriores, y estos desafíos ciertamente deben sopesarse al momento de seleccionar una herramienta de desarrollo. Pero primero, echemos una mirada a algunas de las nuevas características específicas del IDE y los beneficios que nos proporcionan.

1.7.1 Mejoras cosméticas Aunque se han hecho numerosos cambios al IDE, los que usted probablemente notará primero son los cambios cosméticos a la funcionalidad existente. Las versiones anteriores de Visual Basic han intentado establecer un equilibrio entre mantener el espacio disponible en la pantalla y permitir acceso a uno sólo a tanta funcionalidad como sea posible. La tabla Cambios Cosméticos describe algunas de las formas en que estos mejoras se han implementado en VB.NET. Característica Descripción Beneficio Soporte para Los Ejecutando el

Característica Descripción Beneficio monitores múltiples

desarrolladores pueden usar más de un monitor al mismo tiempo

código en una ventana y depurando en otra, los desarrolladores puede simular de forma más precisa la experiencia del usuario final.

Formularios organizados en pestañas

Se usa una disposición de pestañas para mostrar los formularios MDI hijos dentro del entorno de desarrollo. Las ventanas de código, las pantallas de ayuda, las ventanas de diseño de formularios y la página de inicio todas pueden ubicarse unas sobre otras y mostrarlas en un mismo panel.

Aunque no se puede ver toda la información al mismo tiempo, al menos se tiene el beneficio de ocupar menos espacio real de pantalla.

Caja de herramientas

En vez de mostrar los controles en una cuadrícula, los controles se presentan de forma vertical, con una descripción a lado de cada uno.

En versiones anteriores de Visual Basic, tenías que señalar cada control para ver el nombre del control. (Esto era en especial frustrante cuando se desarrollaban controles personalizados, debido a que frecuentemente podían tener todos el mismo icono por defecto.=



Característica Descripción Beneficio Código expandible

Usando una interfaz similar a los esquemas de Microsoft Word, ahora puede dividir el código en secciones y ocultarlas o expandirlas con un simple clic.

Los desarrolladores ahora pueden mantener una vista de alto nivel su código, permitiéndoles migrar a través de sus aplicaciones de forma más eficiente.

Ayuda En lugar de tener que presionar F1, el IDE .NET ahora observa lo que se hace y presenta ayuda sensible al contexto en su propia ventana.

Se tiene disponible continuamente ayuda precisa para los desarrolladores en tiempo real.

Tabla Cambios cosméticos

1.7.2 Aceleradores del desarrollo

Por supuesto, no todas las características nuevas del IDE son simplemente accesorias. Los desarrolladores de VB.NET también han proporcionado nuevas interfaces para usar la funcionalidad existente de forma más eficaz. Las características presentadas en la Tabla Aceleradores de desarrollo tienen sus evidentes predecesores en VB 6.0, pero ahora permiten a los desarrolladores generar sus aplicaciones más eficazmente. Característica Descripción Beneficio Diseñador de menús

Usando el nuevo Diseñador de menús, ahora puede editar menús directamente en el formulario al que está asociado el menú.

Antes, tenía que seleccionar el elemento Editor de menú en el menú Herramientas. Este cambio acelera el desarrollo y reduce los errores asociados con el uso de un formulario

Característica Descripción Beneficio equivocado.

Explorador de soluciones

A diferencia del Explorador de proyectos de las versiones anteriores, el Explorador de soluciones presenta un repositorio para administrar recursos de desarrollo heterogéneos.

Ahora puede administrar componentes que no han sido creados con VB. (La habilidad de que VB trabaje mejor con otros lenguajes de programación es una de las fuerzas impulsoras detrás de la iniciativa .NET.)

Explorador de servidores

Ahora puede ver los servidores disponibles para una aplicación cliente/servidor o de Internet y directamente incorporar sus recursos en el código.

Lo que antes se hacía manualmente ahora puede hacerse usando arrastrar-y-pegar. Por ejemplo, si tiene un procedimiento almacenado en un servidor en SQL, puede directamente ubicar el procedimiento almacenado y hacer la actualización directamente en pantalla. Ahora puede hacer más programando visualmente, reduciendo las posibilidades de error. Por ejemplo, si tiene un procedimiento almacenado en SQL Server, podría ubicar el procedimiento almacenado y arrastrarlo al



Característica Descripción Beneficio panel correspondiente. VB se encarga del resto de la codificación de forma automática.

Página de inicio

La pantalla de apertura que aparece cuando se inicia VB, ahora se genera usando DHTML.

La Página de inicio proporciona una ubicación central para establecer preferencias, leer noticias de productos, ponerse en contacto con otros programadores y obtener acceso a otro tipo de información que le permita mejorar su rendimiento con Visual Studio.

Tabla Aceleradores del desarrollo

2 Introducción a soluciones, proyectos y elementos

Para administrar con eficacia los elementos (como referencias, conexiones de datos, carpetas y archivos) necesarios para llevar a cabo la labor de programación, Visual Studio .NET ofrece dos contenedores: soluciones y proyectos. Para ver y administrar estos contenedores y sus elementos asociados se proporciona una interfaz, el Explorador de soluciones, que forma parte del entorno de desarrollo integrado (IDE).

2.1 Contenedores: soluciones y proyectos

Las soluciones y los proyectos contienen elementos en forma de referencias, conexiones de datos, carpetas y archivos necesarios para crear la aplicación. Un contenedor de tipo solución puede contener varios proyectos y un contenedor de tipo proyecto normalmente contiene varios elementos. El uso de

estos contenedores le permite beneficiarse del entorno de desarrollo integrado de varias formas: Puede administrar la configuración de la solución en su totalidad o dividida en proyectos individuales Puede utilizar el Explorador de soluciones para controlar los detalles de la administración de archivos al mismo tiempo que se centra en los elementos que constituyen la labor de programación Puede agregar elementos útiles a varios proyectos de la solución o a la solución sin tener que hacer referencia a dichos elementos en cada proyecto Puede trabajar en diversos archivos, independientes de soluciones o proyectos

2.2 Elementos: archivos, referencias y conexiones de datos

Los elementos pueden ser archivos y otras partes del proyecto como referencias, conexiones de datos o carpetas. Los elementos pueden organizarse de varias formas en el Explorador de soluciones: En forma de elementos del proyecto, es decir, elementos comprendidos en el proyecto, tales como formularios, archivos de código fuente y clases de un proyecto del Explorador de soluciones. La organización y la presentación dependerán de la plantilla de proyecto que se seleccione, así como de cualquier modificación que se realice. En forma de elementos de la solución para archivos que se aplican a la solución en su totalidad en la carpeta Elementos de la solución del Explorador de soluciones. En forma de varios archivos que se corresponden con archivos reales que no están asociados a ningún proyecto ni a ninguna solución y que pueden mostrarse en la carpeta Archivos varios.

2.3 Elementos de la solución Una solución, en calidad de contenedor, puede controlar varios tipos de elementos. Por ejemplo, dentro de una solución puede haber proyectos. No obstante, puede encontrarse con elementos que desee administrar independientemente de un proyecto, pero en asociación con una solución. Estos elementos, que se consideran elementos de la solución, aparecerán en la carpeta Elementos de la solución en el Explorador de soluciones. Los elementos de la solución siempre estarán disponibles en el Explorador de soluciones, cuando abra la solución.



Los elementos de la solución son independientes del proyecto

Los elementos de la carpeta Elementos de la solución son archivos independientes del proyecto creados además de los archivos de proyecto. Estos elementos representan archivos fundamentales para el desarrollo de los proyectos, pero no pertenecen a un proyecto en particular. Las hojas de estilos en cascada son elementos comunes de una solución. Una sola hoja de estilos, por ejemplo, puede estandarizar el formato de numerosas páginas Web en varios proyectos. Cuando se cierra la solución, la hoja de estilos permanece junto a las páginas Web. Cuando vuelve a abrirse la solución, la hoja de estilos aparece debajo del nodo Elementos de la solución del Explorador de soluciones. Los archivos de proyecto que aparezcan en el Explorador de soluciones debajo del proyecto al que se van a agregar están incluidos en generaciones de proyectos o soluciones. No se generará ningún archivo de solución que aparezca en la carpeta Elementos de la solución. Puede utilizar control de código fuente con los elementos de solución y con proyectos y archivos de proyectos. Los elementos de una solución son fundamentales para los proyectos de una solución. Aunque se administren en forma de vínculos y pueda guardarlos en cualquier ubicación, puede que desee guardarlos en el directorio de la solución. El archivo de la solución (.sln) recuerda y, lo que es más importante, realiza un seguimiento de la ubicación de los elementos de la solución.

3 Características gráficas de .NET

Utilizar el Explorador de soluciones El Explorador de soluciones le permite ver elementos y realizar tareas de administración de elementos en una solución o en un proyecto. También le permite utilizar los editores de Visual Studio .NET para

trabajar en archivos fuera del contexto de una solución o proyecto. Presentación jerárquica Una única solución y sus proyectos se muestran mediante una presentación jerárquica, que proporciona información actualizada sobre el estado de la solución, los proyectos y los elementos. Esto le permitirá trabajar en varios proyectos al mismo tiempo. Elementos y contenedores La administración de los elementos que se muestran en el Explorador de soluciones se basa en la relación del elemento con los contenedores del proyecto y de la solución. Los elementos pueden relacionarse de las siguientes formas:

• Como elementos del proyecto, que aparecen debajo de una carpeta de proyecto en el Explorador de soluciones; por ejemplo, formularios, archivos de código fuente y clases.

• Como elementos de la solución, que aparecen en la carpeta Elementos de la solución en el Explorador de soluciones.

• Como archivos varios, es decir, archivos que no están asociados a ningún proyecto ni a ninguna solución y que se muestran en la carpeta Archivos varios.

El Explorador de soluciones es flexible en el sentido de que permite trabajar independientemente de un proyecto, en otras palabras, pueden modificarse y crearse archivos sin un proyecto. El Explorador de soluciones muestra este tipo de archivos en la carpeta Archivos varios. También es posible trabajar con archivos asociados únicamente a la solución. Estos elementos se mostrarán en la carpeta Elementos de la solución.

3.1 Explorador de soluciones



El Explorador de soluciones proporciona una vista organizada de los proyectos y sus archivos, así como acceso rápido a los comandos relativos a ellos. Normalmente, una barra de herramientas asociada a esta ventana ofrece los comandos que se utilizan con más frecuencia con el elemento resaltado en la lista. Para tener acceso al Explorador de soluciones, seleccione Explorador de soluciones en el menú Ver. Vista de árbol

Esta vista estándar del Explorador de Soluciones presenta la solución activa como un contenedor lógico de uno o más proyectos y de los elementos asociados a ellos. Puede abrir elementos de proyecto para modificarlos, además de llevar a cabo otras tareas de administración directamente desde esta vista. Dado que diferentes tipos de proyectos harán que también los elementos se almacenen de manera diferente, la estructura de carpetas en el Explorador de soluciones no refleja necesariamente el almacenamiento físico real de los elementos enumerados.

Cuando la opción "Realizar seguimiento del elemento activo en el Explorador de Soluciones" está seleccionada en el cuadro de diálogo Proyectos y soluciones, Entorno, Opciones, el Explorador de soluciones abre automáticamente la carpeta del elemento activo, se desplaza hasta su nodo en vista de árbol y selecciona su nombre. El elemento seleccionado va cambiando conforme se trabaja con los distintos archivos en un proyecto o solución o con los distintos componentes en un diseñador de entorno de desarrollo integrado (IDE). Cuando esta opción está desactivada, la selección en el Explorador de soluciones no cambia automáticamente. Para asociar un archivo a una solución, pero no a un proyecto específico, agregue el archivo directamente a la solución. Se mostrará entonces un nuevo nodo para el archivo agregado en la carpeta Elementos de la solución. Otros archivos que aún no se hayan asociado a la solución activa o a alguno de sus proyectos se colocarán en la carpeta Archivos varios. Éstos suelen ser archivos abiertos o creados en su disco local mientras trabajaba con un proyecto.

Nota Para mostrar todos los archivos de la carpeta Archivos varios, seleccione la opción "Mostrar archivos varios en el Explorador de soluciones" en el cuadro de diálogo Documentos, Entorno, Opciones. Al seleccionar esta opción, se activa también el comando Ver en el explorador del menú Archivo, para mostrar documentos Web externos no incluidos en una aplicación Web.

Proyecto en negrita El proyecto que se muestra en negrita está seleccionado como Proyecto de inicio con fines de ejecución y depuración. Si hay más de un proyecto de inicio, entonces se muestra en negrita el nodo de la solución en la vista de árbol. Los proyectos de inicio se ejecutan automáticamente al iniciar el depurador de Visual Studio. Aunque, de forma predeterminada, se considere proyecto inicial al primer proyecto creado en la solución, es posible cambiar con facilidad los proyectos que deberán ejecutarse primero al generar o ejecutar una solución.

Con la opción "Generar proyectos de inicio y dependencias únicamente al ejecutar" del cuadro de diálogo Proyectos y soluciones, Entorno, Opciones seleccionada, sólo se generarán el proyecto inicial y sus dependencias cuando se presione F5 o se seleccione el comando Iniciar en el menú Depurar. O bien Cuando se presione CTRL + MAYÚS + b o se escoja el comando Generar solución del menú Ejecutar. Con esta opción desactivada, cualquiera de estas acciones generará todos los proyectos, dependencias y archivos de soluciones. Solución en negrita

Cuando una solución se muestra en negrita, indica que la opción para ejecutar varios proyectos al iniciar el depurador está habilitada. Aunque la opción está habilitada, no significa que se hayan seleccionado proyectos para ejecutarse; de forma predeterminada, están configurados para que no se ejecuten.

Comandos Puede abrir archivos, agregar y quitar elementos y realizar otras tareas de administración. Cada plantilla de proyecto dispone de sus propias carpetas e iconos para indicar la naturaleza de los elementos del proyecto. Puede agregar carpetas y elementos que se ajusten a las necesidades de su proyecto de desarrollo individual. Los iconos pueden indicar diferente información acerca de un elemento. Por ejemplo, según el proyecto, podría ver un icono que indica que el elemento es un archivo HTML o que un archivo está bajo el control del código fuente. Además, cada plantilla de proyecto determina qué herramientas y diseñadores están asociados a un tipo de archivo, así como los



comandos disponibles para la administración de elementos.

Selección Al seleccionar una solución, proyecto o elemento en la lista, automáticamente se actualizan los comandos disponibles. Por ejemplo, el comando Copiar Web sólo está disponible en la barra de herramientas del Explorador de soluciones si hay una aplicación Web seleccionada en la lista. Puede hacer doble clic en un archivo para mostrarlo en el diseñador, herramienta o editor asociado al tipo de archivo. Para cambiar el editor predeterminado de algunos tipos de archivo, haga clic con el botón secundario en el archivo y, después, elija Abrir con en el menú contextual.

Selección múltiple Es posible seleccionar varios elementos de un solo proyecto o varios elementos que abarquen varios proyectos. Seleccione varios elementos si desea llevar a cabo operaciones por lotes (con el fin de abrir simultáneamente varios archivos para editar, por ejemplo) o cuando desee determinar o editar las propiedades que comparten dos o más elementos de solución. Al seleccionar varios elementos, los comandos disponibles representan la intersección de los comandos comunes a todos los elementos seleccionados.

3.1.1 Iconos de la barra de herramientas

En la barra de herramientas del Explorador de soluciones sólo aparecen los botones específicos del elemento seleccionado en la lista. Por ejemplo, si selecciona un archivo .asax, aparece un conjunto de botones en la barra de herramientas. Sin embargo, si se selecciona un archivo .asp, sólo aparece el botón Propiedades. Debido a que el proyecto seleccionado determina los iconos de la barra de herramientas, esta lista es una representación parcial de los que podría encontrar al trabajar en el Explorador de soluciones. Mostrar todos los archivos

Muestra todos los elementos de proyecto, incluso los excluidos y los que normalmente están ocultos. Inicialmente, el proyecto determina qué elementos están ocultos. Copiar proyecto

Abre el cuadro de diálogo Copiar proyecto para copiar un proyecto Web completo o un conjunto de proyectos Web de un servidor Web a otro. También puede duplicar un proyecto Web en el mismo servidor con un nombre nuevo. Este comando sólo está disponible cuando hay un proyecto Web seleccionado. Abrir

Abre el elemento seleccionado en el editor predeterminado para ese elemento, tal y como determina la plantilla de proyecto. El editor predeterminado de un tipo de archivo específico se puede cambiar en el cuadro de diálogo Abrir con; haga clic con el botón secundario en el archivo, en el Explorador de soluciones, y seleccione Abrir con en el menú contextual. Por ejemplo, puede cambiar el editor de recursos por el editor de texto para los archivos de recursos. Ver código

Abre el archivo seleccionado para editarlo en el Editor de código. Actualizar

Actualiza el estado de los elementos del proyecto o solución que se haya seleccionado. Sugerencia: Si forma parte de un grupo de desarrollo que trabaje con archivos de proyectos compartidos que se hayan combinado y se mantengan bajo control de código fuente, seleccione este botón para mostrar el estado actual de los archivos incluidos en su solución activa. Propiedades

Muestra la interfaz de usuario de propiedades correspondiente al elemento seleccionado en la vista de árbol.

3.1.1.1 Iconos de señal Los iconos de señal muestran información sobre el estado de los archivos. Elemento no encontrado



El elemento se ha movido, cambiado el nombre o eliminado del directorio del proyecto y no se encuentra. Protegido

El elemento se ha incluido en una base de datos de control de código fuente. Desprotegido en exclusiva

El elemento está desprotegido desde una base de datos de control de código fuente sólo para un desarrollador. El resto de desarrolladores no puede obtener acceso al archivo. Desprotegido para uso compartido

El elemento está desprotegido desde una base de datos de control de código fuente para su uso compartido por parte de un equipo de desarrollo. Las diferentes versiones del elemento se combinarán en el momento de la protección.

3.2 Examinar clases con la Vista de Clases

La Vista de clases muestra una vista programática de los símbolos del código, por ejemplo, los espacios de nombres, las clases, los métodos y las funciones. Los símbolos están organizados por proyectos, y dentro de cada proyecto, el contenido se muestra en una vista de árbol jerarquizada, que indica las relaciones de contención entre los símbolos. Asimismo, puede aparecer otra información estructural, como las clases e interfaces base y los métodos suplantables. Esta vista lógica de la solución y sus proyectos permite comprender mejor la estructura del código y las interrelaciones existentes entres sus diversos símbolos. Todos los símbolos están representados por iconos que indican su tipo y, si contienen otros símbolos, se pueden expandir haciendo clic en el signo más (+) que aparece junto al icono o presionando la tecla + del teclado numérico para ver sus miembros. Para desplazarse a los símbolos del código basta con hacer doble clic en ellos. Si la definición de un símbolo no está disponible, su declaración se mostrará en el Examinador de objetos. Otro modo de desplazarse por los símbolos consiste en invocar al comando Búsqueda rápida de símbolos del Examinador de objetos para un símbolo seleccionado en la Vista de clases presionando ALT+MAYÚS+F12.

La Vista de clases se diferencia del Examinador de objetos en que está pensada para proyectos y símbolos de la solución, más que para componentes externos o a los que se haga referencia. Además, muestra la estructura de anidación real de los símbolos, a diferencia de la vista plana del Examinador de objetos. La Vista de clases se diferencia del Explorador de soluciones en que proporciona una vista lógica del código, mientras que el explorador proporciona una vista física de la solución centrada en los archivos. Nota No es necesario compilar los proyectos para ver sus símbolos en la Vista de clases, ya que según se agregan o modifican símbolos a un proyecto, ésta se actualiza dinámicamente para reflejar los cambios. Como resultado, no es necesario un comando de actualización. Para abrir la ventana Vista de clases, presione CTRL+MAYÚS+C o elija Vista de clases en el menú Ver. Vista de clases - Ordenar por <vista>

El botón Ordenar por le permite elegir una vista de los datos determinada. La Información sobre herramientas del botón muestra el nombre de la vista actual. Las opciones disponibles son:

• Ordenar alfabéticamente: los símbolos se enumeran alfabéticamente por sus nombres en orden ascendente (a - z).

• Ordenar por tipo: los símbolos del mismo tipo se enumeran juntos; todas las clases aparecen juntas, todas las interfaces aparecen juntas, etc. Este orden no se puede cambiar.

• Ordenar por acceso: los símbolos se enumeran según su tipo de acceso, como public, protected o private.

• Agrupar por tipo: los símbolos del mismo tipo se agrupan bajo una carpeta virtual. Este orden no se puede cambiar.

Nueva carpeta Método alternativo para organizar símbolos utilizados con frecuencia, este botón crea una nueva carpeta a la que puede arrastrar símbolos y otras carpetas y tener fácil acceso a ellos.



Iconos de la Vista de clases La Vista de clases muestra varios iconos, cada uno representa un tipo de símbolo diferente, como un espacio de nombres, una clase, una función o una variable. La siguiente tabla presenta los iconos que se muestran en la Vista de clases, con una descripción de cada uno.

Icono Descripción

Espacio de nombres

Clase

Interfaz

Estructura

Unión

Enum

TypeDef

Módulo

Intrínseco

Delegado

Excepción

Mapa

Global

Método o función

Operador

Propiedad

Campo o variable

Evento

Constante

Elemento de tipo enumerado

Elemento de mapa

Declaración externa

Macro

Plantilla

Desconocido o error

3.3 Página de inicio La Página de inicio proporciona una ubicación central para establecer preferencias, leer noticias de productos, ponerse en contacto con otros

programadores y obtener acceso a otro tipo de información que le permita mejorar su rendimiento con Visual Studio. Para ver la Página de inicio, seleccione Mostrar página de inicio en el menú Ayuda. Determinados paneles, como los que figuran en la ficha Recursos en línea, reciben actualizaciones periódicas a través de Internet. El entorno de desarrollo integrado (IDE) descargará estas actualizaciones de forma automática cada vez que seleccione uno de estos paneles estando conectado a Internet. Si no está conectado, el panel mostrará la última información recibida. Además, el filtro actual de Ayuda seleccionará el contenido en línea de modo que sólo aparezca la información relevante. Nota Al cambiar un filtro de Ayuda en la Página de inicio, se cambia también el filtro aplicado a la documentación de MSDN. A continuación se describen cada una de las fichas de la Página de inicio.

3.3.1 Mi perfil. Utilice esta ficha de la Página de inicio para establecer sus preferencias de trabajo en el entorno de desarrollo integrado (IDE). Para ver la Página de inicio, seleccione Mostrar página de inicio en el menú Ayuda. Perfil Muestra los perfiles predeterminados que establecen automáticamente las opciones Esquema de teclado, Diseño de ventana y Filtro de Ayuda. Si cambia una de las configuraciones predeterminadas una vez seleccionado un perfil predefinido, el nombre del perfil cambia a "(Personalizado)".

• Programador de Visual Studio: especifica la opción Predeterminados de Visual Studio para Esquema de teclado, Diseño de ventana y Filtro de Ayuda.

• Programador de Visual Basic: especifica la opción Visual Basic 6.0 para Esquema de teclado, Diseño de ventana y el Filtro de Ayuda de Visual Basic.

• Programador de Visual C++: especifica la opción Visual C++ 6.0 para Esquema de teclado, Diseño de ventana y el Filtro de Ayuda de Visual C++.

• Programador de Visual InterDev: especifica la opción Visual Basic 6.0 para Esquema de teclado, Predeterminados de Visual Studio para Diseño de ventana y ningún Filtro de Ayuda.



• Programador de macros de VS: especifica la opción Predeterminados de Visual Studio para Esquema de teclado, Diseño de ventana y Filtro de Ayuda de las macros de Visual Studio.

• Programador de Visual C#: especifica la opción Predeterminados de Visual Studio para Esquema de teclado, Diseño de ventana y el Filtro de Ayuda de Visual C#.

• Programador de Visual J#: especifica la opción Predeterminados de Visual Studio para Esquema de teclado, Ventana de diseño de Visual Studio y el Filtro de Ayuda de Visual J#.

• Programador avanzado: especifica la opción Predeterminados de Visual Studio para Esquema de teclado, Mínimo para Diseño de ventana y Filtro de Ayuda. Este perfil sólo está disponible con Visual Studio Edición académica.

Esquema de teclado Muestra las posibles configuraciones de teclas de método abreviado que puede utilizar. También puede crear combinaciones de teclado personalizadas o cambiar combinaciones de teclado en el panel Teclado de las opciones Entorno del cuadro de diálogo Opciones. Diseño de ventana Muestra las posibles configuraciones de ventana predeterminadas. Una vez seleccionado un diseño, se pierde cualquier personalización realizada con anterioridad y se aplica el diseño seleccionado.

• Predeterminados de Visual Studio: este diseño oculta automáticamente el Explorador de servidores y la ventana Cuadro de herramientas a lo largo del extremo izquierdo del IDE; el Explorador de soluciones y la Vista de clases se acoplan mediante fichas a la derecha, con la ventana Propiedades y la ventana Ayuda dinámica acopladas mediante fichas por debajo.

• Visual Basic 6: este diseño oculta automáticamente el Explorador de servidores a lo largo del extremo izquierdo del IDE y acopla el Cuadro de herramientas a la izquierda; el Explorador de soluciones y la Vista de clases se acoplan mediante fichas a la derecha, con la ventana Propiedades y la ventana Ayuda dinámica acopladas mediante fichas por debajo.

• Visual C++ 6: este diseño coloca las ventanas Vista de recursos, Vista de clases y

Explorador de soluciones acopladas mediante fichas a la izquierda; la ventana Propiedades y las ventanas Ayuda dinámica se acoplan mediante fichas por debajo, también a la izquierda.

• Estudiante: este diseño coloca las ventanas Vista de clases y Explorador de soluciones acopladas mediante fichas a la izquierda, con la ventana Ayuda dinámica debajo; y las ventanas Lista de tareas y Resultados acopladas mediante fichas en la parte inferior.

• Sin herramientas: este diseño sólo muestra el espacio de edición, sin ninguna ventana de herramientas abierta.

Filtro de Ayuda Muestra los posibles filtros predeterminados para la documentación de Microsoft Developer Network (MSDN) y la información mostrada en paneles de la Página de inicio. El filtro de Ayuda que seleccione no se aplicará al contenido mostrado en la ventana Ayuda dinámica. También puede cambiar el filtro de Ayuda aplicado desde las ventanas Contenido, Índice y Buscar de MSDN. Mostrar Ayuda Especifica si se muestra la Ayuda dentro de una ventana en el IDE o en una ventana independiente disponible fuera del IDE. Al iniciar mostrar Especifica qué interfaz de usuario aparece al iniciar Visual Studio. Elija entre Mostrar página de inicio, Cargar última solución cargada, Mostrar el cuadro de diálogo Abrir proyecto, Mostrar el cuadro de diálogo Nuevo proyecto y Mostrar el entorno vacío.

3.3.2 Proyectos. Esta ficha de la Página de inicio proporciona una lista de soluciones recientes y le permite obtener acceso a cuadros de diálogo clave para crear proyectos nuevos y abrir proyectos existentes. Para ver la Página de inicio, seleccione Mostrar página de inicio en el menú Ayuda. Nombre Muestra los nombres de las soluciones creadas anteriormente. Modificado Muestra el día y la hora en que se actualizó por última vez la solución. Abrir proyecto Muestra el cuadro de diálogo Abrir proyecto.



Nuevo proyecto Muestra el cuadro de diálogo Nuevo proyecto.

3.3.3 Recursos en línea. Este panel de la Página de inicio proporciona un sistema de búsqueda para localizar temas en el área de documentación principal así como códigos de ejemplo en línea. Para buscar en línea, debe estar conectado a Internet. Para ver la Página de inicio, seleccione Mostrar página de inicio en el menú Ayuda. Obtener el perfil de los ejemplos Reduce los resultados de la búsqueda limitándola a aquellos ejemplos que coincidan con los requisitos del perfil seleccionado. De forma predeterminada, este perfil coincide con el perfil seleccionado en la ficha Mi perfil de la Página de inicio. Los cambios que realice en el perfil utilizado en esta ficha no afectarán al perfil seleccionado en la ficha Mi perfil. Filtrar por Elija Palabra clave para buscar en los ejemplos con texto de búsqueda personalizado. Seleccione Tipo para buscar en los ejemplos utilizando una categoría de ejemplos predefinida. Ejemplos de la Ayuda Muestra una lista de los ejemplos que contiene la documentación de MSDN.

3.4 Tipos de proyectos Cuando se crea un nuevo proyecto, los iconos de los cuadros de diálogo Nuevo proyecto y Agregar proyecto representan los tipos de proyecto disponibles y sus plantillas. La plantilla de proyecto asociada con el icono de proyecto elegido determina el tipo de resultado y otras opciones disponibles para el proyecto.

Hay dos modelos de proyecto básicos en Visual Basic: local y Web. En el presente curso nos vamos a centrar principalmente en los proyectos locales, los cuales se describen brevemente en la siguiente tabla.

Plantilla de proyecto Se utiliza para crear

Plantilla de aplicaciónpara Windows

Aplicaciones autónomastradicionales para Windows o unainterfaz rica para una aplicaciónWeb distribuida.

Nota para Visual Basic Estoreemplaza las plantillas de

Plantilla de proyecto Se utiliza para crear proyecto EXE estándar de VisualBasic 6.0.

Plantilla Biblioteca declases

Clases o componentesreutilizables que puedancompartirse con otros proyectos.Este tipo de proyecto se consideraque no tiene ventanas y nocontendrá una clase formulario deWindows Forms

Plantilla Biblioteca decontroles de Windows

Controles personalizados parautilizarlos en formulariosWindows Forms

Plantilla Aplicación WebASP.NET

Aplicaciones Web ASP.NETprogramables.

Plantilla de AplicaciónWeb de ASP.NET Mobile

Aplicaciones Web ASP.NETpara PDA (asistentes personalesdigitales), teléfonos móviles yotros dispositivos móviles.

Plantilla Servicio WebASP.NET

Los servicios Web XML secrean con ASP.NET,funcionalidad que puedepublicarse y recibir llamadas deaplicaciones externas

Plantilla Biblioteca decontroles Web

Controles personalizados parautilizarlos en páginas deformularios Web Forms

Nota para Visual Basic Estetipo de proyecto es análogo alproyecto de controles ActiveX deVisual Basic 6.0.

Plantilla Aplicación deconsola

Aplicaciones de línea decomandos.

Plantilla Servicio deWindows

Aplicaciones de larga duraciónque no tienen una interfaz deusuario. Las aplicaciones deservicios de Windows (antesdenominadas "servicios NT")pueden supervisar elementos talescomo el rendimiento del sistema.

Plantilla Nuevo proyectoen carpeta existente

Proyectos en blanco dentro deuna carpeta de aplicación existenteque sirven para utilizar archivos deun proyecto preexistente. Estaplantilla puede utilizarse tanto conproyectos locales como conproyectos Web.

Plantilla Proyecto vacío Proyecto vacío. La plantilla crea



Plantilla de proyecto Se utiliza para crear la estructura de archivos necesariapara almacenar la información dela aplicación; las referencias,archivos o componentes debenagregarse manualmente.

Plantilla Proyecto Webvacío

Para usuarios avanzados quedesean empezar a programar en unentorno vacío y agregar su propiafuncionalidad basada en elservidor.

3.4.1 Creando Aplicaciones Una parte importante de Visual Studio.NET

es la capacidad de crear aplicaciones Windows que se ejecutan localmente en los equipos de los usuarios. Visual Studio .NET permite crear la aplicación con su interfaz de usuario mediante formularios Windows Forms.

3.4.2 Aplicaciones Windows de Visual Studio Una aplicación Windows de Visual Studio se

desarrolla en torno al Framework .NET, un amplio conjunto de clases que permiten programar aplicaciones sofisticadas. Por ejemplo, puede crear aplicaciones Windows mediante cualquier lenguaje de programación .NET (Visual Basic, C#, Extensiones administradas para C++ y muchos otros) y las utilidades de depuración .NET.

Las aplicaciones Windows creadas con clases

.NET proporcionan otros beneficios. Es posible obtener acceso a los servicios del sistema operativo y beneficiarse de las ventajas que proporciona el entorno de ejecución del usuario. Puede tener acceso a datos utilizando ADO.NET. GDI+ permite realizar funciones avanzadas de dibujado y pintado en los formularios. Las aplicaciones Windows pueden realizar llamadas a métodos que se exponen a través de servicios Web XML, lo cual invita a aprovechar la información y los recursos de procesamiento de diferentes fuentes y socios.

3.4.3 Las aplicaciones Windows y Visual Studio Al igual que con cualquier otra aplicación

.NET, se pueden crear aplicaciones Windows en un editor de texto, hacer llamadas a métodos y clases .NET, compilar la aplicación en la línea de comandos y distribuir el programa ejecutable resultante.

También puede utilizar Visual Studio .NET.

Cuando utilice Visual Studio .NET para crear aplicaciones Web, estará creando esencialmente la misma aplicación que podría crear a mano. La ventaja de utilizar Visual Studio .NET es que proporciona herramientas que hacen que el desarrollo de aplicaciones sea mucho más rápido, sencillo y confiable. Entre estas herramientas se incluyen:

• Diseñadores visuales para

formularios Windows Forms con controles de arrastrar y colocar.

• Editores de código inteligentes que incluyen finalización de instrucciones, comprobación de sintaxis y otras características de IntelliSense.

• Compilación y depuración integradas.

• Utilidades de administración de proyectos para la creación y administración de archivos de aplicación, incluida la implementación en servidores de intranet o Internet.

Si ya utilizó Visual Studio antes, este tipo de funciones le parecerán familiares, porque son similares a las disponibles en versiones anteriores de Visual Basic y Visual C++. Visual Studio .NET las amplía para ofrecer un entorno de primer nivel para programar aplicaciones Windows.

3.4.4 Desarrollo de aplicaciones Windows El desarrollo de aplicaciones Windows con

Visual Studio puede tomar muchas formas diferentes. Se pueden crear aplicaciones de formularios Windows Forms y servicios Windows que aprovechen todas las posibilidades de .NET Framework, o utilizar Visual C++ para crear aplicaciones Win32.



3.4.5 Aplicaciones de servicios de Windows Si utiliza Microsoft Visual Studio .NET o

Microsoft .NET Framework SDK, podrá generar servicios fácilmente al crear una aplicación que se instale como servicio. Este tipo de aplicación se denomina Servicio de Windows. Con las funciones del marco de trabajo, es posible crear servicios, instalarlos, iniciarlos, detenerlos y controlar su comportamiento.

3.4.6 Proyectos Win32 Se puede utilizar el Asistente para proyectos

con el fin de crear tipos de proyecto Win32, incluidas aplicaciones de consola, aplicaciones Windows ejecutables, bibliotecas de vínculos dinámicos y bibliotecas estáticas. Para crear un proyecto de Aplicación para Windows La base de la mayor parte de soluciones que impliquen formularios Windows Forms es el proyecto Aplicación para Windows. Resulta sencillo crearlo mediante el entorno de desarrollo integrado (IDE).

1. En el menú Archivo, elija Nuevo y, a continuación, seleccione Proyecto.

2. En el panel Tipos de proyecto, elija el idioma que desee.

3. En el panel Plantillas, elija Aplicación para Windows para proyectos de Visual Basic.

Nota En el cuadro Nombre, asigne al proyecto un nombre único, que indique cuál es el propósito de la aplicación. En el cuadro Ubicación, escriba el directorio en el que desee guardar el proyecto o haga clic en el botón Examinar para desplazarse hasta él.

Se abrirá el Diseñador de Windows Forms, que mostrará el formulario Form1 del proyecto creado.

4 Controles de formularios Windows

4.1 Cuadro de Mensajes

4.1.1 Función 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 aproximadamente 1024 caracteres, según el ancho de los caracteres utilizados. Si Prompt va a tener más de una línea, éstas pueden separarse mediante un carácter de retorno de carro (Chr(13)), un carácter de avance de línea (Chr(10)) o la combinación retorno de carro-avance de línea (Chr(13)) & (Chr(10)) entre cada línea.

Title Opcional. Expresión de tipo String que se muestra en la barra de título 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 horizontalmente.

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 pantalla. Si se omite YPos, el cuadro de diálogo se situará, en sentido vertical, a aproximadamente un tercio del alto total de la pantalla.



Comentarios: 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 posición, deberá conservar el correspondiente delimitador de coma. Ejemplo En este ejemplo se muestran distintas formas de utilizar la función InputBox para pedir al usuario que introduzca un valor. Si se omiten las posiciones x e y, el cuadro de diálogo quedará centrado automáticamente respecto a ambos ejes. La variable MyValue contiene el valor introducido por el usuario al hacer clic en Aceptar o presionar la tecla ENTRAR. Si el usuario hace clic en Cancelar, se devolverá una cadena de longitud cero. Dim message, title, defaultValue As String Dim myValue As Object message = "Enter a value between 1 and 3" ' Set prompt. title = "InputBox Demo" ' Set title. DefaultValue = "1" ' Set default value. ' Display message, title, and default value. myValue = InputBox(message, title, defaultValue) ' Display dialog box at position 100, 100. myValue = InputBox(message, title, defaultValue, 100, 100)

4.1.2 Función 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.

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 aproximadamente 1024 caracteres, según el ancho de los caracteres utilizados. Si Prompt va a tener más de una línea, éstas pueden separarse mediante un carácter de retorno de

carro (Chr(13)), un carácter de avance de línea (Chr(10)) o la combinación retorno de carro/avance de línea (Chr(13)) & (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 predeterminado 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ítulo del cuadro de diálogo. Si se omite Title, en la barra de título aparecerá el nombre de la aplicación.

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

Enumeración 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.

Información 64 Muestra el icono Mensaje de información.

DefaultButton1 0 El primer botón es el predeterminado.

DefaultButton2 256 El segundo botón es el predeterminado.



Enumeración Valor Descripción

DefaultButton3 512 El tercer botón es el predeterminado.

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

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

MsgBoxSetForeground

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

MsgBoxRight 524288 Texto alineado a la derecha.

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

El primer grupo de valores (0 a 5) describe el número y tipo de botones mostrados en el cuadro de diálogo; el segundo grupo (16, 32, 48, 64) detalla el estilo de icono; el tercero (0, 256, 512) determina el botón predeterminado; el cuarto (0, 4096), la modalidad del cuadro de mensaje; y, por último, el quinto grupo especifica si la ventana del cuadro de mensaje está en primer plano o no, así como la alineación y la dirección que ha de tener el 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. Valores devueltos Valor

OK 1

Cancel 2

Abort 3

Retry 4

Ignore 5

Yes 6

No 7

Excepciones o errores

Tipo de excepción Condición

ArgumentException

Prompt no esuna expresiónString o Titleno es válido.

InvalidOperationException

El procesono se estáejecutando enmodo interactivo deusuario.

InvalidEnumArgumentException

Uno o másparámetros noson miembrosde lasenumeraciones MsgBoxResulto MsgBoxStyle.

Comentarios Si el cuadro de diálogo muestra un botón Cancel, presionar la tecla ESC tendrá el mismo efecto que hacer clic en Cancel. Si el cuadro de diálogo contiene un botón Help, existe ayuda contextual para ese cuadro de diálogo en concreto. Sin embargo, no se devolverá ningún valor hasta que se haga clic en uno de estos botones. Nota Si desea especificar más que el primer argumento, deberá utilizar la función MsgBox en una expresión. Si omite alguno de los argumentos de posición, deberá conservar el correspondiente delimitador de coma. Ejemplo: En este ejemplo se utiliza la función MsgBox para mostrar un mensaje de error crítico en un cuadro de diálogo con botones Sí y No. El botón No se considera la respuesta predeterminada. Todo ello se consigue combinando los valores de constante de MsgBox en una expresión numérica. En este caso, si se agrega 4 (la combinación de botones Sí/No) y 16 (la ventana Mensaje crítico) y 256 (el segundo botón como botón predeterminado) se obtiene un total de 276. El valor que devuelve la función MsgBox depende del botón que elija el usuario: Sí devuelve un valor 6; No un valor 7. Dim msg As String Dim title As String Dim style As MsgBoxStyle



Dim response As MsgBoxResult msg = "Do you want to continue?" ' Define message. style = MsgBoxStyle.DefaultButton2 Or _ MsgBoxStyle.Critical Or MsgBoxStyle.YesNo title = "MsgBox Demonstration" ' Define title. ' Display message. response = MsgBox(msg, style, title) If response = MsgBoxResult.Yes Then ' User chose Yes. ' Perform some action. Else ' Perform some other action. End If

4.2 Insertar controles en el formulario

Existe una gran variedad de controles que se puede insertar en los formularios Windows Forms, según las necesidades de la aplicación. La mayoría de los formularios se diseñan mediante la adición de controles a la superficie del formulario, para definir una interfaz de usuario. Un control es un componente de un formulario que se utiliza para mostrar información o aceptar los datos introducidos por el usuario. Para dibujar un control en un formulario

1. Abra el formulario. 2. En el Cuadro de herramientas, haga clic en el

control que desee agregar al formulario. 3. En el formulario, haga clic en el punto en que

desee que se encuentre la esquina superior izquierda del control y arrastre hasta donde desee que se encuentre la esquina inferior derecha del control.

El control se agregará al formulario con la ubicación y el tamaño especificados.

Cada control tiene definido un tamaño predeterminado. Puede agregar un control al formulario con su tamaño predeterminado arrastrándolo desde el Cuadro de herramientas al formulario. Para agregar un control a un formulario

1. Abra el formulario. 2. En el Cuadro de herramientas, haga clic en el

control que desee y arrástrelo al formulario.

3. El control se agregará al formulario en la ubicación especificada, con su tamaño predeterminado.

Nota Puede hacer doble clic en un control del Cuadro de herramientas para agregarlo al margen superior izquierdo del formulario con su tamaño predeterminado.

4.3 Propiedades controles

4.3.1 Editar las propiedades del control

Para editar las propiedades de uno o más controles 1. En el cuadro de diálogo, seleccione el control

que desee modificar. Nota Si selecciona varios controles, sólo será posible modificar las propiedades que sean comunes a todos ellos.

2. En la ventana Propiedades, cambie las propiedades del control.

Para deshacer los cambios de las propiedades de un control

1. Asegúrese de que el control tiene el foco en el Editor de cuadros de diálogo.

2. Elija Deshacer en el menú Edición (si el foco no está en el control, este comando no estará disponible).

4.4 Controles básicos de formularios Windows

4.4.1 Label

Los controles Label se utilizan normalmente para proporcionar texto descriptivo de un control. Por ejemplo, se puede utilizar un objeto Label para agregar texto descriptivo para un control TextBox e informar al usuario del tipo de datos que se espera tener en el control. Los controles Label se pueden utilizar también para agregar texto descriptivo a un formulario para proporcionar al usuario información útil. Por ejemplo, se puede agregar Label en la parte superior de Form que proporciona al usuario instrucciones sobre cómo introducir datos en los controles del formulario. Los controles Label se pueden utilizar también para mostrar información en



tiempo de ejecución sobre el estado de una aplicación. Por ejemplo, se puede agregar un control Label a un formulario para mostrar el estado de cada archivo cuando se procesa una lista de archivos. Label participa en el orden de tabulación de un formulario, pero no recibe el foco (el siguiente control del orden de tabulación recibe el enfoque). Por ejemplo, si la propiedad UseMnemonic está establecida en true y se especifica un carácter mnemotécnico (el primer carácter después del símbolo &) en la propiedad Text del control, cuando el usuario presiona ALT + la tecla mnemotécnica, el foco se mueve hacia el siguiente control del orden de tabulación. Esta característica permite desplazarse por un formulario mediante el teclado. Además de mostrar texto, el control Label puede mostrar asimismo una imagen mediante la propiedad Image, o una combinación de las propiedades ImageIndex e ImageList. Nota Para que Label sea transparente, hay que establecer la propiedad BackColor a Color.Transparent.

4.4.2 TextBox

El control TextBox permite al usuario escribir texto en una aplicación. Este control tiene funcionalidad adicional que no se encuentra en el control de cuadro de texto de Windows estándar, como el enmascaramiento de caracteres de contraseña y la edición de múltiples líneas. Habitualmente, se utiliza un control TextBox para mostrar, o aceptar como entrada, una sola línea de texto. Es posible utilizar las propiedades Multiline y ScrollBars para permitir que se muestren o escriban varias líneas de texto. Establezca las propiedades AcceptsTab y AcceptsReturn en true con el fin de permitir una mayor manipulación de texto en un control TextBox multilínea. El texto que se muestra en el control se encuentra almacenado en la propiedad Text. De forma predeterminada, en un cuadro de texto se puede escribir 2048 caracteres como máximo. Si establece la propiedad MultiLine en true, podrá escribir un máximo de 32 KB de texto. La propiedad Text puede establecerse en tiempo de diseño con la ventana Propiedades, en tiempo de ejecución mediante código o por medio de la introducción de datos por el usuario en tiempo de ejecución. El contenido actual de un cuadro de texto puede recuperarse en tiempo de ejecución mediante la lectura de la propiedad Text.

Para limitar la cantidad de texto escrito en un control TextBox, establezca la propiedad MaxLenght en un número de caracteres específico. Los controles TextBox se pueden utilizar también para aceptar contraseñas y otra información delicada. Es posible utilizar la propiedad PasswordChar para enmascarar caracteres escritos en una versión de una sola línea del control. Para restringir que se escriba texto en un control TextBox, se puede crear un controlador de eventos para el evento KeyDown con el fin de validar cada carácter escrito en el control. También se puede restringir toda entrada de datos en un control TextBox; para ello, establezca la propiedad ReadOnly en true. Nota La mayor parte de la funcionalidad del control TextBox se hereda de la clase TextBoxBase.

4.4.3 Button

El control Button de los formularios Windows Forms permite al usuario hacer clic en él para ejecutar una acción. Cuando se hace clic en el botón, da la sensación de que se ha presionado y soltado. Cada vez que el usuario hace clic en un botón, se invoca al controlador del evento Click. El código se ubica en el controlador del evento Click para ejecutar la acción deseada. El texto que se muestra en el botón se almacena en la propiedad Text. Si este texto supera el ancho del botón, se ajustará en la línea siguiente. No obstante, si el control no dispone del alto suficiente, el texto aparecerá cortado. La propiedad Text puede contener una tecla de acceso, que permite al usuario presionar la tecla ALT junto con la tecla de acceso para "hacer clic" en el control. La propiedad Font y la propiedad TextAlign controlan la apariencia del texto. El control Button puede mostrar también imágenes, por medio de las propiedades Image e ImageList. Se puede hacer clic en Button utilizando el mouse (ratón), la tecla ENTRAR o la BARRA ESPACIADORA si el botón tiene foco. Se establece la propiedad AcceptButton o CancelButton de un objeto Form para permitir a los usuarios hacer clic en un botón presionando ENTRAR o ESCAPE incluso si el botón no tiene foco. Esto proporciona al formulario el comportamiento de un cuadro de diálogo. Al mostrar un formulario mediante el método ShowDialog, se puede utilizar la propiedad



DialogResult de un botón para especificar el valor devuelto de ShowDialog.

Nombre Descripción

Abort El valor devuelto por el cuadro de diálogoes Abort (suele enviarse desde un botónAnular).

Cancel El valor devuelto por el cuadro de diálogoes Cancel (suele enviarse desde un botónCancelar).

Ignore El valor devuelto por el cuadro de diálogoes Ignore (suele enviarse desde un botónOmitir).

No El valor devuelto por el cuadro de diálogoes No (suele enviarse desde un botón No).

None El cuadro de diálogo devuelve Nothing. Esto significa que el cuadro de diálogomodal continúa ejecutándose.

OK. El valor devuelto por el cuadro de diálogoes OK (suele enviarse desde un botónAceptar).

Retry. El valor devuelto por el cuadro de diálogoes Retry (suele enviarse desde un botónReintentar).

Yes. El valor devuelto por el cuadro de diálogoes Yes (suele enviarse desde un botón Sí).

Tabla Valores devueltos por la propiedad DialogResult. Es posible cambiar la apariencia del botón. Por ejemplo, para darle un aspecto liso a una página Web, hay que establecer la propiedad FlatStyle en FlatStyle.Flat. La propiedad FlatStyle también puede establecerse en FlatStyle.Popup, y el botón presentará un aspecto liso hasta que el puntero del mouse pase sobre el mismo, con lo cual a partir de ese momento el botón adoptará la apariencia de un botón estándar de Windows. Nota: Si el control que tiene el foco acepta y procesa la acción de presionar la tecla ENTRAR, el control Button no lo procesa. Por ejemplo, si un control TextBox multilínea o cualquier otro botón tiene foco, dicho control procesa la acción de presionar la tecla ENTRAR en lugar del botón que representa la acción de Aceptar.

4.4.4 Checkbox

El control CheckBox de los formularios Windows Forms indica si una condición determinada está activada o desactivada. Se utiliza habitualmente para presentar al usuario una selección de tipo Sí/No o Verdadero/Falso. Puede utilizar grupos de casillas de verificación para mostrar múltiples opciones entre las cuales el usuario puede elegir una o más. El control casilla de verificación es similar al control botón de opción, puesto que los dos se utilizan para indicar una selección realizada por el usuario. Sólo difieren en que en un grupo de botones de opción no se puede seleccionar más de un botón de opción. Sin embargo, en un grupo de casillas de verificación es posible seleccionar tantas casillas de verificación como se desee. Puede conectar una casilla de verificación a elementos de una base de datos mediante enlaces simples de datos. También puede agrupar múltiples casillas de verificación por medio del control GroupBox. Esto resulta útil para mejorar la apariencia visual y para el diseño de la interfaz de usuario, puesto que permite mover juntos los controles agrupados por el diseñador de formularios El control CheckBox tiene dos importantes propiedades: Checked y CheckState. La propiedad Checked devuelve true o false. Se utiliza la propiedad Checked para obtener o establecer el valor de un control de casilla de verificación de dos estados. La propiedad CheckState devuelve CheckState.Checked o CheckState.Unchecked; o bien, si la propiedad ThreeState está definida como true, CheckState puede devolver también CheckState.Indeterminate. En el estado indeterminado, el cuadro se muestra atenuado para indicar que la opción no está disponible. El control de la casilla de verificación puede mostrar una imagen o texto o ambos. La propiedad Appearance determina si la casilla de verificación aparece en su forma típica o como un botón. Nota Si se establece la propiedad ThreeState en true, la propiedad Checked devuelve true para los estados activado o indeterminado. La propiedad FlatStyle determina el estilo y el aspecto del control. Si la propiedad FlatStyle se establece en FlatStyle.System, el sistema operativo del usuario determina la apariencia del control. Nota Cuando se establece la propiedad FlatStyle en FlatStyle.System, se omite la propiedad CheckAlign y se muestra el control con la alineación



ContentAlignment.MiddleLeft o ContentAlignment.MiddleRight. Si se establece la propiedad CheckAlign en una de las alineaciones a la derecha, se muestra el control con la alineación ContentAlignment.MiddleRight; de lo contrario, se muestra con la alineación ContentAlignment.MiddleLeft. A continuación se describe en qué consiste un estado indeterminado. Se puede partir de una casilla de verificación que determina si el texto seleccionado en un control RichTextBox está en negrita. Al seleccionar texto se puede hacer clic en la casilla de verificación para poner en negrita la selección. De igual forma, al seleccionar un poco de texto, la casilla muestra si el texto seleccionado está en negrita. Si éste contiene texto en negrita y normal, la casilla de verificación tendrá un estado indeterminado.

4.4.5 Groupbox

Los controles GroupBox de formularios Windows Forms se utilizan para proporcionar un agrupamiento identificable para otros controles. Normalmente, los cuadros de grupo se utilizan para subdividir un formulario por funciones. Por ejemplo, podría tener un formulario de pedido que especifique opciones de envío con un grupo lógico de controles RadioButton, como el servicio de transporte urgente que se va a utilizar. La agrupación de todas las opciones en un cuadro de grupo ofrece al usuario una pista visual lógica. Además, en tiempo de diseño es fácil mover todos los controles, ya que, al mover el control GroupBox, también se mueve todo su contenido. Los controles GroupBox y Panel son similares; sin embargo, el control GroupBox es el único de los dos que muestra un título y el control Panel es el único de los dos que puede tener barras de desplazamiento. La propiedad Text define el título del cuadro de grupo. GroupBox muestra un marco alrededor de un grupo de controles con o sin título. Se pueden agregar controles a GroupBox mediante el método Add de la propiedad Controls. Nota Solo se pueden seleccionar o recibir foco los controles que se incluyen en el control GroupBox. No puede seleccionarse ni recibir foco todo el control GroupBox.

4.4.6 Panel

Los controles Panel de formularios Windows Forms se utilizan para proporcionar un agrupamiento identificable para otros controles. Normalmente, los paneles se utilizan para subdividir un formulario por funciones. Agrupar todas las opciones en un panel ofrece al usuario una pista visual lógica. En tiempo de diseño todos los controles se pueden mover fácilmente; cuando se mueve el control Panel, todos los controles que contiene se desplazan también. Se puede obtener acceso a los controles agrupados en un panel mediante su propiedad Controls. Los controles Panel y GroupBox son similares; sin embargo, el control Panel es el único de los dos que puede tener barras de desplazamiento y el control GroupBox es el único de los dos que muestra un título. Panel es un control que contiene otros controles. Al igual que sucede con otros controles contenedores, como el control GroupBox, si la propiedad Enabled del control Panel está establecida en false, los controles contenidos dentro de Panel también se deshabilitarán. Para mostrar barras de desplazamiento, establezca la propiedad AutoScroll en true. Para personalizar la apariencia del panel, establezca las propiedades BackColor, BackgroundImage y BorderStyle. El control Panel se muestra de forma predeterminada sin bordes. La propiedad BorderStyle sirve para distinguir el área del panel de otras áreas del formulario, determina si el panel está rodeado por un borde invisible (None), una línea simple (FixedSingle) o una línea sombreada (Fixed3D). Debido a que el control Panel deriva de la clase ScrollableControl, se puede utilizar la propiedad AutoScroll para habilitar barras de desplazamiento en el control Panel. Cuando la propiedad AutoScroll está establecida en true, es posible desplazarse a cualquier control situado dentro de Panel, aunque fuera de su región visible, con las barras de desplazamiento proporcionadas.

4.4.7 Radiobutton

Los controles RadioButton de formularios Windows Forms 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 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". Cuando se hace clic en un control RadioButton, su propiedad Checked se establece en true y se llama al controlador de eventos Click. El evento CheckedChanged se produce cuando cambia el valor de la propiedad Checked. Si la propiedad AutoCheck se establece en true (la opción predeterminada), al seleccionar el botón de opción se desactivarán automáticamente los demás botones de opción del grupo. Normalmente, esta propiedad sólo se establece en false cuando se utiliza código de validación para comprobar que el botón de opción seleccionado corresponde a una opción válida. El texto que se muestra dentro del control se establece con la propiedad Text, que puede contener teclas de acceso directo. Una tecla de acceso directo permite al usuario "hacer clic" en el control; para ello, debe presionar la tecla ALT junto con la tecla de acceso Si se establece la propiedad Appearance en Appearance.Button, el control RadioButton puede tener la apariencia de un botón de comando o botón alternar, que parece estar presionado cuando está seleccionado. Los botones de opción pueden mostrar también imágenes mediante las propiedades Image e ImageList. Todos los controles RadioButton de un contenedor determinado, como Form, constituyen un grupo. Para crear varios grupos en un formulario, coloque cada grupo en su propio contenedor, como un control GroupBox o Panel. Nota En ocasiones, el botón de opción se denomina botón de radio.

4.5 Orden de tabulación El orden de tabulación es el orden en el que el usuario mueve el foco de un control a otro al presionar la tecla TABULADOR. Cada formulario tiene su propio orden de tabulación. De forma predeterminada, el orden de tabulación es el mismo que el orden en el que se crearon los controles. La numeración del orden de tabulación empieza por cero. Para establecer el orden de tabulación de un control

1. En el menú Ver, elija Orden de tabulación. Esto activa el modo de selección del orden de tabulación en el formulario. En la esquina superior izquierda de cada control aparecerá un número (que representa la propiedad TabIndex).

2. Haga clic secuencialmente en los controles para establecer el orden de tabulación que desee.

Nota La posición de un control dentro del orden de tabulación puede establecerse en cualquier valor mayor o igual a cero. Cuando existen duplicados, se evalúa el orden z de los dos controles y se coloca primero el control superior. El orden z es la disposición visual en capas de los controles de un formulario a lo largo del eje z del formulario (profundidad). El orden z determina qué controles se encuentran por delante de otros controles.

3. Cuando termine, elija otra vez Orden de tabulación en el menú Ver para abandonar el modo de orden de tabulación.

Nota Los controles que no pueden tener el foco, así como los deshabilitados e invisibles, no tienen propiedad TabIndex y no se incluyen en el orden de tabulación. Cuando el usuario presiona la tecla TABULADOR, estos controles se omiten. También es posible establecer el orden de tabulación en la ventana Propiedades, mediante la propiedad TabIndex. La propiedad TabIndex de un control determina su posición dentro del orden de tabulación. De forma predeterminada, para el primer control que se dibuja el valor de TabIndex es 0; para el segundo, el valor de TabIndex es 1 y así sucesivamente. Además, como opción predeterminada, los controles GroupBox tienen su propio valor TabIndex, que es un número entero. Un control GroupBox no puede tener por sí mismo el foco en tiempo de ejecución. Por tanto, cada control de un GroupBox tiene su propio valor TabIndex decimal, comenzando con .0. Naturalmente, conforme aumenta el valor TabIndex de un control GroupBox, los controles que contiene aumentarán en consecuencia. Si cambia el valor de TabIndex de 5 a 6, el valor de TabIndex del primer control de su grupos cambia automáticamente a 6.0, etc. Finalmente, es posible omitir cualquier control del formulario en el orden de tabulación. Habitualmente, al presionar sucesivamente la tecla TABULADOR en tiempo de ejecución, se selecciona cada control en el orden de tabulación. Al desactivar la propiedad TabStop, es posible hacer que un control se pase por alto en el orden de tabulación del formulario.



Para quitar un control del orden de tabulación • Establezca la propiedad TabStop del control

en false en la ventana Propiedades. Un control cuya propiedad TabStop se haya establecido en false continúa manteniendo su posición en el orden de tabulación, aunque se omita al recorrer los controles con la tecla TABULADOR. Nota En tiempo de ejecución, un grupo de botones de opción tiene una sola tabulación en tiempo de ejecución. El botón seleccionado (es decir, el botón para el que el valor de Checked es true), tiene su propiedad TabStop establecida automáticamente en true, mientras que los demás botones tienen su propiedad TabStop establecida en false.

4.6 Validar el contenido del control Con frecuencia, se comprueba si la información que especifican los usuarios en un formulario Windows Forms es válida. Por ejemplo, si tiene un control TextBox para un número de teléfono, puede comprobar que contiene sólo los caracteres correctos (números, paréntesis, guiones, etc.). Con frecuencia, se utilizan expresiones regulares para validar datos especificados por el usuario. Validación en acción Para validar el contenido de un control, escriba código que controle el evento Validating. En el controlador de eventos, debe probar una condición determinada (como el número de teléfono del ejemplo anterior). La validación es uno de una serie de eventos que tiene lugar durante el procesamiento. Si la prueba da error, debe definir la propiedad Cancel del CancelEventArgs del evento Validating como True. Esto cancela el evento Validating y devuelve el foco al control. El efecto práctico es que el usuario no puede dejar el control hasta que los datos sean válidos. Cerrar el formulario y reemplazar la validación Un efecto secundario de que el control mantenga el foco cuando los datos no son válidos es que no se puede cerrar el formulario primario con los métodos que se usan normalmente para cerrar un formulario:

• Haciendo clic en el botón Cerrar. • A través del menú Sistema que aparece

cuando se hace clic con el botón secundario del mouse (ratón) en la barra de título.

• Llamando al método Close mediante programación.

Sin embargo, en algunos casos, puede permitir al usuario cerrar el formulario independientemente de que los valores de los controles sean válidos o no. Puede reemplazar la validación y cerrar un formulario que contenga datos no válidos creando un controlador para el evento Closing del formulario. En el evento, defina la propiedad Cancel como False. Esto obliga al formulario a cerrarse. Nota Si fuerza al formulario a cerrarse de esta manera, se pierde la información de los controles que no se haya guardado antes. Nota Los formularios modales no validan el contenido de los controles cuando se cierran. No obstante, puede utilizar la validación de controles para bloquear el foco en un control, pero no tiene que preocuparse por el comportamiento relativo al cierre del formulario. Ejemplo: En este ejemplo se valida la escritura por parte del usuario de al menos ocho caracteres en un control TextBox. Private Sub TextBox1_Validating(ByVal sender As Object, _ ByVal e As System.ComponentModel.CancelEventArgs) _ Handles TextBox1.Validating If TextBox1.Text.Length < 8 Then MessageBox.Show _ ("El valor introducido no es válido;" _ & " debe tener al menos 8 caracteres.") e.Cancel = True End If End Sub

4.7 Otros Controles

4.7.1 LinkLabel

El control LinkLabel de formularios Windows Forms permite agregar vínculos de estilo Web a aplicaciones de formularios Windows Forms. El control LinkLabel es similar a un control Label, con la excepción de que puede mostrar un hipervínculo. Puede utilizar el control LinkLabel para todo aquello para lo que pueda utilizar el control Label. También puede establecer parte del texto como un vínculo a un archivo, una carpeta o una página Web. Además de todas las propiedades, métodos y eventos del control Label, el control LinkLabel posee propiedades para hipervínculos y colores de vínculo. La propiedad LinkArea establece el área del texto que activa el vínculo. Las propiedades LinkColor, VisitedLinkColor y ActiveLinkColor establecen los colores del vínculo. El evento LinkClicked determina qué ocurre cuando se selecciona el texto del vínculo.



El uso más simple del control LinkLabel es utilizarlo para mostrar un único vínculo mediante la propiedad LinkArea, aunque también se pueden mostrar varios hipervínculos con la propiedad Links, que permite obtener acceso a una colección de vínculos. Asimismo, en la propiedad LinkData se pueden especificar datos de cada objeto Link individual. Cada hipervínculo puede realizar una tarea distinta dentro de una aplicación. Por ejemplo, puede utilizar un hipervínculo para mostrar un sitio Web en Microsoft Internet Explorer o para cargar un archivo de registro asociado a una aplicación. Cada hipervínculo que se muestra en el control LinkLabel es una instancia de la clase LinkLabel.Link. La clase LinkLabel.Link define información apariencia, estado y ubicación del hipervínculo. Además, la propiedad LinkData de la clase LinkLabel.Link permite asociar al hipervínculo información, como, por ejemplo, una dirección URL que se va a mostrar. Cuando un usuario hace clic en un hipervínculo del control, se provoca el evento LinkClicked y el objeto LinkLabel.Link que representa el hipervínculo en el que se hizo clic se pasa como parte del objeto LinkLabelLinkClickedEventArgs que se pasa como parámetro al controlador de eventos. Puede utilizar este objeto para obtener el objeto LinkLabel.Link asociado al hipervínculo en el que el usuario hizo clic. Todos los hipervínculos contenidos en el control LinkLabel se almacenan en la instancia de la clase LinkLabel.LinkCollection para el control. Existen dos maneras de agregar un hipervínculo al control LinkLabel. La forma más rápida es especificar un objeto LinkArea y asignarlo a la propiedad LinkArea. De este modo, se puede especificar un solo hipervínculo en el texto del control. Para agregar varios hipervínculos, puede utilizar el método Add de la clase LinkLabel.LinkCollection mediante el acceso a la colección a través de la propiedad Links. Cuando se crea un control LinkLabel, se agrega a LinkLabel.LinkCollection un hipervínculo predeterminado que contiene todo el texto del control LinkLabel. Para reemplazar este vínculo predeterminado, especifique una nueva área de vínculo con la propiedad LinkArea o especifique un vínculo con el método Add de LinkLabel.LinkCollection. También puede quitar el hipervínculo predeterminado utilizando el método Remove de la clase LinkLabel.LinkCollection. LinkLabel proporciona varias propiedades que permiten definir la apariencia de los hipervínculos en el control. Las propiedades ActiveLinkColor, DisabledLinkColor, LinkColor y VisitedLinkColor

definen los colores que se utilizan al mostrar un hipervínculo en distintos estados. La propiedad LinkBehavior define cómo se muestra el subrayado asociado a un hipervínculo.

4.7.2 Listbox

Un control ListBox de formularios Windows Forms muestra una lista de elementos de los cuales el usuario puede seleccionar uno o más. 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. Cuando la propiedad MultiColumn se establece en true, el cuadro de lista muestra elementos en varias columnas y aparece una barra de desplazamiento horizontal. Cuando la propiedad MultiColumn se establece en false, el cuadro de lista muestra elementos en una única columna y aparece una barra de desplazamiento vertical. Cuando ScrollAlwaysVisible se establece en true, la barra de desplazamiento aparece, independientemente del número de elementos. La propiedad SelectionMode determina cuántos elementos de la lista pueden seleccionarse a la vez. La propiedad SelectedIndex devuelve un valor entero que corresponde al primer elemento seleccionado en el cuadro de lista. Para cambiar mediante programación el elemento seleccionado, cambie el valor SelectedIndex en el código; el elemento correspondiente de la lista aparecerá resaltado en el formulario Windows Forms. Si no se selecciona ningún elemento, el valor de SelectedIndex es -1. Si se selecciona el primer elemento de la lista, el valor SelectedIndex es 0. Cuando se seleccionan múltiples elementos, el valor SelectedIndex refleja el elemento seleccionado que aparece primero en la lista. La propiedad SelectedItem es similar a SelectedIndex, pero devuelve el elemento en sí, habitualmente un valor de cadena. La propiedad Items.Count refleja el número de elementos de la lista. Su valor es siempre uno más que el mayor valor posible para SelectedIndex, ya que SelectedIndex está basado en cero. Para agregar o eliminar elementos de un control ListBox, utilice los métodos Items.Add, Items.Insert, Items.Clear o Items.Remove. También puede agregar elementos a la lista mediante la propiedad Items en tiempo de diseño. Normalmente, Windows controla la tarea de dibujar los elementos que se van a mostrar en el control ListBox. Utilice la propiedad DrawMode y controle



los eventos MeasureItem y DrawItem para poder reemplazar el dibujo automático de Windows y dibujar los elementos por sí mismo. Utilice controles ListBox dibujados por el propietario para mostrar elementos de alto variable, imágenes, un color o una fuente diferente para el texto de cada elemento de la lista. La propiedad HorizontalExtent así como los métodos GetItemHeight y GetItemRectangle también proporcionan ayuda a la hora de dibujar elementos propios. Además de la funcionalidad de presentación y selección, ListBox también proporciona funciones que permiten agregar de manera eficaz elementos al control ListBox y buscar texto en los elementos de la lista. Los métodos BeginUpdate y EndUpdate permiten agregar un gran número de elementos a ListBox sin tener que volver a dibujar el control cada vez que se agrega un elemento a la lista. Los métodos FindString y FindStringExact permiten buscar un elemento de la lista que contenga una cadena de búsqueda específica. Las propiedades Items, SelectedItems y SelectedIndices proporcionan acceso a las tres colecciones que ListBox utiliza. En la tabla siguiente se presentan las tres colecciones que ListBox utiliza y se indica su uso dentro del control.

Clase de colección Uso dentro del cuadro de lista

ListBox.ObjectCollection

Contiene todos los elementosincluidos en el control ListBox.

ListBox.SelectedObjectCollection

Contiene una colección de loselementos seleccionados, queconstituye un subconjunto de loselementos incluidos en el controlListBox.

ListBox.SelectedIndexCollection

Contiene una colección de losíndices seleccionados, queconstituye un subconjunto de losíndices deListBox.ObjectCollection. Estosíndices especifican los elementosseleccionados.

El método Add de la clase ListBox.ObjectCollection permite agregar elementos a ListBox. El método Add puede aceptar cualquier objeto al agregar un miembro a ListBox. Cuando se agrega un objeto a ListBox, el control utiliza el texto definido en el método ToString del objeto, a menos que se especifique un nombre de miembro del objeto en la propiedad DisplayMember. Para agregar elementos, además del método Add de la

clase ListBox.ObjectCollection, puede usar también la propiedad DataSource de la clase ListControl.

4.7.3 CheckedListBox

El control CheckedListBox de los formularios Windows Forms complementa al control ListBox. Hace casi todo lo que puede hacer un cuadro de lista y, además, puede mostrar una marca de verificación junto a los elementos de la lista. Estos dos controles también se diferencian en que los cuadros de lista con marcas de verificación sólo admiten DrawMode.Normal y solamente pueden tener un elemento o ningún elemento seleccionado. Observe que un elemento seleccionado aparece resaltado en el formulario y que no es lo mismo que un elemento activado. En tiempo de ejecución, se pueden agregar elementos a los cuadros de lista con marcas de verificación mediante el Editor de la colección de cadenas, o bien se les pueden agregar elementos dinámicamente desde una colección, utilizando la propiedad Items. Este control presenta una lista de elementos por los que el usuario se puede desplazar mediante el teclado o la barra de desplazamiento situada a la derecha del control. El usuario puede colocar una marca de verificación junto a uno o más elementos, y puede explorar los elementos activados con CheckedListBox.CheckedItemCollection y CheckedListBox.CheckedIndexCollection. Para agregar objetos a la lista en tiempo de ejecución, hay que asignar una matriz de referencias a objetos con el método AddRange. De este modo la lista muestra el valor de cadena predeterminado para cada objeto. Es posible agregar elementos individuales a la lista con el método Add. El objeto CheckedListBox admite tres estados a través de la enumeración CheckState: Checked, Indeterminate y Unchecked. Hay que establecer el estado de Indeterminate en el código, ya que la interfaz de usuario de CheckedListBox no proporciona ningún mecanismo para ello. Si UseTabStops es true, CheckedListBox reconocerá y extenderá los caracteres de tabulación en el texto de un elemento, creando columnas. Sin embargo, las posiciones de tabulación están presentes y no pueden modificarse. La clase CheckedListBox admite las siguientes tres colecciones indizadas:



Clase de colección Uso dentro del cuadro de lista conmarcas de verificación

CheckedListBox.ObjectCollection

Todos los elementos incluidos en elcontrol CheckedListBox.

CheckedListBox.CheckedItemCollection

Elementos activados (incluidos loselementos con estado indeterminado),que es un subconjunto de loselementos que contiene el controlCheckedListBox.

CheckedListBox.CheckedIndexCollection

Índices activados, que constituyen unsubconjunto de los índices de lacolección de elementos. Estos índicesespecifican elementos que estánactivados o en un estadoindeterminado.

4.7.4 ComboBox

El control ComboBox de los formularios Windows Forms se utiliza para mostrar datos en un cuadro combinado desplegable. De forma predeterminada, el control ComboBox aparece en dos partes: la parte superior es un cuadro de texto que permite al usuario escribir un elemento de la lista. La segunda parte es un cuadro de lista que muestra una lista de elementos de entre los que el usuario puede seleccionar uno La propiedad SelectedIndex devuelve un valor entero que corresponde al elemento seleccionado en la lista. Para cambiar mediante programación el elemento seleccionado, cambie el valor de SelectedIndex en el código; el elemento correspondiente de la lista aparecerá en la parte de cuadro de texto del cuadro combinado. Si no se selecciona ningún elemento, el valor de SelectedIndex es -1. Si se selecciona el primer elemento de la lista, el valor de SelectedIndex es 0. La propiedad SelectedItem es similar a SelectedIndex, pero devuelve el elemento en sí, normalmente un valor de cadena. La propiedad Items.Count refleja el número de elementos de la lista. Su valor es siempre uno más que el mayor valor posible para SelectedIndex, ya que SelectedIndex está basado en cero. Para agregar o eliminar elementos de un control ListBox, utilice los métodos Items.Add, Items.Insert, Items.Clear o Items.Remove. También puede agregar elementos a la lista mediante la propiedad Items del diseñador. Un ComboBox muestra un campo de edición combinado con un ListBox y permite al usuario

seleccionar una opción de la lista o escribir texto nuevo. El comportamiento predeterminado de ComboBox es mostrar un campo de edición con una lista desplegable oculta. La propiedad DropDownStyle determina el estilo que mostrará el cuadro combinado. Puede escribir un valor que permita lo siguiente: una lista desplegable simple, en que la lista se muestra siempre; un cuadro de lista desplegable, en que la parte de texto no se puede editar y es necesario presionar una flecha para ver el cuadro de lista desplegable; o el cuadro de lista desplegable predeterminado, en que la parte de texto se puede editar y el usuario debe presionar la tecla de flecha para ver la lista. Para que siempre se muestre una lista que el usuario no puede editar, use un control ListBox. Para agregar objetos a la lista en tiempo de ejecución, asigne una matriz de referencias a objetos con el método AddRange. De este modo la lista muestra el valor de cadena predeterminado para cada objeto. Puede agregar objetos individuales con el método Add. Además de la funcionalidad de presentación y selección, el ComboBox proporciona también características que permiten agregar elementos al ComboBox y buscar texto en los elementos de la lista de forma eficaz. Los métodos BeginUpdate y EndUpdate permiten agregar un gran número de elementos al ComboBox sin que el control se tenga que volver a dibujar cada vez que se agrega un elemento a la lista. Los métodos FindString y FindStringExact permiten buscar un elemento de la lista que contenga una cadena de búsqueda concreta. Estas propiedades se pueden usar para administrar el elemento de la lista seleccionado actualmente, la propiedad Text para especificar la cadena que se muestra en el campo de edición, la propiedad SelectedIndex para obtener o establecer el elemento actual y la propiedad SelectedItem para obtener o establecer una referencia al objeto.

4.7.5 Picturebox

El control PictureBox de los formularios Windows Forms se utiliza para mostrar gráficos en formato de mapa de bits, GIF, JPEG, metarchivo, icono o PNG. La imagen que se muestra está determinada por la propiedad Image, que se puede establecer en tiempo de ejecución o en tiempo de diseño. La propiedad SizeMode controla el ajuste entre la imagen y el control.



Establezca la propiedad Image con el objeto Image que desea mostrar, ya sea en tiempo de diseño o en tiempo de ejecución. La propiedad SizeMode controla el recorte y la ubicación de la imagen en el área de presentación; los valores de esta propiedad se establecen en la enumeración PictureBoxSizeMode. Se puede cambiar el tamaño del área de presentación en tiempo de ejecución con la propiedad ClientSize. El control PictureBox se muestra de forma predeterminada sin bordes. Para proporcionar un borde estándar o tridimensional, utilice la propiedad BorderStyle con el fin de distinguir el cuadro de imagen del resto del formulario, incluso si no contiene ninguna imagen. Modos de recorte y ubicación (Propiedad SizeMode, Enumeración PictureBoxSizeMode)

Nombre de miembro

Descripción

AutoSize El tamaño de PictureBox debeajustarse igual que el tamaño de laimagen que contiene.

CenterImage La imagen se muestra en el centro siPictureBox es más grande que laimagen. Si la imagen es más grandeque PictureBox, la imagen se colocaen el centro de PictureBox y se recortan los bordes exteriores.

Normal La imagen se coloca en la esquinasuperior izquierda de PictureBox. Laimagen se recorta si es más grandeque el objeto PictureBox que la contiene.

StretchImage La imagen situada dentro dePictureBox se estira o encoge paraajustarse al tamaño de PictureBox.

4.7.6 Timer

El componente Timer de formularios Windows Forms produce un evento a intervalos regulares. Este componente está diseñado para un entorno de formularios Windows. La longitud de los intervalos está definida por la propiedad Interval, cuyo valor se expresa en milisegundos. Cuando el componente está habilitado, el evento Tick se produce a cada intervalo. Aquí es donde se agrega el código que se va a ejecutar. Los métodos más importantes del componente Timer son

Start y Stop, que activan y desactivan el temporizador. Cuando el temporizador está desactivado, se reinicia; no hay modo de hacer una pausa en un componente Timer. Al aplicar este temporizador, utilice el evento Tick para realizar una operación de sondeo o para mostrar una pantalla de inicio durante un período de tiempo determinado. Siempre que la propiedad Enabled se establece en true y la propiedad Interval es mayor que cero, el evento Tick se provoca en los intervalos especificados en la propiedad Interval.

4.7.7 TabControl

El control TabControl de formularios Windows Forms muestra múltiples fichas, similares a los divisores de un cuaderno o a las etiquetas de las carpetas de un archivador. Las fichas pueden contener imágenes y otros controles. Puede utilizar el control de fichas para crear cuadros de diálogo con varias páginas como los que suelen aparecer en el sistema operativo Windows, por ejemplo, en el control Pantalla del panel de control. La propiedad más importante de TabControl es TabPages, que contiene las fichas individuales. Cada ficha individual es un objeto TabPage. Cuando se hace clic en una ficha, se produce el evento Click correspondiente al objeto TabPage.

4.7.8 TrackBar

El control TrackBar de formularios Windows Forms (también denominado en ocasiones control "deslizante") se utiliza para desplazarse por grandes volúmenes de información o para ajustar visualmente una configuración numérica. El control TrackBar tiene dos partes: el control de posición, también conocido como control deslizante, y las marcas de paso. El control de posición es la parte que puede ajustarse. Su posición corresponde a la propiedad Value. Las marcas de paso son indicadores visuales espaciados a intervalos regulares. La barra de seguimiento se desplaza en los incrementos que se especifiquen y puede alinearse horizontal o verticalmente. Por ejemplo, se puede usar la barra de seguimiento para controlar la velocidad de intermitencia del cursor o la velocidad del mouse (ratón) en un sistema.



Las propiedades principales del control TrackBar son Value, TickFrequency, Minimum y Maximum. TickFrequency es el espaciado de las marcas de paso. Minimum y Maximum son los valores mínimo y máximo que se pueden representar en la barra de seguimiento. Otras dos propiedades importantes son SmallChange y LargeChange. El valor de la propiedad SmallChange es el número de posiciones que se desplaza el control de posición en respuesta a la acción de presionar la tecla FLECHA DERECHA o FLECHA IZQUIERDA. El valor de la propiedad LargeChange es el número de posiciones que se desplaza el control de posición en respuesta a la acción de presionar la tecla RE PÁG o AV PÁG, o en respuesta a la acción de hacer clic con el mouse en la barra de seguimiento a ambos lados del control de posición. TrackBar es un control desplazable similar al control ScrollBar. Para configurar los intervalos entre los que se desplaza el valor de la propiedad Value de una barra de seguimiento, establezca la propiedad Minimum para especificar el extremo inferior del intervalo y la propiedad Maximum para especificar el extremo superior del intervalo. La propiedad LargeChange define el incremento que se debe sumar o restar de la propiedad Value al hacer clic en uno de los lados del control deslizante. La barra de seguimiento se puede mostrar horizontal o verticalmente. Este control se puede utilizar para entrar los datos numéricos obtenidos mediante la propiedad Value. Estos datos numéricos se pueden mostrar en un control o se pueden utilizar en el código.

4.7.9 ProgressBar

El control ProgressBar de formularios Windows Forms indica el progreso de un proceso, mediante la presentació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 largo como, por ejemplo, la carga de un archivo grande. Las propiedades más importantes del control ProgressBar son Value, Minimum y Maximum. Las propiedades Minimum y Maximum establecen los valores máximo y mínimo que puede mostrar la barra de progreso. La propiedad Value representa el

progreso realizado para completar la operación. Puesto que la barra mostrada en el control se compone de bloques, el valor que muestra el control ProgressBar sólo se aproxima al valor actual de la propiedad Value. En función del tamaño del control ProgressBar, la propiedad Value determina cuándo se muestra el siguiente bloque. El modo más común de actualizar el valor de progreso actual es escribir código para definir la propiedad Value. En el ejemplo de la carga de un archivo grande, podría establecer el máximo en el tamaño del archivo en kilobytes. Por ejemplo, si se establece la propiedad Maximum en 100, la propiedad Minimum en 10 y la propiedad Value en 50, se mostrarán 5 rectángulos, que es la mitad de los que se pueden mostrar. Sin embargo, hay otros modos de modificar el valor que muestra el control ProgressBar, aparte de definir la propiedad Value directamente. La propiedad Step se puede utilizar para especificar un valor con el que incrementar la propiedad Value. Así, al llamar al método PerformStep, se incrementará el valor. Para variar el valor de incremento, puede utilizar el método Increment y especificar un valor con el que incrementar la propiedad Value. Otro control que informa gráficamente al usuario acerca de una acción actual es el control StatusBar.

4.7.10 ListView

El control ListView de formularios Windows Forms muestra una lista de elementos con iconos. Puede utilizar una vista de lista para crear una interfaz de usuario similar al panel derecho del Explorador de Windows. El control tiene cuatro modos de vista: LargeIcon, SmallIcon, List y Details. El modo LargeIcon muestra iconos grandes junto al texto de los elementos; si el control es lo suficientemente grande, los elementos aparecen en varias columnas. El modo SmallIcon es igual, pero muestra iconos pequeños. El modo List muestra iconos pequeños, pero siempre en una sola columna. El modo Details muestra los elementos en varias columnas. El modo de vista está determinado por la propiedad View. Todos los modos de vista pueden mostrar imágenes procedentes de listas de imágenes. La propiedad clave del control ListView es Items, que contiene los elementos que muestra el control. La propiedad SelectedItems contiene la colección de elementos seleccionados actualmente en el control. Si la propiedad MultiSelect se establece en true, el



usuario puede seleccionar varios elementos, por ejemplo, para arrastrar y colocar en otro control varios elementos a la vez. Si la propiedad CheckBoxes se establece en true, el control ListView puede mostrar casillas de verificación junto a los elementos. La propiedad Activation determina el tipo de acción que debe realizar el usuario para activar los elementos de la lista: las opciones son Standard, OneClick y TwoClick. La activación OneClick necesita un solo clic para activar el elemento. La activación TwoClick requiere que el usuario haga doble clic para activar el elemento; un solo clic cambia el color del texto del elemento. La activación Standard requiere que el usuario haga doble clic para activar un elemento, pero la apariencia del elemento no cambia. Un control ListView permite mostrar una lista de elementos con texto y, de forma opcional, con un icono que identifique el tipo de elemento. Por ejemplo, la lista de archivos del Explorador de Windows es similar en apariencia a un control ListView. Muestra una lista de los archivos y carpetas seleccionados actualmente en el árbol. Cada archivo y cada carpeta muestra un icono asociado para ayudar a identificar el tipo de archivo o carpeta. La clase ListViewItem representa un elemento dentro de un control ListView. Los elementos que se muestran en la lista se pueden presentar en una de cuatro vistas distintas. Se pueden mostrar como iconos grandes, como iconos pequeños o como iconos pequeños en una lista vertical. Los elementos también pueden tener subelementos que contengan información relacionada con el elemento primario. El cuarto estilo de vista (vista de detalles) permite mostrar el elemento y sus subelementos en una cuadrícula con encabezados de columna que identifican la información mostrada de cada subelemento. ListView admite la selección única o múltiple. La función de selección múltiple permite a los usuarios hacer su selección en una lista de elementos de forma similar a un control ListBox. Además, el usuario puede activar elementos seleccionados para realizar una tarea. Por ejemplo, se puede utilizar un control ListView para mostrar una lista de archivos que la aplicación puede abrir y utilizar. El usuario puede seleccionar los archivos que desea abrir y, a continuación, hacer doble clic en ellos para activar los elementos y abrir los archivos en la aplicación. El ListView también puede mostrar casillas de verificación, mediante la propiedad CheckBoxes, para permitir al usuario activar los elementos sobre los que desea realizar una acción. El control ListView se puede utilizar de diversas formas. Por ejemplo, para mostrar información de una aplicación, una base de datos o un archivo de texto. El ListView también se puede utilizar para obtener

información suministrada por el usuario, como la selección de un conjunto de archivos para su procesamiento. ListView ofrece un gran número de propiedades que proporcionan flexibilidad a la apariencia y al comportamiento. La propiedad View permite cambiar la forma en la que se muestran los elementos. Las propiedades LargeImageList, SmallImageList y StateImageList permiten especificar los objetos ImageList que contienen las imágenes que se muestran para los elementos y, en el caso del StateImageList, las casillas de verificación que se muestran cuando la propiedad CheckBoxes está establecida en true. Para determinar los elementos activados, puede utilizar la propiedad CheckedItems para obtener acceso a la colección ListView.CheckedListViewItemCollection. La propiedad Columns permite obtener acceso al ListView.ColumnHeaderCollection, el cual almacena los encabezados de columna que se muestran cuando la propiedad View del control está establecida en View.Details. Los elementos se agregan y se quitan del ListView mediante la propiedad Items. La propiedad Items permite obtener acceso al ListView.ListViewItemCollection del control, el cual proporciona métodos para manipular los elementos del control. Si desea permitir al usuario editar el texto de un elemento, puede utilizar la propiedad LabelEdit. Cuando el control contiene un gran número de elementos, a veces es más sencillo para el usuario verlos de forma ordenada. Se puede utilizar la propiedad Sorting para ordenar los elementos alfabéticamente. Muchas de las propiedades del control ListView se utilizan cuando la propiedad View está establecida en View.Details. La propiedad AllowColumnReorder permite al usuario del control ListView volver a configurar el orden de las columnas en tiempo de ejecución. La propiedad FullRowSelect permite seleccionar un elemento y sus subelementos en lugar de sólo el elemento. Para mostrar líneas de cuadrícula en la vista de detalles que identifiquen los límites de los elementos y subelementos en el ListView, se puede utilizar la propiedad GridLines. La propiedad HeaderStyle permite especificar el tipo de encabezado de columna que se va a mostrar. Además de las distintas propiedades disponibles para un control ListView, existen métodos y eventos que la aplicación puede utilizar para proporcionar funciones adicionales al ListView. Los métodos BeginUpdate y EndUpdate permiten agregar varios elementos a un ListView sin tener que volver a dibujar el control cada vez que se agrega un elemento, lo que mejora el rendimiento. Si el control ListView muestra



elementos y subelementos, es posible que desee proporcionar alguna funcionalidad cuando el usuario haga clic con el botón secundario del mouse (ratón) en un subelemento. Para determinar el elemento en cuyo subelemento se está haciendo clic, se puede utilizar el método GetItemAt. Al realizar la validación de los elementos después de que el usuario los haya editado, es posible que desee mostrar un elemento específico al usuario para que lo cambie. Se puede llamar al método EnsureVisible para garantizar que el elemento específico se encuentre en el área visible del control. Si la propiedad LabelEdit está establecida en true, se pueden realizar tareas como la validación del texto editado antes y después de cambiarlo mediante la creación de un controlador de eventos para los eventos BeforeLabelEdit y AfterLabelEdit. Para realizar tareas como la apertura de un archivo o la presentación de un cuadro de diálogo para editar un elemento mostrado en un ListView, puede crear un controlador de eventos para el evento ItemActivate. Si permite al usuario ordenar los elementos de un ListView al hacer clic en un encabezado de columna, puede crear un controlador de eventos para el evento ColumnClick que realice la ordenación. Cuando la propiedad CheckBoxes está establecida en true, puede determinar cuándo se ha producido un cambio en el estado de activación de un elemento mediante el control del evento ItemCheck.

4.7.11 TreeView

El control TreeView de formularios Windows Forms muestra una jerarquía de nodos similar al modo en que se muestran los archivos y las carpetas en el panel izquierdo del Explorador de Windows. Cada nodo puede contener otros nodos, que se denominan nodos secundarios. Los nodos primarios, nodos que contienen nodos secundarios, pueden mostrarse expandidos o contraídos. Si la propiedad CheckBoxes se establece en true, las vistas de árbol pueden mostrar casillas de verificación junto a los nodos. Entonces, es posible activar o desactivar nodos mediante programación estableciendo la propiedad Checked del nodo en true o false. Las propiedades clave del control TreeView son Nodes y SelectedNode. La propiedad Nodes contiene la lista de los nodos de nivel superior en la vista de árbol. La propiedad SelectedNode establece el nodo actualmente seleccionado. Es posible mostrar iconos junto a los nodos; las imágenes se toman del control ImageList establecido en la propiedad ImageList de la vista de árbol. La propiedad ImageIndex establece

la imagen predeterminada para los nodos de la vista de árbol. La colección Nodes contiene todos los objetos TreeNode asignados al control TreeView. A los nodos de árbol de esta colección se les conoce como los nodos de árbol raíz. Cualquier nodo de árbol que se agregue posteriormente a un nodo de árbol raíz se conoce como nodo secundario. Como cada TreeNode puede contener una colección de otros objetos TreeNode, puede ser difícil determinar la ubicación en la estructura de árbol cuando se recorre la colección en iteración. Se puede analizar la cadena TreeNode.FullPath usando el valor de la cadena PathSeparator para determinar dónde empieza y termina una etiqueta TreeNode. Al lado de los nodos de árbol se pueden mostrar imágenes asignando un objeto ImageList a la propiedad ImageList y haciendo referencia al valor de índice de una Image de la ImageList para asignar Image. Establezca la propiedad ImageIndex en el valor de índice de la Image que desea que se muestre cuando no esté seleccionado un nodo de árbol. De igual manera, establezca la propiedad SelectedImageIndex en el valor de índice de la Image que desea que se muestre cuando esté seleccionado un nodo de árbol. Las imágenes a las que hacen referencia los valores de las propiedades ImageIndex y SelectedImageIndex son las imágenes predeterminadas que muestran todos los nodos de árbol asignados a la colección Nodes. Cada nodo de árbol puede reemplazar las imágenes predeterminadas estableciendo las propiedades TreeNode.ImageIndex y TreeNode.SelectedImageIndex. Los nodos de árbol se pueden expandir para mostrar el siguiente nivel de nodos de árbol secundarios. El usuario puede expandir el TreeNode haciendo clic en el botón con el signo más (+), si se muestra al lado del TreeNode, o se puede expandir el TreeNode llamando al método TreeNode.Expand. Para expandir todos los niveles de nodos de árbol secundarios de la colección Nodes, llame al método ExpandAll. El nivel secundario del TreeNode se puede contraer llamando al método TreeNode.Collapse, o el usuario puede presionar el botón con el signo menos (-) si se muestra al lado del TreeNode. También se puede llamar al método TreeNode.Toggle para alternar los estados de árbol expandido y contraído. Si se desea, los nodos de árbol pueden mostrar casillas de verificación. Para mostrar casillas de verificación, establezca la propiedad CheckBoxes de la TreeView en true. La propiedad Checked se establece en true para nodos de árbol en estado activado. Nota Si la propiedad TreeNode.Checked se establece desde el evento BeforeCheck o AfterCheck, el evento



se provoca varias veces y puede producirse un comportamiento imprevisto. Por ejemplo, la propiedad Checked puede establecerse en el controlador de eventos cuando los nodos secundarios se están actualizando de forma recursiva, de forma que el usuario no tenga que expandir y comprobar cada uno de los nodos uno por uno. Para evitar que el evento se provoque varias veces, hay que agregar lógica al controlador de eventos para que sólo ejecute el código recursivo si la propiedad Action de TreeViewEventArgs no está establecida en TreeViewAction.Unknown. La apariencia del control TreeView se puede cambiar estableciendo algunas de sus propiedades de presentación y estilo. Si se establece ShowPlusMinus en true, se muestra un botón con el signo más (+) o con el signo menos (-) al lado de cada objeto TreeNode que se puede expandir o contraer, según corresponda. Si se establece la propiedad ShowRootLines en true, la TreeView muestra líneas que unen entre sí todos los nodos de árbol raíz. Se pueden mostrar líneas que unan los nodos de árbol secundarios con su correspondiente nodo raíz estableciendo la propiedad ShowLines en true. Si se establece la propiedad HotTracking en true, cambia la apariencia de las etiquetas de nodo de árbol cuando el puntero del mouse pasa sobre ellas. Cuando se hace un seguimiento completo de las etiquetas de los nodos de árbol, dichas etiquetas tienen el aspecto de un hipervínculo. Nota Si se establecen las propiedades CheckBoxes, Scrollable, ImageIndex y SelectedImageIndex en tiempo de ejecución, se vuelve a crear el identificador TreeView para que se actualice la apariencia del control. Esto hace que se contraigan todos los nodos de árbol, con excepción del TreeNode seleccionado.

4.7.12 DateTimePicker

El control DateTimePicker de formularios Windows Forms permite al usuario seleccionar un solo elemento de una lista de fechas y horas. Cuando se usa para representar una fecha, aparece en dos partes: una lista desplegable con una fecha representada como texto y una cuadrícula, que aparece al hacer clic en la flecha hacia abajo que se encuentra junto a la lista. La cuadrícula es similar al control MonthCalendar, que puede utilizarse para seleccionar múltiples fechas. Una alternativa a la cuadrícula, útil para la edición de horas en lugar de fechas, son los botones arriba y abajo que aparecen cuando la propiedad ShowUpDown se establece en true.

Cuando la propiedad ShowCheckBox se establece en true, junto a la fecha seleccionada en el control se muestra una casilla de verificación. Si la casilla de verificación está activada, el valor de fecha y hora seleccionado se puede actualizar. Cuando la casilla de verificación está sin marcar, el valor no está disponible. Las propiedades MaxDate y MinDate del control determinan el intervalo de fechas y horas. La propiedad Value contiene la fecha y hora actualmente establecidas en el control. Los valores pueden mostrarse en cuatro formatos, establecidos por la propiedad Format: Long, Short, Time o Custom. Si se selecciona un formato personalizado, deberá establecer la cadena adecuada en la propiedad CustomFormat. El control DateTimePicker se utiliza para permitir al usuario seleccionar una fecha y una hora, y para mostrar esa fecha y esa hora en el formato especificado. Es posible limitar las fechas y las horas que se pueden seleccionar al establecer las propiedades MinDate y MaxDate. Para cambiar la presentación de la parte del control que corresponde al calendario, establezca las propiedades CalendarForeColor, CalendarFont, CalendarTitleBackColor, CalendarTitleForeColor, CalendarTrailingForeColor y CalendarMonthBackground. La propiedad Format establece la clase DateTimePickerFormat del control. La propiedad Format predeterminada de la fecha es DateTimePickerFormat.Long. Si la propiedad Format se establece en DateTimePickerFormat.Custom, se puede crear un estilo de formato propio mediante el establecimiento de la propiedad CustomFormat y la construcción de una cadena de formato personalizado. La cadena de formato personalizado puede ser una combinación de caracteres de campos personalizados y de otros caracteres literales. Por ejemplo, se puede presentar la fecha como "June 01, 2001 - Friday" al establecer la propiedad CustomFormat en "MMMM dd, yyyy - dddd". Si desea utilizar un control de estilo de flechas para ajustar el valor de fecha y hora, establezca la propiedad ShowUpDown en true. El control de calendario no se desplegará cuando se seleccione el control. Para ajustar la fecha y la hora, se puede seleccionar cada elemento por separado y utilizar los botones Arriba y Abajo para cambiar el valor. Si se necesita aplicar un formato de fecha personalizado y limitar la selección a una sola fecha, se puede utilizar un control DateTimePicker en lugar de MonthCalendar. Al utilizar DateTimePicker, se



limitará la necesidad de validar muchos datos de valores de fecha y hora. Nota El control DateTimePicker sólo admite calendarios gregorianos.

4.7.13 MonthCalendar

El control MonthCalendar de formularios Windows Forms 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 los días numerados del mes, organizados en columnas bajo los días de la semana, con el intervalo de fechas seleccionadas resaltado. Para seleccionar un mes diferente, puede hacer clic en los botones de flecha a los lados del título del mes. A diferencia del control DateTimePicker, de apariencia similar, con este control es posible seleccionar más de una fecha. La apariencia del control MonthCalendar es altamente configurable. De forma predeterminada, la fecha de hoy se muestra con un círculo y se indica también en la parte inferior de la cuadrícula. Para cambiar esta función, puede establecer las propiedades ShowToday y ShowTodayCircle en false. También puede agregar números de semana al calendario; para ello, establezca la propiedad ShowWeekNumbers en true. Si establece la propiedad CalendarDimensions, podrá mostrar varios meses en horizontal y en vertical. De forma predeterminada, se muestra el domingo como primer día de la semana; sin embargo, es posible designar cualquier día mediante la propiedad FirstDayOfWeek. También puede establecer que ciertas fechas se muestren en negrita una sola vez, anualmente o mensualmente; para ello, agregue objetos DateTime a las propiedades BoldedDates, AnnuallyBoldedDates y MonthlyBoldedDates. La propiedad más importante del control MonthCalendar es SelectionRange, es decir, el intervalo de fechas seleccionadas en el control. El valor de SelectionRange no puede superar al número máximo de días que se puede seleccionar, establecido en la propiedad MaxSelectionCount. Las primeras y últimas fechas que puede seleccionar el usuario las determinan las propiedades MaxDate y MinDate. La apariencia de la parte del control correspondiente al calendario se puede cambiar mediante las propiedades ForeColor, Font, TitleBackColor, TitleForeColor, TrailingForeColor y BackColor.

Si se necesita aplicar un formato de fecha personalizado y limitar la selección a una sola fecha, se puede utilizar un control DateTimePicker en lugar de un MonthCalendar. El uso del DateTimePicker elimina en gran medida la necesidad de validar los valores de fecha y hora.

4.7.14 DomainUpDown

El control DomainUpDown de formularios Windows Forms se asemeja a una combinación de un cuadro de texto y un par de botones para moverse hacia arriba o hacia abajo por una lista. El control muestra y establece una cadena de texto a partir de una lista de opciones. Para seleccionar la cadena, el usuario puede hacer clic en los botones hacia arriba y hacia abajo para desplazarse por una lista, puede presionar las teclas de FLECHA ARRIBA y FLECHA ABAJO o escribir una cadena que coincida con un elemento de la lista. Un posible uso para este control es la selección de elementos de una lista de nombres ordenados alfabéticamente. (Para ordenar la lista, establezca la propiedad Sorted en true.) La función de este control es muy similar a la del cuadro de lista o el cuadro combinado, pero ocupa muy poco espacio. Las propiedades más importantes del control son Items, ReadOnly y Wrap. La propiedad Items contiene la lista de objetos cuyos valores de texto se muestran en el control. El usuario también puede escribir texto en el control, sin embargo, si ReadOnly se establece en true, la cadena escrita debe coincidir con uno de los elementos de la colección para que pueda aceptarse. Si Wrap se establece en true, al desplazarse más allá del último elemento irá al primer elemento de la lista y viceversa. Los métodos más importantes del control son UpButton y DownButton. Este control sólo muestra cadenas de texto. Si desea un control que muestre valores numéricos, utilice el control NumericUpDown. Un control DomainUpDown muestra un único valor de cadena seleccionado de una colección Object haciendo clic en los botones Arriba o Abajo del control. Al seleccionar un elemento, el objeto se convierte a un valor de cadena para que pueda mostrarse en el control de flechas. Para crear una colección de objetos que se mostrarán en el control DomainUpDown, se pueden agregar o quitar los elementos por separado mediante los métodos Add y Remove. Se puede llamar a dichos



métodos en un controlador de eventos, como el correspondiente al evento Click de un botón. Cuando se llama a los métodos UpButton o DownButton, bien en el código o mediante el clic de los botones Arriba o Abajo, se llama a UpdateEditText para actualizar la nueva cadena. Si se establece UserEdit en true, se compara la cadena con uno de los valores de la colección antes de actualizar el texto mostrado en el control.

4.7.15 NumericUpDown

El control NumericUpDown de formularios Windows Forms 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. 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. Al presionar la tecla FLECHA ARRIBA, se mueve hacia arriba hacia el valor máximo; al presionar la tecla FLECHA ABAJO, el valor se mueve hacia el mínimo. Un ejemplo donde puede ser útil este tipo de control es el control de volumen de un reproductor de música. Los controles numéricos de flechas se utilizan en muchas aplicaciones del Panel de control de Windows. Los números que se muestran pueden tener diversos formatos, entre ellos el hexadecimal. Las propiedades más importantes del control son Value, Maximum (valor predeterminado 100), Minimum (valor predeterminado 0) e Increment (valor predeterminado 1). La propiedad Value establece el número seleccionado actualmente en el control. La propiedad Increment establece la cantidad en la que se ajusta el valor cuando el usuario hace clic en un botón arriba o abajo. Cuando el foco se desplaza fuera del control, la entrada escrita se valida frente a los valores máximo y mínimo. Los métodos más importantes del control son UpButton y DownButton. El usuario también puede escribir un valor, a menos que la propiedad ReadOnly se haya establecido en true. Para aplicar formato a la representación numérica, se puede establecer la propiedad DecimalPlaces, Hexadecimal o ThousandsSeparator. Para mostrar valores hexadecimales en el control, hay que establecer la propiedad Hexadecimal en true. Para mostrar un separador de miles en los números decimales cuando corresponda, hay que establecer la

propiedad ThousandsSeparator en true. Para especificar el número de dígitos que deben aparecer detrás del símbolo decimal, hay que establecer la propiedad DecimalPlaces en el número de posiciones decimales que se desee mostrar. Para especificar el intervalo de valores permitidos en el control, hay que establecer las propiedades Minimum y Maximum. Se establece el valor de Increment con el fin de especificar el valor que se debe aumentar o disminuir para la propiedad Value cuando el usuario hace clic en los botones de flecha Arriba o Abajo. Cuando se llama a los métodos UpButton o DownButton, ya sea en el código o al hacer clic en los botones Arriba o Abajo, el nuevo valor queda validado y el control se actualiza con el nuevo valor en el formato correspondiente. En concreto, si UserEdit está establecido en true, se llama a ParseEditText antes de validar o actualizar el valor. Después, se comprueba si el valor se encuentra entre los valores Minimum y Maximum, y se llama al método UpdateEditText.

4.7.16 RichTextBox

El control RichTextBox de formularios Windows Forms 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 desplazamiento; 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. Como sucede con el control TextBox, el texto que se muestra se establece con la propiedad Text. El control RichTextBox tiene numerosas propiedades para dar formato al texto. Para manipular archivos, los métodos LoadFile y SaveFile pueden mostrar y escribir varios formatos de archivo, entre ellos texto sin formato, texto sin formato Unicode y formato de texto enriquecido (RTF). Los posibles formatos de archivo



se enumeran en RichTextBoxStreamType (Enumeración). Puede utilizar el método Find para buscar cadenas de texto o caracteres específicos. También puede utilizar un control RichTextBox para vínculos de estilo Web; para ello, establezca la propiedad DetectUrls en true y escriba código para controlar el evento LinkClicked. Para evitar que el usuario manipule una parte o la totalidad del texto del control, puede establecer la propiedad SelectionProtected en true. Para deshacer y rehacer la mayoría de las operaciones de edición de un control RichTextBox, llame a los métodos Undo y Redo. El método CanRedo permite determinar si la última operación deshecha por el usuario puede aplicarse de nuevo al control. El control RichTextBox permite al usuario escribir y modificar texto, al tiempo que proporciona características de formato más avanzadas que el control TextBox estándar. El texto se puede asignar directamente al control o se puede cargar desde un archivo de formato de texto enriquecido (RTF) o de texto sin formato. Al texto del control se le puede asignar formato de carácter y párrafo. El control RichTextBox ofrece varias propiedades que se pueden emplear para aplicar formato a cualquier parte del texto del control. Para cambiar el formato del texto, primero se debe seleccionar. Sólo se le puede asignar formato de carácter y párrafo al texto seleccionado. Una vez configurado el formato de una sección de texto seleccionada, todo el texto que se escriba a continuación tendrá el mismo formato, hasta que se realice un cambio de configuración o se seleccione una sección diferente del documento del control. La propiedad SelectionFont permite cambiar el texto a negrita o a cursiva. Esta propiedad también se puede utilizar para cambiar el tamaño y el tipo de letra del texto. La propiedad SelectionColor permite cambiar el color del texto. Para crear listas con viñetas se puede utilizar la propiedad SelectionBullet. Para ajustar el formato de párrafo, también es posible establecer las propiedades SelectionIndent, SelectionRightIndent y SelectionHangingIndent. El control RichTextBox tiene métodos que proporcionan funciones para abrir y guardar archivos. El método LoadFile permite cargar un archivo de texto RTF o ASCII existente en el control. También es posible cargar datos desde una secuencia de datos ya abierta. El método SaveFile permite guardar un archivo en formato RTF o ASCII. De manera similar al método LoadFile, se puede utilizar el método SaveFile para guardar en una secuencia de datos abierta. El control RichTextBox también proporciona funciones para buscar cadenas de texto. El método

Find se sobrecarga para buscar cadenas de texto y caracteres específicos en el texto del control. También se puede inicializar el control a datos de RichTextBox almacenados en la memoria. Por ejemplo, se puede inicializar la propiedad Rtf a una cadena que contiene el texto que se va a mostrar, incluyendo los códigos RTF que determinan cómo se debe dar formato al texto. Si el texto del control contiene vínculos, por ejemplo, a sitios Web, se puede utilizar la propiedad DetectUrls para que los vínculos se muestren correctamente en el texto del control. A continuación, se puede controlar el evento LinkClicked para realizar las tareas asociadas a los vínculos. La propiedad SelectionProtected permite proteger el texto del control de manera que el usuario no lo pueda manipular. Al proteger el texto del control, se puede controlar el evento Protected para determinar en qué momento el usuario ha intentado modificar el texto protegido y advertirle de que está protegido o indicarle una forma estándar para manipularlo. Las aplicaciones que ya utilizan controles TextBox se pueden adaptar fácilmente para que utilicen controles RichTextBox. No obstante, el control RichTextBox no tiene el mismo límite de capacidad de caracteres de 64 K que el control TextBox. Normalmente, se utiliza RichTextBox para proporcionar funciones de manipulación y presentación de texto similares a las de aplicaciones de procesamiento de texto como Microsoft Word.

4.7.17 ImageList

El componente ImageList de formularios Windows Forms se utiliza para almacenar imágenes que, a partir de ese momento, podrán mostrar otros. Una lista de imágenes permite escribir código para un catálogo de imágenes único y consistente. Por ejemplo, para girar las imágenes que muestra un control Button, simplemente cambie la propiedad ImageIndex del botón. También puede asociar la misma lista de imágenes con varios controles. Por ejemplo, si utiliza un control ListView y un control TreeView para mostrar la misma lista de archivos, al cambiar el icono de un archivo en la lista de imágenes, el nuevo icono aparecerá en ambas vistas. Puede utilizar una lista de imágenes con cualquier control que tenga una propiedad ImageList o, en el caso del control ListView, las propiedades SmallImageList y LargeImageList. Entre los controles que pueden asociarse con una lista de



imágenes se incluyen los siguientes: ListView, TreeView, ToolBar, TabControl, Button, CheckBox, RadioButton y Label. Para asociar la lista de imágenes con un control, establezca la propiedad ImageList del control como el nombre del componente ImageList. La propiedad clave del componente ImageList es Images, que contiene las imágenes que utilizará el control asociado. Puede tener acceso a cada una de las imágenes mediante su valor de índice. La propiedad ColorDepth determina el número de colores con los que se pueden representar las imágenes. Todas las imágenes se muestran con el mismo tamaño, establecido por la propiedad ImageSize. Las imágenes de mayor tamaño se ajustan a este tamaño. Normalmente, la clase ImageList la utilizan otros controles, como ListView, TreeView o ToolBar. Se pueden agregar mapas de bits, iconos o metarchivos a ImageList y los demás controles podrán utilizar las imágenes que necesiten. ImageList utiliza un identificador para administrar la lista de imágenes. Handle no se crea hasta que se realizan determinadas operaciones en la lista de imágenes, como por ejemplo, obtener las propiedades Count o Handle, y llamar al método Draw.

4.7.18 HelpProvider

El componente HelpProvider de los formularios Windows Forms se utiliza para asociar un archivo de Ayuda HTML Help 1.x (ya sea un archivo .chm, producido con HTML Help Workshop o un archivo .htm) a una aplicación para Windows. Puede proporcionar ayuda de varias maneras:

• Proporcionar ayuda contextual para controles de formularios Windows Forms.

• Proporcionar ayuda contextual sobre un cuadro de diálogo en particular o sobre controles específicos de un cuadro de diálogo.

• Abrir un archivo de Ayuda en áreas específicas, como la página principal de una Tabla de contenido, el Índice o una función de búsqueda.

Agregar un componente HelpProvider al formulario Windows Forms permite al resto de los controles del formulario exponer las propiedades Help del componente HelpProvider, Esto posibilita proporcionar ayuda sobre los controles del formulario Windows Forms. Puede asociar un archivo de Ayuda

con el componente HelpProvider por medio de la propiedad HelpNamespace. Para especificar el tipo de Ayuda que se proporciona, llame a SetHelpNavigator y proporcione al control especificado un valor de la enumeración HelpNavigator. Para proporcionar la palabra clave o el tema de Ayuda, llame al método SetHelpKeyword. Opcionalmente, puede utilizar el método SetHelpString para asociar una cadena de Ayuda específica a otro control. Cuando el usuario presione la tecla F1 mientras el control tiene el foco, la cadena asociada por medio de este método se mostrará en una ventana emergente. Si no estableció HelpNamespace, deberá utilizar SetHelpString para proporcionar el texto de Ayuda. Si estableció tanto HelpNamespace como la cadena de Ayuda, tendrá precedencia la Ayuda basada en HelpNamespace. Cuando se agrega a un formulario, el componente HelpProvider aparece en la bandeja de components en la parte inferior del Diseñador de Windows Forms. HelpProvider llama a los métodos de Help para proporcionar la funcionalidad de Ayuda.

4.7.19 ToolTip

El componente ToolTip de formularios Windows Forms muestra texto cuando el usuario apunta con el cursor sobre algún control. Un componente ToolTip puede asociarse a cualquier control. Por ejemplo, este componente se puede utilizar para ahorrar espacio en un formulario, puede mostrar un pequeño icono en un botón y utilizar un control ToolTip para explicar la función del botón. Un componente ToolTip proporciona una propiedad ToolTip a múltiples controles de un formulario Windows Forms u otro contenedor. Normalmente, la clase ToolTip se utiliza para notificar a los usuarios el uso al que está destinado un control. Por ejemplo, si coloca un componente ToolTip en un formulario, puede mostrar "Escriba aquí su nombre" e indicar el formato para un control TextBox y "Haga clic aquí para guardar los cambios" para un control Button. Los métodos principales del componente ToolTip son SetToolTip y GetToolTip. Puede utilizar el método SetToolTip para establecer las informaciones sobre herramientas que se muestran para los controles. Las propiedades más importantes son Active, que debe establecerse en true para que aparezca la información sobre herramientas, y AutomaticDelay, que establece el periodo de tiempo durante el que se muestra la



información, cuánto tiempo debe apuntar el usuario al control para que aparezca la información y cuánto tarda en aparecer la ventana de información siguiente. Además de para proporcionar ayuda, la clase ToolTip se puede utilizar para proporcionar información de estado en tiempo de ejecución. Por ejemplo, se podría utilizar la clase ToolTip para mostrar datos sobre la velocidad de conexión y la calidad de la línea cuando el usuario desplace el cursor del mouse sobre un control PictureBox que muestra el estado de la conexión a Internet. La clase ToolTip dispone de propiedades que permiten modificar la velocidad y la duración de la presentación de la ventana de información sobre herramientas. AutoPopDelay determina durante cuánto tiempo se muestra la ventana de información sobre herramientas; las propiedades InitialDelay y ReshowDelay determinan el retraso antes de que se muestre una ventana de información sobre herramientas. Para establecer todas estas propiedades de manera coherente, utilice la propiedad AutomaticDelay. Este valor se utiliza para calcular y establecer los valores de las demás propiedades de retraso. Para que se muestre el texto de información sobre herramientas de un control, independientemente de si Form o el contenedor donde se encuentra el control están habilitados, utilice la propiedad ShowAlways. Si desea que no se muestre ningún texto de información sobre herramientas en la aplicación, utilice la propiedad Active. La clase ToolTip se puede utilizar en cualquier contenedor. Para especificar el contenedor específico donde se utilizará la clase ToolTip, utilice el constructor ToolTip. Para que el texto de información sobre herramientas se muestre siempre que el usuario mueva el cursor del mouse sobre un control, el texto de información sobre herramientas se debe asociar al control en una instancia de la clase ToolTip. Para asociar un texto de información sobre herramientas a un control, utilice el método SetToolTip. Para cambiar el texto al que está asociado el control, el método SetToolTip se puede llamar más de una vez para el mismo control. Si desea obtener el texto al que está asociado un control, utilice el método GetToolTip. Para quitar todos los textos de información sobre herramientas asociados a una instancia de la clase ToolTip, utilice el método RemoveAll. Nota La información sobre herramientas no se muestra para los controles que están deshabilitados.

4.7.20 StatusBar

El control StatusBar de formularios Windows Forms se utiliza en los formularios como un área, que habitualmente se muestra en la parte inferior de una ventana, en la que una aplicación puede mostrar información de estado de diferentes tipos. Los controles StatusBar pueden tener paneles de barra de estado que muestren texto o iconos con información de estado o una serie de iconos animados que indiquen el funcionamiento de un proceso (como por ejemplo Microsoft Word cuando indica que se está guardando un documento). Internet Explorer utiliza una barra de estado que indica la dirección URL de una página cuando el mouse (ratón) pasa sobre el hipervínculo; Microsoft Word ofrece información sobre la ubicación de página, la ubicación de sección y los modos de edición, tales como sobrescribir y revisar cambios; por último, Visual Studio utiliza la barra de estado para ofrecer información contextual como, por ejemplo, indicaciones de cómo manipular las ventanas acoplables, ya sea acopladas o flotantes. Para mostrar un único mensaje en la barra de estado, establezca la propiedad ShowPanels en false (el valor predeterminado) y la propiedad Text de la barra de estado en el texto que desee que aparezca en la barra de estado. Puede dividir la barra de estado en paneles para mostrar información de varios tipos; para ello, establezca la propiedad ShowPanels en true y utilice el método Add de la clase StatusBarPanelCollection, al que se puede tener acceso a través de la propiedad Panels del control. Usando los métodos de la propiedad Panels se pueden quitar paneles del control u obtener acceso a un panel en espcífico. Normalmente, un control StatusBar está formado por objetos StatusBarPanel, cada uno de los cuales muestra texto o un icono. También puede proporcionar paneles personalizados dibujados por el usuario como una barra de progreso o una serie de imágenes que muestren el estado de la aplicación. Normalmente, un control StatusBar muestra información acerca del objeto que se está mostrando en un control Form, los componentes del objeto o información contextual relativa a la operación de ese objeto en la aplicación. El control StatusBar dispone de propiedades que permiten personalizar el aspecto del control. Si StatusBar se muestra en un formulario cuyo tamaño se puede cambiar, utilice la propiedad SizingGrip para mostrar un control de tamaño en la esquina inferior



derecha del formulario para indicar a los usuarios que el tamaño del formulario se puede cambiar. Si desea determinar cuándo se hace clic a un objeto StatusBarPanel en un control StatusBar, puede crear un controlador para el evento PanelClick. Para realizar operaciones de dibujo personalizadas en un panel, puede crear un controlador para el evento DrawItem. Los datos del evento que se envían al controlador de eventos proporciona información sobre el panel que se va a dibujar y el objeto Graphics que se utilizará para realizar las tareas de dibujo. Cuando se crea una instancia de StatusBar, se establecen las propiedades de lectura y escritura en sus valores iniciales.

4.7.21 NotifyIcon

El componente NotifyIcon de formularios Windows Forms 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 programa 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. Cada componente NotifyIcon muestra un solo icono en el área de estado. Si tiene tres procesos en segundo plano y desea que se muestre un icono para cada uno, deberá agregar tres componentes NotifyIcon al formulario. Las principales propiedades del componente NotifyIcon son Icon y Visible. La propiedad Icon establece el icono que aparece en el área de estado. Para que aparezca el icono, la propiedad Visible debe establecerse en true. Los iconos tienen asociada información sobre herramientas y menús contextuales. Los menús emergentes de un icono se definen con la propiedad ContextMenu. La propiedad Text asigna texto de información sobre herramientas. Para que el icono aparezca en el área de estado, la propiedad Visible debe establecerse en true.

4.7.22 ErrorProvider

El componente ErrorProvider de los

formularios Windows Forms se utiliza para validar los datos que proporciona el usuario en un formulario o control. Habitualmente, se utiliza junto con la validación de entrada del usuario en un formulario o

con la presentación de errores dentro de un conjunto de datos. Un proveedor de errores es una alternativa mejor que mostrar un mensaje de error en un cuadro de mensaje, porque una vez que se descarta un cuadro de mensaje, el mensaje de error deja de estar visible. El componente ErrorProvider muestra un icono de error ( ) junto al control correspondiente, por ejemplo, un cuadro de texto; cuando el usuario coloca el puntero del mouse (ratón) sobre el icono de error aparece una información sobre herramientas que muestra la cadena del mensaje de error.

Las propiedades más importantes del componente ErrorProvider son DataSource, ContainerControl e Icon. La propiedad ContainerControl debe establecerse en el contenedor adecuado (habitualmente el formulario Windows Forms), para que el componente ErrorProvider muestre un icono de error en el formulario. Cuando se agrega el componente en el diseñador, la propiedad ContainerControl se establece en el formulario contenedor; si agrega el control mediante código, deberá establecerlo usted mismo.

La propiedad Icon puede establecerse en un icono de error personalizado, en lugar del predeterminado. Cuando se establece la propiedad DataSource, el componente ErrorProvider puede mostrar mensajes de error para un conjunto de datos. El método clave del componente ErrorProvider es SetError, que especifica la cadena del mensaje de error y dónde debe aparecer el icono de error.

ErrorProvider presenta un mecanismo simple para indicar al usuario final que un control de un formulario tiene un error asociado. Si se especifica una cadena de descripción de error para el control, se muestra un icono junto a éste. El icono parpadea de la manera que especifica BlinkStyle, con la frecuencia que especifica BlinkRate. Cuando el mouse (ratón) pase por encima del icono, se mostrará la información sobre herramientas con una cadena de descripción del error.

Normalmente, ErrorProvider se utiliza con controles enlazados a datos. Si utiliza ErrorProvider con controles enlazados a datos, debe especificar la propiedad ContainerControl en el constructor o estableciendo la propiedad ContainerControl.

4.8 Creación de controles en tiempo de ejecución

Para agregar un control a un formulario mediante programación, declare e instancia una variable del tipo de control que desea insertar en el formulario dentro



del manejador del evento en que desee que se agregue el control. Establezca la propiedad Location para el control y cualesquiera otras propiedades de la variable del control, según convenga y finalmente agregue el control a la colección controles del formulario. Es importante instanciar la variable usando la palabra clave New y también establecer los valores para la propiedad Location, de otra manera se disparará un excepción en tiempo de ejecución o no se presentará el control en pantalla. Hay que tener cuidado de no establecer la ubicación del control más allá de los límites del tamaño del formulario. Por ejemplo, se podría insertar en el método que controla el evento Click del botón Button1 dentro de la clase del formulario, código similar al siguiente para agregar una referencia a la variable de control MyText, establecer el valor de Location para el control y agregar el control: ' Visual Basic Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim MyText As New TextBox() MyText.Location = New Point(25, 25) Me.Controls.Add(MyText) End Sub

4.9 Colección de controles Todo formulario de Windows tiene una propiedad Controls del tipo Control.ControlCollection que representa la colección de controles que contiene el formulario. Los controles del formulario pueden ser manipulados usando los métodos disponibles en la colección. En la tabla se muestran algunos métodos disponibles en esta colección:

Método Descripción

Add Agrega el control especificado a la colecciónde controles.

Clear Quita todos los controles de la colección.

Contains Determina si el objeto especificado es unmiembro de la colección.


IndexOf Recupera el índice del control especificado de la colección de controles.

Remove Quita el control especificado de la colección de controles.

RemoveAt Quita un control de la colección de controles en la ubicación del índice especificada.

Ejemplo En el siguiente ejemplo se quita un Control de Control.ControlCollection de la clase derivada Panel si se trata de un miembro de la colección. En el ejemplo se supone que se ha creado un control Panel, un control Button y al menos un control RadioButton en Form. Los controles RadioButton se agregan al control Panel y el control Panel se agrega a Form. Al hacer clic en el botón, el botón de opción denominado radioButton2 se quita de Control.ControlCollection. ' Remove the RadioButton control if it exists. Private Sub RemoveButton_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles RemoveButton.Click If Panel1.Controls.Contains(RadioAddRangeButton) Then Panel1.Controls.Remove(RadioAddRangeButton) End If End Sub

4.10 Clase Form Form es una representación de cualquiera de las ventanas que se muestran en una aplicación. La clase Form se puede usar para crear ventanas estándar, de herramientas, sin bordes y flotantes. También se puede utilizar la clase Form para crear ventanas modales, como cuadros de diálogo. El formulario MDI (interfaz de múltiples documentos), que es un tipo especial de formulario, puede contener otros formularios, denominados formularios MDI secundarios. Un formulario MDI se crea estableciendo la propiedad IsMdiContainer en true. Los formularios MDI secundarios se crean estableciendo la propiedad MdiParent en el formulario MDI principal que va a contener el formulario secundario. Mediante las propiedades disponibles en la clase Form, se puede definir el aspecto, el tamaño, el color y las características de administración de ventanas correspondientes a la ventana o al cuadro de diálogo que se crea. La propiedad Text permite especificar el título de la ventana en la barra de título. Las propiedades Size y DesktopLocation permiten definir el tamaño y la posición que tendrá la ventana cuando



se muestre. Se puede usar la propiedad de color ForeColor para cambiar el color de primer plano predeterminado de todos los controles que se coloquen en el formulario. Las propiedades FormBorderStyle, MinimizeBox y MaximizeBox permiten controlar si el formulario se puede minimizar, maximizar o cambiar de tamaño en tiempo de ejecución. Además de las propiedades, se pueden usar los métodos de la clase para manipular un formulario. Por ejemplo, se puede usar el método ShowDialog para mostrar un formulario como cuadro de diálogo modal. El método SetDesktopLocation se puede usar para situar el formulario en el escritorio. Los eventos de la clase Form permiten reaccionar ante las acciones llevadas a cabo en el formulario. El evento Activated se puede usar para realizar operaciones como la actualización de los datos que se muestran en los controles del formulario cuando se activa dicho formulario. Un formulario tiene como tamaño predeterminado un alto de 300 píxeles y un ancho de 300 píxeles.

4.11 Menús El componente MainMenu de formularios Windows Forms muestra un menú en tiempo de ejecución. Si se agrega este componente al Diseñador de Windows Forms, el Diseñador de menús permitirá configurar visualmente la estructura del menú principal. Todos los submenús del menú principal y los elementos individuales son objetos MenuItem. Para designar un elemento de menú como elemento predeterminado, establezca la propiedad DefaultItem en true. El elemento predeterminado aparece en negrita cuando se hace clic en el menú. El valor de la propiedad Checked del elemento de menú puede ser true o false, e indica si éste está seleccionado. La propiedad RadioCheck del elemento de menú personaliza la apariencia del elemento seleccionado: si RadioCheck se establece en true, aparecerá un botón de opción junto al elemento; si se establece en false, aparecerá una marca de verificación. El control MainMenu representa el contenedor para la estructura de menú de un formulario. Un menú está formado por objetos MenuItem que representan los comandos de menú individuales de la estructura de menú. Cada objeto MenuItem puede ser un comando de la aplicación o un menú primario para otros elementos de submenú. Para enlazar MainMenu con el objeto Form que lo mostrará, asigne MainMenu a la propiedad Menu de Form. En el caso de aplicaciones que admiten varios idiomas, se puede utilizar la propiedad RightToLeft

para mostrar el texto del menú de derecha a izquierda con el fin de admitir idiomas como el árabe, que se lee de derecha a izquierda. Se pueden crear objetos MainMenu distintos para representar diferentes estructuras de menú para el formulario. Si se desea volver a utilizar la estructura de menú contenida en un objeto MainMenu específico, se puede utilizar el método CloneMenu correspondiente para crear una copia. Una vez se disponga de una copia de la estructura de menú, se pueden realizar las modificaciones adecuadas para la nueva estructura de menú.

4.11.1 Agregar menús y elementos de menú a formularios Windows Forms

Un menú de un formulario Windows Form se crea con un objeto MainMenu, que es una colección de objetos MenuItem. Para agregar menús a los formularios Windows Forms en tiempo de diseño, agregue el componente MainMenu y, a continuación, agréguele elementos de menú mediante el Diseñador de menús. Los menús también se pueden agregar mediante programación; para ello, agregue uno o varios objetos MainMenu a un formulario Windows Form y agregue objetos MenuItem a la colección. Los procedimientos descritos en este tema muestran cómo crear un menú sencillo denominado Archivo, ya sea con el Diseñador de menús o en el código. Para agregar un menú a un formulario Windows Forms en tiempo de diseño

1. Abra el formulario al que desee agregar un menú en el Diseñador de Windows Forms.

2. En el Cuadro de herramientas, haga doble clic en el componente MainMenu.

Se agregará un menú al formulario (con el texto "Escriba aquí") y se agregará el componente MainMenu a la bandeja de componentes. Para agregar un menú a un formulario Windows Forms mediante programación

1. En el Editor de código, cree un nuevo método público que incluya el código que agrega el menú al formulario.

' Visual Basic Public Sub AddMenu() End Sub



2. Agregue, dentro del método, código similar al siguiente para crear una instancia del componente MainMenu:

' Visual Basic Dim mnuFileMenu as New MainMenu() Me.Menu = mnuFileMenu

Una vez que haya agregado un componente MainMenu al formulario Windows Forms, deberá agregarle elementos de menú. El Diseñador de menús permite agregar elementos de menú al componente de menú en tiempo de diseño. El contenido de los menús se mantiene dentro de una colección, de modo que, para agregar elementos a un menú en tiempo de ejecución, deberá agregar objetos MenuItem a esta colección. Para agregar elementos de menú a un menú en tiempo de diseño

1. Haga clic en el componente MainMenu del formulario Windows Forms.

Se mostrará el texto "Escriba aquí". 2. Haga clic en el texto que se muestra y escriba

el nombre del elemento de menú que desea agregarle.

3. Para agregar otro elemento de menú, haga clic en otra área "Escriba aquí" dentro del Diseñador de menús.

• Haga clic en el área que se encuentra a la derecha del elemento de menú actual para agregar un submenú.

O bien • Haga clic en el área que se

encuentra bajo el elemento de menú actual para agregar otra entrada al mismo menú.

Para agregar elementos de menú a un menú mediante programación

1. Si no existe ya uno, agregue un componente MainMenu al formulario Windows Forms dentro de un método público y asigne una instancia de la clase MainMenu a la propiedad Menu del formulario.

' Visual Basic Public Sub AddMenuAndItems() Dim mnuFileMenu as New MainMenu() Me.Menu = mnuFileMenu End Sub

2. Dentro del método, cree objetos MenuItem para agregarlos a la colección del objeto MainMenu:

' Visual Basic Dim myMenuItemFile as New MenuItem("&File") Dim myMenuItemNew as New MenuItem("&New")

Nota De forma predeterminada, un objeto MainMenu no contiene elementos de menú, de modo que el primer elemento de menú que se agrega se convierte en encabezado del menú. Ésta es la razón por la que la propiedad Text de myMenuItemFile se establece en &File.

3. Dentro del método, asigne el elemento de menú de nivel superior y agréguele los elementos de menú siguientes:

' Visual Basic mnuFileMenu.MenuItems.Add(myMenuItemFile) myMenuItemFile.MenuItems.Add(myMenuItemNew)

Nota Para crear submenús, puede agregar objetos MenuItem a la propiedad MenuItems del objeto MenuItem primario. En el ejemplo anterior, si deseara agregar un tercer elemento de menú (myMenuItemFolder) como submenú del segundo elemento de menú (myMenuItemNew), debería incluir las siguientes líneas de código: ' Visual Basic Dim myMenuItemFolder as New MenuItem("&Folder") myMenuItemNew.MenuItems.Add(myMenuItemFolder)

Los elementos de menú también se pueden agregar dinámicamente en el momento de crearlos, de forma que las propiedades se establecen en el momento de crearlas y agregarlas. Por ejemplo, para agregar un cuarto elemento de menú a la colección anterior, escriba el fragmento de código siguiente: ' Visual Basic mnuFileMenu.MenuItems.Add("Save &As")

4.11.2 Agregar funcionalidad a los elementos de menú

Finalmente, una vez establecida la estructura del menú, deseará proporcionar funcionalidad a los elementos del menú. A menudo, esto se consigue mediante el controlador de eventos del evento MenuItem.Click



4.12 Barras de Herramientas (Control)

El control ToolBar de formularios Windows Forms se utiliza en los formularios como una barra de controles que muestra una fila de menús desplegables y botones de mapas de bits que activan comandos. Los botones pueden aparecer como un botón estándar, un botón de alternar o un botón desplegable. Por lo tanto, hacer clic en un botón de una barra de herramientas puede ser un equivalente a elegir un comando de menú. Puede configurar los botones para que aparezcan y se comporten como botones de comando, menús desplegables o separadores. Habitualmente, una barra de herramientas contiene botones y menús que corresponden a los elementos de la estructura de menús de una aplicación y proporciona acceso rápido a las funciones y comandos de la aplicación de uso más frecuente. Un control ToolBar suele estar "acoplado" en la parte superior de su ventana primaria, pero también se puede acoplar a cualquier lado de la ventana. Una barra de herramientas puede mostrar información sobre herramientas cuando el usuario sitúa el puntero del mouse (ratón) en un botón de la barra. La información sobre herramientas es una pequeña ventana emergente que describe de forma breve el propósito del botón o del menú. Para mostrar información sobre herramientas, debe establecerse la propiedad ShowToolTips en true. Nota Algunas aplicaciones tienen controles muy similares a la barra de herramientas que tienen la capacidad de "flotar" sobre la ventana de la aplicación y se puede cambiar su posición. El control ToolBar de Windows Forms no puede realizar estas acciones. Cuando la propiedad Appearance se establece en Normal, los botones de la barra de herramientas aparecen realzados en tres dimensiones. Puede establecer la propiedad Appearance de la barra de herramientas en Flat para proporcionar a la barra de herramientas y a sus botones una apariencia plana. Cuando el puntero del mouse se mueve sobre un botón plano, la apariencia del botón cambia a tridimensional. Los botones de las barras de herramientas pueden dividirse en grupos lógicos por medio de separadores. Un separador es un botón de barra de herramientas con la propiedad Style establecida en Separator. Aparece como un espacio vacío en la barra de herramientas. Cuando la barra de herramientas tiene una apariencia plana, los separadores de botones aparecen como líneas, en lugar de como espacios entre los botones.

El control ToolBar permite crear barras de herramientas agregando objetos Button a una colección Buttons. Se puede usar el Editor de colecciones para agregar botones a un control ToolBar; cada objeto Button debe tener asignado un texto o una imagen, aunque es posible asignarle ambas cosas. La imagen la proporciona un componente ImageList asociado, indicando el valor de índice de la imagen a la propiedad ImageIndex para cada ToolBarButton. A continuación, se puede asignar texto que aparecerá debajo o a la derecha de la imagen estableciendo la propiedad Text de ToolBarButton. En tiempo de ejecución, puede agregar o quitar botones de la colección ToolBarButtonCollection mediante los métodos Add y Remove. Para programar los botones de una barra de herramientas, agregue código a los eventos ButtonClick del control ToolBar, usando la propiedad Button de la clase ToolBarButtonClickEventArgs para determinar en qué botón se hizo clic. Si no se ha establecido ButtonSize, se calcula un objeto Size dentro de la clase para establecerlo de manera predeterminada. El tamaño calculado se ajustará a la imagen más grande y al texto asignados a los controles ToolBarButton.

5 Elementos de Programación

5.1 Tipos de Datos El tipo de datos de un elemento de programación hace referencia al tipo de datos que puede contener y a cómo se almacenan éstos. Los tipos de datos se aplican a todos los valores que pueden almacenarse en la memoria del equipo o participar en la evaluación de una expresión. Cada variable, literal, constante, propiedad, argumento de procedimiento y valor devuelto por un procedimiento tiene un tipo de datos. Un tipo de datos declarado está especificado como parte de la declaración de un elemento de programación. A menos que utilice la programación sin tipos, debe declarar los tipos de datos de todos los elementos de programación. Los tipos de datos de Visual Basic .NET se pueden clasificar en función de si una variable de un tipo específico almacena sus propios datos o un puntero a los datos. Esta clasificación afecta a la forma en que se implementa un tipo de datos.



5.1.1 Tipos de valores y tipos de referencia

Un tipo de datos es un tipo de valores si almacena los datos en su propia asignación de memoria. Un tipo de referencia contiene un puntero a otra ubicación de memoria que almacena los datos. Los tipos de valores incluyen:

• Todos los tipos de datos numéricos • Boolean, Char y Date • Todas las estructuras, incluso si sus

miembros son tipos de referencia • Las enumeraciones, ya que su tipo

subyacente es siempre Byte, Short, Integer o Long

Los tipos de referencia incluyen: • String • Todas las matrices, incluso si sus elementos

son tipos de valores • Los tipos de clase, como Form • Delegados

Puede asignar indistintamente un tipo de referencia o un tipo de valores a una variable del tipo de datos Object. Una variable Object siempre contiene un puntero a los datos, nunca los propios datos. Sin embargo, si se asigna un tipo de valor a una variable Object, ésta se comporta como si contuviera sus propios datos. Puede saber si una variable Object está actuando como un tipo de referencia o como un tipo de valores si la pasa al método IsReference de la clase Information en el espacio de nombres Microsoft.VisualBasic. Microsoft.VisualBasic.Information.IsReference devuelve True si el contenido de la variable Object representa un tipo de referencia.

5.1.2 Tipos de datos como clases y estructuras

Cada tipo de datos básico de Visual Basic .NET es compatible con una estructura o una clase en el espacio de nombres System. El compilador utiliza la palabra clave de cada tipo de datos como alias para la clase o estructura subyacente. Por ejemplo, declarar una variable con la palabra reservada Byte es igual que declararla con el nombre completo de estructura System.Byte. Common Language Runtime también admite estructuras y clases que Visual Basic .NET no proporciona. Por ejemplo, las estructuras

System.UInt16, System.UInt32 y System.UInt64 ofrecen los equivalentes sin signo de Short, Integer y Long. Puede utilizar estos tipos sin signo para declarar variables y constantes, así como tener acceso a los métodos que .NET implementa en estos tipos. Sin embargo, Visual Basic .NET no admite operaciones o conversiones de tipo que impliquen a tipos que no proporciona la aplicación. En .NET Framework, una estructura es un tipo de valor y una clase es un tipo de referencia. Por este motivo, las estructuras .NET admiten tipos de valor como Char e Integer, mientras que las clases .NET admiten tipos de referencia como Object y String. Como cada tipo de referencia representa una clase .NET subyacente, es preciso utilizar la palabra clave New al inicializarlo. La instrucción siguiente inicializa una matriz: Dim Totals() As Single = New Single(8) {} También puede utilizar la palabra clave New para inicializar un tipo de valor. Esto resulta especialmente útil si el tipo tiene un constructor que toma parámetros.

5.1.2.1 Miembros de tipos de datos Puesto que están admitidos por las estructuras y clases de .NET, los tipos de datos de Visual Basic tienen miembros. Estos miembros incluyen constructores, métodos, propiedades y campos. Puede obtener acceso a los miembros (excepto los constructores) de una variable del mismo modo que a los métodos y propiedades de un objeto. En el ejemplo siguiente se utilizan las propiedades Year, Month y Day, y el método DaysInMonth de la estructura System.DateTime para determinar cuántos días restan del mes actual: Dim Current As Date ' El tipo de datos Date es soportado por System.DateTime. Dim DaysRemaining As Integer ' Días restantes de este mes. ' ... Current = Now ' Obtiene la fecha y la hora actual en Current. DaysRemaining = Date.DaysInMonth(Current.Year, Current.Month) - Current.Day Conviene señalar que se debe calificar una referencia a un miembro de tipo de datos, bien con el nombre del tipo (Date) o bien con el nombre de una variable declarada de dicho tipo (Current).

5.1.2.2 Ejemplos de miembros de tipos de datos

Los siguientes prototipos de código ilustran algunos métodos, propiedades y campos útiles con los tipos de datos: <Char>.IsDigit() ' Returns True if character is a numeric digit.



<Char>.IsLower() ' Returns True if character is a lowercase letter. <Date>.IsLeapYear() ' Returns True if current year is a leap year. <Date>.ToUniversalTime() ' Returns local date/time converted to UTC. <Double>.IsInfinity() ' Returns True if contents represent infinity. <Double>.IsNaN() ' Returns True if contents are not a number (0/0). <Long>.MaxValue ' Constant representing largest positive Int64 value. <Object>.GetType() ' Returns Type object representing type of <Object>. <Object>.GetType().GetTypeCode() ' Returns type code of <Object>. <String>.Chars(<index>) ' Character at position <index> of <String>. <String>.Length ' Number of characters currently in <String>. Todos los tipos numéricos, incluidos Byte y Char, exponen los campos públicos MaxValue y MinValue, que pueden ser muy útiles al trabajar con estos tipos.

5.1.2.3 Equivalencia de miembro de tipos de datos

.NET Framework proporciona también varios métodos para tipos de datos que podrían resultar equivalentes a funciones y palabras clave de Visual Basic. Por ejemplo, System.Decimal.ToSingle() realiza el mismo tipo de acciones que la palabra clave CSng realiza en la expresión Decimal. Sin embargo, Visual Basic no siempre utiliza los métodos de .NET Framework para realizar conversiones u otras operaciones. No está garantizado que CSng utilice System.<tipo de datos>.ToSingle(), y por consiguiente no se garantiza que los resultados sean los mismos bajo condiciones extremas o fuera de los márgenes habituales.

5.1.3 Tipos de datos numéricos 5.1.3.1 Tipos integrales Los tipos de datos integrales son aquellos que sólo representan números enteros. Los tipos de datos integrales con signo son Short (16 bits), Integer (32 bits) y Long (64 bits). Si una variable almacena siempre números enteros en lugar de números con una parte decimal, declárela como variable de uno de estos tipos.

El tipo integral sin signo es Byte (8 bits). Si una variable contiene datos binarios o datos de naturaleza desconocida, declárela como variable de este tipo. Si se necesitan más de ocho bits de datos, declare la variable como una matriz de elementos de tipo Byte. Los operadores aritméticos son más rápidos con los tipos integrales que con cualquier otro tipo de datos. Con el que más rápidos son es con el tipo de datos Integer de Visual Basic .NET. Los tipos integrales son especialmente útiles como variables de contador en bucles For ... Next. Como Byte es un tipo sin signo con un intervalo de 0-255, no puede representar un número negativo. Si utiliza el operador menos (-) unario en una expresión que produce un resultado del tipo Byte, Visual Basic convierte primero la expresión a Integer. 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 asignarle un número decimal, se redondea el número, como en el ejemplo siguiente: Dim K As Integer ' El rango válido es de -2147483648 a +2147483647. ' ... K = 2147483648 ' Provoca un error. K = CInt(5.9) ' Establece K a 6. Los datos binarios almacenados en variables Byte como matrices se conservan durante las conversiones de formato. No debería utilizar una variable String para datos binarios, ya que su contenido puede dañarse durante la conversión entre los formatos ANSI y Unicode. Esta conversión puede realizarse de forma automática cuando Visual Basic lee datos de archivos o escribe en ellos, o cuando llama a archivos DLL, métodos y propiedades. Para tipos integrales, los caracteres de tipo literal son S para Short, I para Integer y L para Long. No existe un carácter de tipo literal para Byte.

5.1.3.2 Tipos no integrales Los tipos de datos no integrales son aquellos que representan números que contienen tanto partes enteras como decimales. Los tipos de datos numéricos no integrales son Decimal (punto fijo de 128 bits), Single (punto flotante de 32 bits) y Double (punto flotante de 64 bits). Todos ellos son tipos con signo. Si una variable puede contener una valor decimal, declárela como variable de uno de estos tipos. El tipo de datos Decimal admite como máximo 29 dígitos significativos y puede representar de 7,9228 x 1028. Es especialmente adecuado para cálculos, como los financieros, que necesitan un gran número de dígitos pero no pueden tolerar errores de redondeo.



Para asignar una valor de gran tamaño a una variable o constante Decimal, debe agregar el carácter de tipo literal a un literal numérico si es demasiado largo para el tipo de datos Long, tal y como se puede ver en el ejemplo siguiente: Dim DecVar As Decimal DecVar = 9223372036854775808 ' Overflow; too big for Long data type. DecVar = 9223372036854775808D ' No overflow; Decimal data type. Los números con punto flotante (Single y Double) tienen intervalos mayores que los números Decimal pero pueden estar sujetos a errores de redondeo. Los tipos de punto flotante admiten menos dígitos significativos que Decimal pero pueden representar valores de mayor magnitud. Los valores de punto flotante se pueden expresar como mmmEeee, donde mmm es la mantisa (los dígitos significativos) y eee es el exponente (una potencia de 10). El valor positivo más elevado de un tipo de datos Single es 3,4028235E+38, y el valor positivo más elevado de un tipo de datos Double es 1,79769313486231570E+308. Para tipos no integrales, los caracteres de tipo literal son D para Decimal, F para Single y R para Double.

5.1.4 Tipos de datos de caracteres Visual Basic proporciona tipos de datos de caracteres para trabajar con caracteres que se pueden mostrar e imprimir. Aunque ambos tipos utilizan caracteres Unicode, Char contiene un único carácter, mientras que String contiene cualquier número de caracteres.

5.1.4.1 Tipo Char El tipo de datos Char es un único carácter Unicode de dos bytes (16 bits). 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. Se pueden realizar conversiones de tipos con funciones como AscW y ChrW. Si el modificador de comprobación de tipos (Option Strict) está activado, se debe agregar el carácter de tipo literal a un literal de cadena con un sólo carácter para identificarlo como el tipo de datos Char, como se muestra en el siguiente ejemplo: Option Strict On ' ... Dim CharVar As Char

CharVar = "@" ' Cannot convert String to Char with Option Strict On. CharVar = "@"C ' Successfully assigns single character to CharVar. Recuerde que el tipo Char no tiene signo. El carácter de tipo literal para Char es C.

5.1.4.2 Tipo String El tipo de datos String es una secuencia de cero o más caracteres Unicode de dos bytes (16 bits). Si una variable siempre contiene una cadena de caracteres y nunca contiene un valor numérico, declárela para que sea del tipo String, como en el ejemplo siguiente: Private S As String

A continuación puede asignar cadenas a esta variable y manipularla mediante el uso de funciones de cadena, como en el ejemplo siguiente: S = "Database" S = Microsoft.VisualBasic.Left(S, 4) ' Establece S a "Data".

El tipo de datos String contiene caracteres Unicode, cada uno de los cuales tiene un valor entre 0 y 65.535. Una variable o argumento String es siempre una cadena de longitud variable, que crece o se reduce al asignarle nuevos datos. Algunas veces las cadenas se completan con espacios iniciales o finales. Las funciones Trim, LTrim y RTrim eliminan estos espacios. Quizás encuentre útiles estas funciones cuando trabaje con cadenas. No existe ningún carácter de tipo literal para String. Sin embargo, el compilador trata los literales encerrados entre comillas dobles (" ") como String.

5.1.5 Tipos de datos varios Visual Basic proporciona varios tipos de datos que no están orientados a números o caracteres. En lugar de ello, tratan con datos especializados como valores de tipo sí/no o fecha y hora.

5.1.5.1 Boolean (Tipo) El tipo de datos Boolean es un valor sin signo que se interpreta como True o False (verdadero o falso). Si una variable sólo puede contener información de tipo verdadero/falso, sí/no o activado/desactivado, declárela como de tipo Boolean. El valor predeterminado de Boolean es False. En el ejemplo siguiente, RunningVB es una variable Boolean que almacena un único parámetro de tipo sí/no. Dim RunningVB As Boolean ' Check to see if program is running on VB engine. If ScriptEngine = "VB" Then



RunningVB = True End If

No existe ningún carácter de tipo literal para Boolean.

5.1.5.2 Date (Tipo) El tipo de datos Date es un entero con signo de 64 bits (8 bytes). Cada incremento representa 100 nanosegundos de tiempo transcurrido desde el principio (12:00 a.m.) del 1 de enero del año 1 del calendario gregoriano. Una variable o constante del tipo de datos Date contiene tanto la fecha como la hora, como en el ejemplo siguiente: SomeDate = #11/18/2002 10:36 AM#

Si no se incluye una fecha en un literal de fecha/hora, Visual Basic establece la parte de fecha del valor en 1 de junio de 0001. Si se incluye una hora en un literal de fecha/hora Visual Basic establece la parte de hora del valor en el inicio del día, es decir, medianoche. Al convertir un tipo de datos numérico en Date, Visual Basic trata su valor como un entero con signo. Si se intenta convertir un número negativo, se produce un error. No existe ningún carácter de tipo literal para Date. Sin embargo, el compilador trata los literales encerrados entre caracteres de signo de número (# #) como Date.

5.1.5.3 Object (Tipo) El tipo de datos Object es una dirección de 32 bits (4 bytes) que apunta a un objeto dentro de la aplicación o en alguna otra aplicación. Al declarar una variable como Object, puede utilizarla posteriormente para hacer referencia a cualquier objeto reconocido por la aplicación, como en el ejemplo siguiente: Dim objDb As Object Dim MyCollection As New Collection() ' ... Suponer que MyCollection ya ha sido llenada. objDb = MyCollection.Item(1)

Al declarar una variable de objeto, es preferible utilizar una clase específica en lugar del genérico Object; por ejemplo, Database en lugar de Object, en el ejemplo precedente. También es preferible utilizar la clase más específica disponible, como TextBox en lugar de Control, así se podrá tener acceso a sus propiedades y métodos. Normalmente puede utilizar la lista Clases del Examinador de objetos para buscar nombres de clase disponibles. Las variables del tipo de datos Object pueden apuntar también a datos de cualquier tipo. Esto significa que puede asignar una variable, constante o expresión de cualquier tipo de datos a una variable Object. Para determinar el tipo de datos al que hace referencia la

variable Object actualmente, puede utilizar el método GetTypeCode de la clase Type, como en el ejemplo siguiente: Dim MyObject As Object ' ... Suppose MyObject has now had something assigned to it. Dim DatTyp As Integer DatTyp = Type.GetTypeCode(MyObject.GetType()) Los elementos de programación declarados como Object pueden aceptar valores de cualquier tipo de datos. Object se trata como un tipo de valor cuando contiene un tipo de valor, y como tipo de referencia cuando contiene un tipo de referencia. En cada caso, una variable Object no contiene el propio valor, sino un puntero al valor. Siempre utiliza cuatro bytes en la memoria del sistema, pero sin incluir el almacenamiento 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. No existe ningún carácter de tipo literal para Object.

5.2 Variables A menudo, es necesario almacenar valores de forma temporal para efectuar cálculos en Visual Basic. Por ejemplo, puede que necesite calcular varios valores, compararlos y realizar distintas operaciones con ellos, en función del resultado de la comparación. Para poder comparar los valores, debe guardarlos, pero no es necesario que los almacene en una propiedad. Visual Basic, al igual que la mayoría de los lenguajes de programación, utiliza variables para almacenar valores. Una variable tiene un nombre (la palabra que se utiliza para referirse al valor que contiene la variable) y un tipo de datos (que determina la clase de datos que puede almacenar la variable). Una variable puede representar una matriz, si es necesario que almacene un conjunto indizado de elementos de datos estrechamente relacionados entre sí. Para efectuar cálculos y asignar el resultado a una variable, se utilizan instrucciones de asignación, como se muestra en el siguiente código: ApplesSold = 10 ' El valor 10 es asignado a la variable. ApplesSold = ApplesSold + 1 ' La variable es incrementada.

Nota El signo igual (=) de este ejemplo es un operador de asignación, no un operador de igualdad. El valor se asigna a la variable ApplesSold.



5.2.1 Declaración de variables Una variable se declara para especificar su nombre y sus características. La instrucción de declaración para variables es Dim. Su ubicación y contenido determinan las características de la variable.

5.2.1.1 Niveles de declaración Una variable local es aquella que se declara dentro de un procedimiento. Una variable de módulo se declara en el interior del módulo, pero no dentro de un procedimiento interno del módulo. La categoría de una variable que no sea local, en una clase o estructura, depende de que la variable esté o no compartida. Si una variable se declara con la palabra clave Shared, es una variable compartida, y existe en una única copia compartida por todas las instancias de la clase o estructura. De lo contrario, es una variable de instancia, y se crea una copia independiente de ella para cada instancia de la clase o estructura. Una copia determinada de una variable de instancia sólo está disponible en la instancia para la cual se creó.

5.2.1.2 Declarar el tipo de datos La cláusula As de la instrucción de declaración permite definir el tipo de datos o de objetos de la variable que se está declarando. Se puede especificar cualquiera de los siguientes tipos para una variable:

• Un tipo de datos elemental, como Boolean, Long o Decimal.

• Un tipo de datos compuesto, como una matriz o una estructura.

• Un tipo de objeto, o de clase, de Visual Basic u otra aplicación, como Label o TextBox.

Se pueden declarar varias declarar distintas variables en la misma instrucción sin necesidad de repetir el tipo de datos. En las instrucciones que se muestran a continuación, las variables I, J y K se declaran como de tipo Integer, L y M como Long y X e Y como Single: Dim I, J, K As Integer ' Las tres son variables de tipo Integer. Dim L, M As Long, X, Y As Single ' L y M son Long, X y Y son Single.

5.2.1.3 Declarar el período de duración El período de duración de una variable representa el tiempo durante el cual la variable está disponible para que pueda ser utilizada. Una variable local declarada con una instrucción Dim sólo existe durante la ejecución del procedimiento. Cuando finaliza el procedimiento, todas sus variables locales desaparecen

y sus valores se pierden. No obstante, si se declara una variable local con la palabra clave Static, ésta seguirá existiendo y conservará su valor aunque finalice el procedimiento. Las variables de módulo, compartidas y de instancia conservan sus valores mientras continúe la ejecución de la aplicación.

5.2.1.4 Declarar el ámbito El ámbito de una variable está formado por todo código que puede hacer referencia a la variable sin tener que especificar su nombre. El ámbito de una variable está determinado por la ubicación en la que se haya declarado la variable. El código de una región determinada puede utilizar las variables definidas en dicha región sin necesidad de especificar los nombres de las variables. Cuando se declara un ámbito, se aplican las siguientes reglas:

• El ámbito de una variable de módulo es el espacio de nombres completo en el que está definido el módulo.

• El ámbito de una variable de instancia o compartida es la estructura o clase en la que se ha declarado.

• El ámbito de una variable local es el procedimiento en el que se ha declarado.

• No obstante, si se declara una variable local dentro de un bloque, su ámbito será únicamente el propio bloque. Un bloque es un conjunto de instrucciones que terminan por una instrucción End, Else, Loop o Next; por ejemplo, una construcción For...Next o If...Then...Else...End If.

5.2.1.5 Declarar la accesibilidad La accesibilidad de una variable viene determinada por la palabra o palabras clave, Dim, Public, Protected, Friend, Protected Friend o Private, que se utilizan en la instrucción de declaración. Con cualquiera de estas palabras clave se puede declarar una variable de módulo, estructura, clase o instancia. Dentro de un procedimiento, solamente está permitida la palabra clave Dim, y la accesibilidad siempre es privada.

5.2.2 Variables de tipo objecto Una variable, además de almacenar valores, puede hacer referencia a un objeto. Puede asignar un objeto a



una variable por los mismos motivos que asigna un valor a una variable:

• Un nombre de variable suele ser más corto y más fácil de recordar que la ruta de acceso completa a los métodos o propiedades necesarios para obtener acceso al propio objeto.

• El uso de una variable que hace referencia a un objeto es más eficiente que el acceso reiterado al propio objeto mediante los métodos o propiedades adecuados.

• Es posible cambiar una variable para que haga referencia a otros objetos durante la ejecución del código.

Las variables de objeto permiten reducir la cantidad de código que hay que escribir. Por ejemplo, podría encontrarse ante un segmento de código como el siguiente: ' Hay que asumi que Me es un Form válido, o reemplazar Me con un Form válido. Me.Activate() ' Activa el formulario. Me.ActiveControl = Label1 ' Activa algún control del formulario. ' ... Me.ActiveForm.ActiveControl.Text = "Test" Me.ActiveForm.ActiveControl.Location = New Point(100, 100) Me.ActiveForm.ActiveControl.Show() Podría abreviar este segmento de código utilizando una variable de objeto para el control, con lo que aumentaría la rapidez de su ejecución. Es conveniente que declare la variable de objeto con la clase concreta que desee asignarle (Control en el ejemplo siguiente). Una vez que haya asignado un objeto a la variable, podrá tratarla exactamente igual que al objeto al que hace referencia. También puede establecer o devolver las propiedades del objeto o utilizar cualquiera de sus métodos, como en el ejemplo siguiente: Dim ctrlBal As Control ' Must declare to be of class Control. ' ... ctrlBal = Me.ActiveForm.ActiveControl ctrlBal.Text = "Test" ctrlBal.Location = New Point(100, 100) ctrlBal.Show()

5.3 Período de duración, ámbito y accesibilidad de variables

5.3.1 Período de duración El período de duración de un elemento declarado es el tiempo durante el cual está disponible para el uso. Las variables son los únicos elementos que tienen un período de duración; para ello, el compilador trata los

argumentos del procedimiento y los valores devueltos de las funciones como casos especiales de las variables. El período de duración de una variable representa el tiempo durante el cual puede contener un valor. Su valor puede variar en su período de duración, pero siempre contiene un valor.

5.3.1.1 Períodos de duración diferentes Una variable declarada en el nivel de módulo, habitualmente existe durante todo el tiempo de ejecución de la aplicación. Una variable no compartida declarada en una clase o una estructura existe como una copia separada de cada instancia de la clase o la estructura en la que se ha declarado; una variable de esta clase tiene el mismo período de duración que la instancia. No obstante, una variable Shared sólo tiene un período de duración, que es el tiempo completo de ejecución de la aplicación. Las variables locales declaradas con Dim solamente existen mientras se ejecuta el procedimiento en el que se declaran. Esto también es aplicable a los argumentos del procedimiento y a cualquier valor devuelto de función. No obstante, si el procedimiento llama a otros procedimientos, las variables locales conservan su valor durante la ejecución de los últimos.

5.3.1.2 Comienzo del período de duración El período de duración de una variable local empieza con la ejecución del procedimiento en el que se declara. Las variables locales se inicializan con el valor predeterminado de su tipo de datos en el momento en que empieza la ejecución del procedimiento. Las variables numéricas (incluidas Byte y Char) se inicializan a cero, las variables Date a la medianoche del 1 de enero del año 1, las variables Boolean a False y las variables de tipo referencia (incluidas las cadenas, matrices y Object) a Nothing. Los miembros de una variable de estructura se inicializan como si cada uno fuera una variable independiente. De forma similar, los elementos de una variable de matriz se inicializan de manera individual. Si una variable se declara con un inicializador, el valor especificado se le asigna cuando se ejecuta su instrucción de declaración, como se muestra en el siguiente ejemplo: Dim X As Double = 18.973 ' X ha sido iniciada previmente a 0.

Las variables declaradas en un bloque de un procedimiento se inicializan a su valor predeterminado cuando entran en el procedimiento. Dichas inicializaciones tienen lugar se ejecute o no el bloque.

5.3.1.3 Final del período de duración Cuando finaliza la ejecución de un procedimiento, el valor de sus variables locales no se conserva, y se



recupera la memoria utilizada para los elementos locales. La siguiente vez que se ejecute el procedimiento, se crearán de nuevo todos sus elementos locales y se inicializarán las variables locales. Cuando finaliza una instancia de una clase o una estructura, se pierde el valor de sus variables no compartidas. Cada nueva instancia de la clase o la estructura crea todos sus elementos no compartidos e inicializa las variables no compartidas. Los elementos Shared se conservan hasta que finaliza la ejecución de la aplicación.

5.3.1.4 Prolongar el período de duración Si una variable local se declara con la palabra clave Static, su período de duración se alarga más que el tiempo de ejecución del procedimiento en el que se declara. Si el procedimiento está contenido dentro de un módulo, la variable estática sobrevive mientras dure la ejecución de la aplicación. Si una variable estática se declara en un procedimiento dentro de una clase, el período de duración de la variable depende de si el procedimiento es compartido. Si el procedimiento se declara con la palabra clave Shared, el período de duración de la variable continúa hasta que finaliza la aplicación. Si el procedimiento no es compartido, sus variables estáticas son miembros de instancia de la clase y sus períodos de duración será iguales a los de la instancia de clase. En el ejemplo siguiente, la función RunningTotal calcula un total acumulado mediante la suma de un valor nuevo al total de los valores previos almacenados en la variable estática ApplesSold: Function RunningTotal(ByVal Num As Integer) As Integer Static ApplesSold As Integer ApplesSold = ApplesSold + Num Return ApplesSold ' ApplesSold conserva su valor actual. End Function

Si ApplesSold se hubiera declarado sin utilizar Static, los valores acumulados anteriormente no se habrían conservado después de las llamadas a la función, y ésta sencillamente habría devuelto el mismo valor con el que se le llamó. Puede generar el mismo período de duración si declara ApplesSold en el nivel de módulo. No obstante, si cambia de esta forma el ámbito de una variable, el procedimiento dejará de tener acceso exclusivo a él. Dado que otros procedimientos podrían tener acceso a la variable y cambiar su valor, el total acumulado no sería confiable, lo que podría dificultar el mantenimiento del código.

5.3.2 Ámbito El ámbito de un elemento declarado es el conjunto de código que puede hacerle referencia sin calificar su nombre o marcarlo como disponible mediante una instrucción Imports. Un elemento puede tener uno de los niveles de ámbito siguientes:

• Ámbito de bloque: disponible únicamente en el bloque de código en el que se ha declarado.

• Ámbito de procedimiento: disponible únicamente dentro del procedimiento en el que se ha declarado.

• Ámbito de módulo: disponible en todo el código del módulo, la clase o la estructura donde se ha declarado.

• Ámbito de espacio de nombres: disponible en todo el código del espacio de nombres.

Estos niveles de ámbito progresan desde el más restringido (bloque) al más amplio (espacio de nombres), donde ámbito más restringido significa el conjunto de código más pequeño que puede hacer referencia al elemento sin calificación. El ámbito de un elemento se especifica al declararlo y puede depender de los factores siguientes:

• La región (bloque, procedimiento, módulo, clase o estructura) donde se declara el elemento.

• El espacio de nombres que contiene la declaración del elemento.

• La accesibilidad que se declara para el elemento.

Tenga cuidado cuando defina variables del mismo nombre pero con ámbito diferente, puesto que ello podría causar resultados inesperados. Elección del ámbito de una variable El ámbito de una variable está formado por todo código que puede hacer referencia a la variable sin tener que especificar su nombre. El ámbito de una variable está determinado por la ubicación en la que se haya declarado la variable. En lo que se refiere al ámbito, es importante tener en cuenta que las variables locales son una opción idónea para cualquier tipo de cálculo provisional. Sólo consumen memoria cuando se ejecuta el procedimiento, y sus nombres no son susceptibles de entrar en conflicto. Por ejemplo, es posible crear varios procedimientos distintos que contengan una



variable denominada intTemp. En tanto que intTemp esté declarado como una variable local, cada procedimiento reconocerá únicamente su propia versión de intTemp. Cualquier procedimiento puede cambiar el valor de su variable intTemp local sin que ello afecte a las variables intTemp del resto de los procedimientos. Nota Las variables de módulo, compartidas, de instancia y estáticas consumen recursos de memoria hasta que finaliza la ejecución de la aplicación, por lo que no conviene utilizarlas si no es realmente necesario. En general, cuando se declara una variable o una constante, es un buen hábito de programación asignar un ámbito lo más restringido posible (el ámbito de un bloque es el más restringido). Esto permite que no se pierda memoria y reduce al mínimo la posibilidad de que el código haga referencia por error a una variable incorrecta. Del mismo modo, sólo debería declararse una variable como Static si es necesario que conserve su valor entre una llamada al procedimiento y otra.

5.3.3 Accesibilidad La accesibilidad de un elemento declarado es la capacidad para utilizarlo; es decir, el permiso para que el código pueda leerlo o modificarlo. Está determinada no solamente por cómo se declara el propio elemento, sino también por la accesibilidad del contenedor del elemento. Si el elemento contenedor no está accesible, tampoco lo estarán los elementos contenidos, aunque se hayan declarado como Public. Por ejemplo, una variable Public de una estructura Private está accesible desde el interior de la clase que contiene la estructura, pero no desde el exterior.

5.3.3.1 Public La palabra clave Public de la instrucción Dim declara elementos como accesibles desde cualquier parte del mismo proyecto, desde otros proyectos que hagan referencia al proyecto, y desde un ensamblado generado a partir del proyecto. El código siguiente muestra un ejemplo de declaración Public: Public Class ClassForEverybody

Puede utilizar Public solamente en el nivel de módulo, espacio de nombres o archivo. Esto es, puede declarar un elemento público en un archivo de código fuente o dentro de un módulo, clase o estructura, pero no dentro de un procedimiento.

5.3.3.2 Protected La palabra clave Protected de la instrucción Dim declara elementos como accesibles solamente desde

dentro de la misma clase o desde una clase derivada de ella. El código siguiente muestra un ejemplo de declaración Protected: Protected Class ClassForMyHeirs Sólo puede utilizar Protected en el nivel de clase, y solamente cuando declare un miembro de una clase.

5.3.3.3 Friend La palabra clave Friend de la instrucción Dim declara elementos como accesibles desde dentro del mismo proyecto, pero no desde fuera de él. El código siguiente muestra un ejemplo de declaración Friend: Friend StringForThisProject As String

Puede utilizar Friend solamente en el nivel de módulo, espacio de nombres o archivo. Esto es, puede declarar un elemento de tipo amigo en un archivo de código fuente o dentro de un módulo, una clase o una estructura, pero no dentro de un procedimiento. Protected Friend La palabra clave Protected junto con la palabra clave Friend en la instrucción Dim declaran elementos como accesibles desde clases derivadas o desde dentro del mismo proyecto, o ambos. El código siguiente muestra un ejemplo de declaración Protected Friend: Protected Friend StringForProjectAndHeirs As String

Sólo puede utilizar Protected Friend en el nivel de clase, y solamente cuando declare un miembro de una clase.

5.3.3.4 Private La palabra clave Private en la instrucción Dim declara elementos como accesibles solamente desde dentro del mismo módulo, clase o estructura. El código siguiente muestra un ejemplo de declaración Private: Private NumberForMeOnly As Integer

Puede utilizar Private solamente en el nivel de módulo, espacio de nombres o archivo. Esto es, puede declarar un elemento privado en un archivo de código fuente o dentro de un módulo, clase o estructura, pero no dentro de un procedimiento. Nota En el nivel de módulo, la instrucción Dim sin palabras clave de accesibilidad equivale a una declaración Private. No obstante, podría convenirle usar la palabra clave Private para facilitar la lectura y la interpretación del código.

5.4 Constantes y Enumeraciones Las constantes son una forma de utilizar nombres significativos en el lugar de valores que no se modifican. Las constantes almacenan valores que, como su nombre indica, permanecen constantes



durante la ejecución de una aplicación. El uso de constantes puede hacer más legible el código, puesto que se utilizan nombres significativos en lugar de números. Las enumeraciones proporcionan una forma cómoda de trabajar con conjuntos de constantes relacionadas y de asociar valores de constantes con nombres. Por ejemplo, se puede declarar una enumeración para un conjunto de constantes de tipo entero asociadas con los días de la semana, y después utilizar los nombres de los días en el código en lugar de sus valores enteros.

5.4.1 Constantes A menudo el código contiene valores constantes que vuelven a aparecer. También puede ocurrir que el código dependa de ciertos números difíciles de recordar o cuyo significado no sea evidente. En estos casos, puede mejorar considerablemente la legibilidad del código y facilitar su mantenimiento mediante constantes. Una constante es un nombre significativo que toma el lugar de un número o cadena que no cambia. Las constantes almacenan valores que, como su nombre indica, permanecen constantes durante la ejecución de una aplicación. Las constantes se declaran con la instrucción Const, utilizando las mismas directrices que en la creación de nombres de variables. Si Option Strict está On, debe declarar explícitamente el tipo de constante. El ámbito de una constante es el mismo que el de una variable declarada en la misma ubicación. Para crear una constante que exista en el ámbito de un procedimiento concreto, declárela dentro de dicho procedimiento. Para crear una constante disponible en toda la aplicación, declárela con la palabra clave Public en la sección de declaraciones de la clase. Nota Aunque las constantes son de algún modo similares a las variables, no se pueden modificar ni asignársele valores como a éstas últimas. Las constantes que se utilizan en el código pueden ser intrínsecas al modelo de objeto para los controles o componentes con los que trabaja o definidas por el usuario, es decir, creadas por éste.

5.4.1.1 Declaración de constantes La instrucción Const se utiliza para declarar una constante y establecer su valor. Al declarar una constante, puede asignar un nombre significativo a un valor. Una vez que se declara una constante, no se puede modificar ni se le puede asignar un nuevo valor.

Una constante puede declararse dentro de un procedimiento o en la sección de declaraciones de un módulo, clase o estructura. Las constantes de nivel de clase o de estructura son de tipo Private de manera predeterminada, pero también se pueden declarar como Public, Friend, Protected o Protected Friend según el nivel apropiado de acceso al código. La constante debe tener un nombre simbólico válido (las reglas son las mismas que se aplican para la creación de nombres de variables) y una expresión que se componga de constantes numéricas o de cadena, y operadores; no obstante, no se pueden utilizar llamadas a funciones. Para declarar una constante

• Escriba una declaración que incluya un especificador de acceso, la palabra clave Const y una expresión, como en los ejemplos siguientes:

Public Const DaysInYear = 365 Private Const WorkDays = 250

Si Option Strict está On, debe declarar una constante de forma explícita especificando un tipo de datos (Boolean, Byte, Char, DateTime, Decimal, Double, Integer, Long, Short, Single o String). Si Option Strict está Off, el compilador asigna un tipo de datos a la constante. Para declarar una constante con Option Strict On

• Con Option Strict On, escriba una declaración que incluya la palabra clave As y un tipo de datos explícito, como en los siguientes ejemplos:

Option Strict On Public Const MyInteger As Integer = 42 Private Const DaysInWeek As Short = 7 Protected Friend Const Funday As String = "Sábado" Pueden declararse varias constantes en una sola línea, si bien para facilitar la lectura del código se recomienda declarar solamente una constante por línea. Si declara varias constantes en una sola línea, todas ellas deben tener el mismo nivel de acceso (Public, Private, Friend, Protected, o Protected Friend). Para declarar varias constantes en una sola línea

• Separe las declaraciones con una coma y un espacio, como en el ejemplo siguiente:

Public Const Four As Integer = 4, Five As Integer = 5, Six As Integer = 44



5.4.2 Enumeraciones Las enumeraciones proporcionan una forma cómoda de trabajar con conjuntos de constantes relacionadas y de asociar valores de constantes con nombres. Por ejemplo, se puede declarar una enumeración para un conjunto de constantes de tipo entero asociadas con los días de la semana, y después utilizar los nombres de los días en el código en lugar de sus valores enteros. Una enumeración se crea con la instrucción Enum en la sección de declaraciones de una clase o módulo. Un tipo Enum tiene un nombre, un tipo subyacente y un conjunto de campos, cada uno de los cuales representa una constante. El nombre debe ser un calificador de Visual Basic .NET válido. El tipo subyacente puede ser uno de los tipos enteros: Byte, Short, Long o Integer. Integer es el valor predeterminado. Las enumeraciones tienen siempre establecimiento inflexible de tipos y no son intercambiables con los tipos de números enteros. Puede asignarse el mismo valor a varios campos. Al hacerlo, el compilador marca uno de los valores Enum como principal para la conversión y reflexión de cadenas. Se pueden asignar explícitamente valores a constantes en una enumeración mediante una instrucción de asignación. Se admiten todos los valores enteros, incluidos los números negativos.

5.4.2.1 Declaración de enumeraciones Una enumeración se crea con la instrucción Enum en la sección de declaraciones de una clase o módulo. No puede declarar una enumeración dentro de un método. Para especificar el nivel apropiado de acceso al código, utilice Private, Protected, Friend o Public. Para declarar una enumeración

• Escriba una declaración que incluya un nivel de acceso, la palabra clave Enum y un nombre válido, como en los ejemplos siguientes:

Private Enum MyEnum Public Enum MyEnum Protected Enum MyEnum Friend Enum MyEnum Protected Friend Enum MyEnum

De manera predeterminada, la primera constante de una enumeración se inicializa con 0 y las siguientes se inicializan con un valor igual al de la constante anterior más uno. Por ejemplo, la siguiente enumeración, Days, contiene una constante denominada Domingo con el valor 0, una constante

denominada Lunes con el valor 1, una constante denominada Martes con el valor 2, etc.: Public Enum Days Domingo Lunes Martes Miércoles Jueves Viernes Sábado End Enum

Se pueden asignar explícitamente valores a constantes en una enumeración mediante una instrucción de asignación. Se puede asignar cualquier valor entero, incluidos números negativos. Por ejemplo, puede que desee que las constantes con valores menores que cero representen condiciones de error. En la siguiente enumeración, a la constante Invalido se le asigna explícitamente el valor –1, y a la constantes Domingo se le asigna el valor 0. Debido a que es la primera constante de la enumeración, Sábado también se inicializa con el valor 0. El valor de Lunes es 1 (el valor de Domingo más uno); el valor de Martes es 2, y así sucesivamente. Public Enum WorkDays Sábado Domingo = 0 Lunes Martes Miercoles Jueves Viernes Invalido = -1 End Enum Las enumeraciones son de tipo Integer de manera predeterminada. Puede declararlas explícitamente como Integer, Short, Long o Byte. Para declarar una enumeración explícitamente

• Escriba una declaración con la sintaxis siguiente:

Public Enum MyEnum As Byte Zero One Two End Enum

Las enumeraciones no pueden tener valores de punto flotante. Si se asigna un valor de punto flotante a una enumeración con Option Strict On, se producirá un error del compilador. Si Option Strict está Off, el valor se convierte automáticamente al tipo Enum.



5.5 Matrices Las matrices permiten hacer referencia a una serie de variables mediante un mismo nombre y utilizar un número, denominado índice o subíndice, para distinguirlas. De esta forma, se puede crear un código más simple y reducido en muchos casos, ya que es posible utilizar bucles que usen el índice para procesar eficientemente cualquier número de elementos de la matriz. Dimensiones de matriz Las matrices pueden tener una o varias dimensiones. La dimensión (el rango) de la matriz corresponde al número de subíndices que se utilizan para identificar un elemento individual. Se pueden especificar hasta 32 dimensiones, aunque no es habitual tener más de tres. Tamaño de matriz Cada dimensión de una matriz tiene una longitud distinta de cero. Los elementos de la matriz son contiguos en cada dimensión, desde 0 hasta el mayor valor del subíndice de esa dimensión. Puesto que Visual Basic asigna espacio para todos los elementos de una matriz, se debe evitar declarar una matriz mayor de lo necesario. Una matriz de longitud cero es una matriz sin elementos. A veces resulta necesario especificar matrices de este tipo, por ejemplo al utilizar formularios Windows Forms. Para hacerlo, declare una de las dimensiones de la matriz como –1. La matriz estará vacía, pero existirá. En consecuencia, una variable que apunte a la matriz no será igual a Nothing. Las matrices de Visual Basic no tienen un tamaño fijo. Después de haber creado una matriz, se puede cambiar su tamaño. La instrucción ReDim asigna un objeto matriz completamente nuevo a la variable matriz especificada. Por consiguiente, ReDim puede cambiar la longitud de cada dimensión.

5.5.1 Matrices como objetos En Visual Basic .NET, las matrices son objetos, de modo que cada tipo de matriz es un tipo de referencia individual. Este hecho implica lo siguiente:

• Una variable matriz mantiene un puntero a los datos que constituyen los elementos y la información de rango y longitud.

• Cuando se asigna una variable de matriz a otra, sólo se copia el puntero.

• No se considera que dos variables de matrices son del mismo tipo de datos a no ser que tengan el mismo rango y elemento de tipo de datos.

5.5.2 Clase de matriz Todas las matrices heredan de la clase Array, procedente del espacio de nombres System, por lo que es posible obtener acceso a los métodos y a las propiedades de System.Array para cualquier matriz. Por ejemplo, la propiedad Rank devuelve el rango de la matriz, mientras que el método Sort permite ordenar sus elementos. Tipo de elemento de matriz Una declaración de matriz especifica un tipo de datos y todos sus elementos deben ser de ese tipo. Cuando el tipo es Object, los elementos individuales pueden contener diferentes clases de datos (objetos, cadenas, números, etc.). Se pueden declarar matrices de cualquiera de los tipos de datos fundamentales, de una estructuras o de clases de objetos. También se puede declarar una matriz que contenga otras matrices como sus elementos. En este caso, las matrices constituyentes deben tener el mismo elemento de tipo de datos, que se especifica en la declaración. Una matriz de matrices se denomina una matriz escalonada porque las matrices constituyentes no tienen por qué tener los mismos tamaños. Nota Las matrices escalonadas no son compatibles con Common Language Specification (CLS). Esto significa que no se deben exponer matrices escalonadas desde ninguna clase que deba ser consumida por código compatible con CLS.

5.5.2.1 Declarar variables de matriz 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 variable, tal y como muestra el siguiente ejemplo:

Dim MySingleArray() As Integer



Para declarar una variable de matriz multidimensional

• En la declaración, agregue un par de paréntesis detrás del nombre de la variable y coloque comas dentro de los paréntesis para separar las dimensiones, tal y como muestra el siguiente ejemplo:

Dim My4DArray(,,,) As Short ' Four-dimensional array.

Para declarar una variable de matriz escalonada

• En la declaración, agregue tantos pares de paréntesis detrás del nombre de la variable como niveles de matrices anidadas haya, tal y como se ve en el siguiente ejemplo:

Dim MyJaggedArray()()() As Byte ' Array of arrays of Byte arrays.

5.5.3 Inicializar matrices Se puede inicializar una variable de matriz como parte de su propia declaración. Se puede realizar una de las siguientes acciones en la instrucción de declaración:

• Especificar la longitud inicial de una o más de las dimensiones entre paréntesis detrás del nombre de la variable, sin asignar un objeto de matriz a la variable.

• Asignar un objeto de matriz a la variable, mediante la cláusula New. Al utilizar una cláusula New, ésta debe ir seguida de llaves ({}), incluso si están vacías.

• Asignar un objeto matriz a la variable y suministrar las longitudes iniciales mediante la cláusula New.

• Asignar un objeto matriz a la variable y suministrar los valores de elementos iniciales mediante la cláusula New. Puede suministrar ambas longitudes y valores en la misma cláusula New.

Si especifica longitudes de dimensión en los paréntesis detrás del nombre de la variable, debe utilizar una instrucción de asignación posterior para asignar un objeto de matriz a la variable. En las siguientes declaraciones de ejemplo se muestra la sintaxis correcta e incorrecta para una variable de matriz unidimensional: Dim BA(2) As Byte ' Currently contains Nothing (no object). Dim BA(2) As Byte = New Byte() ' INVALID (New after length specified). Dim BA() As Byte = New Byte() {} ' Empty Byte array object. Dim BA() As Byte = New Byte() ' INVALID (missing braces). Dim BA() As Byte = New Byte(2) ' INVALID (missing braces).

Dim BA() As Byte = New Byte() {0,1,2} ' (0) through (2). Dim BA() As Byte = New Byte(2) {0,1,2} ' (0) through (2).

Una variable de matriz multidimensional se puede inicializar de forma similar. En las siguientes declaraciones de ejemplo se muestra una variable de matriz bidimensional declarada como una matriz de tipo Short con 2 filas y 2 columnas. Dim S2X2(1, 1) As Short ' (0) through (1), (0) through (1). Dim S2X2(1, 1) As Short = New Short(,) ' INVALID (New after lengths). Dim S2X2(,) As Short = New Short(,) ' INVALID (missing braces). Dim S2X2(,) As Short = New Short(1, 1) ' INVALID (missing braces). Dim S2X2(,) As Short = New Short(,) {} ' Empty array object. Dim S2X2(,) As Short = New Short(1, 1) {} ' Elements have default value. Dim S2X2(,) As Short = New Short(,) {{5, 6}, {7, 8}} ' Four elements. El primer argumento representa las filas; el segundo, las columnas. En las matrices de las declaraciones anteriores, los valores del índice varían entre 0 y 1 tanto para las filas como para las columnas. Al inicializar una variable de matriz escalonada, sólo puede especificar las longitudes de dimensión para la matriz del nivel superior. En las siguientes declaraciones de ejemplo se muestra la sintaxis correcta e incorrecta para una matriz de matrices con elementos de tipo Byte: Dim JB(1)() As Byte ' Matriz de dos matrices de elementos Byte. Dim JB(1)(1) As Byte ' INVALIDO (sólo puede especificar el tamaño del nivel superior). Dim JB(1)() As Byte = New Byte()() ' INVALIDO (palabra clave New después del tamaño). Dim JB()() As Byte = {New Byte() {}, New Byte() {}} ' Matriz vacía. Dim JB()() As Byte = {New Byte(1) {}, New Byte(1) {}} ' Valores por defecto. Dim JB()() As Byte = {New Byte() {5, 6}, New Byte() {7, 8}}

En la última de las declaraciones anteriores, JB se inicializa en dos elementos, JB(0) y JB(1), cada uno de los cuales se inicializa en una matriz de tipo Byte de dos elementos, la primera con los valores de los elementos 5 y 6 y la segunda con los elementos 7 y 8. Límites de tamaño de matriz La longitud de cada dimensión de una matriz se limita al valor máximo del tipo de datos Long, el cual es (2 ^ 64) - 1. El límite de tamaño total de una matriz varía, según el sistema operativo y la cantidad de memoria disponible. El uso de una matriz que supere la cantidad de RAM disponible en el sistema será más lento, ya que las operaciones de lectura y escritura deberán realizarse en el disco.



Nota Puesto que en Visual Basic .NET las matrices son objetos, es importante distinguir entre un objeto de matriz y una variable de matriz. Un objeto matriz, una vez creado, no cambia de tamaño o rango. Sin embargo, una variable de matriz puede recibir la asignación de diferentes matrices de distintos tamaños y rangos durante su existencia.

5.5.4 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 incluye la palabra clave Preserve en la instrucción ReDim. Por ejemplo, la siguiente instrucción asigna una nueva matriz, inicializa sus elementos a partir de los elementos correspondientes de MyArray y asigna la nueva matriz a MyArray. ReDim Preserve MyArray(10, 20)

En una matriz de varias dimensiones, cuando se utiliza Preserve, sólo se puede cambiar la última dimensión. Si se intenta cambiar cualquiera de las otras dimensiones, se produce un error en tiempo de ejecución. Si no se conoce el tamaño real de una dimensión, se puede utilizar el método GetUpperBound, que devuelve el valor de subíndice más alto de la dimensión especificada. En el siguiente ejemplo, la primera línea es válida, pero no la segunda, ya que intenta cambiar la primera dimensión de las dos existentes. ReDim Preserve Matrix(Matrix.GetUpperBound(0), Matrix.GetUpperBound(1) + 10) ReDim Preserve Matrix(Matrix.GetUpperBound(0) + 10, Matrix.GetUpperBound(1))

5.6 Operadores Un operador es una unidad de código que realiza una operación sobre uno o más elementos de código que devuelven valores. Tal operación puede ser una operación aritmética, como una suma o una multiplicación; una operación de concatenación, que combina dos cadenas en una nueva; una operación de

comparación, que determina cuál de dos valores es mayor; una operación lógica, que evalúa si dos expresiones son ambas verdaderas. Los operadores combinados con elementos de código que devuelven valores como literales o variables forman expresiones o, en el caso del operador de asignación, instrucciones. El siguiente es un ejemplo de una instrucción que utiliza el operador de asignación simple (=): x = 45 En el ejemplo anterior, el operador de asignación realiza la operación de asignación: toma el valor del lado derecho del operador y lo asigna a la variable del lado izquierdo. Varios operadores pueden realizar acciones en una expresión o instrucción simples, como se demuestra a continuación: x = 45 + y * z ^ 2 En este ejemplo, se realizan las operaciones de la expresión situada a la derecha del operador de asignación y el valor resultante se asigna a la variable x, situada a la izquierda. No existe límite en cuanto al número de operadores que se pueden combinar en una expresión, pero debe comprender la Prioridad de operadores en Visual Basic para asegurarse de que obtendrá los resultados previstos.

5.6.1 Operadores aritméticos Los operadores aritméticos se utilizan para realizar muchas de las operaciones aritméticas habituales que implican el cálculo de valores numéricos representados por literales, variables, otras expresiones, llamadas a funciones y propiedades, y constantes.

5.6.1.1 Operaciones aritméticas Puede sumar dos valores en una expresión con el operador + o restar un valor de otro con el operador -, como se muestra en los siguientes ejemplos: Dim x As Integer x = 67 + 34 x = 32 - 12

La negación también utiliza el operador -, pero con una sintaxis algo diferente, como se muestra a continuación: Dim x As Integer = 65 Dim y As Integer y = -x

La multiplicación y la división utilizan los operadores * y /, respectivamente, como en estos ejemplos: Dim y As Double y = 45 * 55.23



y = 32 / 23

La exponenciación utiliza el operador ^, como se muestra a continuación: Dim z As Double z = 23 ^ 3 ' z equals the cube of 23.

La división de enteros se lleva a cabo con el operador \. La división de enteros devuelve el número de veces que un entero puede dividirse exactamente en otro. Con este operador, sólo se pueden utilizar tipos enteros (Byte, Short, Integer y Long). Todos los demás tipos deben convertirse antes a tipo integral. A continuación se muestra un ejemplo de una división de enteros: Dim k As Integer k = 23 \ 5 ' k = 4

El módulo aritmético se calcula con el operador Mod. Este operador devuelve el resto una vez que se divide el divisor por el dividendo un número integral de veces. Si tanto el divisor como el dividendo son tipos integrales, el valor devuelto es integral. Si el divisor y el dividendo son tipos de punto flotante, el valor devuelto es una variable de punto flotante. Dos ejemplos ilustran este comportamiento: Dim x As integer = 100 Dim y As Integer = 6 Dim z As Integer z = x Mod y ' z equals 4. Dim a As Double = 100.3 Dim b As Double = 4.13 Dim c As Double c = a Mod b ' c equals 1.18.

5.6.1.2 Seguridad de tipos Normalmente, los operandos deben ser del mismo tipo. Por ejemplo, si agrega una variable Integer, debe agregarla a otra variable Integer, y la variable a la que se asigna el valor debe ser de tipo Integer también. Una buena forma de garantizar la seguridad de tipos consiste en utilizar Option Strict. Si el valor de Option Strict es On, Visual Basic .NET realiza automáticamente conversiones de seguridad de tipos. De esta forma, si intenta agregar una variable Integer a una variable Double y asignar el valor a una variable Double, la operación continúa normalmente. Por otra parte, las conversiones no seguras o de restricción, causan un error del compilador. Por tanto, si intenta agregar una variable Integer a una variable Double y asignar el valor a la variable Integer, se produce un error del compilador, porque una variable Double no se puede convertir implícitamente al tipo Integer. No obstante, si el valor de Option Strict es Off, se permite realizar estas conversiones de restricción implícitas, aunque pueden producir la pérdida

inesperada de datos o de precisión. Por este motivo, se recomienda utilizar Option Strict On para escribir código de producción.

5.6.2 Operadores Concatenación Los operadores de concatenación combinan varias cadenas en una sola. Hay dos operadores de concatenación, + y &; ambos llevan a cabo la operación de concatenación básica, como se muestra a continuación: Dim x As String x = "Con" & "caten" & "ation" ' x equals "Concatenation". x = "Con" + "caten" + "ation" ' x equals "Concatenation".

Estos operadores también concatenan variables String, como en el ejemplo siguiente: Dim x As String = "abc" Dim y As String = "def" Dim z As String z = x & y ' z equals "abcdef". z = x + y ' z equals "abcdef".

Si el valor de Option Strict es On, el operador + requiere explícitamente cadenas para las operaciones de concatenación. También realiza operaciones aritméticas con operandos numéricos cuando el valor de Option Strict es On. No obstante, si el valor de Option Strict es Off, el operador + admite una amplia variedad de conversiones implícitas para operaciones de concatenación. El operador & sólo se define para operandos de tipo String y siempre amplía sus operandos a String, independientemente de la configuración de Option Strict. El operador & está recomendado para la concatenación de cadenas, porque está definido exclusivamente para cadenas y reduce las posibilidades de generar una conversión no deseada.

5.6.3 Operadores relacionales o de comparación

Los operadores de comparación comparan dos expresiones y devuelven un valor Boolean que representa el resultado de la comparación. Existen operadores para comparar valores numéricos, operadores para comparar cadenas y operadores para comparar objetos. Los tres tipos de operadores se describen a continuación.

5.6.3.1 Comparar valores numéricos Para comparar valores numéricos se utilizan seis operadores de comparación numérica. En la siguiente



tabla se muestran los operadores y un ejemplo de la condición que prueba cada uno.

Operador Condición que prueba

Ejemplos

= (Igualdad) ¿Es el valor que representa la primera expresión igual que el valor que representa la segunda?

23 = 33 ' False 23 = 23 ' True 23 = 12 ' False

<> (Desigualdad)

¿Es el valor que representa la primera expresión no igual que el valor que representa la segunda?

23 <> 33 ' True 23 <> 23 ' False 23 <> 12 ' True

< (Less than) ¿Es el valor que representa la primera expresión menor que el valor que representa la segunda?

23 < 33 ' True 23 < 23 ' False 23 < 12 ' False

> (Mayor que)

¿Es el valor que representa la primera expresión mayor que el valor que representa la segunda?

23 > 33 ' False 23 > 23 ' False 23 > 12 ' True

<= (Menor o igual que)

¿Es el valor que representa la primera expresión menor o igual que el valor que representa la segunda?

23 <= 33 ' True 23 <= 23 ' True 23 <= 12 ' False

>= (Mayor o igual que)

¿Es el valor que representa la primera expresión mayor o igual que el valor que representa la segunda?

23 >= 33 ' False 23 >= 23 ' True 23 >= 12 ' True

5.6.3.2 Comparar cadenas Para comparar cadenas se utiliza el operador Like, así como los operadores de comparación numérica. El operador Like permite especificar un modelo; después se compara la cadena con el modelo y, si coincide, el resultado es True. De lo contrario, el resultado es False. Los operadores numéricos permiten comparar valores String basándose en el tipo de ordenación: "73" < "9" ' This result is True.

El resultado es True porque el primer carácter de la primera cadena se ordena antes que el primer carácter de la segunda cadena. Si los primeros caracteres fueran iguales, la comparación continuaría con el siguiente carácter de las dos cadenas, y así sucesivamente. La igualdad de cadenas también se puede probar mediante el operador de igualdad, como en este ejemplo: "734" = "734" ' The result is True.

En este ejemplo, las dos cadenas se comparan directamente y, puesto que son iguales, se devuelve True. Si una cadena es un prefijo de otra, como "aa" y "aaa", la cadena más larga se ordena después de la más corta. Por tanto, la siguiente expresión es verdadera (True): "aaa" > "aa" El criterio de ordenación se basará en una comparación binaria o una comparación textual en función del valor de Option Compare.

5.6.3.3 Comparar objetos Puede utilizar el operador Is para determinar si dos variables de objeto hacen referencia a la misma instancia de un objeto. Por ejemplo: Dim x As MyClass Dim y As New MyClass() x = y If x Is y Then ' Insert code to continue program execution.

En este ejemplo, la evaluación de x Is y devuelve True, porque las dos variables hacen referencia a la misma instancia. Compare este resultado con el del ejemplo siguiente: Dim x As New MyClass() Dim y As New MyClass() If x Is y then ' Insert code to continue program execution. En este ejemplo, la evaluación de x Is y devuelve False, puesto que aunque las variables son del mismo tipo, hacen referencia a instancias diferentes de ese tipo. Para probar si un objeto es de un tipo concreto se utiliza el operador TypeOf...Is. . La sintaxis es la siguiente:



TypeOf <object expression> Is <TypeName>

Cuando TypeName especifica un tipo de interfaz, el operador TypeOf ... Is devuelve True si el objeto implementa el tipo de interfaz. Cuando TypeName es un tipo de clase, el operador devuelve True (verdadero) si el objeto es una instancia de la clase especificada o una instancia que se deriva de la especificada. Por ejemplo: Dim x As Button x = New Button() If TypeOf x Is Control Then ' Insert code to continue program execution. Puesto que el tipo de x es Button, y Button hereda de Control, la expresión TypeOf x Is Control se evalúa como True.

5.6.4 Operadores lógicos Los operadores lógicos comparan expresiones Boolean y devuelven un resultado Boolean. Los operadores And, Or, AndAlso, OrElse y Xor aceptan dos operandos, mientras que el operador Not sólo acepta un operando. El operador Not realiza la negación lógica de una expresión Boolean. En términos simples, proporciona lo contrario de la expresión que evalúa. Si la evaluación de la expresión devuelve True, Not proporciona False; si devuelve False, Not proporciona True. A continuación se muestra un ejemplo: Dim x As Boolean x = Not 23 > 12 ' x equals False. x = Not 23 > 67 ' x equals True. El operador And realiza la conjunción lógica de dos expresiones Boolean. Es decir, si la evaluación de ambas expresiones es True, el operador And devuelve True. Si al evaluar una o las dos expresiones se obtiene False, And devuelve False. El operador Or realiza la disyunción lógica de dos expresiones Boolean. Si la evaluación de alguna expresión devuelve True, Or devuelve True. Si la evaluación de alguna expresión devuelve True, Or devuelve False. Xor realiza la exclusión lógica en dos expresiones. Si la evaluación de una de las expresiones devuelve True (pero no las dos), Xor devuelve True. Si la evaluación devuelve True o False para las dos expresiones, Xor devuelve False. A continuación se muestran ejemplos de uso de los operadores And, Or y Xor: Dim x As Boolean x = 23 > 12 And 12 >4 ' x = True

x = 12 > 23 And 12 > 4 ' x = False x = 23 > 12 Or 4 > 12` ' x = True x = 23 > 45 Or 4 > 12 ' x = False x = 23 > 45 Xor 12 > 4 ' x = True x = 23 > 12 Xor 12 > 4 ' x = False x = 12 > 23 Xor 4 > 12 ' x = False Nota Además de ser operadores lógicos, Not, Or, And y Xor también realizan operaciones aritméticas bit a bit cuando se utilizan en valores numéricos. Puede encontrar información sobre esta funcionalidad en Operadores aritméticos. El operador AndAlso es muy similar al operador And, ya que también realiza la conjunción lógica de dos expresiones Boolean. La diferencia clave entre AndAlso y And es que AndAlso muestra comportamiento de corto-circuito. Si el valor de la primera expresión evaluada de una expresión AndAlso es False, no se evaluará la segunda expresión y se devolverá False para la expresión AndAlso. De manera similar, el operador OrElse realiza la disyunción lógica de evaluación "cortocircuitada" de dos expresiones Boolean. Si la evaluación de la primera expresión de una expresión OrElse devuelve True, no se evaluará la segunda expresión y se devolverá True para la expresión OrElse. A continuación se muestran algunos ejemplos que ilustran la diferencia entre And, Or y sus equivalentes: 12 > 45 And MyFunction(4) ' MyFunction() is called. 12 > 45 AndAlso MyFunction(4) ' MyFunction() is not called. 45 > 12 Or MyFunction(4) ' MyFunction is called. 45 > 12 OrElse MyFunction(4) ' MyFunction is not called

En el primer ejemplo, se llama a MyFunction() aunque 12 > 45 devuelve False, debido a que no se "cortocircuita" la evaluación de And. En el segundo ejemplo, no se llama a MyFunction porque 12 > 45 devuelve False, con lo cual AndAlso "cortocircuita" la evaluación de la segunda expresión. En el tercer ejemplo, se llama a MyFunction aunque 45 > 12 devuelve True, debido a que no se "cortocircuita" la evaluación de Or. En el cuarto ejemplo, no se llama a MyFunction porque 45 > 12 devuelve True, con lo cual OrElse "cortocircuita" la evaluación de la segunda expresión.

Nota Aunque And y Or admiten operaciones bit a bit con valores numéricos, AndAlso y OrElse no lo hacen.



5.6.5 Combinación eficaz de operadores

Las expresiones complejas pueden contener muchos operadores diferentes. Considere la siguiente instrucción: x = (45 * (y + z)) ^ (2 / 85) * 5 + z La creación de expresiones complejas como éstas requiere comprender a fondo las reglas de prioridad de operador. En este tema, que le ayudará a construir expresiones eficientes, se presupone que está familiarizado con las reglas de prioridad de operador.

5.6.5.1 Expresiones numéricas En expresiones numéricas como la del ejemplo anterior, los operadores siguen un estricto modelo de prioridad. Primero se lee cualquier variable o propiedad existente y se ejecutan las posibles llamadas a funciones que devuelven valores. Una vez recuperados estos valores, se evalúan las expresiones según las reglas de prioridad de operador. Primero se realiza la exponenciación (^), después la negación (-). Éstos operadores van seguidos de la multiplicación (*) y la división (/), que tienen la misma prioridad de operador y, por tanto, se ejecutan en el orden textual en que aparecen de izquierda a derecha. La división de enteros (\) se produce a continuación, seguida del módulo aritmético (Mod). Después se realizan la suma (+) y la resta (-); los Operadores lógicos/bit a bit se evalúan en último lugar. Cuando una expresión incluye operadores de igual prioridad, la evaluación se realiza de izquierda a derecha en el orden en que aparezcan.

5.6.5.2 Expresiones booleanas Las expresiones Boolean pueden ser aún más complejas que las expresiones numéricas, dado que combinan operadores aritméticos, operadores de comparación y operadores lógicos. A continuación se muestra un ejemplo que contiene las tres clases de operadores: x + y > z And z + y < w

En este ejemplo, las operaciones aritméticas se realizan mediante el operador +, las de comparación con los operadores > y <, y las lógicas con el operador And. Cuando se evalúan expresiones con diferentes clases de operadores, normalmente la prioridad estándar de operadores determina el orden de la operación.

5.6.5.3 Expresiones entre paréntesis

A menudo, desea que la ejecución de las operaciones se realice en un orden diferente del que determina la prioridad de operador. Considere este ejemplo: x = z * y + 4 En este ejemplo, z se multiplica por y, y a continuación el resultado se suma a 4. Pero, ¿qué ocurre si se desean sumar y y 4 antes de multiplicar por z? En tal caso, puede anular la prioridad de operador mediante paréntesis. Si escribe una expresión entre paréntesis, fuerza a que dicha expresión se evalúe primero, independientemente de la prioridad de operador. Así, para forzar a la expresión anterior a que evalúe primero la suma, volvería a escribir el ejemplo de la siguiente manera: x = z * (y + 4)

Ahora el valor de y se suma a 4 y esa suma se multiplica por z. Puede anidar expresiones en múltiples niveles para forzar más la prioridad. A las expresiones con mayor profundidad de anidamiento se les concede prioridad principal, seguidas de las expresiones de menor profundidad de anidamiento y así sucesivamente. Observe el ejemplo siguiente: x = (z * 4) ^ (y * (z + 2)) Aquí, z + 2 tiene prioridad principal, y después tienen prioridad las demás expresiones entre paréntesis. La exponenciación, que generalmente tiene mayor prioridad que la suma o la multiplicación, se evalúa en último lugar debido a que las otras expresiones están escritas entre paréntesis.

5.7 Flujo de control Si se deja libre, un programa avanza por sus instrucciones de principio a fin. Algunos programas muy simples pueden escribirse sólo con este flujo unidireccional. No obstante, la mayor eficacia y utilidad de cualquier lenguaje de programación se deriva de la posibilidad de cambiar el orden de ejecución con instrucciones de control y bucles. Las instrucciones de flujo de control permiten regular el flujo de ejecución de un programa. Mediante instrucciones de control, puede escribir código de Visual Basic para tomar decisiones y repetir acciones. Otra instrucción muy útil es With...End With, que permite ejecutar una serie de instrucciones sin necesidad de volver a calificar un objeto.

5.7.1 Estructuras 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 instrucciones de decisión que admite Visual Basic incluyen:

• If...Then • If...Then...Else • Select...Case • Try...Catch...Finally

5.7.1.1 If...Then...Else (Instrucciones) Se pueden utilizar instrucciones If...Then...Else para ejecutar una instrucció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 valores 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 instrucciones Else y End If, como muestra el ejemplo siguiente: Sub FixDate() Dim MyDate As Date = #2/13/1973# If MyDate < Now Then MyDate = Now End Sub Para ejecutar más de una línea de código cuando la condición es True se utiliza 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 New System.Windows.Forms.Label ' ... Sub AlertUser(ByVal Value As Long) If Value = 0 Then AlertLabel.ForeColor = Color.Red AlertLabel.Font = New Font(AlertLabel.Font, _ FontStyle.Bold Or FontStyle.Italic) End If End Sub

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

Puede utilizar If...Then...Else con la instrucción Else para definir dos bloques 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 New System.Windows.Forms.Label ' ... Sub AlertUser(ByVal Value As Long) If Value = 0 Then AlertLabel.ForeColor = Color.Red AlertLabel.Font = New Font(AlertLabel.Font, _ FontStyle.Bold Or FontStyle.Italic) Else AlertLabel.Forecolor = Color.Black AlertLabel.Font = New Font(AlertLabel.Font, _ FontStyle.Regular) End If End Sub

Probar condiciones adicionales si la primera condición es False Puede agregar una o más instrucciones ElseIf a If...Then...Else para probar 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 instrucción Else sólo se ejecutará si el valor de las condiciones de todas las instrucciones If y ElseIf es False. Function Bonus(ByVal Performance As Integer, ByVal Salary 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 If End Function

Visual Basic prueba las condiciones en el orden en que aparecen en las pruebas 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 instrucciones correspondiente. La ejecución realiza entonces una bifurcación al final del bloque If...Then...Else. 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 instrucciones If...Then...Else anidadas o muchas instrucciones ElseIf.

5.7.1.2 Select...Case (Instrucciones) 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 instrucciones 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 bloque 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 omitirse una instrucción Case Else. En el ejemplo siguiente se usa Select...Case para evaluar el nivel de rendimiento que se pasa al procedimiento Function. Observe que cada instrucció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 instrucció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 Integer, 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 Select End Function

5.7.1.3 Try...Catch...Finally (Instrucciones)

Puede utilizar la instrucción Try...Catch...Finally para el control estructurado de excepciones. Así puede ejecutarse un bloque concreto de instrucciones si se produce una excepción especificada mientras se ejecuta el código. Cuando esto ocurre, se dice que el código provoca la excepción, que se detecta con la instrucción Catch correspondiente. La ejecución entra en el bloque Try...Catch...Finally con el bloque de instrucciones que sigue a la instrucción Try. Si Visual Basic finaliza este bloque sin que se genere una excepción, busca la instrucción opcional Finally al final del bloque. Si ha proporcionado la instrucción Finally, Visual Basic ejecuta el bloque de instrucciones que está a continuación de dicha instrucción. En cualquier caso, a continuación el control se transfiere a la instrucción que sigue a la instrucción End Try. Si se produce una excepción, Visual Basic examina las instrucciones Catch en el orden en que aparecen dentro de Try...Catch...Finally. Si encuentra una instrucción Catch que controla la excepción generada, ésta ejecuta el bloque de instrucciones correspondiente. Cuando termina de ejecutar el bloque Catch, ejecuta el bloque Finally si existe. Después, la ejecución continúa en la instrucción que sigue a End Try. Una instrucción Catch controla una excepción que es del mismo tipo que el declarado en la instrucción Catch o de un tipo derivado de éste. Si se incluye una instrucción Catch que no especifica un tipo de excepción, ésta controlará cualquier excepción derivada de la clase Exception. Si tal instrucción es la última instrucción Catch, puede detectar cualquier excepción no controlada en los bloques Catch anteriores. Una instrucción Catch puede incluir opcionalmente la cláusula When, independientemente de que especifique o no un tipo de excepción. La cláusula When va seguida de una expresión que debe poder convertirse a tipo Boolean. La excepción sólo se controla si es del tipo correcto y la expresión When se evalúa como True, como en el ejemplo siguiente: Catch Exc As System.NotSupportedException When SupportCheck >= 1 Si se incluye la instrucción opcional Finally, el bloque de instrucciones correspondiente es siempre el último código que se ejecuta inmediatamente antes de que el control abandone Try...Catch...Finally. Esto es así, aunque se produzca una excepción no controlada o se ejecute una instrucción Exit Try.



Puede utilizarse cualquier número de instrucciones Catch e incluirse u omitirse una instrucción Finally. No obstante, debe utilizarse al menos una instrucción Catch o una instrucción Finally. No es posible bifurcar fuera de un bloque Try, en un bloque Catch o dentro o fuera de un bloque Finally. Puede bifurcar de un bloque Catch a un bloque Try asociado con ese bloque Catch. Por ejemplo, si una construcción Try...Catch...Finally está anidada dentro de otra, un bloque Catch puede bifurcar al bloque Try de su propio nivel de anidamiento, pero no a ningún otro bloque Try. En el ejemplo siguiente, Try...Catch...Finally intenta calcular la fecha y la hora de 100 años exactamente a partir del valor que se proporciona en la variable GivenDate de Object: Dim GivenDate As Object ' Should contain date/time information. Dim NextCentury As Date Try NextCentury = DateAdd("yyyy", 100, GivenDate) Catch ThisExcep As System.ArgumentException ' At least one argument has an invalid value. Catch ThisExcep As ArgumentOutOfRangeException ' The result is later than December 31, 9999. Catch ThisExcep As InvalidCastException ' GivenDate cannot be interpreted As a date/time. Catch ' An unforeseen exception has occurred. Finally ' This block is always executed before leaving. End Try

Las excepciones que se pueden prever a partir de la función DateAdd se pueden controlar en los tres primeros bloques Catch, además se puede tratar cualquier excepción imprevista en el último bloque Catch. Con independencia de lo que suceda, el bloque Finally es siempre el código que se ejecuta en último lugar antes de abandonar Try...Catch...Finally. Si ThisExcep no aparece en una instrucción de declaración como Dim, la instrucción Catch con la cláusula As sirve como declaración de la variable de excepción.

5.7.2 Estructuras de bucles Las estructuras de bucles permiten ejecutar una o más líneas de código repetitivamente. 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 bucles que admite Visual Basic incluyen:

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

5.7.2.1 While (Instrucción) Se puede utilizar la instrucción While para ejecutar un bloque de instrucciones, un número de veces indefinido, dependiendo del valor de tipo Boolean de 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 permanezca en True. En el ejemplo siguiente, el procedimiento CheckWhile 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. 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 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 ExitWhileExample() Dim Counter As Integer = 0



Dim Number As Integer = 8 While Number <> 10 If Number < 0 Then Exit While Number = Number - 1 Counter = Counter + 1 End While MsgBox("The loop ran " & Counter & " times.") ' Runs 9 times. End Sub Nota Para detener un bucle sin fin, presione ESC o CTRL+INTER.

5.7.2.2 Do...Loop (Instrucciones) Puede utilizar instrucciones Do...Loop para ejecutar un bloque de instrucciones un número de veces indefinido dependiendo del valor de tipo Boolean de 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 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. 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 procedimiento 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.") ' Runs 4 times. End Sub ' ... 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.") ' Runs 1 time. End Sub Repetir instrucciones hasta que una condición sea True Hay dos maneras de utilizar la palabra clave Until 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 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 CheckWhileLast, las instrucciones 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.") ' Runs 5 times. 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.") ' Runs 5 times. 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 ejecutarse un número extremadamente elevado de veces e incluso infinitamente. 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.") ' Runs 8 times. End Sub Nota Para detener un bucle sin fin, presione ESC o CTRL+INTER. Reemplazar la instrucción Continue Visual Basic .NET no admite la instrucción Continue de anteriores versiones de Visual Basic. Sin embargo, es posible obtener la misma funcionalidad si se utiliza una etiqueta de instrucción en la instrucción Loop y se bifurca hacia ella desde el interior del bucle: Dim LoopCounter As Integer = 0 Do While LoopCounter < 100 LoopCounter += 1 Dim SkipToNextIteration As Boolean ' Local to this loop. ' Processing, which might change value of SkipToNextIteration. If SkipToNextIteration = True Then GoTo EndOfLoop ' More processing if SkipToNextIteration was still False. EndOfLoop: Loop ' Acts like Continue.

5.7.2.3 For...Next (Instrucciones) Los 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 previsto 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 [ As datatype ] = start To end [ Step step ] ' Statement block to be executed for each value of counter. Next [ counter ]

La variable counter debe ser un tipo de datos numérico que admita los operadores mayor o igual que (>=), menor o igual 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. Normalmente también son Integer. El valor opcional step puede ser positivo o negativo. Si se omite, se considera que es 1. Si counter no está declarada fuera del bucle, puede utilizar la cláusula As para declararla como parte de la instrucción For. Al iniciarse la ejecución del bucle For...Next, Visual Basic evalúa start, end y step. Después asigna start a counter. Antes de ejecutar el bloque de instrucciones, 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 comparar 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. El bucle no termina hasta que counter haya superado el valor final. Si counter es igual a end, el bucle continúa. La comparación que determina si se ejecuta el bloque es counter <= end si step es positivo y counter >= end si step es negativo. 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 contadora I y sus valores start y



end. 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 = 0 To UBound(A) A(I) = 128 Next I End Sub

Los valores de iteración start, end y step sólo se evalúan una vez, antes de iniciarse el bucle. Si 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 longitud 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 J se 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. 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

Salir de un bucle For...Next antes de que el contador supere su valor final Puede salir de un bucle For...Next antes de que el contador supere su valor final utilizando la instrucción Exit For. Por ejemplo, puede desear salir de un bucle

si detecta una condición que hace que sea innecesario o no se pueda continuar la iteración, como puede ser un valor erróneo o una solicitud de finalización. Asimismo, si detecta una excepción en Try...Catch...Finally, puede utilizar Exit For al final del bloque Finally.

5.7.2.4 For Each...Next (Instrucciones) 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 [ As datatype ] In collection ' Statement block to be executed for each value of elementvariable. 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. Si elementvariable no está declarada fuera del bucle, puede utilizar la cláusula As para declararla como parte de la instrucción For Each. Para cada iteración del bucle, Visual Basic establece la variable elementvariable en uno de los elementos de la colección y ejecuta el bloque de instrucciones. 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 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 Each. El siguiente procedimiento acepta un formulario y establece el color de fondo de cada control del formulario en azul claro: Sub LightBlueBackground(ByVal ThisForm As System.Windows.Forms.Form) Dim ThisControl As System.Windows.Forms.Control For Each ThisControl In ThisForm.Controls ThisControl.BackColor = System.Drawing.Color.LightBlue Next ThisControl End Sub La colección debe ser un objeto que implemente la interfaz IEnumerable del espacio de nombres System.Collections. IEnumerable define el método GetEnumerator, que devuelve un objeto enumerador para la colección. El objeto enumerador expone la propiedad Current y el método MoveNext. Visual Basic utiliza éstos para recorrer la colección. El tipo



de datos de los elementos devueltos por Current debe ser convertible al tipo de datos de elementvariable. Modificar elementos La propiedad Current del objeto enumerador es ReadOnly y devuelve una copia local de cada elemento de la colección. Esto significa que no es posible modificar los propios elementos en un bucle For Each...Next. Cualquier modificación que haga afectará sólo a la copia local de Current y no se verá reflejada de nuevo en la colección. Sin embargo, si un elemento es un tipo de referencia, es posible modificar los miembros de la instancia a los que apunta. Esta es la razón por la cual, en el ejemplo anterior, se puede modificar el miembro BackColor de cada elemento ThisControl, aunque no se pueda modificar el propio ThisControl. Acceso a matrices Dado que System.Array implementa la interfaz IEnumerable, todas las matrices exponen el método GetEnumerator. Esto significa que es posible recorrer una matriz con un bucle For Each...Next. Sin embargo, sólo podrá leer los elementos de la matriz, no modificarlos. El propósito del siguiente procedimiento es calcular la suma de los elementos de una matriz y reiniciar cada elemento a cero: Function SumAndReset(ByRef A() As Integer) As Integer Dim Elt As Integer Dim Sum As Integer = 0 For Each Elt In A Sum += Elt Elt = 0 Next Elt Return Sum End Function

La suma funciona según los esperado, porque se basa sólo en leer los elementos. Sin embargo, la reinicialización a cero no funciona según lo esperado, porque sólo se reinicia a cero la copia local mientras los elementos originales permanecen sin modificar en la colección. Alterar la colección El objeto enumerador no permite alterar la colección mediante la adición, eliminación, sustitución o reordenación de elementos. Si altera la colección después de haber iniciado un bucle For Each...Next, el objeto enumerador deja de ser válido y el siguiente intento de acceso a un elemento produce una excepción InvalidOperationException. Recorrer la colección

Cuando se ejecuta un bucle For Each...Next, el recorrido de la colección está bajo el control del objeto enumerador devuelto por el método GetEnumerator. El orden de recorrido no lo determina Visual Basic, sino el método MoveNext del objeto enumerador. Esto significa que tal vez no pueda predecir qué elemento de la colección es el primero que se devuelve en elementvariable o qué elemento es el siguiente en ser devuelto tras un elemento dado. 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 expone la colección. Es posible que obtenga resultados más confiables si utiliza un bucle diferente, tal como For...Next o Do...Loop. Salir de un bucle For Each...Next antes de terminar con la colección Puede salir de un bucle For Each...Next antes de que haya recorrido la colección mediante la instrucción Exit For. Por ejemplo, puede desear salir de un bucle si detecta una condición que hace que sea innecesario o no se pueda continuar la iteración, como puede ser un valor erróneo o una solicitud de finalización. Asimismo, si detecta una excepción en Try...Catch...Finally, puede utilizar Exit For al final del bloque Finally.

5.7.3 Bucles For...Next más rápidos La actualización de las variables Integer es un poco más rápida que en el caso de las variables Short o Long. Esta diferencia sólo es apreciable si se realizan muchos miles de operaciones. No obstante, la diferencia entre Integer y Single o Decimal se aprecia más rápidamente. El ejemplo siguiente muestra algunas variaciones posibles: Dim Fastest As Integer ' First case -- Integer is fastest. For Fastest = 0 to 100000 ' Statements to execute for each value of Fastest. Next Fastest ' ... Dim NotAsFast As Long ' Second case -- Long is not as fast. For NotAsFast = 0 to 100000 ' Statements to execute for each value of NotAsFast. Next NotAsFast ' ... Dim MuchSlower As Decimal ' Third case -- Decimal is slower. For MuchSlower = 0 to 100000 ' Statements to execute for each value of MuchSlower. Next MuchSlower



En el primer caso anterior, la ejecución tarda un poco menos que en el segundo caso. Sin embargo, si Fastest supera 2.147.483.647 se produce un error. Esto se soluciona en los casos segundo y tercero, puesto que los tipos Long y Decimal aceptan una gama más amplia de enteros, aunque se ejecutan más lentamente. Para tipos de datos que utilizan 4 o más bytes, la manipulación de tipos más pequeños suele requerir menos tiempo que la de tipos más grandes.

5.7.4 With...End With (Instrucciones) En Visual Basic generalmente se debe especificar un objeto en cada instrucción que llame a uno de sus métodos o que tenga acceso a una de sus propiedades. Sin embargo, si tiene una serie de instrucciones que operan en un mismo objeto, puede utilizar una instrucción With...End With para especificar el objeto solo una sola vez para todas las instrucciones. De este modo puede acelerar la ejecución de los procedimientos y evitar la escritura repetitiva. El ejemplo siguiente establece el color del primer plano y el estilo de fuente de una etiqueta según el valor de un argumento de procedimiento. Dim AlertLabel As New System.Windows.Forms.Label ' ... Sub AlertUser(ByVal Value As Long) With AlertLabel If Value = 0 Then .ForeColor = Color.Red .Font = New Font(.Font, FontStyle.Bold Or FontStyle.Italic) Else .Forecolor = Color.Black .Font = New Font(.Font, FontStyle.Regular) End If End With End Sub Puede anidar instrucciones With...End With para conseguir mayor eficacia. En el siguiente ejemplo se inserta una fórmula en la celda A1 y después se da formato a la fuente. Sub MyInput() With Workbooks("Book1").Worksheets("Sheet1").Cells(1, 1) .Formula = "=SQRT(50)" With .Font .Name = "Arial" .Bold = True .Size = 8 End With End With End Sub

5.7.5 Instrucciones de control anidadas

Puede colocar instrucciones de control dentro de otras instrucciones de control, por ejemplo un bloque If...Then...Else dentro de un bucle For...Next. Cuando una instrucción de control se coloca dentro de otra, se dice que está anidada. En Visual Basic, las instrucciones de control pueden anidarse tantos niveles como se desee. A fin de que las estructuras de decisión y los bucles anidados sean más fáciles de leer, es práctica habitual aplicar sangría al cuerpo de cada uno. En el siguiente ejemplo, el procedimiento suma los elementos positivos de cada fila de la matriz: Public Sub SumRows(ByVal A(,) As Double, ByRef R() As Double) Dim I, J As Integer For I = 0 To UBound(A, 1) R(I) = 0 For J = 0 To UBound(A, 2) If A(I, J) > 0 Then R(I) = R(I) + A(I, J) End If Next J Next I End Sub

Observe que el primer Next cierra el bucle For interno y el último Next cierra el bucle For externo. Del mismo modo, en las instrucciones If anidadas, las instrucciones End If se aplican automáticamente a la instrucción If anterior más próxima. Los bucles Do anidados funcionan de forma similar; la instrucción Loop más interna está emparejada con la instrucción Do más interna.

5.7.6 Exit (Instrucción)

La instrucción Exit permite salir directamente de cualquier estructura de decisión, bucle o procedimiento. Transfiere inmediatamente la ejecución a la instrucción que sigue a la última instrucción de control. La sintaxis de la instrucción Exit especifica el tipo de instrucción de control desde la que se transfiere la ejecución. Son posibles las siguientes versiones de la instrucción Exit:

• Exit Select • Exit Try • Exit Do • Exit While • Exit For



También puede salir directamente de un procedimiento Function, Sub o Property; la sintaxis es parecida a la de Exit For y Exit Do:

• Exit Sub • Exit Function • Exit Property

Exit Sub, Exit Function y Exit Property pueden aparecer todas las veces que sea necesario, en cualquier punto del cuerpo del procedimiento. Incluso pueden aparecer dentro de una instrucción de control como If...Then...Else. Estas instrucciones son útiles cuando un procedimiento ha completado su cometido y puede volver inmediatamente.

5.7.6.1 Salir de instrucciones de control anidadas

Si se encuentra una instrucción Exit dentro de instrucciones de control anidadas, la ejecución continúa con la instrucción que sigue al final de la instrucción de control más interna del tipo especificado en la instrucción Exit. En el ejemplo siguiente, la instrucción Exit For se encuentra en el bucle For interno, de modo que pasa el control a la instrucción que sigue al bucle y continúa con el bucle For externo.

Public Sub InvertElements(ByRef A(,) As Double) Dim I, J As Integer For I = 0 To UBound(A, 1) For J = 0 To UBound(A, 2) If A(I, J) = 0 Then Exit For ' Cannot complete this row. Else A(I, J) = 1 / A(I, J) End If ' Control comes here if the Exit For is executed. Next J Next I End Sub

5.7.6.2 Múltiples instrucciones Exit

La instrucción Exit en cualquiera de sus formas puede aparecer tantas veces como sea necesaria dentro del bucle o instrucción apropiados. En el siguiente ejemplo se muestra esto dentro de un bucle Do:

Dim x, y, z As Double

Do Until y = -1 If x < 0 Then Exit Do x = Math.Sqrt(x) If y > 0 Then Exit Do y = y + 3 If z = 0 Then Exit Do z = x / z Loop

La instrucción Exit Do funciona con todas las versiones de sintaxis del bucle Do (con While o Until) y Exit For funciona con todas las versiones de sintaxis del bucle For (con o sin Each).

6 Procedimientos Un procedimiento es un bloque de instrucciones de Visual Basic delimitado por una instrucción de declaración y una instrucción End. En Visual Basic, todo el código se incluye dentro de procedimientos. Los procedimientos se invocan desde otras partes del código. Cuando finaliza la ejecución de un procedimiento, éste devuelve el control al código que lo invocó, que recibe el nombre de código de llamada. El código de llamada es una instrucción o una expresión contenida en una instrucción, que hace referencia al procedimiento por su nombre y le transfiere el control. Tipos de procedimientos Visual Basic utiliza varios tipos de procedimientos: Los procedimientos Sub ejecutan acciones, pero no devuelven un valor al código de llamada. Los procedimientos de control de eventos son procedimientos Sub que se ejecutan en respuesta a un evento desencadenado por una acción del usuario o por un suceso en un programa. Los procedimientos Function devuelven un valor al código de llamada. Los procedimientos Property devuelven y asignan valores de propiedades en objetos o módulos. Procedimientos y código estructurado

Todas las líneas de código de una aplicación deben encontrarse dentro de un procedimiento, por ejemplo, Main, Calculate o Button1_Click. La aplicación se leerá con mayor facilidad si subdivide los procedimientos grandes en procedimientos más pequeños.

Los procedimientos son útiles para realizar tareas repetitivas o compartidas, como cálculos de uso



frecuente, manipulación de texto y controles, y operaciones con bases de datos. Se puede llamar a un procedimiento desde distintos lugares del código; de modo que los procedimientos se prestan a servir de unidades de creación de la aplicación.

La estructuración del código en procedimientos aporta las siguientes ventajas:

• Los procedimientos permiten desglosar los programas en unidades lógicas independientes. Es más fácil depurar unidades individuales que todo un programa sin procedimientos.

• Los procedimientos desarrollados para un programa pueden utilizarse en otros programas, generalmente sin tener que realizar apenas modificaciones.

6.1 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 llamar desde cualquier parte de una aplicación.

6.1.1 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 = defaultvalue

6.1.2 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 paréntesis. El uso de la palabra clave Call también es opcional. 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 muestra 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 identifica la tarea que se va a iniciar. Sub TellOperator(ByVal Task As String) Dim Stamp As Date ' Stamp is local to TellOperator. Stamp = TimeOfDay() ' Get current time for time stamp. ' Use MessageBox class of System.Windows.Forms namespace. MessageBox.Show("Starting " & Task & " at " & CStr(Stamp)) End Sub

Una llamada típica a TellOperator tendría esta forma: Call TellOperator("file update")

6.2 Procedimientos Function Un procedimiento Function consiste en una serie de instrucciones de Visual Basic delimitadas por las instrucciones Function y End Function. Cada vez que se llama a un procedimiento de este tipo, se ejecutan las instrucciones de éste, desde la primera instrucción ejecutable tras la instrucció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 ademá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. Los procedimientos Function pueden definirse en módulos, clases y estructuras. 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.

6.2.1 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 immediately. ' ... 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 instrucció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 generan errores de compilación: Function AllOnes(ByVal N As Integer) As Integer() Dim I As Integer ' Singleton Integer, not Integer array. 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() ' Compiler error: call with no argument. End Function

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 Date ' ... End Function Function FindSqrt(ByVal Number As Single) As Single ' ... End Function

6.2.2 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 expresió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 Math.Sqrt((Side1 ^ 2) + (Side2 ^ 2)) End Function

Son llamadas habituales a Hypotenuse las siguientes: Dim TestLength, TestHypotenuse, X, Y, Area As Single TestHypotenuse = Hypotenuse(TestLength, 10.7) ' Assume TriangleArea is a defined Function procedure — the ' returned value from Hypotenuse is used as an argument to TriangleArea. 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 StrComp. 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.

6.3 Procedimientos Property

Un procedimiento Property consiste en una serie de instrucciones de Visual Basic que manipulan una propiedad personalizada en un módulo, una clase o una estructura. Los procedimientos Property también se conocen como descriptores de acceso de propiedades.

Una propiedad se diferencia de una variable pública o de un campo en los siguientes aspectos:

Una propiedad se implementa con código ejecutable (sus procedimientos Property), y no con una instrucción de declaración individual. Los procedimientos Property se ejecutan cuando se establece o se recupera el valor de la propiedad. Esto permite que una clase realice acciones personalizadas cuando el código del cliente obtiene acceso a la propiedad. Una propiedad no tiene asociada a su declaración ninguna ubicación de almacenamiento. Aunque los procedimientos Property suelen definir constantes y variables locales, éstas no suelen estar disponibles para el código de acceso a la propiedad. Por lo tanto, aunque es posible incluir una variable o un campo como miembro de una estructura o una matriz, no lo es en el caso de una propiedad.

• Una propiedad puede definirse como de sólo lectura, sólo escritura o lectura y escritura. El valor predeterminado es de lectura y escritura.

Visual Basic proporciona los siguientes procedimientos Property: Los procedimientos Get devuelven el valor de una propiedad; se llama a estos procedimientos cuando se obtiene acceso a la propiedad en una expresión. Los procedimientos Set establecen el valor de una propiedad, e incluyen una referencia de objeto; se llama a estos procedimientos cuando se le asigna un valor a la propiedad. Normalmente los procedimientos Property se definen por parejas, utilizando las palabras clave Get y Set, pero si la propiedad es de sólo lectura (Get) o de sólo escritura (Set) puede definirse cada procedimiento de forma individual.

6.3.1 Declaración de propiedades

Una propiedad se define mediante un bloque de código delimitado por las instrucciones Property y End Property. Dentro del bloque, cada procedimiento Property aparece como un bloque interno encerrado entre una instrucción de declaración (Get o Set) y una instrucción End. La sintaxis para declarar una propiedad y sus procedimientos es la siguiente:

[Default] [accessibility] Property propertyname[(argumentlist)] As datatype Get ' ... Return expression ' expression is returned as property's value. End Get Set [(ByVal newvalue As datatype)] ' ... lvalue = newvalue ' newvalue is the new value to be assigned. End Set End Property La accesibilidad puede ser Public, Protected, Friend, Protected Friend o Private. Las propiedades pueden definirse en clases, estructuras y módulos. De forma predeterminada las propiedades son Public, es decir, pueden llamarse desde cualquier parte de una aplicación.

6.3.2 Declaración de argumentos

Los argumentos se declaran del mismo modo que en un procedimiento Function o Sub, a excepción de que el mecanismo utilizado para pasar el argumento es por valor.

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

[Optional] ByVal [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 argumentname As datatype = defaultvalue



En un procedimiento Get, el valor devuelto se suministra a la expresión de llamada como valor de la propiedad. En un procedimiento Set, el nuevo valor de la propiedad se pasa a través del argumento de la instrucción Set. Si un argumento se declara de forma explícita, el tipo de datos de éste debe ser el mismo que el de la propiedad. Si no se declara un argumento, el compilador utiliza el argumento implícito Value para representar el nuevo valor que se va a asignar a la propiedad.

6.3.3 Sintaxis de llamada Un procedimiento Property se invoca de forma implícita mediante el código que hace referencia a la propiedad. El código utiliza el nombre de la propiedad del mismo modo que si se tratase del nombre de una variable, a excepción de que debe suministrar valores a todos los argumentos que no sean opcionales, y debe encerrar la lista de argumentos entre paréntesis. Si no se proporcionan argumentos, se puede omitir el paréntesis. La sintaxis de una llamada implícita a un procedimiento Set Property es la siguiente: propertyname[(argumentlist)] = expression

Los siguientes ejemplos de llamadas muestran la sintaxis de llamada permitida para un procedimiento Get Property:

lvalue = propertyname[(argumentlist)] Do While (propertyname[(argumentlist)] > expression) Nota El tipo de datos de una propiedad y el acceso a dicha propiedad se definen en la instrucción Property, no en los procedimientos Property. Una propiedad sólo puede tener un tipo de datos y un tipo de accesibilidad. Por ejemplo, no puede definirse una propiedad de forma que establezca un valor Decimal, y que a la vez obtenga un valor Double. Del mismo modo, Private Set y Public Get no pueden definirse en la misma propiedad. Para conseguir esta funcionalidad, puede definir un propiedad Public ReadOnly y un método de configuración Private independiente de la propiedad.

6.4 Argumentos de procedimientos En la mayoría de los casos, un procedimiento necesita algunos datos sobre las circunstancias en las que se le ha llamado. Un procedimiento que ejecuta tareas repetidas o compartidas utiliza datos distintos en cada

llamada. Estos datos se componen de variables, constantes y expresiones que se pasan al procedimiento cuando se le llama. Un valor que se pasa a un procedimiento se denomina argumento.

6.4.1 Declaración del tipo de datos de un argumento

El tipo de datos de un argumento se declara utilizando la cláusula As en su declaración. Por ejemplo, la siguiente función acepta una cadena y un entero: Function Appointment(ByVal Day As String, ByVal Hour As Integer) As String ' Code to return any appointment for the given day and time. End Function

Si el modificador de comprobación de tipos (Option Strict (Instrucción)) está desactivado, la cláusula As será opcional, salvo que alguno de los argumentos la utilice, en cuyo caso el resto de los argumentos tendrá que utilizarla también. Si la comprobación de tipos está activada, la cláusula As será obligatoria para todos los argumentos del procedimiento. Si desea pasar diferentes tipos de datos a un argumento en particular, tales como Byte a Integer o clases de enlace en tiempo de ejecución a Object, deberá tener Option Strict Off.

6.4.2 Pasar un argumento con ByVal y ByRef

En Visual Basic, puede pasarse un argumento a un procedimiento por valor o por referencia, especificando las palabras clave ByVal o ByRef, respectivamente. Pasar un argumento por valor implica que el procedimiento no puede modificar el contenido del elemento variable en el código de llamada subyacente al argumento. Pasar un argumento por referencia permite que el procedimiento modifique el contenido de la misma forma que puede hacerlo el propio código de llamada. La distinción que se hace entre pasar los argumentos por valor y por referencia no tiene nada que ver con la clasificación de los tipos de datos en tipos de valor y tipos de referencia. No obstante, ambas categorías interactúan entre sí.

6.4.3 Argumentos variables y no variables

El elemento de programación subyacente a un argumento puede ser un elemento variable, con capacidad para cambiar de valor, o un elemento no variable. La siguiente tabla muestra elementos variables y no variables.



Elementos variables Elementos no variables

Variables declaradas, incluidas las variables de objetos

Constantes

Campos (de clases) Literales

Elementos matriciales Enumeraciones

Elementos estructurales Expresiones

Los argumentos no variables no se modifican nunca en el código de llamada, aunque se pasen por referencia. El procedimiento al que se llama podría modificar su copia del argumento no variable, pero la modificación no afectaría al elemento subyacente al código de llamada.

6.4.4 Mecanismo para pasar argumentos

Si se pasa un elemento no variable como argumento, el procedimiento no podrá modificarlo nunca en el código de llamada, se pase con ByVal o con ByRef. En la tabla siguiente se resume, para un elemento variable, la interacción entre el tipo de datos del elemento y el mecanismo para pasarlos.

Tipo de elemento

Pasado con ByVal

Pasado con ByRef

Tipo de valor (sólo contiene un valor)

El procedimiento no puede modificar la variable ni ninguno de los miembros de ésta.

El procedimiento puede modificar lavariable y losmiembros deésta.

Tipo de referencia (contiene un puntero a una instancia de clase o estructura)

El procedimiento no puede modificar la variable, pero puede cambiar los miembros de la instancia a la que señala.

El procedimiento puede cambiarla variable ylos miembrosde la instanciaa la que señala.

6.4.4.1 Determinación del mecanismo para pasar argumentos

El mecanismo para pasar argumentos se determina en la declaración del procedimiento. El código de llamada no puede reemplazar a un mecanismo ByVal, pero, si un argumento se declara con ByRef, el código de llamada puede forzar al mecanismo para que pase el argumento por valor; para ello hay que encerrar el nombre del argumento entre paréntesis en la llamada. Esto se ilustra en el siguiente ejemplo:

Sub DoSomething(ByRef InString As String) ' Code that makes changes to InString. End Sub ' ... Dim Str As String = "Cannot be replaced if passed ByVal" Call DoSomething((Str)) ' Pass Str ByVal even though declared ByRef. ' The parentheses around Str protect it from change.

En Visual Basic, el valor predeterminado es pasar los argumentos por valor. Este código se puede leer con más facilidad si se utiliza la palabra clave ByVal, como en el ejemplo siguiente:

Sub PostAccounts(ByVal AcctNum As Integer) ' Code to post accounts. End Sub

Cuando se pasa una variable por referencia, debe utilizarse la palabra clave ByRef para especificar este mecanismo. El ejemplo anterior puede ampliarse con un segundo argumento, como se muestra a continuación:

Sub PostAccount(ByVal AcctNum As Integer, ByRef RunningTotal As Single) ' Code to post account for AcctNum and change value of RunningTotal. End Sub

Es un hábito de programación recomendado incluir la palabra clave ByVal o ByRef con cada argumento que declare.

6.4.4.2 Selección del mecanismo para pasar argumentos

A la hora de elegir uno de los dos mecanismos que existen para pasar argumentos, el criterio más importante que hay que tener en cuenta es la exposición al cambio de las variables de llamada. La ventaja de pasar un argumento con ByRef es que el procedimiento puede devolver un valor al código de



llamada por medio del argumento. La ventaja de pasarlo con ByVal es que protege a la variable de los cambios que sobre ella pueda efectuar el procedimiento. Aunque el mecanismo que se utilice para pasar argumentos también puede afectar al rendimiento del código, la diferencia suele ser insignificante. Existe una excepción: cuando se pasa un tipo de valor con ByVal. En esta caso, Visual Basic copia todo el contenido de los datos del argumento. Por lo tanto, para un tipo de valor grande, como una estructura, lo más eficiente es pasarlo con ByRef. Para los tipos de referencia, sólo se copia el puntero de cuatro bytes a los datos. Por lo tanto, se pueden pasar argumentos de tipo String u Object ByVal sin perjudicar al rendimiento.

6.4.4.3 Pasar argumentos con ByVal Si pasa un argumento variable por valor utilizando la palabra clave ByVal, el procedimiento no puede modificar la propia variable. No obstante, si el argumento es un tipo de referencia, puede modificar los miembros del objeto al que señala, aunque no pueda reemplazar el propio objeto. En concreto, puede modificar los miembros del objeto. Por ejemplo, si el argumento es una variable de matriz, no puede asignarle otra matriz, pero sí puede cambiar uno o más de sus elementos. La modificación de los elementos queda reflejada en la variable de matriz subyacente al código de llamada.

6.4.4.4 Pasar argumentos con ByRef Si pasa un argumento variable por referencia utilizando la palabra clave ByRef, el procedimiento puede modificar la propia variable. En concreto, si el argumento es una variable de objeto, puede asignarle un nuevo objeto. Esta reasignación también afecta a la variable de objeto del programa de llamada.

6.4.5 Argumentos opcionales Un argumento de un procedimiento puede ser opcional si así se especifica, es decir, que no es necesario suministrarlo al llamar al procedimiento. Los argumentos opcionales se indican mediante la palabra clave Optional en la definición del procedimiento. Se aplican las siguientes reglas:

• Todos los argumentos opcionales de la definición del procedimiento deben especificar un valor predeterminado.

• El valor predeterminado de un argumento opcional debe ser una expresión constante.

• Todos los argumentos que vayan a continuación de un argumento opcional en la definición del procedimiento también deben ser opcionales.

La siguiente sintaxis muestra una declaración de procedimiento con un argumento opcional: Sub subname(ByVal arg1 As type1, Optional ByVal arg2 As type2 = default)

6.4.6 Llamar a procedimientos con argumentos opcionales

Cuando se llama a un procedimiento con un argumento opcional, se puede elegir si se suministra o no el argumento. Si no se suministra, el procedimiento utiliza el valor predeterminado declarado para dicho argumento. Si se omiten uno o más argumentos opcionales de la lista de argumentos, hay que utilizar comas sucesivas para delimitar sus posiciones. En el ejemplo de llamada siguiente se suministran los argumentos primero y cuarto, pero no el segundo ni el tercero: Call subname(arg1, , , arg4) ' Leaves out arg2 and arg3.

6.4.7 Determinar si un argumento opcional está presente

En tiempo de ejecución un procedimiento no puede detectar si un argumento determinado se ha omitido o si el código de llamada ha suministrado de forma explícita el valor predeterminado de dicho argumento. Si fuese necesario hacer esta distinción, se podría establecer como valor predeterminado un valor improbable. El procedimiento que se muestra a continuación incluye el argumento opcional Office y comprueba si su valor predeterminado, QJZ, ha sido omitido: Sub Notify(ByVal Company As String, Optional ByVal Office As String = "QJZ") If Office = "QJZ" Then Debug.WriteLine("Office not supplied -- notifying Headquarters") Office = "Headquarters" End If ' Code to notify headquarters or specified office. End Sub

Si el argumento opcional es un tipo de referencia, como String, puede utilizar Nothing como valor predeterminado, siempre y cuando éste no sea un valor esperado para el argumento. Otra forma de definir un procedimiento con argumentos opcionales consiste en utilizar una



sobrecarga. Si tiene un argumento opcional, puede definir dos versiones sobrecargadas del procedimiento, una con el argumento y otra sin él. Este planteamiento se complica a medida que aumenta el número de argumentos opcionales. No obstante, tiene la ventaja de que permite saber con total certeza si el programa de llamada ha suministrado o no cada argumento opcional.

6.4.8 Matrices de parámetros Normalmente no es posible llamar a un procedimiento con un número de argumentos superior al especificado en la declaración del procedimiento. Si se necesita un número indeterminado de argumentos, puede declararse una matriz de parámetros, que permite que un procedimiento acepte una matriz de valores para un argumento. No es necesario conocer el número de elementos de la matriz de parámetros en el momento de definir el procedimiento. El tamaño de la matriz se determina individualmente en cada llamada al procedimiento. Utilice la palabra clave ParamArray para denotar una matriz de parámetros. Se aplican las siguientes reglas:

• Un procedimiento sólo puede tener una matriz de parámetros, que debe ser el último argumento de la definición del procedimiento.

La matriz de parámetros debe pasarse por valor. Es un hábito de programación recomendado incluir de manera explícita la palabra clave ByVal en la definición del procedimiento. El código del procedimiento debe considerar a la matriz de parámetros una matriz unidimensional; el tipo de datos de los elementos de la matriz ha de ser el mismo que el tipo de datos de ParamArray.

• La matriz de parámetros es opcional de forma automática. Su valor predeterminado es una matriz unidimensional vacía del tipo de elemento de la matriz de parámetros.

• Todos los argumentos que preceden a la matriz de parámetros deben ser obligatorios. La matriz de parámetros debe ser el único argumento opcional.

Cuando uno de los argumentos del procedimiento al que se llame sea una matriz de parámetros, ésta podrá tomar cualquiera de estos valores:

Ninguno, es decir, puede omitirse el argumento ParamArray. En este caso, se pasará una matriz vacía al procedimiento. También puede pasarse la palabra clave Nothing, obteniéndose el mismo efecto. Una lista con un número de argumentos indeterminado, separados por comas. El tipo de los datos de cada argumento debe poder convertirse implícitamente al tipo de elemento ParamArray.

• Una matriz con el mismo tipo de elemento que la matriz de parámetros.

En el siguiente ejemplo se muestra cómo se puede definir un procedimiento con una matriz de parámetros:

Sub StudentScores(ByVal Name As String, ByVal ParamArray Scores() As String) Dim I As Integer Debug.WriteLine("Scores for " & Name & ":") ' Use UBound function to determine largest subscript of array. For I = 0 To UBound(Scores) Debug.WriteLine("Score " & I & ": " & Scores(I)) Next I End Sub

En los siguientes ejemplos se muestran llamadas típicas a StudentScores:

StudentScores("Anne", "10", "26", "32", "15", "22", "24", "16") StudentScores("Mary", "High", "Low", "Average", "High") Dim JohnScores() As String = {"35", "Absent", "21", "30"} StudentScores("John", JohnScores)

7 Funciones de Visual Basic .NET

7.1 Manipulación de cadenas La clase String de .NET Framework proporciona muchos métodos integrados para facilitar la comparación y manipulación de cadenas. Ahora resulta sencillo obtener datos acerca de una cadena, o crear nuevas cadenas mediante la manipulación de las cadenas actuales. El lenguaje Visual Basic .NET



también tiene métodos inherentes que duplican muchas de estas funcionalidades.

7.1.1 Tipos de métodos de manipulación de cadenas

En esta sección se describen diferentes formas de analizar y manipular cadenas. Algunos métodos son parte del lenguaje Visual Basic, mientras que otros son inherentes a la clase String. Los métodos de Visual Basic .NET se utilizan como funciones inherentes al lenguaje. Pueden utilizarse sin calificación en el código. En el siguiente ejemplo se muestra el uso habitual de un comando de manipulación de cadenas de Visual Basic .NET: Dim aString As String = "SomeString" Dim bString As String bString = Mid(aString, 3, 3) En este ejemplo, la función Mid realiza una operación directa en aString y asigna el valor a bString. También puede manipular cadenas con los métodos de la clase String. Existen dos tipos de métodos en String: métodos compartidos y métodos de instancia. Un método compartido es un método que se deriva de la propia clase String y no necesita una instancia de dicha clase para funcionar. Estos métodos se pueden calificar con el nombre de la clase (String) en vez de con una instancia de dicha clase. Por ejemplo: Dim aString As String bString = String.Copy("A literal string") En el ejemplo anterior, el método String.Copy es un método estático, que actúa sobre una expresión dada y asigna el valor resultante a bString. En contraste, los métodos de instancia se derivan de una instancia concreta de String y deben calificarse con el nombre de la instancia. Por ejemplo: Dim aString As String = "A String" Dim bString As String bString = aString.SubString(2,6) ' bString = "String"

En este ejemplo, el método SubString es un método de la instancia de String (es decir, aString). Realiza una operación en aString y asigna ese valor a bString.

7.1.2 Nothing y cadenas El tiempo de ejecución de Visual Basic y .NET Framework evalúan Nothing de modo diferente cuando se trata de cadenas. Considere el ejemplo siguiente: Dim MyString As String = "This is my string" Dim stringLength As Integer ' Explicitly set the string to Nothing. MyString = Nothing ' stringLength = 0

stringLength = Len(MyString) ' This line, however, causes an exception to be thrown. stringLength = MyString.Length El tiempo de ejecución de Visual Basic .NET evalúa Nothing como una cadena vacía, es decir, como "". Sin embargo, .NET Framework, no lo hace, e iniciará una excepción cuando se intente realizar una operación de cadena en Nothing.

7.1.3 Comparar cadenas Puede comparar dos cadenas con el método String.Compare. Éste es un método estático sobrecargado de la clase de cadena base. En su forma más común, este método puede utilizarse para comparar directamente dos cadenas basándose en el orden alfabético. Funciona de manera similar a la función StrComp (Función) de Visual Basic. En el siguiente ejemplo se ilustra cómo se utiliza este método: Dim myString As String = "Alphabetical" Dim secondString As String = "Order" Dim result As Integer result = String.Compare (myString, secondString) Este método devuelve un entero que indica la relación entre las dos cadenas comparadas basándose en el criterio de ordenación. Un resultado con un valor positivo indica que la primera cadena es mayor que la segunda. Un resultado negativo indica que la primera cadena es más pequeña y cero indica igualdad entre la dos cadenas. Cualquier cadena, incluida una cadena vacía, se evalúa como mayor que una referencia nula. Las sobrecargas adicionales del método String.Compare permiten indicar si deben tenerse en cuenta los formatos de mayúsculas y minúsculas y las referencias culturales, y si deben compararse subcadenas dentro de las cadenas proporcionadas.

7.1.4 Buscar cadenas dentro de cadenas

En ocasiones es útil tener información sobre los caracteres de una cadena y de su posición dentro de la cadena. Una cadena se puede considerar como una matriz de caracteres (instancias Char); se puede recuperar un carácter concreto haciendo referencia al índice de dicho carácter a través de la propiedad Chars. Por ejemplo: Dim myString As String = "ABCDE" Dim myChar As Char myChar = myString.Chars(3) ' myChar = "D" Puede utilizar el método String.IndexOf para que devuelva el índice donde se encuentra un carácter concreto, como en el siguiente ejemplo: Dim myString As String = "ABCDE"



Dim myInteger As Integer myInteger = myString.IndexOf("D") ' myInteger = 3

En el ejemplo anterior, se utilizó el método IndexOf de myString para obtener el índice correspondiente a la primera instancia del carácter "C" de la cadena. IndexOf es un método sobrecargado; las otras sobrecargas proporcionan métodos para buscar cualquiera de los caracteres de un conjunto o una cadena dentro de otra cadena, entre otros. El comando InStr de Visual Basic .NET también permite realizar funciones similares.

7.1.5 Crear nuevas cadenas a partir de cadenas existentes

Cuando utiliza cadenas, puede que desee modificar las que tiene para crear otras nuevas. Puede que desee hacer algo tan simple como convertir toda la cadena a mayúsculas o eliminar los espacios finales; o hacer algo más complejo, como extraer una subcadena de una cadena. La clase System.String proporciona una amplia gama de opciones para modificar, manipular y crear nuevas cadenas a partir de las existentes. Para combinar varias cadenas, puede utilizar los operadores de concatenación (& o +). También puede utilizar String.Concat (Método) para concatenar una serie de cadenas o cadenas contenidas en objetos. A continuación se muestra un ejemplo del método String.Concat: Dim aString As String = "A" Dim bString As String = "B" Dim cString As String = "C" Dim dString As String = "D" Dim myString As String ' myString = "ABCD" myString = String.Concat(aString, bString, cString, dString)

Las cadenas se pueden convertir en cadenas totalmente en mayúsculas o totalmente minúsculas con funciones de Visual Basic .NET UCase (Función) o LCase (Función) o mediante los métodos String.ToUpper (Método) y String.ToLower (Método). A continuación se muestra un ejemplo: Dim myString As String = "UpPeR oR LoWeR cAsE" Dim newString As String ' newString = "UPPER OR LOWER CASE" newString = UCase(myString) ' newString = "upper or lower case" newString = LCase(myString) ' newString = "UPPER OR LOWER CASE" newString = myString.ToUpper ' newString = "upper or lower case" newString = myString.ToLower

El método String.Format y el comando Format de Visual Basic .Net pueden generar una nueva cadena mediante la aplicación de formato a una cadena

determinada. A veces puede ser necesario eliminar espacios iniciales o finales de una cadena. Por ejemplo, podría estar analizando una cadena que tiene espacios insertados con fines de alineación. Puede eliminar esos espacios con la función String.Trim (Método) o con la función Trim de Visual Basic .NET. A continuación se muestra un ejemplo: Dim spaceString As String = _ " This string will have the spaces removed " Dim oneString As String Dim twoString As String ' This removes all trailing and leading spaces. oneString = spaceString.Trim ' This also removes all trailing and leading spaces. twoString = Trim(spaceString) Si sólo desea quitar los espacios finales, puede utilizar el método String.TrimEnd (Método) o la función RTrim. Del mismo modo, si desea quitar los espacios iniciales, puede utilizar el método String.TrimStart (Método) o la función LTrim. Las funciones String.Trim y otras relacionadas también permiten eliminar instancias de un carácter específico al final de las cadenas. El siguiente ejemplo elimina todas las instancias iniciales y finales del carácter "#": Dim myString As String = "#####Remove those!######" Dim oneString As String OneString = myString.Trim("#")

También puede agregar caracteres iniciales o finales mediante los métodos String.PadLeft (Método) o String.PadRight (Método). Si tiene exceso de caracteres en el cuerpo de la cadena, puede eliminarlos con String.Remove (Método), o puede reemplazarlos con otro carácter mediante String.Replace (Método). Por ejemplo: Dim aString As String = "This is My Str@o@o@ing" Dim myString As String Dim anotherString As String ' myString = "This is My String" myString = aString.Remove(14, 5) ' anotherString = "This is Another String" anotherString = myString.Replace("My", "Another") Puede utilizar el método String.Replace para reemplazar caracteres individuales o cadenas de caracteres. La instrucción Mid (Instrucción) de Visual Basic .NET también se puede utilizar para reemplazar una cadena interior por otra. Asimismo, puede utilizar String.Insert (Método) para insertar una cadena dentro de otra, como en el ejemplo siguiente: Dim aString As String = "This is My Stng" Dim myString As String ' Results in a value of "This is My String". myString = aString.Insert(13, "ri")



El primer parámetro del método String.Insert es el índice del carácter tras el cual se insertará la cadena, y el segundo parámetro es la cadena que se va a insertar. Se puede concatenar una matriz de cadenas con una cadena separadora mediante String.Join (Método). El siguiente es un ejemplo: Dim shoppingItem(2) As String Dim shoppingList As String shoppingItem(0) = "Milk" shoppingItem(1) = "Eggs" shoppingItem(2) = "Bread" shoppingList = String.Join(",", shoppingItem)

El valor de shoppingList tras ejecutar este código es "Milk,Eggs,Bread". Es de reseñar que si la matriz tiene miembros vacíos, el método agrega igualmente una cadena separadora entre todas las instancias vacías de la matriz. También se puede crear una matriz de cadenas a partir de una sola cadena mediante String.Split (Método). En el siguiente ejemplo se demuestra lo contrario que en el ejemplo anterior: se convierte una lista de la compra en una matriz de artículos de la compra. En este caso el separador es una instancia del tipo de datos Char; por tanto, se le agrega el carácter de tipo literal c. Dim shoppingList As String = "Milk,Eggs,Bread" Dim shoppingItem(2) As String shoppingItem = shoppingList.Split(","c) La función Mid (Función) de Visual Basic .NET puede utilizarse para agregar subcadenas a una cadena. En el siguiente ejemplo se muestra el uso de estas funciones: Dim aString As String = "Left Center Right" Dim rString, lString, mString As String ' rString = "Right" rString = Mid(aString, 13) ' lString = "Left" lString = Mid(aString, 1, 4) ' mString = "Center" mString = Mid(aString, 6,6) También se pueden generar subcadenas de una cadena con String.Substring (Método). Este método acepta dos argumentos: el índice del carácter donde debe comenzar la subcadena y la longitud de la subcadena. El método String.Substring funciona de modo similar a la función Mid. A continuación se muestra un ejemplo: Dim aString As String = "Left Center Right" Dim subString As String ' subString = "Center" subString = aString.SubString(5,6)

Existe una diferencia muy importante entre el método String.SubString y la función Mid. La función Mid toma un argumento que indica la posición del carácter donde debe comenzar la subcadena, a partir de la

posición 1. El método String.SubString toma un índice del carácter de la cadena donde debe comenzar la subcadena, a partir de la posición 0. Así, si tiene una cadena "ABCDE", los caracteres individuales se numeran 1,2,3,4,5 si se utilizan con la función Mid, y 0,1,2,3,4 si se utilizan con el función System.String.

7.2 Analizar cadenas de fecha y hora [Visual Basic]

De forma parecida a la de los tipos numéricos, la clase DateTime tiene la capacidad de convertir una cadena en un objeto DateTime. Se pueden usar los métodos Parse y ParseExact para convertir una representación de cadena de una fecha u hora en un objeto DateTime. El método Parse convierte todas las representaciones de cadena válidas, mientras que el método ParseExact sólo convierte las cadenas con el formato que se especifique. Ambos métodos pueden convertir satisfactoriamente cualquier cadena que tenga el formato de uno de los modelos de DateTime estándar descritos en la sección Cadenas de formato de fecha y hora. Los valores utilizados para representar los nombres de los meses y los días, además del orden de presentación de los componentes de DateTime, se definen en los proveedores de formato. Los métodos Parse y ParseExact aceptan un proveedor de formato, lo que permite especificar y analizar explícitamente cadenas específicas de referencia cultural. Si no se especifica ningún proveedor de formato, se utiliza el proveedor asociado al subproceso actual. De manera predeterminada, toda información sobre la fecha y la hora, que no se encuentre en la cadena que se pasa, se rellena con la información de fecha y hora actual desde DateTime.Now. Por ejemplo, si se analiza la cadena "1/1/00", sólo se han especificado las propiedades Month, Year y Day de DateTime. Otras propiedades, como Minutes, Seconds y Ticks, se establecen en los valores actuales especificados en DateTime.Now. Este comportamiento se puede modificar especificando DateTimeStyles.NoCurrentDateDefault, que hace que Year, Month y Day se establezcan en "1" en lugar de en el año, el mes y el día actuales.

7.2.1 Parse

En el ejemplo de código siguiente se ilustra el uso del método Parse para convertir una cadena en DateTime. En este ejemplo, para realizar el análisis, se utiliza la referencia cultural asociada al subproceso



actual. Si el objeto CultureInfo asociado a la referencia cultural actual no puede analizar la cadena de entrada, se inicia una FormatException.

Dim MyString As String = "Jan 1, 2002" Dim MyDateTime As DateTime = DateTime.Parse(MyString) Console.WriteLine(MyDateTime)

También se puede especificar un objeto CultureInfo establecido en una de las referencias culturales que define dicho objeto. En el ejemplo de código siguiente se utiliza un proveedor de formato para analizar una cadena alemana en un objeto DateTime. Un objeto CultureInfo que representa la referencia cultural de-DE se define y se pasa con la cadena que se está analizando para garantizar el análisis correcto de esta cadena concreta. Esto descarta el valor que tenga CurrentCulture del CurrentThread.

Imports System.Globalization Dim MyCultureInfo As CultureInfo = new CultureInfo("de-DE") Dim MyString As String = "12 Juni 2002" Dim MyDateTime As DateTime = DateTime.Parse(MyString, MyCultureInfo) Console.WriteLine(MyDateTime)

En el ejemplo de código siguiente se utiliza la enumeración DateTimeStyles para especificar que la información de fecha y hora actual no se debe agregar al objeto DateTime en los campos que no defina la cadena.

Imports System.Globalization Dim MyCultureInfo As CultureInfo = new CultureInfo("de-DE") Dim MyString As String = "12 Juni 2002" Dim MyDateTime As DateTime = DateTime.Parse(MyString, MyCultureInfo, DateTimeStyles.NoCurrentDateDefault) Console.WriteLine(MyDateTime)

7.2.2 ParseExact El método ParseExact sólo convierte en objeto DateTime el modelo de cadena especificado. Cuando se pasa a este método una cadena que no tiene el formato especificado, se inicia una FormatException. Se puede definir uno de los especificadores de formato

de fecha y hora estándar o una combinación limitada de los especificadores de formato de fecha y hora personalizados. Si se usan los especificadores de formato personalizados, se puede construir una cadena de reconocimiento personalizada. En el ejemplo de código siguiente, se pasa al método ParseExact un objeto de cadena que se debe analizar, seguido de un especificador de formato, seguido de un objeto CultureInfo. Este método ParseExact sólo puede analizar cadenas que muestren el modelo de fecha larga de la referencia cultural en-US. Imports System.Globalization Dim MyCultureInfo As CultureInfo = new CultureInfo("en-US") Dim MyString As String = "Tuesday, April 10, 2001" Dim MyDateTime As DateTime = DateTime.ParseExact(MyString, "D", MyCultureInfo) Console.WriteLine(MyDateTime)

7.3 Manipulación de fechas y horas. Estructura DateTime.

El tipo de valor DateTime representa fechas y horas cuyos valores están comprendidos entre la medianoche (12:00:00) del 1 de enero de 0001 d.C. (era cristiana) y las 11:59:59 de la noche del 31 de diciembre de 9999 d.C. (era cristiana). Los valores de hora se miden en unidades de 100 nanosegundos, denominadas pasos, y una fecha concreta es el número de pasos transcurridos desde las 12:00 de la noche del 1 de enero de 1 d.C. (era cristiana) en el calendario GregorianCalendar. Por ejemplo, un valor en pasos de 31241376000000000L representa la fecha de viernes, 1 de enero de 0100 a las 12:00:00 de la noche. Un valor DateTime siempre se expresa en el contexto de un calendario explícito o predeterminado. Los tipos de valor DateTime y TimeSpan se diferencian en que DateTime representa un instante de tiempo, mientras que TimeSpan representa un intervalo de tiempo. Esto significa, por ejemplo, que se puede restar una instancia de DateTime de otra para obtener el intervalo de tiempo entre ambas. O bien, se podría agregar un TimeSpan positivo al DateTime actual para calcular una fecha futura. A una instancia de DateTime se le pueden sumar y restar valores de tiempo. Los valores de tiempo pueden ser positivos o negativos, y pueden expresarse en unidades tales como pasos, segundos o instancias de TimeSpan. Los métodos y las propiedades de este



tipo de valor tienen en cuenta una serie de detalles, como los años bisiestos y el número de días de un mes. Las descripciones de valores de tiempo de este tipo suelen expresarse utilizando el estándar de hora universal coordinada (UTC), que antes se denominaba hora media de Greenwich (GMT). Los cálculos y las comparaciones de instancias de DateTime sólo tienen significado si las instancias se crean en la misma zona horaria. Por este motivo, se da por sentado que el programador dispone de algún mecanismo externo, como una variable o una directiva explícita, para saber en qué zona horaria se creó un DateTime. A la hora de realizar cálculos o comparaciones, los métodos y las propiedades de esta estructura utilizan siempre la zona horaria local. Cuando se realiza un cálculo en una instancia de DateTime, como Add o Subtract, el valor de la instancia no se modifica. En lugar de ello, el cálculo devuelve una nueva instancia de DateTime cuyo valor es el resultado del cálculo. Cada miembro de DateTime usa de forma implícita el calendario gregoriano para realizar su operación, con la excepción de los constructores que especifican un calendario y los métodos que indican implícitamente un calendario con un parámetro derivado de IFormatProvider; por ejemplo, System.Globalization.DateTimeFormatInfo. Utilice la clase System.Globalization.Calendar para realizar las operaciones de fecha y hora con un calendario diferente. Este tipo se hereda de IComparable, IFormattable e IConvertible. Utilice la clase Convert para las conversiones en lugar de la implementación de miembro de interfaz explícita de IConvertible de este tipo.

7.4 Manipulación de Intervalos de Tiempo. Estructura TimeSpan.

El valor de una instancia de TimeSpan representa un período de tiempo. Ese valor corresponde al número de pasos (ticks) incluidos en la instancia y puede ir de Int64.MinValue a Int64.MaxValue. Un paso es la unidad de tiempo más pequeña que se puede especificar, y equivale a 100 nanosegundos. Tanto la especificación de un número de pasos como el valor de TimeSpan puede ser positivo o negativo. Se puede representar TimeSpan como una cadena con el formato "[-]d.hh:mm:ss.ff", donde "-" es un signo opcional para valores de TimeSpan negativos, el componente "d" corresponde a los días, "hh" a las horas, "mm" a los minutos, "ss" a los segundos y "ff"

a las fracciones de segundo. Por ejemplo, un TimeSpan inicializado con 1.0e+13 pasos (ticks) representa "11.13:46:40", lo cual corresponde a 11 días, 13 horas, 46 minutos y 40 segundos. Debido a la variación del número de días en meses y años, la unidad mayor de tiempo que utiliza TimeSpan es el día.

7.5 Métodos públicos. A continuación se enumeran los métodos de la estructura TimeSpan.


Add Agrega el TimeSpan especificadoa esta instancia.

Compare Compara dos valores deTimeSpan y devuelve un enteroque indica su relación.

CompareTo Compara esta instancia con unobjeto especificado y devuelveuna indicación de los valoresrelativos.

Duration Devuelve un TimeSpan cuyovalor es el valor absoluto de estainstancia.

Equals Devuelve un valor que indica sidos instancias de TimeSpan soniguales.

FromDays Devuelve un TimeSpan querepresenta un número de díasespecificado con una precisiónaproximada al milisegundo máscercano.

FromHours Devuelve un TimeSpan querepresenta un número de horasespecificado cuya precisión seaproximada al milisegundo máscercano.

FromMilliseconds Devuelve un TimeSpan querepresenta un número demilisegundos especificado.

FromMinutes Devuelve un TimeSpan querepresenta un número de minutosespecificado con una precisiónaproximada al milisegundo máscercano.

FromSeconds Devuelve un TimeSpan querepresenta un número desegundos especificado con una



Método Descripción precisión aproximada almilisegundo más cercano.

FromTicks Devuelve un TimeSpan querepresenta un tiempo especificadoen unidades de paso.

Negate Devuelve un TimeSpan cuyovalor es el valor negado de estainstancia.

Parse Crea un objeto TimeSpan a partirde un intervalo de tiempoindicado mediante una cadenaespecificada.

Subtract Resta el objeto TimeSpanespecificado de esta instancia.

7.6 Conversiones implícitas y explícitas

Una conversión implícita no requiere ninguna sintaxis especial en el código fuente. En el ejemplo siguiente, Visual Basic .NET convierte de forma implícita el valor de K a punto flotante de precisión simple antes de asignarlo a Q. Dim K As Integer Dim Q As Double ' ... K = 432 ' Integer widens to Double, so Option Strict can be On. Q = K

Una conversión explícita utiliza una palabra clave de conversión de tipos. Visual Basic .NET proporciona varias de estas palabras clave, que convierten una expresión entre paréntesis en el tipo de datos deseado. Estas palabras clave actúan como funciones, pero el compilador genera el código en la misma línea, de modo que la ejecución es un poco más rápida que con una llamada de función. En esta extensión del ejemplo anterior, la palabra clave CInt convierte el valor de Q de nuevo en un entero antes de asignarlo a K: Q = Math.Sqrt(Q) ' Q had been assigned the value 432 from K. K = CInt(Q) ' K now has the value 21 (rounded square root of 432).

La tabla siguiente muestra las palabras clave de conversión disponibles.

Palabra clave de

conversión de tipos

Convierte una

expresión en el

siguiente tipo de datos

Tipos de datos permitidos para la expresión que se va

a convertir

CBool Boolean Cualquier tipo numérico(incluido el tipo Byte y lostipos enumerados), String yObject

CByte Byte Cualquier tipo numérico,cualquier tipo enumerado,Boolean, String y Object

CChar Char String y Object CDate Date String y Object CDbl Double Cualquier tipo numérico

(incluido el tipo Byte y lostipos enumerados), Boolean,String y Object

CDec Decimal Cualquier tipo numérico(incluido el tipo Byte y lostipos enumerados), Boolean,String y Object

CInt Integer Cualquier tipo numérico(incluido el tipo Byte y lostipos enumerados), Boolean,String y Object

CLng Long Cualquier tipo numérico(incluido el tipo Byte y lostipos enumerados), Boolean,String y Object

CObj Object Cualquier tipo CShort Short Cualquier tipo numérico

(incluido el tipo Byte y lostipos enumerados), Boolean,String y Object

CSng Simple Cualquier tipo numérico(incluido el tipo Byte y lostipos enumerados), Boolean,String y Object

CStr String Cualquier tipo numérico(incluido el tipo Byte),Boolean, Char, matrizChar(), Date y Object

CType Tipo especificado después de

Al convertir a un tipo básico(incluida una matriz de untipo básico), se permiten los



Palabra clave de

conversión de tipos

Convierte una

expresión en el

siguiente tipo de datos

Tipos de datos permitidos para la expresión que se va

a convertir

la coma (,) mismos tipos para la palabraclave de conversióncorrespondiente Al convertir a un tipocompuesto, las interfaces queimplementa y las clases de lasque hereda

7.6.1 La palabra clave CType La palabra clave CType actúa sobre dos argumentos. El primero es la expresión que va a convertirse y el segundo es la clase de objeto o el tipo de datos de destino. El siguiente ejemplo muestra el uso de CType. K = CType(Q, Integer) ' Uses CType keyword instead of CInt. F = CType(W, Label) ' Coerces W to the specific object class Label.

Puede utilizar CType para convertir valores en tipos de datos compuestos así como en tipos básicos. También puede utilizarlo para convertir una clase de objeto en el tipo de una de sus interfaces, como en el ejemplo siguiente: ' Assume class CZone implements interface IZone. Dim H As Object Dim CZ As CZone ' Cannot use a type as first argument of CType. H = CType(CZ, IZone) ' Coerces CZone object to its interface IZone. CType también puede convertir tipos de matrices, como en el ejemplo siguiente: Dim V() As ClassV ' Array of ClassV objects. Dim ObArray() As Object ' Array of objects to be assigned. ' Some object array is assigned to ObArray. If TypeOf ObArray Is ClassV() ' Check for run-time type compatibility. V = CType(ObArray, ClassV()) ' ObArray can be converted to ClassV. End If

Nota Los valores utilizados con una palabra clave de conversión deben ser válidos para el tipo de datos de destino; de lo contrario, se produce un error. Por ejemplo, si intenta convertir un tipo Long en Integer, el valor de Long debe estar dentro del intervalo válido para el tipo de datos Integer. Precaución La especificación de CType para convertir de un tipo de clase a otro produce un error

en tiempo de ejecución si no existe relación de herencia entre los dos tipos. La acción de realizar una conversión explícita se denomina también convertir una expresión en un determinado tipo de datos o clase de objeto.

7.7 Funciones de comprobación de tipos de datos

En la siguiente tabla se presentan algunas de las funciones más comunmente usadas para comprobación de tipos de datos. Función Descripción IsArray IsArray devuelve True si la

variable apunta a una matriz; si no, devuelve False. IsArray es especialmente útil en el caso de objetos que contienen matrices.

IsDate IsDate devuelve True si la expresión es de tipo Date, o si es una cadena que se puede convertir al tipo Date; si no, devuelve False.

IsDBNull IsDBNull devuelve True si el tipo de datos de Expression se evalúa como de tipo DBNull; si no, IsDBNull devuelve False. El valor System.DBNull indica que la expresión de tipo Object representa datos que no se encuentran o no existen. DBNull no es lo mismo que Nothing, que indica que una variable no se ha inicializado todavía. Tampoco es lo mismo que una cadena de longitud cero (""), a la que a veces se hace referencia como cadena de valor null.

IsError IsError devuelve True si la expresión representa una variable Object que se deriva de la clase Exception en el espacio de nombres System. Una excepción que se deriva de System.Exception puede capturarse con las instrucciones Try...Catch...Finally.

IsNothing IsNothing devuelve True si la expresión representa una variable de tipo Object que no tiene actualmente ningún objeto asignado; en caso contrario, devuelve False.



Función Descripción IsNumeric IsNumeric devuelve True si

Expression se reconoce globalmente como un número; si no, devuelve False. IsNumeric devuelve True si el tipo de datos de Expression es Short, Integer, Long, Decimal, Single o Short. También devuelve True si Expression es de tipo String y se puede convertir al tipo Double. Devuelve False si Expression es del tipo Date.

IsReference Devuelve un valor de tipo Boolean que indica si una expresión es un tipo de referencia.

8 Estructura de un programa de Visual Basic

Un programa de Visual Basic consta de unidades de creación estándar. El código de Visual Basic se almacena en módulos de proyecto. Los proyectos se componen de archivos, que se compilan en aplicaciones. Al iniciar un proyecto y abrir el editor de código, verá que ya hay código en el lugar que le corresponde y en el orden correcto. Cualquier código que cree debe seguir esta secuencia:

1. Instrucciones Option 2. Instrucciones Imports 3. Procedimiento Main 4. Instrucciones Class, Module y Namespace,

si corresponde

Además, un programa puede contener instrucciones de compilación condicional. Estas instrucciones se pueden ubicar en cualquier parte del módulo. Muchos programadores prefieren ponerlas al final. Si escribe instrucciones en un orden distinto, pueden producirse errores de compilación.

8.1 Instrucciones Option Las instrucciones Option establecen reglas de base para el código subsiguiente, y de esta forma ayudan a prevenir errores de sintaxis y de lógica. La instrucción Option Explicit asegura que todas las variables están declaradas y escritas correctamente, lo que reducirá el posible tiempo que deberá utilizarse posteriormente para depurar. La instrucción Option Strict ayuda a

prevenir errores de lógica y pérdidas de datos que puedan producirse al trabajar entre variables de diferentes tipos. La instrucción Option Compare especifica la forma en que se comparan las cadenas entre sí, mediante su disposición de tipo Binary o Text.

8.2 Instrucciones Imports Las instrucciones Imports le permiten poner nombre a clases y otros tipos definidos en el espacio de nombres importado sin tener que calificarlos.

8.3 Procedimiento Main El procedimiento Main es el "punto inicial" de la aplicación, el primer procedimiento al cual se obtiene acceso al ejecutar el código. Main señala el lugar que corresponde al código al cual debe obtenerse acceso en primer lugar. En Main, se puede especificar el formulario se cargará primero al iniciar el programa, se puede saber si se está ejecutando una copia de la aplicación en el sistema, establecer un conjunto de variables para la aplicación o abrir una base de datos que la aplicación requiera. Hay cuatro variedades de Main:

• Sub Main() • Sub Main(ByVal CmdArgs() As String) • Function Main() As Integer • Function Main(ByVal CmdArgs() As String) As Integer

La variedad más común de este procedimiento es Sub Main( ).

8.4 Instrucciones Class, Module y Namespace

Las clases y los módulos forman la mayoría del código del archivo de código fuente. Contienen la mayor parte del código que se escribe; principalmente instrucciones Sub, Function, Method y Event, junto con declaraciones de variable y otro código necesario para que funcione la aplicación.

8.5 Instrucciones de compilación condicional

Las instrucciones de compilación condicional pueden aparecer en cualquier lugar dentro del módulo. Están configuradas para ejecutarse si se cumplen determinadas condiciones en tiempo de ejecución. También puede utilizarlas para depurar la aplicación, ya que el código condicional se ejecuta únicamente en modo de depuración.

programación con visualbasic.net parte i con Índice

Documents