Contenido

Unidad 1 ............................................................................................................ 12
Introducción a Visual Basic ............................................................................... 12
1.1. Nociones básicas .................................................................................... 12
1.1.1. Historia ....................................................................................................... 12
1.1.2. Concepto .................................................................................................... 14
1.1.3. Ventajas ..................................................................................................... 14
1.1.4. Requerimientos ........................................................................................... 15
1.1.5. Compilación ................................................................................................ 15
1.1.6. Modos de operación .................................................................................... 16
1.1.7. Reglas de Visual Basic ................................................................................. 16
1.2. Teoría de Objetos ................................................................................... 18
1.2.1. Clase .......................................................................................................... 18
1.2.2. Objeto ........................................................................................................ 18
1.2.3. Propiedades ................................................................................................ 19
1.2.4. Métodos...................................................................................................... 20
1.2.5. Evento ........................................................................................................ 20
1.2.6. Procedimientos de evento ............................................................................ 21
1.2.7. Encapsulación ............................................................................................. 22
1.2.8. Polimorfismo ............................................................................................... 22
Unidad 2 ............................................................................................................ 23
Trabajar con Visual Basic .................................................................................. 23
2.1. Estructura de proyecto........................................................................... 23
2.1.1. Proyecto ..................................................................................................... 23
2.1.2. Módulos...................................................................................................... 23
2.1.3. Procedimientos............................................................................................ 24
2.1.4. Declaraciones.............................................................................................. 24
2.2. IDE de Visual Basic................................................................................. 25
2.2.1. Entorno de Desarrollo Integrado (IDE).......................................................... 25
2.2.2. Ventana Explorador de Proyecto................................................................... 25
2.2.3. Ventana Diseñador de Formularios ............................................................... 26
2.2.4. Ventana de código....................................................................................... 26
2.2.5. Caja de herramientas................................................................................... 27
2.2.6. Ventana de propiedades .............................................................................. 27
2.2.7. Funciones básicas del IDE............................................................................ 28
2.3. Crear una aplicación............................................................................... 32
2.3.1. Pasos básicos.............................................................................................. 32
2.3.2. Colocar los objetos ...................................................................................... 32
2.3.3. Establecer las propiedades ........................................................................... 33
2.3.4. Escribir el código ......................................................................................... 34
Unidad 3 ............................................................................................................ 36
Objetos de Visual Basic ..................................................................................... 36
3.1. El formulario .......................................................................................... 36
3.1.1. Formulario (Clase: Form) ............................................................................. 36
3.1.2. Propiedades de formularios .......................................................................... 37
3.1.3. Métodos de formularios ............................................................................... 38
3.1.4. Eventos de formularios ................................................................................ 38
 3.2. Los controles ..........................................................................................39
3.2.1. Etiqueta (Clase: Label) ................................................................................ 39
3.2.2. Botón de comando (Clase: CommandButton) ................................................ 40
3.2.3. Caja de texto (Clase: TextBox) ..................................................................... 41
3.2.4. Marco (Clase: Frame) .................................................................................. 43
3.2.5. Caja de imagen (Clase: PictureBox) .............................................................. 43
3.2.6. Botón de opción (Clase: OptionButton) ......................................................... 44
3.2.7. Caja de verificación (Clase: CheckBox) ......................................................... 44
3.2.8. Caja de lista (Clase: ListBox) ........................................................................ 44
3.2.9. Caja combinada (Clase: ComboBox) ............................................................. 45
3.2.10. Barra de desplazamiento (Clase: HScrollBar, VScrollBar) ................................ 46
3.2.11. Temporizador (Clase: Timer)........................................................................ 46
3.2.12. Imagen (Clase: Image)................................................................................ 46
3.2.13. Figura (Clase: Shape) .................................................................................. 47
3.2.14. Línea (Clase: Line) ...................................................................................... 47
3.2.15. Ubicación de los controles básicos ................................................................ 47
3.2.16. Ejemplo de los controles básicos .................................................................. 48
Unidad 4 ............................................................................................................50
Código en Visual Basic .......................................................................................50
4.1. Espacios de memoria..............................................................................50
4.1.1. Identificadores ............................................................................................ 50
4.1.2. Tipos de datos ............................................................................................ 50
4.1.3. Declaración de espacios de memoria ............................................................ 52
4.1.4. Alcance de variables y constantes................................................................. 53
4.1.5. Declaración de variables .............................................................................. 53
4.1.6. Declaración de constantes (simbólicas)......................................................... 54
4.1.7. Constantes intrínsecas ................................................................................. 54
4.1.8. Arreglos...................................................................................................... 55
4.1.9. Objetos y espacios de memoria.................................................................... 56
4.2. Operadores.............................................................................................57
4.2.1. Aritméticos.................................................................................................. 57
4.2.2. Lógicos ....................................................................................................... 58
4.2.3. Relacionales ................................................................................................ 58
4.2.4. Operadores especiales ................................................................................. 59
4.2.5. Precedencia de los operadores ..................................................................... 59
4.3. Estructuras de control ............................................................................60
4.3.1. Programación estructurada .......................................................................... 60
4.3.2. Tipos de estructuras .................................................................................... 60
4.3.3. Estructura bifurcativa If-Then-ElseIf-Else ...................................................... 60
4.3.4. Estructura bifurcativa Select-Case................................................................. 61
4.3.5. Estructura repetitiva For-Next ...................................................................... 62
4.3.6. Estructura repetitiva Do-Loop....................................................................... 63
4.4. Procedimientos.......................................................................................64
4.4.1. Procedimientos y subrutinas......................................................................... 64
4.4.2. Ventajas de los procedimientos .................................................................... 65
4.4.3. Clasificación de procedimientos .................................................................... 66
4.4.4. Alcance de procedimientos........................................................................... 67
4.4.5. Trabajar con procedimientos ........................................................................ 67
4.4.6. Transferencia de parámetros........................................................................ 69
4.4.7. Ejemplo completo de la unidad .................................................................... 70
Unidad 5 ............................................................................................................ 71
Funciones intrínsecas ........................................................................................ 71
5.1. Funciones en general ............................................................................. 71
5.1.1. Expresiones ................................................................................................ 71
5.1.2. Funciones ................................................................................................... 71
5.1.3. Instrucciones .............................................................................................. 72
5.2. Funciones de cadena .............................................................................. 72
5.2.1. Tratamiento de cadenas .............................................................................. 72
5.2.2. Cambiar a mayúsculas y minúsculas ............................................................. 73
5.2.3. Determinar la longitud de una cadena .......................................................... 73
5.2.4. Buscar caracteres dentro de una cadena....................................................... 73
5.2.5. Extraer e insertar caracteres a una cadena ................................................... 74
5.2.6. Tratamiento de espacios en blanco............................................................... 74
5.2.7. Convertir a número y a cadena .................................................................... 75
5.2.8. Obtener cadenas de caracteres con formato ................................................. 75
5.2.9. Mapa de caracteres ..................................................................................... 77
5.3. Funciones numéricas.............................................................................. 78
5.3.1. Funciones matemáticas................................................................................ 78
5.3.2. Funciones de ajuste decimal ........................................................................ 78
5.3.3. Función de número aleatorio ........................................................................ 79
5.4. Funciones de fecha y hora...................................................................... 79
5.4.1. Obtener la fecha y hora del sistema.............................................................. 79
5.4.2. Establecer la fecha y hora del sistema .......................................................... 79
5.4.3. Realizar cálculos con fechas y horas ............................................................. 79
5.4.4. Devolver fechas y horas............................................................................... 82
5.4.5. Cronometrar procesos ................................................................................. 82
5.5. Funciones de Objetos............................................................................. 82
5.5.1. Cuadro de diálogo de entrada InputBox ........................................................ 82
5.5.2. Cuadro de diálogo de mensajes MsgBox ....................................................... 83
Unidad 6 ............................................................................................................ 87
Archivos............................................................................................................. 87
6.1. Nociones básicas .................................................................................... 87
6.1.1. Unidades .................................................................................................... 87
6.1.2. Archivos...................................................................................................... 88
6.1.3. Directorios .................................................................................................. 88
6.2. Instrucciones de archivos ...................................................................... 89
6.2.1. Instrucciones para manipular directorios ....................................................... 89
6.2.2. Instrucciones para manipular archivos .......................................................... 89
6.3. Funciones de archivos ............................................................................ 91
6.3.1. Funciones para manipular directorios............................................................ 91
6.3.2. Funciones de archivos cerrados .................................................................... 92
6.3.3. Funciones de archivos abiertos..................................................................... 92
6.4. Objetos de archivos................................................................................ 93
6.4.1. Caja de lista de archivos (Clase: FileListBox) ................................................. 93
6.4.2. Caja de lista de directorio (Clase: DirListBox) ................................................ 93
6.4.3. Caja de lista de unidades (Clase: DriveListBox) ............................................. 93
6.4.4. Cuadro de diálogo común (Clase: CommonDialog) ........................................ 94
 6.5. Archivos secuenciales.............................................................................97
6.5.1. Abrir archivos secuenciales .......................................................................... 97
6.5.2. Leer archivos secuenciales ........................................................................... 97
6.5.3. Escribir en archivos secuenciales .................................................................. 97
6.6. Archivos aleatorios .................................................................................98
6.6.1. Abrir archivos aleatorios............................................................................... 98
6.6.2. Leer registros de archivos aleatorios ............................................................. 99
6.6.3. Escribir registros en archivos directos ..........................................................100
6.6.4. Localizar una posición de registro ................................................................100
6.6.5. Tareas comunes de archivos aleatorios ........................................................100
Unidad 7 ..........................................................................................................103
Bases de Datos ................................................................................................103
7.1. Introducción a Bases de Datos.............................................................103
7.1.1. Nociones básicas ........................................................................................103
7.1.2. Arquitectura de bases de datos ...................................................................104
7.1.3. Tecnologías de bases de datos ....................................................................104
7.1.4. Proveedores OLE DB...................................................................................105
7.1.5. Lenguajes de bases de datos ......................................................................106
7.1.6. Modos de manipulación de registros ............................................................107
7.2. Objetos de acceso a datos ADO ............................................................107
7.2.1. Modelo de objetos de ADO..........................................................................107
7.2.2. El objeto Connection...................................................................................108
7.2.3. El objeto Recordset ....................................................................................110
7.2.4. Procedimiento para utilizar el modelo ADO...................................................112
7.3. Acceso a datos mediante Visual Basic y ADO .......................................113
7.3.1. Métodos para utilizar ADO...........................................................................113
7.3.2. Controles enlazados a datos........................................................................114
7.3.3. El control de datos ADO..............................................................................114
7.3.4. Creación de objetos ADO en código.............................................................118
7.3.5. El diseñador de entorno de datos ................................................................120
7.4. Lenguaje de consulta estructurado SQL...............................................122
7.4.1. Introducción a SQL.....................................................................................122
7.4.2. Elementos del lenguaje SQL........................................................................123
7.4.3. Consultas de selección (SELECT) .................................................................124
7.4.4. Consultas de acción (DELETE, INSERT, UPDATE) .........................................125
7.5. Reportes de bases de datos..................................................................126
7.5.1. Introducción a reportes ..............................................................................126
7.5.2. Pasos para crear un reporte ........................................................................127
7.5.3. Partes del generador de reportes ................................................................131
7.5.4. Campos de un reporte ................................................................................132
Unidad 8 ..........................................................................................................134
Tecnología OLE ................................................................................................134
8.1. Teoría de OLE .......................................................................................134
8.1.1. Estándar COM ............................................................................................134
8.1.2. Automatización ..........................................................................................134
8.1.3. Tecnología OLE y ActiveX............................................................................135
8.1.4. Componentes ActiveX .................................................................................135
8.1.5. Componentes en proceso y fuera de proceso ...............................................136
 8.2. Aplicaciones habilitadas para ActiveX.................................................. 137
8.2.1. Objetos insertables .....................................................................................137
8.2.2. Control contenedor OLE ..............................................................................137
8.2.3. Control de aplicación ActiveX.......................................................................140
8.3. Componentes de código ....................................................................... 141
8.3.1. Referencias a un objeto ..............................................................................141
8.3.2. Crear referencias a objetos .........................................................................142
8.3.3. Utilizar las propiedades y métodos de un objeto ...........................................142
8.3.4. Responder a los eventos de un objeto .........................................................143
8.3.5. Ejemplo completo usando componente de código.........................................144
8.4. Controles ActiveX ................................................................................. 145
8.4.1. Cargar controles ActiveX .............................................................................145
8.4.2. Archivos de controles ActiveX ......................................................................145
8.4.3. Control ActiveX Animation ...........................................................................146
8.4.4. Control ActiveX CoolBar ..............................................................................147
8.4.5. Control ActiveX DTPicker.............................................................................148
8.4.6. Control ActiveX ImageList ...........................................................................148
8.4.7. Control ActiveX TreeView ............................................................................149
8.4.8. Control ActiveX ListView..............................................................................151
8.4.9. Control ActiveX ToolBar ..............................................................................154
8.4.10. Control ActiveX TabStrip .............................................................................155
8.4.11. Conclusiones sobre ActiveX .........................................................................156
Unidad 9 .......................................................................................................... 157
Funciones API.................................................................................................. 157
9.1. Teoría de funciones API ....................................................................... 157
9.1.1. Funciones API ............................................................................................157
9.1.2. Las API de Windows ...................................................................................157
9.1.3. Declarar funciones API................................................................................157
9.1.4. Utilizar funciones API..................................................................................158
9.1.5. Visor de texto API ......................................................................................159
9.2. Técnicas para usar funciones API ........................................................ 160
9.2.1. Resolver conflictos de nombre de API ..........................................................160
9.2.2. Enviar cadenas a funciones API ...................................................................160
9.2.3. Recibir cadenas de funciones API ................................................................160
9.2.4. Utilizar procedimientos generales auxiliares..................................................161
9.2.5. Utilizar funciones API sin parámetros ...........................................................162
Consideración final.......................................................................................... 163
 Índice de figuras
Figura 1.1.- Evolución del Basic. ............................................................................... 13
Figura 2.1.- Estructura de un proyecto ...................................................................... 24
Figura 2.2.- Ventana Proyecto .................................................................................. 25
Figura 2.3.- Ventana Diseñador de formulario ........................................................... 26
Figura 2.4.- Ventana de código................................................................................. 26
Figura 2.5.- Cuadro de herramientas......................................................................... 27
Figura 2.6.- Ventana de propiedades. ....................................................................... 27
Figura 2.7.- Diálogo Nuevo proyecto al iniciar Visual Basic ......................................... 28
Figura 2.8.- Diálogo Nuevo proyecto estándar ........................................................... 28
Figura 2.9.- Diálogo Agregar formulario .................................................................... 29
Figura 2.10.- Menú emergente del explorador de proyecto........................................... 29
Figura 2.11.- Diálogo Agregar módulo ........................................................................ 30
Figura 2.12.- Diálogo Propiedades del proyecto ........................................................... 31
Figura 2.13.- Diálogo Opciones de editor .................................................................... 31
Figura 2.14.- Agregar objetos a un formulario ............................................................. 33
Figura 2.15.- Modificar las propiedades de objetos ...................................................... 33
Figura 2.16.- Seleccionar objeto para procedimiento de evento .................................... 34
Figura 2.17.- Seleccionar evento para procedimiento de evento ................................... 35
Figura 2.18.- Escribir código en un procedimiento de evento........................................ 35
Figura 3.1.- Despliegue del operador punto............................................................... 37
Figura 3.2.- Elementos básicos de una ventana. ........................................................ 38
Figura 3.3.- Caja de herramientas (Clases)................................................................ 47
Figura 3.4.- Ejemplo de los controles básicos. ........................................................... 48
Figura 4.1.- Diálogo Examinador de objetos. ............................................................. 55
Figura 4.2.- Estructura If-Then-Else simple................................................................ 61
Figura 4.3.- Estructura If-Then-Else completa............................................................ 61
Figura 4.4.- Estructura Select Case ........................................................................... 62
Figura 4.5.- Estructura For-Next. .............................................................................. 63
Figura 4.6.- Estructuras Do-Loop. ............................................................................. 64
Figura 5.1.- Función supuesta Licuar......................................................................... 71
Figura 5.2.- Función en general ................................................................................ 72
Figura 5.3.- Función Seno. ....................................................................................... 72
Figura 5.4.- Posiciones de una cadena de caracteres ................................................. 73
Figura 5.5.- Cuadro de diálogo InputBox ................................................................... 83
Figura 5.6.- Cuadro de diálogo MsgBox ..................................................................... 83
Figura 5.7.- Cuadro de mensaje de Información ........................................................ 84
Figura 5.8.- Cuadro de mensaje de Crítico................................................................. 84
Figura 5.9.- Cuadro de mensaje de Exclamación........................................................ 84
Figura 5.10.- Cuadro de mensaje de Pregunta............................................................. 85
Figura 5.11.- Cuadro de mensaje Si y No .................................................................... 85
Figura 5.12.- Cuadro de mensaje Aceptar y Cancelar ................................................... 85
Figura 5.13.- Cuadro de mensaje Crítico Aceptar y Cancelar......................................... 85
Figura 6.1.- Memorias de un sistema de cómputo ...................................................... 88
Figura 6.2.- Archivo de documento de Word.............................................................. 88
Figura 6.3.- Estructura de directorios y archivos ........................................................ 89
Figura 6.4.- Objetos de archivos. .............................................................................. 94
Figura 6.5.- Diálogo Componentes (Control Diálogo Común) ...................................... 95
Figura 7.1.- Tabla “Productos” de una base de datos. ...............................................104
Figura 7.2.- Arquitectura de Bases de Datos.............................................................104
Figura 7.3.- Acceso de Visual Basic a Bases de Datos................................................105
Figura 7.4.- Modelo de objetos ADO. .......................................................................107
Figura 7.5.- Diálogo de componentes (Control de datos ADO) ...................................115
Figura 7.6.- Ventana de la propiedad ConnectionString .............................................115
Figura 7.7.- Asistente para crear una conexión a un origen de datos ADO..................116
Figura 7.8.- Diálogo de propiedades para establecer el origen de registros.................116
Figura 7.9.- Ventana de referencias a librerías de objetos .........................................118
Figura 7.10.- Diálogo Componentes (Diseñadores) .....................................................120
Figura 7.11.- Diseñador del objeto Entorno de datos ..................................................121
Figura 7.12.- Diálogo Crystal Report Gallery ...............................................................127
Figura 7.13.- Diálogo de selección de Tablas para reportes .........................................128
Figura 7.14.- Diálogo de selección de Campos para reportes .......................................128
Figura 7.15.- Diálogo para agrupar los registros de un reporte ....................................129
Figura 7.16.- Diálogo para filtrar los registros de un reporte........................................129
Figura 7.17.- Diálogo para seleccionar la plantilla de diseño de un reporte ...................130
Figura 7.18.- Diálogo de confirmación para crear un reporte .......................................130
Figura 7.19.- Vista de diseño de un reporte de Crystal Report .....................................131
Figura 7.20.- Vista preliminar de un reporte de Crystal Report ....................................131
Figura 7.21.- Tipos de campos de Crystal Report........................................................132
Figura 7.22.- Editor de ecuaciones de Crystal Report ..................................................133
Figura 7.23.- Campos especiales de Crystal Report.....................................................133
Figura 8.1.- Diálogo Insertar objeto .........................................................................138
Figura 8.2.- Diálogo Pegado especial .......................................................................138
Figura 8.3.- Diálogo Componentes (Objetos insertables) ...........................................141
Figura 8.4.- Cuadro de herramientas (Objetos insertables)........................................141
Figura 8.5.- Ventana de código con eventos de un objeto componente ......................143
Figura 8.6.- Ejemplo del control ActiveX Animation ...................................................146
Figura 8.7.- Ejemplo de control ActiveX CoolBar .......................................................147
Figura 8.8.- Ejemplo del control ActiveX DTPicker .....................................................148
Figura 8.9.- Propiedades del control ActiveX ImageList .............................................149
Figura 8.10.- Ejemplo del control ActiveX TreeView ....................................................150
Figura 8.11.- Ejemplo del control ActiveX ListView Vista Iconos grandes ......................152
Figura 8.12.- Ejemplo del control ActiveX ListView Vista Iconos pequeños....................152
Figura 8.13.- Ejemplo del control ActiveX ListView Vista Lista......................................152
Figura 8.14.- Ejemplo del control ActiveX ListView Vista Reporte .................................153
Figura 8.15.- Ejemplo del control ActiveX ToolBar.......................................................154
Figura 8.16.- Ejemplo del control ActiveX TabStrip .....................................................155
Figura 9.1.- Visor de texto API ................................................................................159
 Índice de tablas
Tabla 1.1.- Lista de prefijos de objetos de Visual Basic. ............................................ 17
Tabla 3.1.- Propiedades más importantes del formulario. .......................................... 38
Tabla 3.2.- Métodos más importantes del formulario................................................. 38
Tabla 3.3.- Eventos más importantes del formulario. ................................................ 39
Tabla 3.4.- Algunas propiedades de la etiqueta. ....................................................... 39
Tabla 3.5.- Algunas propiedades del botón de comando............................................ 40
Tabla 3.6.- Algunas propiedades de la caja de texto. ................................................ 41
Tabla 3.7.- Propiedades más importantes de listas. .................................................. 45
Tabla 3.8.- Métodos más importantes de las cajas de lista ........................................ 45
Tabla 3.9.- Propiedades más importantes de la barra de desplazamiento. .................. 46
Tabla 4.1.- Tipos de datos provistos por Visual Basic. ............................................... 51
Tabla 4.2.- Operadores aritméticos de Visual Basic ................................................... 57
Tabla 4.3.- Resultados de operaciones lógicas.......................................................... 58
Tabla 4.4.- Operadores relacionales de Visual Basic. ................................................. 58
Tabla 4.5.- Precedencia de operadores .................................................................... 59
Tabla 5.1.- Constantes de formato para números ..................................................... 76
Tabla 5.2.- Símbolos especiales de formato para números ........................................ 76
Tabla 5.3.- Constantes de formato para fechas y horas............................................. 76
Tabla 5.4.- Símbolos para crear formatos de fecha y hora......................................... 77
Tabla 5.5.- Juego de caracteres ASCII de 0 a 127 .................................................... 78
Tabla 5.6.- Funciones matemáticas.......................................................................... 78
Tabla 5.7.- Funciones de ajuste numérico ................................................................ 78
Tabla 5.8.- Valores del parámetro Intervalo de funciones de fecha y hora.................. 80
Tabla 5.9.- Funciones que devuelven parte de una fecha .......................................... 81
Tabla 5.10.- Estilos de cajas de mensajes MsgBox...................................................... 84
Tabla 5.11.- Valores devueltos por MsgBox ................................................................ 86
Tabla 6.1.- Especificaciones del parámetro “Tipo” de la instrucción Open ................... 90
Tabla 6.2.- Propiedades del objeto Diálogo Común ................................................... 95
Tabla 6.3.- Valores de la propiedad Flags................................................................. 96
Tabla 6.4.- Métodos del objeto Diálogo Común......................................................... 96
Tabla 7.1.- Propiedades del objeto Connection de ADO............................................109
Tabla 7.2.- Opciones de la propiedad CursorLocation. ..............................................109
Tabla 7.3.- Métodos del objeto Connection de ADO .................................................109
Tabla 7.4.- Propiedades del objeto Recordset de ADO..............................................110
Tabla 7.5.- Opciones de la propiedad CursorType ....................................................110
Tabla 7.6.- Opciones de la propiedad LockType.......................................................111
Tabla 7.7.- Valores que devuelve la propiedad EditMode..........................................111
Tabla 7.8.- Métodos del objeto Recordset de ADO ...................................................112
Tabla 7.9.- Eventos del objeto Recordset de ADO ....................................................112
Tabla 7.10.- Algunos comandos de SQL ....................................................................123
Tabla 7.11.- Algunas cláusulas de SQL......................................................................124
Tabla 7.12.- Operadores de comparación SQL...........................................................124
Tabla 7.13.- Funciones de agregado SQL ..................................................................124
Tabla 8.1.- Propiedades del control contenedor OLE ................................................139
Tabla 8.2.- Métodos del control contenedor OLE......................................................139
Tabla 8.3.- Archivos de controles ActiveX ................................................................146
Tabla 8.4.- Constantes del argumento relationship ..................................................151
Tabla 8.5.- Estilos del objeto Button de ToolBar ......................................................155
Tabla 9.1.- Archivos contenedores de funciones API ................................................157
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

Unidad 1

Introducción a Visual Basic

“La manera de lograr las cosas es empezándolas”

. – Horace Greeley

1.1. Nociones básicas

1.1.1. Historia
Los lenguajes de programación han surgido como consecuencia de la necesidad de
hacer que los sistemas de cálculo y almacenamiento electrónicos sean útiles al
hombre. De esta manera han marchado Hardware y Software, hardware
requiriendo software y software requiriendo hardware.
El primer sistema electrónico de cálculo data de 1946 y se llamaba ENIAC, un sistema
que efectuaba ciertas operaciones, ocupaba el tamaño de una habitación y utilizaba
18.000 válvulas de vacío. Al año siguiente, 1947, Laboratorios Bell crea el transistor,
tres capas de silicio polarizadas; y luego Texas Instrument en 1959 logra
aumentar el nivel de densidad de capas para obtener el primer circuito integrado de
seis transistores. El circuito integrado es el corazón de los sistemas de cálculo
moderno y los más recientes albergan a casi 1,5 millones de transistores.
Los primeros lenguajes de programación, como el lenguaje máquina y
ensamblador, requerían que el programador fuera experto y conociera fielmente el
hardware. Es así como comienzan a aparecer los lenguajes de programación de
alto nivel, tales como COBOL, ADA, FORTRAN y BASIC. La versión original del
lenguaje Basic fue creada en 1964 por John G. Kemeny (Budapest, 1926 – USA
1992) y Thomas E. Kurtz (Illinois 1928), y estaba dirigido fundamentalmente a
principiantes, es decir, para todo aquel que se iniciara como programador; de ahí
su nombre BASIC o “Código de Instrucción Simbólico para todo Propósito de
principiantes (Beginner’s All purpose Symbolic Instruction Code), aunque su
nombre original fue True BASIC.
Para 1978, cuando los microprocesadores comienzan a hacerse populares y surgen
los primeros PC (computadores personales), el lenguaje Basic se establece como
un estándar y se crea la normativa BASIC STANDAR. La tecnología continuó su
avance, y con ella los requerimientos de software más veloces y eficientes. En el año
de 1983 aparece el procesador 80286 y los conceptos de programación estructurada
y compilación del código fuente; y Basic comienza a ser despreciado, pues era visto
para novatos, su característica de lenguaje secuencial era ineficiente, carecía
de herramientas de compilación confiables, no disponía de librerías y era imposible

12 12
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

intercambiar información y acceder al interior de las máquinas con él; mientras

tanto se hacían muy populares los lenguajes C y

13 13
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

PASCAL. Basic debía evolucionar y la IBM crea una versión modificada de Basic
llamaba BASICA, la cual fracasó. Paralelamente, la empresa Microsoft saca al
mercado la versión estructurada de Basic denominada GWBASIC para DOS.
Posteriormente otra empresa, Borland, crea su propia versión de Basic
estructurado, pero agrega mejoras de velocidad optimizando la compilación en su
producto TURBO BASIC. Microsoft compite con Borland optimizando también la
compilación y corrigiendo casi todos los defectos de las versiones anteriores, para
finalmente obtener Quick-BASIC. Las últimas versiones del sistema operativo MS-
DOS incluían una versión algo recortada de Quick-BASIC llamada QBASIC.
En 1985 aparece Windows, la Interfaz de Usuario Gráfica (GUI) de Microsoft para
su sistema operativo MS-DOS; y comienzan a aparecer conceptos tales como
multitarea, multiprocesamiento y objetos de programación. El programa Windows
permitía administrar casi la totalidad de servicios de usuario del sistema con
procesadores de texto, hojas de cálculo, programas de dibujo y diseño, antivirus y
hasta una calculadora. Era necesario crear aplicaciones que se ejecutaran
utilizando esta GUI. Es así como los diseñadores de Microsoft combinan,
convenientemente, la interfaz gráfica con su lenguaje de programación por
excelencia, QBASIC; obteniéndose una de las primeras versiones visuales de
lenguajes de programación, la cual recibió el nombre Visual Basic.
Desde que apareció Visual Basic, ya Basic no es sólo para novatos, sino que
representa una alternativa para programadores de todos los niveles, quienes
estimulados por su gran versatilidad y potencia, comienzan a utilizarlo. Para los
años de 1993 y 1994, Visual Basic comienza a hacerse muy popular con su versión
3.0 de 16 bits. La versión 4.0 estuvo lista para 1995, casi paralelo con la aparición
del primer sistema operativo de Microsoft con ambiente gráfico: Windows 95. Este
era el momento de transición de los buses de datos de los microprocesadores de
16 a 32 bits; hecho determinante para que Visual Basic 4.0 estuviera disponible
para ambos buses de datos, por lo que la instalación era opcional para 16 ó 32
bits. No tardó mucho en evolucionar un poco más con su versión 5.0
exclusivamente para 32 bits. A mediados de 1998, Visual Basic adopta su versión
6.0, la cual viene como parte de un paquete de lenguajes de programación visual
para desarrollar aplicaciones Windows llamado Visual Studio 6.0, el cual incluye:
Visual C++ 6.0, Visual FoxPro 6.0, Visual J++ 6.0, Visual InterDev 6.0 y Visual
Basic 6.0. A partir del año 2000 surge la plataforma de Microsoft para servicios
Web (o cualquier servicio basado en red) conocida como framework.NET, la cual
incluye las herramientas para el desarrollo de aplicaciones Visual Studio .NET,
entre ellas se encuentra Visual Basic .NET.
True BASIC Visual Basic .NET

BASIC STANDAR Visual Basic 6.0

GW BASIC Visual Basic 5.0

Quick BASIC Visual Basic 4.0

14 14
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

QBasic Visual Basic 3.0

Figura 1.1.- Evolución del Basic.

15 15
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

1.1.2. Concepto de Visual Basic

Visual Basic es un sistema de desarrollo o lenguaje de programación visual
destinado a crear aplicaciones para el entorno Windows de una manera rápida y
sencilla combinando herramientas de diseño gráfico y un lenguaje de
programación de alto nivel. El término Visual involucra las herramientas gráficas
(GUI) y Basic es el lenguaje de programación, lo que le confiere a Visual Basic la
característica de potencia gráfica y sencillez. El código intrínseco de los objetos
básicos (ventanas y controles) está prediseñado, por lo que no se considera a
Visual Basic como un lenguaje de Programación Orientado a Objeto (OOP), ya que
carece de los mecanismos de herencia y polimorfismo; más bien se considera basado
en objetos, aunque en cierta forma, de las características de la OOP, Visual Basic
conserva algo de Polimorfismo y Encapsulación que veremos mas adelante en el
capítulo Teoría de Objetos.
1.1.3. Ventajas
a) Objetos prediseñados
Visual Basic permite utilizar objetos planos y 3D (ventanas, botones, cajas de
texto, etc.) sin necesidad de crearlos, ya que provee una interfaz gráfica muy
completa y amigable.
b) MDI (Multiple Document Interface)
Esta opción, en contraste con SDI (Single Document Interface), permite crear
una ventana con múltiples ventanas hijas o documentos dependientes. Aplica
tanto para el entorno de desarrollo como para las aplicaciones. Para el entorno
de desarrollo se habilita o deshabilita en el menú “Herramientas | Opciones”,
pestaña “Avanzado”.
c) DDE (Dynamic Data Exchange)
Es un protocolo establecido para intercambiar datos a través de vínculos
activos entre aplicaciones que se ejecutan bajo Microsoft Windows. Por
ejemplo, es posible, desde Visual Basic, leer las celdas de una hoja de calculo
de Excel.
d) DLL (Dynamic Link Libraries)
Las bibliotecas de vínculos dinámicos son archivos con extensión DLL que
contienen rutinas desarrolladas en otros lenguajes como C y FORTRAN, y que
pueden ser accedidas o llamadas desde Visual Basic. El entorno Windows
utiliza estas rutinas para mostrar ventanas y gráficos, administrar la memoria,
controlar puertos, etc. Múltiples aplicaciones pueden acceder a una misma DLL
simultáneamente. La ventaja radica en que se pueden usar las funciones
predefinidas de Windows en tiempo de ejecución de la aplicación, en lugar de
vincular estáticamente en tiempo de diseño o de compilación.
e) OLE (Object Linking Embedding)
Se define como una tecnología que permite a las aplicaciones compartir
objetos de una forma coherente con otras aplicaciones, herramientas de
programación y lenguajes de macros. OLE forma parte de toda una filosofía de
interoperabilidad entre objetos conocida como ActiveX. Resulta ventajoso usar

16 16
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

una aplicación tratada como objeto de la aplicación desarrollada en Visual

Basic, ya que la aplicación objeto conserva sus propiedades y métodos, y no
es necesario escribir código adicional. Por ejemplo, se puede agregar un

17 17
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

documento de Excel, como objeto, a una aplicación Visual Basic, para efectuar
las operaciones normales de una hoja de cálculo, pudiendo modificar datos de
las celdas del documento original si está vinculado, o sólo visualizar y
manipular celdas si está incrustado.
f) ADO (ActiveX Data Object)
Visual Basic provee tres modelos de objetos para acceso a datos: Objetos de
Datos ActiveX (ADO), Objetos de Datos Remotos (RDO) y Objetos de Acceso a
Datos (DAO). La tecnología más reciente es ADO, con un modelo de objetos más
sencillo (y aún más flexible) que RDO o DAO. Un modelo de objetos de acceso
a datos es una colección de objetos que permite la manipulación y definición de
bases de datos diversas sin tener que conocer las directivas intrínsecas de cada
base de datos. Con esta ventaja se puede controlar en forma gráfica o codificada
la conexión, los generadores de instrucciones y los datos devueltos de bases de
datos, que se usarán en cualquier aplicación de Visual Basic.
g) Otras ventajas
Compilador de archivos de ayuda para añadir ayuda personalizada a las
aplicaciones, biblioteca de iconos e imágenes, asistente de empaquetado y
distribución para crear los discos de la aplicación terminada, ayuda completa
en línea, y un editor de código con menús emergentes e interpretador del código.
1.1.4. Requerimientos
Los requerimientos de instalación que aquí se tratan se refieren a la versión de Visual
Basic 6.0. Para versiones anteriores refiérase a los manuales correspondientes.
a) Requerimientos de software:
Sistema operativo de red: Microsoft Windows NT 3.51 o posterior.
Sistema operativo cliente: Microsoft Windows 95 o posterior.
b) Requerimientos de hardware:
Microprocesador: Pentium® 90MHz o superior.
Vídeo: Pantalla VGA de 640x480 o de resolución superior.
Memoria RAM: 24 MB para Windows 95, 32 MB para Windows NT.
Espacio en disco duro Edición Estándar: de 48MB a 80 MB.
Espacio en disco duro Edición Empresarial: de 128MB a 147 MB.
Espacio en disco duro para MSDN (Documentación multimedia): 67MB.
CD-ROM (no se supone soporte para MS-DOS).
1.1.5. Compilación
La compilación es el proceso mediante el cual cualquier lenguaje de programación
convierte su seudo lenguaje al código máquina o código binario para su
procesamiento y ejecución según el sistema operativo instalado. Se dice que el
código máquina (unos y ceros) es el lenguaje de mas bajo nivel, ya que posee las
directivas que interactúan directamente e internamente con el microprocesador.

18 18
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

1.1.6. Modos de operación

La aplicación Visual Basic puede trabajar en dos modos distintos: Modo de Diseño
y Modo de Ejecución. A menudo se dice que cuando se trabaja en modo de diseño
o ejecución se esta en Tiempo de Diseño o en Tiempo de Ejecución. En modo de
diseño el usuario construye interactivamente la aplicación colocando controles en
el formulario, definiendo sus propiedades, y desarrollando funciones para
gestionar los eventos. En modo de ejecución el programador prueba la aplicación.
En este caso la aplicación se compila, se carga en memoria RAM para producir las
directivas necesarias al microprocesador, así el usuario actúa sobre el programa y
prueba como responde este.
1.1.7. Reglas de Visual Basic
Las reglas o convenciones de Visual Basic para codificación y configuración son
pautas que no están enfocadas a la lógica del programa, sino a su estructura y
apariencia física. ¿Por qué existen las convenciones de codificación? La razón
principal de usar un conjunto coherente de convenciones de codificación es
estandarizar la estructura y el estilo de codificación de una aplicación de forma
que el autor y otras personas puedan leer y entender el código fácilmente. Las
convenciones de codificación correctas dan como resultado un código fuente preciso,
legible y sin ambigüedad, que es coherente con otras convenciones del lenguaje y lo
más intuitivo posible.
Un conjunto de convenciones de codificación de propósito general debe definir los
requisitos mínimos necesarios para conseguir los objetivos explicados
anteriormente, dejando libertad al programador para crear la lógica y el flujo
funcional del programa. El objetivo es hacer que el programa sea fácil de leer y de
entender sin obstruir la creatividad natural del programador con imposiciones
excesivas y restricciones arbitrarias. Por tanto, las convenciones sugeridas serán
breves y sugerentes; no muestran todos los objetos y controles posibles, ni
especifican todos los tipos de comentarios informativos que podrían ser útiles. Las
convenciones de codificación pueden incluir los siguientes puntos.
a) Convenciones de nombres para objetos, variables y procedimientos
El cuerpo de un nombre de variable, constante, procedimiento, función u
objeto se debe escribir en mayúsculas y/o minúsculas según el caso, y debe
tener la longitud necesaria para describir su funcionalidad. Hay que utilizar
nombres mnemónicos; es decir, el nombre debe reflejar correctamente la función
del elemento que identifica. Además, los nombres de funciones deben empezar
con un verbo, como IniciarNombreMatriz o CerrarDiálogo. Para nombres que se
usen con frecuencia o para términos largos, se recomienda usar abreviaturas
estándar para que los nombres tengan una longitud razonable. Cuando se usen
abreviaturas, hay que asegurarse de que sean coherentes en toda la aplicación.
Por otra parte, debe cuidar que todas las variables sean declaradas
explícitamente. Mediante la instrucción Option Explicit detectará las variables
no declaradas durante la compilación. Los archivos generados por Visual Basic
se deben guardar con el mismo nombre usado para identificarlo a nivel de objeto.
Esta práctica resulta muy útil a la hora de transportar el código fuente de una
máquina a otra, pues el programador conoce exactamente los archivos a copiar.

19 19
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

b) Comentarios para documentar el código

Todos los procedimientos, funciones y variables deben poseer un comentario
breve que describa las características funcionales de los mismos (qué hace). Esta
descripción no debe describir los detalles de implementación (cómo lo hace),
porque cambian con el tiempo y pueden resultar en comentarios erróneos. Los
argumentos que se pasan a un procedimiento se deben describir cuando sus
funciones no sean obvias o cuando se espera que los argumentos estén en un
intervalo específico. También hay que describir, al principio de cada
procedimiento, los valores devueltos de funciones y las variables globales que se
modifican en el procedimiento. No debe exagerar en los comentarios. Los
comentarios de líneas se inician con el símbolo apóstrofe (‘). El texto que coloque
a la derecha de apóstrofe no será considerado por Visual Basic al momento de
la compilación.
c) Formatos estandarizados para etiquetar
Los nombres de los objetos deben llevar un prefijo de tres letras en
minúsculas coherente que facilite la identificación del tipo de objeto
rápidamente (ver Tabla 1.1).
Tipo de control Prefijo Ejemplo
Barra de desplazamiento horizontal hsb hsbVolumen
Barra de desplazamiento vertical vsb vsbIndice
Barra de estado sta staFechaHora
Barra de herramientas tlb tlbAcciones
Barra de progreso prg prgCargarArchivo
Botón animado ani aniBuzon
Botón de opción opt optGenero
Botones de comando cmd cmdSalir
Casilla de verificación chk chkSoloLectura
Comunicaciones com comFax
Contenedor OLE ole oleHojaCalculo
Cronómetro o temporizador tmr tmrAlarma
Cuadrícula o grid grd grdPrecios
Cuadrícula de datos dgd dgdTitulos
Cuadro combinado de datos dbc dbcAutor
Cuadro combinado cbo cboIngles
Cuadro de imagen pic picVGA
Cuadro de lista lst lstCodigos
Cuadro de lista de archivos fil filOrigen
Cuadro de lista de directorios dir dirSource
Cuadro de lista de unidades drv drvDestino
Cuadro de texto txt txtApellido
Datos dat datBiblio
Control de Datos ADO ado adoBiblio
Diálogo común dlg dlgAbrirArchivo
Etiqueta lbl lblMensajeAyuda
Fichas tab tabOpciones
Forma o figura shp shpCirculo
Formulario frm frmEntrada
Imagen img imgIcono
Información del sistema sys sysMonitor

20 20
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

Línea lin linVertical

Marco fra fraIdioma
Menú mnu mnuAbrirArchivo
Tabla 1.1.- Lista de prefijos de objetos de Visual Basic.

21 21
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

d) Instrucciones de espaciado, formato y sangría.

Normalmente hay una instrucción por línea; sin embargo, se pueden colocar
dos o más instrucciones en una misma línea utilizando dos puntos (:) para
separarlas. Para hacer el código más legible, es mejor colocar cada instrucción
en una línea. Por otra parte se puede dividir una instrucción larga en varias líneas
de código utilizando un espacio en blanco seguido de un guión bajo “_”. Esta
técnica puede hacer que sea más fácil leer el código, tanto en la pantalla como
impreso en papel. No se puede poner un comentario después de partir una
instrucción.
La mayoría de los números utilizados son decimales (base 10). En ocasiones
es conveniente o necesario usar números hexadecimales (base 16) u octales
(base 8). Con el prefijo &H delante de un número se especifica que el número
es hexadecimal. Para especificar que un número es octal, este se debe
preceder con &O. Por ejemplo: &H10 y &O20 equivalen a 16 en decimal.
Los bloques anidados, deben llevar una sangría de cuatro espacios o un
espacio de tabulador cada vez que se efectúe anidamiento. El comentario del
esquema funcional de un procedimiento debe llevar una sangría de un
espacio.

1.2. Teoría de Objetos

1.2.1. Clase
La Clase es un patrón (horma, molde, plantilla) que define las características de un
objeto y describe qué apariencia y comportamiento debe tener el objeto. La clase
define las propiedades del objeto y los métodos utilizados para controlar el
comportamiento del objeto. Podríamos decir que existe la clase mamíferos, la clase
estudiantes o la clase profesor. Como ejemplos de Visual Basic se tiene la clase Form,
la clase CommandButton, la clase PictureBox o la clase TextBox.
1.2.2. Objeto
Cuando crea una aplicación en Visual Basic trabaja con objetos. Puede usar los
objetos que proporciona Visual Basic como controles, formularios y objetos de acceso
a datos. También puede controlar objetos de otras aplicaciones desde su aplicación
de Visual Basic. Puede incluso crear sus propios objetos y definir propiedades y
métodos adicionales para ellos.
El objeto se define como la instancia de una clase que combina datos
(propiedades) y procedimientos (métodos) que pueden ser tratados como una
unidad, por ejemplo un control, formulario, o aplicación. Cada objeto está definido
por una clase. Para comprender la relación entre un objeto y su clase, piense en el
molde de las galletas y las galletas. El molde es la clase que define las características
de cada galleta, como por ejemplo el tamaño y la forma. Se utiliza la clase para
crear objetos. Los objetos son las galletas. En el caso de Visual Basic los controles
del cuadro de herramientas representan clases. El objeto conocido como control no
existe hasta que se coloca en un formulario. Cuando crea un control, está creando
una copia o instancia de la clase del control. Se crean todos los objetos como copias
idénticas de sus clases. Una vez que existen como objetos individuales, es posible

22 22
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

modificar sus propiedades. Por ejemplo, si coloca dos botones de comando en un

formulario, cada objeto botón de comando es una instancia de la clase
CommandButton. Cada objeto comparte un conjunto de

23 23
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

características y capacidades comunes (propiedades, métodos y eventos),

definidos por su clase. Sin embargo, cada uno tiene su propio nombre, se puede
activar y desactivar por separado, se puede colocar en una ubicación distinta del
formulario, etc. Son objetos distintos con distinto valor para la propiedad Name.
Por ejemplo los botones de comando Command1, Command2, Command3 y
Command4 comparten (provienen de) la misma clase, CommandButton.
1.2.3. Propiedades
En Visual Basic, los datos de un objeto (características, datos o atributos) se
llaman propiedades. Puede cambiar las características de un objeto si modifica sus
propiedades. Piense en la clase “Automóvil”, y en el objeto “MiCarro” como
instancia de la clase Automóvil. Una propiedad de MiCarro es su Velocidad. En
Visual Basic, se diría que MiCarro tiene la propiedad Velocidad, la cual se puede
graduar modificando su valor. Suponga que el rango de velocidad de MiCarro es
de 0 a 140 Km/h, y desea establecerlo a 20. En Visual Basic se escribiría mediante
la siguiente sintaxis:
MiCarro.Velocidad = 20

En el ejemplo anterior se estableció el valor de una propiedad. Las propiedades

también pueden devolver sus valores de la siguiente manera:
Tacómetro = MiCarro.Velocidad

En los ejemplos anteriores y en adelante el signo igual “=” se lee como “se le asigna”.
Este signo se usa en BASIC para asignar el valor de la parte izquierda a la parte
derecha del signo. De esta manera, el primer ejemplo se lee “Propiedad Velocidad
de MiCarro se le asigna 20”.
Se pueden establecer casi todas las propiedades en tiempo de diseño usando una
ventana del IDE de Visual Basic conocida como Propiedades sin tener que escribir
código alguno. Otras propiedades no están disponibles en tiempo de diseño, ya
que no aparecen en la ventana de propiedades, por lo que se necesitará escribir
código para establecer u obtener esas propiedades en tiempo de ejecución.
Por otra parte, es posible que durante la ejecución del programa ciertas
propiedades no puedan ser modificadas, mientras que otras sí. En este sentido se
tienen los siguientes tipos de propiedades:
a) Propiedades de lectura y escritura
Las propiedades cuyo valor se puede establecer y obtener en tiempo de
ejecución se llaman propiedades de lectura y escritura.
b) Propiedades de sólo lectura
Las propiedades que sólo se pueden leer (obtener su valor), pero que no se
pueden cambiar (establecer) en tiempo de ejecución se conocen como
propiedades de sólo lectura. Estas propiedades sólo se pueden cambiar en
tiempo de diseño.
Por ejemplo, la propiedad Velocidad de MiCarro es de lectura y escritura, ya que
puede ser leída y establecida en tiempo de ejecución (auto andando); pero la

24 24
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

propiedad “NivelDeGasolina” de MiCarro es de sólo lectura, ya que no se puede

cambiar en tiempo de ejecución (auto andando), y se debe detener la aplicación

25 25
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

para que en tiempo de diseño (auto detenido) se reabastezca el nivel de

combustible.
En general, para cambiar (establecer) el valor de la propiedad de un objeto en
tiempo de ejecución, se utiliza la sintaxis siguiente:
NombreDeObjeto.Propiedad = Valor

También para leer (obtener) el valor de la propiedad de un objeto en tiempo de

ejecución se utiliza la sintaxis siguiente:
Variable = NombreDeObjeto.Propiedad
Sugerencia: Si va a usar el valor de una propiedad más de una vez, el código se
ejecutará más rápidamente si almacena el valor en una variable.
1.2.4. Métodos
Corresponden a los diversos procedimientos que pueden operar sobre el objeto.
Los métodos son parte de los objetos del mismo modo que las propiedades.
Generalmente, los métodos son acciones que desea o está posibilitado a realizar el
objeto, mientras que las propiedades son los atributos que puede establecer o
recuperar. Se podría decir que MiCarro tiene un método "Acelerar" y podría usar la
siguiente sintaxis para cambiar la velocidad:
MiCarro.Acelerar 20

Los métodos pueden afectar a los valores de las propiedades e inclusive activar
procedimientos de evento que veremos mas adelante. En el ejemplo de MiCarro, el
método Acelerar cambia la propiedad Velocidad. Cuando utiliza un método en el
código, la sintaxis depende de los argumentos que necesite el método y de si el
método devuelve o no un valor. En general se utiliza la sintaxis siguiente:
NombreDeObjeto.Método [Arg1, Arg2,...]

De ahora en adelante, en las sintaxis generales, los elementos que aparezcan

entre corchetes [ ] son opcionales de la sintaxis. En este caso Arg1, Arg2,… son
opcionales, de tal manera que si el método no requiere argumentos, la sintaxis sería:
NombreDeObjeto.Método

Si el método devuelve un valor útil, debe asignar el valor a una variable y utilizar
paréntesis con o sin argumentos como se muestra a continuación:
Variable = NombreDeObjeto.Método([Arg1, Arg2,...])

1.2.5. Evento
Un evento es una acción reconocida por un objeto, como cuando el usuario hace
clic con el Mouse o presiona una tecla. Los eventos no sólo son producidos por el
usuario, también pueden ser ocasionados por el sistema, por aplicaciones
externas, e inclusive por la misma aplicación. Por ejemplo, MiCarro podría tener los
eventos "CambioDeVelocidad”, “Estacionarse”, Encendido”, “GiroIzquierdo”, etc. La
sintaxis para alguno de estos eventos de MiCarro sería:

26 26
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

MiCarro_CambioDeVelocidad

27 27
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

MiCarro_Encendido
MiCarro_Estacionarse

En Visual Basic la sintaxis general para el evento de un objeto es:

NombreDeObjeto_NombreDeEvento

1.2.6. Procedimientos de evento

Un procedimiento de evento es una sección de código que se ejecuta cuando se
produce el evento sobre un objeto determinado. Las aplicaciones controladas por
eventos ejecutan código Basic como respuesta a un evento. Cada objeto de Visual
Basic tiene un conjunto de eventos predefinidos. Si se produce uno de esos
eventos, y su procedimiento de evento tiene código asociado, Visual Basic ejecuta
ese código. A cada evento le corresponde una sección de código que es lo que se
conoce como un procedimiento de evento. Cuando se desea que un control
responda a un evento, se escribe código en el procedimiento de ese evento. El objeto
MiCarro tiene un código en el procedimiento de evento CambioDeVelocidad, el cual
define los pasos para mostrar la velocidad actual en el tacómetro, por ejemplo; y su
estructura sería:
Private Sub MiCarro_CambioDeVelocidad()
{Área de código para mostrar velocidad}
End Sub

De modo que un procedimiento de evento en Visual Basic, es de la forma:

Private Sub NombreDeObjeto_NombreDeEvento()
{Área de código}
End Sub

Distintos tipos de eventos pueden ser reconocidos por un mismo objeto; por ejemplo,
el objeto Form es susceptible al evento Click, y también al evento DblClick.
El código de respuesta a los eventos, en cada caso, será como sigue:

Private Sub Form_Click()

{Área de código para un clic sobre el Form}
End Sub

Private Sub Form_DblClick()

{Área de código para un doble clic sobre el Form}
End Sub

Por otra parte, distintos tipos de objetos pueden ser susceptibles a un mismo evento.
Por ejemplo, la mayoría de los objetos reconocen el evento Click. Si el usuario hace
clic sobre el cuerpo del formulario, o sobre el área de un botón de comando, se
ejecutan códigos diferentes:
Private Sub Form_Click()
{Área de código para un clic sobre el formulario}
End Sub

Private Sub cmdBotón_Click()

28 28
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

{Área de código para un clic sobre el botón}

End Sub

29 29
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
1.- Introducción
1.- Introducción
a Visual
a Visual
Basic Basic

1.2.7. Encapsulación
Esta característica de la OOP es la facultad de unificar el código y los datos que la
clase u objeto contiene, así como ocultar el código que maneja dicha información. La
encapsulación nos ayuda a olvidarnos de cual es la implementación realizada en los
procedimientos y datos (métodos y propiedades) de una clase, para que sólo nos
preocupemos de cómo usarlos. La encapsulación es la característica que permite
ocultar cómo están codificados los métodos y propiedades de las clases. El mero
hecho de crear un método o una propiedad en una clase ya implica que estamos
usando la característica de la encapsulación en Visual Basic.
1.2.8. Polimorfismo
Muchas clases pueden proporcionar la misma propiedad o el mismo método y el
que llama no tiene por qué saber la clase a la que pertenece el objeto antes de llamar
a la propiedad o al método. Por ejemplo, una clase Automóvil y una clase Avión
podrían tener la misma propiedad Velocidad o el mismo método Acelerar. El
polimorfismo significa que puede establecer la Velocidad o invocar Acelerar sin
saber si el objeto es MiCarro o MiAvión. Todos los métodos implementados en las
clases deben tener una forma única de comportarse, y las propiedades de las
clases deben ser consistentes con la información que corresponde tratar. El
polimorfismo sería el contrato firmado para que esos procedimientos y datos se
utilicen de forma adecuada. Se dice que una clase es polimórfica cuando podemos
usar sus métodos y propiedades sin importarnos qué objeto los implementa. El
Polimorfismo en Visual Basic se puede usar de dos formas diferentes, según se
compruebe si el miembro de una clase (propiedad o método) pertenece al objeto
que lo utiliza, en tiempo de diseño o en tiempo de ejecución.

30 30
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Unidad 2

Trabajar con Visual Basic

“Cualquier obra grande al principio es imposible”

. - Carlyle

2.1. Estructura de proyecto

2.1.1. Proyecto
El proyecto se define como el grupo archivos asociados necesarios para desarrollar
una aplicación o componente software. En el caso de Visual Basic, el proyecto es
un archivo de texto con extensión .vbp (Visual Basic Project) que contiene
información sobre los archivos que componen la aplicación. Específicamente,
podríamos decir que el proyecto es la aplicación en sí, pero en tiempo de diseño
en el argot de Visual Basic. Los proyectos están conformados por Módulos, dentro
de cada uno de los cuales se encuentran Declaraciones y Procedimientos.
2.1.2. Módulos
El código en Visual Basic se almacena en módulos. Hay tres tipos de módulos: de
formulario, estándar y de clase. Los módulos estándar y de clase carecen de
representación gráfica, mientras que los módulos de formulario poseen la
representación gráfica correspondiente a la interfaz de usuario. Un proyecto puede
contener varios módulos de distintos tipos y cada uno se guarda en archivos por
separado; lo que permite crear código reutilizable por otros proyectos. Cada
módulo estándar, de clase y de formulario posee una sección de Declaraciones y
un conjunto de Procedimientos que veremos más adelante.
a) Módulos de formulario
Los formularios son las ventanas mediante las cuales los usuarios interactúan
con la aplicación. Cada formulario del proyecto tiene asociado un archivo con
extensión .frm, el cual contiene las definiciones de objeto y su código.
b) Módulos estándar
Los módulos estándar son archivos de texto que almacenan código fuente
dividido en procedimientos, a los que pueden tener acceso otros módulos de la
aplicación. Su implementación es obligatoria en el caso de incluir variables
globales al proyecto. La extensión de estos archivos es .bas.

Figura 2.1.- Estructura de un proyecto

24 23
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

c) Módulos de clase
Los módulos de clase (archivo de extensión .cls) son la base para la creación
de objetos en Visual Basic. Puede escribir código en módulos de clase para
ensamblar nuevos objetos. Estos objetos nuevos pueden incluir propiedades y
métodos personalizados.

Figura 2.1.- Estructura de un proyecto

24 24
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

2.1.3. Procedimientos
Cada módulo se divide en procedimientos. Los procedimientos son estructuras que
delimitan un conjunto de instrucciones. Los procedimientos pueden tener alcance
público o privado. Los procedimientos privados sólo se pueden acceder desde el
módulo en el cual están creados, mientras que los procedimientos públicos se pueden
acceder desde cualquier módulo del proyecto. También los procedimientos existen
en tres tipos: Sub, Function, y Property que se estudiarán en detalle en la unidad 4;
por lo pronto sólo es necesario conocer su estructura, la cual según el alcance y el
tipo se pueden ver de la siguiente manera:
Private Sub NombreDeProcedimientoSub()
{Código de instrucciones}
End Sub

Private Function NombreDeProcedimientoFunction()

{Código de instrucciones}
End Function

Los procedimientos se inician con la sentencia Sub y termina con End Sub. De esta
misma manera las funciones comienzan con la sentencia Function y terminan con
End Function. En general, todas las estructuras de Visual Basic se inician con
NombreDeEstructuta y terminan con End NombreDeEstructura. No está permitido
escribir código que no sea dentro de la estructura de procedimientos.
2.1.4. Declaraciones
Independientemente del tipo de módulo, todos poseen un área especial fuera de
la estructura de los procedimientos al inicio del módulo conocida como Sección de
Declaraciones. En esta sección del módulo no se pueden escribir instrucciones,
sólo declaraciones. Las declaraciones consisten en especificar localidades de memoria
o funciones externas (API) mediante un nombre o identificador. En la figura 2.1 se
puede apreciar una aproximación gráfica de la estructura completa de un proyecto,
con dos módulos de formulario, un formulario estándar y la estructura interna de
cada módulo en declaraciones y procedimientos.

Proyecto.vbp
Formulario1.frm Formulario2.frm Módulo.bas
‘Declaraciones ‘Declaraciones ‘Declaraciones

Private Sub Public Sub Private Sub

End Sub End Sub End Sub

Private Function Private Sub Public Function

End Function End Sub End Function

Private Sub Private Sub Public Sub

Figura 2.1.- Estructura de un proyecto

24 25
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

End Sub End Sub End Sub

Figura 2.1.- Estructura de un proyecto

24 26
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

2.2. IDE de Visual Basic

2.2.1. Entorno de Desarrollo Integrado (IDE)
El área de trabajo que interactúa con el usuario en cualquier programa se conoce
como Entorno de Desarrollo Integrado o IDE (Integrated Development Environment).
El entorno de trabajo de Visual Basic integra funciones de diseño, edición,
compilación y depuración de proyectos mediante el uso de una interfaz gráfica
compuesta por ventanas, cuadros de diálogo y herramientas. Todas las ventanas de
Visual Basic se pueden acceder desde el menú Ver. Muchas de las ventanas del IDE
se pueden acoplar o conectar a otra o al borde de la pantalla, esto con el objeto
de organizar el entorno y mejorar la visualización de las herramientas. Para
activar o desactivar el acople de una ventana se debe mostrar el menú emergente
de la ventana (clic derecho sobre la ventana). El entorno permite MDI (Interfaz de
Múltiples Documentos) para manipular varios proyectos al mismo tiempo. Las
funciones integradas son:
a) DISEÑO
b) EDICIÓN
c) COMPILACIÓN
d) DEPURACIÓN
2.2.2. Ventana Explorador de Proyecto
La ventana explorador de proyecto muestra todos los módulos que conforman al
proyecto permitiendo al programador navegar entre los distintos módulos. En la
figura 2.2 se muestran los rasgos más significativos de esta ventana.
a) Botón “Ver código”: muestra la ventana de código del módulo seleccionado.
b) Botón “Ver objeto”: muestra el diseñador de formulario del formulario
seleccionado.
c) Botón “Alternar carpetas”: cambia la vista de árbol, agrupando por tipo de
módulo.
d) Nombre del proyecto y del archivo de proyecto (.vbp) entre paréntesis.
e) Nombre de un módulo de formulario y su archivo asociado (.frm) entre
paréntesis.
f) Nombre de un módulo estándar y su archivo asociado (.bas) entre paréntesis.

a b c

Figura 2.1.- Estructura de un proyecto

24 27
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Figura 2.2.- Ventana Proyecto

Figura 2.1.- Estructura de un proyecto

24 27
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Para gestionar cada módulo o proyecto individualmente (agregar, quitar, guardar),

se hace clic derecho sobre el módulo deseado para desplegar su menú emergente.
Este menú emergente también permite elegir el objeto inicial cuando se manipulan
varios proyectos en una misma sesión.
2.2.3. Ventana Diseñador de Formularios
Esta ventana permite construir la aplicación en forma gráfica mediante el
formulario y el dibujo de los objetos dentro del formulario. Los objetos se pueden
inmovilizar mediante la opción “Bloquear controles” del menú Formato. El grid o rejilla
se puede ocultar y volver a mostrar en el menú “Herramientas | Opciones”, pestaña
“General”. A continuación, la figura 2.3 es un ejemplo del Diseñador de Formularios
“”

Figura 2.3.- Ventana Diseñador de formulario

2.2.4. Ventana de código

La ventana de código es un editor de texto que permite crear, visualizar y

modificar todo el código de Visual Basic. Existe una ventana de código por cada
módulo, ya sea de formulario, estándar o de clase. Vea en la figura 2.4 las partes
de la ventana editora de código para un módulo de formulario llamado frmForm1.
a) Lista de Objetos del formulario frmForm1, incluyendo al mismo formulario.
b) Lista de eventos provistos por el objeto seleccionado en la Lista de Objetos.
c) Sección de declaraciones
d) Área de procedimientos

26 26
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Figura 2.4.- Ventana de código

27 27
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

2.2.5. Caja de herramientas

Esta ventana contiene las clases de los objetos o controles. Con doble clic se
selecciona y se inserta un control en el Centro del formulario activo o con un clic
se selecciona el objeto y luego se puede dibujar en el formulario (ver Figura 2.5).

Puntero Pictute

Label TextBox

Frame CommandButton

CheckBox OptionButton

ComboBox ListBox

HScrollBar VScrollBar

Timer DriveListBox

DirListBox FileListBox

Shape
Line
Image
Data
OLE

Figura 2.5.- Cuadro de herramientas

2.2.6. Ventana de propiedades

Mediante esta ventana es posible ver o establecer las propiedades de los objetos.
Cada vez que selecciona un objeto, la ventana de propiedades se actualiza para
ese objeto. Las partes de la ventana de propiedades (ver Figura 2.6) son:
a) Lista de todos los Objetos.
b) Descripción de la propiedad.
c) Valor de la propiedad.
d) Descripción rápida de la propiedad seleccionada.

b c

28 28
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Figura 2.6.- Ventana de propiedades.

29 29
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

2.2.7. Funciones básicas del IDE

a) Crear un nuevo proyecto:
Según su configuración, al iniciar Visual Basic aparece automáticamente el
cuadro de diálogo “Nuevo proyecto” (ver Figura 2.7), el cual presenta tres
pestañas: “Nuevo”, “Existente” y “Recientes”. La pestaña “Nuevo” permite
crear un nuevo proyecto. La pestaña “Existente” es para cargar un
proyecto guardado. Y la pestaña “Recientes” carga los últimos proyectos
abiertos previamente con Visual Basic.

Figura 2.7.- Diálogo Nuevo proyecto al iniciar Visual Basic

El menú “Archivo | Nuevo proyecto” accede al diálogo de la figura 2.8.

30 30
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Figura 2.8.- Diálogo Nuevo proyecto estándar

Sugerencia: Seleccione EXE estándar en cualquiera de los casos para aplicaciones sencillas.
Mediante el teclado: “CTRL+N” tiene el mismo efecto.

31 31
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

b) Agregar o quitar módulos de formulario del proyecto:

En el menú “Proyecto | Agregar formulario” aparece el diálogo de la figura
2.9, el cual presenta dos pestañas “Nuevo” y “Existente”. Mediante la
pestaña “Existente”, en el proyecto actual se pueden utilizar o importar
formularios creados previamente en otros proyectos.

Figura 2.9.- Diálogo Agregar formulario

Otra forma de acceder al diálogo de la figura 2.9 es mediante el menú

emergente de la ventana Explorador de proyectos (ver Figura 2.10). Este
menú permite agregar, guardar o remover formularios y módulos.

32 32
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Figura 2.10.-Menú emergente del explorador de proyecto

Recuerde: Los menús emergentes de un objeto o ventana se activan haciendo

un clic derecho sobre el objeto o ventana.

33 33
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

c) Agregar o quitar módulos estándar del proyecto:

Haciendo clic en el menú “Proyecto | Agregar módulo” se accede al cuadro de
dialogo que se muestra en la figura 2.11 en la que se puede observar, al
igual que para agregar formulario, las pestañas “Nuevo” y “Existente”.

Figura 2.11.-Diálogo Agregar módulo

También puede activar el menú emergente de la ventana Explorador de

proyecto, con el fin de agregar módulos estándar.
d) Cambiar los modos de operación del proyecto (tiempo de diseño y ejecución):
Utilizando el menú “Ejecutar | Iniciar” o “Ejecutar | Terminar” se puede
pasar a tiempo de ejecución o a tiempo de diseño respectivamente.

Mediante la barra de herramientas, haciendo clic en el botón “Iniciar”

o en el botón “Terminar” se puede pasar a tiempo de ejecución o a
tiempo de diseño.
Facilidad: Presionar la tecla F5 del teclado es equivalente a Iniciar.

e) Guardar los archivos del proyecto:

Menú “Archivo | Guardar proyecto” o “Archivo | Guardar proyecto como”
Mediante la barra de herramientas, haciendo clic en el botón “Guardar”

Se pueden guardar individualmente cada uno de los módulos mediante el menú

“Archivo” o desplegando el menú emergente de la ventana explorador
de proyecto (ver Figura 2.10).
f) Configurar el proyecto:

34 34
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Para acceder a las Propiedades del proyecto (ver Figura 2.12) se usa el
menú “Proyecto | Propiedades de NombreProyecto”. La sección “Objeto

35 35
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

inicial” permite al programador elegir al formulario que se cargará en

forma predeterminada al iniciarse la aplicación.

Figura 2.12.-Diálogo Propiedades del proyecto

g) Configurar el entorno:

Para configurar el IDE se hace clic en el menú “Herramientas | Opciones” y

aparece el diálogo que se muestra en la figura 2.13, en la se pueden apreciar
las pestañas Editor, Formato del editor, General, Acople, Entorno y Avanzado.

Figura 2.13.-Diálogo Opciones de editor

Editor: permite configurar a la ventana de código.

36 36
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Formato del editor: define el tipo, tamaño y color como se mostrarán las
fuentes tipográficas según su uso dentro del código. Esta característica es
para facilitar la visualización del código de parte del usuario.

37 37
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

General: escoge si mostrar o no la cuadricula, y si forzar o no la posición

de los controles a la cuadrícula.
Acople: permite elegir las ventanas del IDE que se podrán acoplar o no.
Entorno: escoge la forma de guardar los cambios, Automática sin
preguntar, Preguntar antes de guardar o Guardado manual
Avanzado: establece si el entorno soporta o no MDI.

2.3. Crear una aplicación

2.3.1. Pasos básicos
Para crear una aplicación (programa) en Visual Basic o cualquier otro lenguaje de
programación visual, existen unos pasos bien definidos, aunque no estrictos, que
ayudan o facilitan el proceso de diseño. Se recomienda inicialmente hacer un
dibujo de la apariencia que tendrá la interfaz de usuario (el formulario), esto con
el fin de ilustrar la ubicación relativa de los objetos que contendrá el formulario.
Los pasos básicos son:
a) Colocar los objetos
b) Establecer las propiedades
c) Escribir el código
2.3.2. Colocar los objetos
El primer paso consiste en la creación de los objetos estableciendo su ubicación, y
tamaño inicial en forma gráfica dentro de un formulario. Cuando se crea un nuevo
proyecto, según el punto 2.2.7(a), automáticamente se crea el primer objeto de la
aplicación, y este es el formulario, incluyendo su módulo de código. En esta
primera parte, el programador debe seleccionar la clase (modelo de objeto) en el
cuadro de herramientas y luego dibujar el objeto en su contenedor respectivo. Los
contenedores son objetos que agrupan a otros objetos, y el único visto hasta el
momento es el formulario.

38 38
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Figura 2.14.-Agregar objetos a un formulario

2.3.3. Establecer las propiedades

Una vez que se han colocado los objetos, se procede a establecer o modificar las
propiedades de los mismos, tales como: color de fondo (BackColor), valor inicial
(Text), rótulo o título (Caption) y la propiedad que nunca se debe dejar de establecer
en esta parte, la propiedad Nombre (Name). Las propiedades se cambian en
la Ventana de propiedades. No debe escribir código sin establecer la propiedad
Nombre previamente, ya que en el paso siguiente de construcción del código, los
procedimientos de evento se crean automáticamente y estos incluyen el nombre
del objeto seleccionado. Si el programador cambia el nombre del objeto,
después de haber escrito el código del mismo, entonces deberá corregir los nombres
de todos los procedimientos de evento del objeto.

39 39
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Figura 2.15.-Modificar las propiedades de objetos

40 40
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

2.3.4. Escribir el código

Finalmente se procede a escribir el código en la Ventana de código. Tal como
vimos en el punto 2.1.3, el código se escribe dentro de un procedimiento; es decir,
entre las sentencias Private Sub y End Sub. Ahora la pregunta es ¿En qué
procedimiento de evento se debe escribir el código? En los lenguajes de
programación visual, a la hora de escribir el código, se deben tener en cuenta dos
elementos: el objeto y el evento. Es relevante entender que un objeto puede
responder a múltiples eventos, y que un mismo tipo de evento puede afectar a
múltiples objetos. Así, el código se divide en procedimientos y cada procedimiento
se corresponde con un objeto específico y a un evento específico de este objeto.
En este sentido, dividimos este paso en tres tareas básicas.
a) Seleccionar el objeto: Se debe analizar cuales de los objetos se han dispuesto
para recibir las acciones del usuario, del sistema, o de una aplicación externa.
Las aplicaciones orientadas a eventos, cuando se ejecutan, sólo muestran la
interfaz y se quedan a la espera de la intervención del usuario (teclado, ratón),
del sistema (reloj del PC), o de una aplicación externa (peticiones); es decir, la
aplicación espera a que ocurra algo, espera los Eventos; y estos tienen lugar
sobre un objeto. En esta primera tarea, el programador debe determinar
cuales de sus objetos recibirá esas acciones. En nuestro ejemplo, tenemos tres
objetos: el formulario, la caja de texto y el botón de comando. El botón de
comando será el que recibirá el evento.

Seleccionar el objeto Command1

Figura 2.16.-Seleccionar objeto para procedimiento de evento

b) Seleccionar el evento: Especificar, para el objeto seleccionado, el evento mediante

el cual la aplicación efectuará algún proceso. El editor crea automáticamente el
procedimiento de evento. Para nuestro ejemplo escogeremos el evento Click.

41 41
Visual
Visual
BasicBasic
6.0 6.0 Unidad
Unidad
2.- Trabajar
2.- Trabajar
con Visual
con Visual
BasicBasic

Seleccionar el evento Click

Figura 2.17.-Seleccionar evento para procedimiento de evento

c) Escribir el código: “Rellenar” el procedimiento de evento creado previamente.

Se escriben las instrucciones necesarias para que, cuando se produzca el
evento sobre el objeto seleccionado, se ejecute el proceso deseado.

Objeto seleccionado Evento seleccionado

Código Basic Procedimiento de evento

Figura 2.18.-Escribir código en un procedimiento de evento

42 42
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Unidad 3

Objetos de Visual
Basic

“La manera más segura de no fracasar es decidirse a tener éxito”

.- Sheridan.

3.1. El formulario
3.1.1. Formulario (Clase: Form)
Un objeto formulario es una ventana o un cuadro de diálogo que forma parte de la
interfaz de usuario de una aplicación cuando esta se ejecuta. Los formularios
pertenecen a la clase “Form”, a la vez que “Form” también es un objeto. Los
formularios son objetos contenedores. Los contenedores son objetos diseñados
para albergar o agrupar a otros objetos, de tal manera que si se mueve o se
elimina al contenedor, también se mueven o eliminan a los objetos contenidos en
él. Para hacer referencia a un objeto contenido dentro de un formulario, se debe
especificar el nombre del formulario seguido de un punto y luego el nombre del
objeto.
NombreForm.NombreObjeto.Propiedad = Valor
NombreForm.NombreObjeto.Método [Parámetro1, Parámetro2,…]

En el caso que el objeto este contenido en el mismo formulario desde el que se hace
referencia, se sustituye el nombre del formulario por la palabra reservada “Me”. La
palabra “Me” es equivalente al nombre del formulario en cuyo módulo se escribe el
código. En otras palabras, para el ejemplo “Me” reemplaza a “NombreForm”,
siempre que la ventana de código pertenezca al formulario llamado
“NombreForm”.
Me.NombreObjeto.Propiedad = Valor
Me.NombreObjeto.Método [Parámetro1, Parámetro2,…]

De esta misma manera, para acceder a propiedades y métodos del formulario actual,
no es necesario escribir su nombre completo como se muestra a continuación.
NombreForm.Propiedad = Valor
NombreForm.Método [Parámetro1, Parámetro2,…]

En su lugar, se hace referencia al formulario actual la palabra reservada “Me”.

43 43
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Me.Propiedad = Valor
Me.Método [Parámetro1, Parámetro2,…]

44 44
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

La palabra “Me”, más que sintaxis, es una gran ayuda a la hora de escribir código,
ya que al colocar el punto justo después de “Me” se despliegan, no sólo las
propiedades y métodos del formulario, sino también los objetos que este contiene
(ver Figura 3.1), facilitándose la escritura y verificándose si existe o no el objeto.

Propiedad
Método
Objeto

Figura 3.1.- Despliegue del operador punto.

Esta funcionalidad es gracias al operador punto del editor de código, y aplica para
todos los objetos del sistema, instancias de objetos y estructuras. Observe que se
presentan iconos diferentes para distinguir entre propiedades, métodos y objetos.
Regla de Visual Basic de prefijo para nombre de objeto Formulario:
frm.

3.1.2. Propiedades de formularios

A continuación se muestra una tabla con la mayoría de las propiedades de los
formularios con su descripción (ver Tabla 3.1), la cual se ha redactado en forma
general ya que existen propiedades que pueden aplicar para otros objetos.
Propiedad Descripción
Appearence Si el objeto es 3D o plano.
AutoRedraw Si re-dibuja o no los resultados de métodos gráficos.
BackColor Color de fondo del objeto.
BorderStyle Estilo del borde del formulario. Puede ser sin borde, borde fijo, borde ajustable, etc.
Caption Título o rótulo del objeto. Para formularios, aparece en la barra de título.
ControlBox Si muestra o no el cuadro de control del formulario.
DrawStyle Estilo de línea de los resultados de métodos gráficos.
DrawWidth Grueso de línea de los resultados de métodos gráficos.
Enabled Si permite o no los eventos del ratón.
FillColor Color de relleno de formas, círculos y cuadros.
FillStyle Estilo de relleno de formas, círculos y cuadros.
Font Nombre y estilo de la fuente tipográfica para el objeto.
ForeColor Color de la fuente tipográfica.
Height Altura del objeto. Según ScaleMode.
Icon Imagen del cuadro de control del formulario.
Left Distancia del lado izquierdo del objeto al borde de su contenedor. Según ScaleMode.
MaxButton Si muestra o no el botón maximizar del formulario.
MinButton Si muestra o no el botón minimizar del formulario.
MouseIcon Imagen personal del apuntador de ratón. MousePointer debe establecerse en 99-Custom.
MousePointer Tipo de imagen del apuntado de ratón sobre el objeto.
Moveable Si se puede mover o no el formulario en tiempo de ejecución.
Name Identificador o nombre del objeto. No acepta espacios ni caracteres especiales.

45 45
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Picture Imagen de fondo. Cualquier archivo gráfico del entorno de Windows.

ScaleHeight Altura interior del objeto. Según ScaleMode.
ScaleLeft Coordenada del lado izquierdo interno del objeto. Según ScaleMode.
ScaleMode Unidad de medida de las coordenadas. Puede ser Twip, Centímetro, Pulgada, etc.
ScaleTop Coordenada del lado superior interno del objeto. Según ScaleMode.

46 46
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Propiedad Descripción
ScaleWidth Ancho interior del objeto. Según ScaleMode.
ShowInTaskBar Si muestra o no la aplicación en la barra de tareas de Windows.
StarUpPosition Posición inicial del formulario cuando se carga o se ejecuta la aplicación.
Tag Información adicional del objeto.
Top Distancia del lado superior del objeto al borde de su contenedor. Según ScaleMode.
Visible Si se muestra o no en la pantalla.
Width Ancho del objeto. Según ScaleMode.
WindowState Modo del formulario “Normal”, “Maximizado” o “Minimizado”
Tabla 3.1.- Propiedades más importantes del formulario.

En la figura siguiente se muestra un formulario (ventana) donde se indican sus

elementos básicos.
Barra de título Botón minimizar Botón maximizar Botón cerrar

Caja de control

Barra de menú
Borde Height

Fondo

Width

Figura 3.2.- Elementos básicos de una ventana.

3.1.3. Métodos de formularios

Método Sintaxis Acción

Mostrar un formulario en forma modal si Estilo = 1. De
Show Objeto.Show [Estilo]
lo contrario es no modal.
Ocultar un formulario. El formulario no se descarga de
Hide Objeto.Hide
la memoria.
Dibujar un círculo sobre el objeto. El centro está en x,
Circle Objeto.Circle (x , y), r [, Color]
y. El radio es r.
Dibujar una línea sobre el objeto. La línea va desde
Line Objeto.Line (x1, y1) - (x2, y2)
x1, y1, hasta x2, y2.
Borrar los resultados de métodos gráficos. Métodos
Cls Objeto.Cls
como Line y Circle son métodos gráficos.
Mover y cambiar tamaño del objeto. Alternativamente
Move Objeto.Move x, y, Ancho, Alto
dispone las propiedades Top, Left, Height y Width
Dibujar un punto sobre el objeto. El tamaño del punto
PSet Objeto.Pset (x, y) [,Color]
depende del valor de la propiedad DrawWidth.
Enfocar al objeto. Los objetos deshabilitados o no
SetFocus Objeto.SetFocus visibles, no pueden ser enfocados.

Tabla 3.2.- Métodos más importantes del formulario

3.1.4. Eventos de formularios

Evento Ocurre cuando…
Click El usuario presiona y suelta un botón del Mouse (ratón) en un objeto.

47 47
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

DblClick El usuario presiona y suelta un botón del Mouse (ratón) en un objeto dos veces.
MouseDown El usuario presiona un botón del Mouse (ratón) en un objeto.
MouseUp El usuario suelta un botón del Mouse (ratón) en un objeto.
MouseMove El usuario mueve el puntero del Mouse (ratón) en un objeto.

48 48
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Evento Ocurre cuando…

KeyDown El usuario presiona una tecla en un objeto que tiene el enfoque.
KeyUp El usuario suelta una tecla en un objeto que tiene el enfoque.
KeyPress El usuario presiona y suelta una tecla en un objeto que tiene el enfoque.
DragDrop El usuario termina una operación de arrastrar y colocar sobre un objeto.
DragOver El usuario ejecuta una operación de arrastrar y colocar sobre un objeto.
Activate Un formulario se convierte en la ventana activa.
Deactivate Un formulario deja de ser la ventana activa.
GotFocus Un objeto recibe el enfoque.
LostFocus Un objeto pierde el enfoque.
Load Un formulario se abre o se carga.
Unload Un formulario se cierra o descarga.
QueryUnload Un formulario se intenta cerrar o descargar.
Paint Un objeto o parte de él se expone si estaba cubierto por otro.
Resize Un formulario cambia de tamaño.
Tabla 3.3.- Eventos más importantes del formulario.

3.2. Los controles

3.2.1. Etiqueta (Clase: Label)
Un control etiqueta es un control gráfico de la clase “Label” que se puede usar
para mostrar algún texto o mensaje que el usuario no podrá cambiar
directamente. Se puede escribir código para cambiar el texto mostrado por un control
Label como respuesta a eventos en tiempo de ejecución, manipulando la propiedad
Caption. Por lo general las etiquetas se usan para rotular otros controles.
Regla de Visual Basic de prefijo para nombre del objeto Etiqueta:
lbl.
Veremos sólo las propiedades, métodos y eventos específicos que no hayan sido
tratados anteriormente para cada objeto.
a) Propiedades de etiquetas
Propiedad Descripción
Alignment Justificación de texto centrada, derecha o izquierda.
AutoSize Si ajusta o no su tamaño al contenido.
BackColor Color de fondo. No tiene efecto si la propiedad BackStyle = 0-Transparent
BackStyle Estilo de fondo de etiquetas (Label) y figuras (Shape).
BorderStyle Estilo del borde del objeto. Puede ser con o sin borde.
Caption Título o rótulo del objeto.
DragIcon Icono que se muestra durante la operación arrastrar y colocar del objeto.
DragMode Modo de la operación arrastrar y colocar del objeto.
ToolTipText Mensaje de la etiqueta de ratón cuando se señaliza al objeto.
WordWrap Si ajusta o no su tamaño en altura al contenido (Caption).
Tabla 3.4.- Algunas propiedades de la etiqueta.

Se pueden establecer las propiedades AutoSize y WordWrap en forma combinada

si desea que el Label muestre líneas de longitud variable o números
variables de líneas. Las etiquetas pueden contener múltiples líneas, para lo cual
se debe insertar en la cadena los caracteres de retorno de carro y línea nueva
(ASCII 13 y 10), que se pueden implementar mediante la constante vbCrLf.

49 49
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

lblLabel.Caption= “Line1” & vbCrLf & “Line2”

50 50
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

La operación de arrastrar y colocar está disponible para la mayoría de los objetos,

siempre y cuando la propiedad DragMode se establezca a 0-Manual. Una vez
iniciada una operación de este tipo, la imagen del icono del puntero de Mouse
(ratón) cambia según la imagen establecida mediante la propiedad DragIcon. La
operación de arrastrar y colocar se inicia mediante el método Drag del objeto
en su evento MouseDown.
b) Métodos de etiquetas
Uno de los métodos más importantes es Drag o arrastrar y colocar, como se le
conoce. Se utilizan los siguientes argumentos: 0-Cancelar, 1-Iniciar, y 2-
Terminar. También es interesante el método Refresh, el cual fuerza al sistema
para volver a dibujar un formulario o un control completo.
c) Eventos de etiquetas
Los eventos más importantes que afectan a una etiqueta son Change,
KeyDown y KeyUp. El evento Change ocurre cuando el valor de la propiedad
Caption se modifica. Como se explicó anteriormente, los eventos KeyDown y
KeyUp son útiles para detectar el inicio y fin de una operación de arrastrar y
colocar.
3.2.2. Botón de comando (Clase: CommandButton)
Se utiliza un control de la clase CommandButton para comenzar, interrumpir o
terminar un proceso, por lo general mediante su evento Click.
Regla de Visual Basic de prefijo para nombre del objeto Botón de comando: cmd.

a) Propiedades de botones de comando

Propiedad Descripción
BackColor Color de fondo. No tiene efecto si la propiedad Style = 0-Estándar.
Cancel Si ejecuta o no el clic de un Botón presionando ESC.
Default Si ejecuta o no el clic de un Botón presionando ENTER.
DisabledPicture Imagen cuando se deshabilita el objeto. No tiene efecto si la propiedad Style = 0-Estándar.
DownPicture Imagen cuando se hace clic en el objeto. No tiene efecto si la propiedad Style = 0-Estándar.
Picture Imagen de fondo. No tiene efecto si la propiedad Style = 0-Estándar.
Style Estilo gráfico de objetos.
TabIndex Orden para el enfoque mediante la tecla TAB.
TabStop Si se enfoca o no mediante la tecla TAB.
Tabla 3.5.- Algunas propiedades del botón de comando

Los botones de comando pueden contener una imagen mediante la propiedad

Picture, siempre que la propiedad Style se establezca a 1-Graphical. Se puede
definir el gráfico que muestra el botón en estado deshabilitado, según la
propiedad DisabledPicture.
También se puede mostrar una imagen determinada por la propiedad
DownPicture en el botón de comando cuando se mantiene presionado el botón
derecho del Mouse (ratón).
TabIndex define el orden de selección de enfoque de los objetos en la medida
que se presiona la tecla TAB, y no aplica en el caso de los objetos cuya la

51 51
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

propiedad TabStop o Enabled se ha establecido a False (False es equivalente a

cero)

52 52
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

b) Métodos de botones de comando

El método más importante es SetFocus. De esta manera se puede enfocar
cualquier objeto mediante código, siempre que el objeto incluya este método y
esté habilitado. El siguiente ejemplo enfoca al botón de comando
“cmdMiBotón”.
cmdMiBotón.SetFocus

c) Eventos de botones de comando

Los eventos más importantes son Click y MouseMove. Se puede ejecutar el
evento clic de un botón de comando de múltiples maneras además de
simplemente haciendo clic en él. El evento clic se puede activar presionando la
tecla ENTRAR siempre que el botón tenga el enfoque o la propiedad Default esté
establecida a True (True es equivalente a cualquier valor distinto de cero).
También presionando la tecla ESC, y habiendo establecido la propiedad Cancel
True. De todos los botones de comando de un formulario, sólo uno tiene
establecido a True la propiedad Default o Cancel.
3.2.3. Caja de texto (Clase: TextBox)
El control de la clase TextBox, también denominado control de campo de edición o
control de edición, permite mostrar, editar e introducir información en tiempo de
ejecución. La clase TextBox esta provista de la propiedad Text, la cual se modifica
por teclado y está disponible por código tanto para lectura como para escritura.
Regla de Visual Basic de prefijo para nombre del objeto Caja de texto:
txt.
a) Propiedades de cajas de texto
Propiedad Descripción
CausesValidation Si ejecuta o no el evento Validate del objeto si pierde el enfoque.
Enabled Si permite o no los eventos del ratón.
HideSelection Si oculta o no la selección del objeto cuando pierde el enfoque.
Locked Si bloquea o no la escritura en cajas de texto.
MaxLength Cantidad de caracteres admisibles en una caja de texto.
MultiLine Si permite o no varias líneas de escritura en una caja de texto.
PasswordChar Carácter para enmascarar la escritura en cajas de texto.
ScrollBars Tipo de barra de desplazamiento para cajas de texto.
SelLength Cantidad de caracteres seleccionados en una caja de texto.
SelStart Posición del cursor dentro de una caja de texto.
SelText Posición del cursor dentro de una caja de texto.
Text Contenido alfanumérico de una caja de texto o combinada.
Tabla 3.6.- Algunas propiedades de la caja de texto.

Para escribir en varias líneas de texto en un control de la clase TextBox,

establezca la propiedad MultiLine a True. Para personalizar la combinación de
barra de desplazamiento en un TextBox, establezca la propiedad ScrollBars.
Las barras de desplazamiento siempre aparecerán en el TextBox cuando su
propiedad MultiLine se haya establecido a True y su propiedad ScrollBars a
cualquier valor excepto a 0-None. Si una caja de texto de múltiples líneas tiene
una barra de desplazamiento horizontal, el texto se no ajustará automáticamente

53 53
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

a la siguiente línea cuando la cantidad de caracteres abarque el tamaño de

la caja de texto.

54 54
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Se puede bloquear contra escritura un control TextBox para evitar que el usuario
cambie su información con la propiedad Locked a True. Y si desea evitar
que el usuario seleccione o enfoque a la caja de texto, coloque a False la
propiedad Enabled. El número de caracteres, que el usuario puede
introducir, también se puede limitar mediante la propiedad MaxLength. Otra
restricción útil para las cajas de texto consiste en enmascarar los caracteres
introducidos para evitar su visualización (contraseñas), así en la propiedad
PasswordChar se define el carácter de máscara.
Con las propiedades SelStart, SelLength y SelText se puede seleccionar parte
del texto de una caja de texto. SelStart define la posición inicial, SelLength la
longitud de la selección en cantidad de caracteres, y SelText devuelve la
cadena seleccionada. Por ejemplo, suponga una caja de texto “txtMiCaja”
contiene el texto “Todos los perros van al cielo”. Al ejecutar esta sección de
código (Click en el botón de comando cmdSeleccionar), en la caja de texto
txtSelección aparece la siguiente cadena de caracteres: “los perros”.
Private Sub cmdSeleccionar_Click()
txtMiCaja.SelStart = 7
txtMiCaja.SelLength = 10
txtSelección = txtMiCaja.SelText
End Sub

) Métodos de cajas de texto

Se puede controlar el enfoque de una caja de texto mediante el método
SetFocus. Recuerde que no se pueden enfocar objetos deshabilitados (Enabled
en False).

txtMiCaja.SetFocus

) Eventos de cajas de texto

Las cajas de texto responden a los siguientes eventos principalmente: Change,
KeyDown, KeyPress, KeyUp, GotFocus, LostFocus y Validate. Se puede
aprovechar el evento Change para deshabilitar un botón de comando si el
contenido de una caja de texto (propiedad Text) es vacío. De esta manera se
inhabilita un proceso hasta que el usuario introduzca datos al programa.

Private Sub txtMiCaja_Change()

Me.cmdBotón.Enabled = Len(Me.txtMiCaja.Text)
End Sub

Len: Es una función que devuelve el número de caracteres de una cadena de texto

Resulta conveniente que al enfocar una caja de texto, el contenido de esta se

seleccione para su fácil modificación.
Private Sub txtMiCaja_GotFocus()
Me.txtMiCaja.SelStart = 0
Me.txtMiCaja.SelLength = Len(Me.txtMiCaja.Text)
End Sub

55 55
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

El evento KeyPress incluye el argumento “KeyAscii As Integer” que representa

el código ASCII de la tecla que el usuario presiona dentro de la caja de texto.

56 56
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Así podrá validar cada carácter introducido. En el ejemplo siguiente, se limita

al usuario a escribir sólo caracteres numéricos.
Private Sub txtMiCaja_KeyPress(KeyAscii As Integer)
If (KeyAscii > 47) And (KeyAscii < 58) Then Exit Sub
KeyAscii = 0
End Sub

El código ASCII del caracter “0” es 48 y el del “9” es 57.

La primera instrucción indica que si el caracter está entre “0” y “9”, debe salir
del procedimiento (Exit Sub), de lo contrario continúa con la siguiente
instrucción, la cual convierte en caracter nulo a la tecla presionada, lo que es
equivalente a bloquear el teclado para ese caracter. También, conociendo que
el código ASCII de la tecla ENTER es 13, se puede seleccionar la siguiente caja
de texto utilizando el método SetFocus.

Private Sub txtMiCaja_KeyPress(KeyAscii As Integer)

If (KeyAscii = 13) Then txtSelección.SetFocus
End Sub

Finalmente, la propiedad CauseValidation del objeto caja de texto activa o

desactiva la sensibilidad del objeto ante el evento Validation. El evento Validation
se ejecuta justo antes de desenfocar al objeto, lo que permite validar el
contenido de la caja de texto y evitar su desenfoque si el valor no es válido,
asignándole al parámetro Cancel True. Suponga que el valor a introducir
debe ser menor o igual que 20; así que se cancelará el desenfoque para valores
mayores a 20

Private Sub txtMiCaja_Validate(Cancel As Boolean)

Cancel = (Me.txtMiCaja.Text > 20)
End Sub

3.2.4. Marco (Clase: Frame)

El objeto de la clase Frame es un contenedor. Este control proporciona un
agrupamiento identificable para controles. También se puede usar un control
Frame para subdividir un formulario funcionalmente. Para agrupar controles,
dibuje primero el control Frame y, a continuación, dibuje los controles dentro de
Frame. De este modo podrá mover (propiedades Top y Left), ocultar (propiedad
Visible) o desactivar (propiedad Enabled) al mismo tiempo tanto al marco como a los
controles contenidos en él. La propiedad BorderStyle establecida a 0-None oculta
la etiqueta del marco. La propiedad TabStop no puede ser negada, ya que está
establecida a True por defecto.
Regla de Visual Basic de prefijo para nombre del objeto Marco:
fra.

3.2.5. Caja de imagen (Clase: PictureBox)

La caja de imagen, también como los marcos, actúa como contenedor. Puede
emplear el control caja de imagen para agrupar controles en la parte superior o

57 57
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

inferior del área interna del formulario o para crear una barra de herramientas o
de estado. El tipo de alineación en el interior del formulario se establece mediante
la propiedad Align. Al igual que con el marco, para agrupar objetos se debe dibujar
primero la caja de imagen y luego los objetos dentro del contenedor. Este tipo de

58 58
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

control permite mostrar imágenes o gráficos de mapa de bits, iconos o meta archivos,
así como también, archivos mejorados JPEG y GIF, mediante la propiedad
Picture. Para hacer que un control PictureBox ajuste su tamaño
automáticamente para mostrar un gráfico completo, establezca su propiedad
AutoSize a True. Por otra parte, Visual Basic provee una función para cargar una
imagen en tiempo de ejecución desde una unidad de disco, denominada LoadPicture.
picMiDib.Picture = LoadPicture(“A:\Nubes.bmp”)

Regla de Visual Basic de prefijo para nombre del objeto Caja de imagen: pic.
3.2.6. Botón de opción (Clase: OptionButton)
Generalmente, los controles de la clase OptionButton se utilizan en un grupo de
opciones para mostrar opciones entre las cuales el usuario sólo puede seleccionar
una. Los controles OptionButton se agrupan si los dibuja dentro de un contenedor
como un control Frame, un control PictureBox o un formulario. Todos los botones
de opción que están dentro del mismo contenedor actúan como un único grupo.
La propiedad más importante es la propiedad Value la cual puede ser True o False.
El evento clic se ejecuta automáticamente con el enfoque del objeto.
Regla de Visual Basic de prefijo para nombre del objeto Botón de opción: opt.
3.2.7. Caja de verificación (Clase: CheckBox)
Se utiliza este control para ofrecer al usuario una opción de tipo Verdadero o
Falso, o Sí o No; o para ofrecer múltiples opciones entre las cuales el usuario
puede seleccionar una o más. La propiedad Value determina el estado del control:
0-Desactivado, 1-Activado, o 2-No disponible.
Aunque puede parecer que los controles Botón de Opción y Caja de Verificación
funcionan de forma similar, hay una diferencia importante: cuando un usuario
selecciona un OptionButton, los otros controles OptionButton del mismo grupo
dejan de estar disponibles automáticamente. Por el contrario, es posible
seleccionar cualquier número de controles de la clase CheckBox.
Regla de Visual Basic de prefijo para nombre del objeto Caja de verificación: chk.
3.2.8. Caja de lista (Clase: ListBox)
La caja de lista muestra un conjunto de elementos entre los cuales el usuario
puede seleccionar uno o más. Si el número de elementos supera al número de filas
que pueden mostrarse, el control agregará automáticamente una barra de
desplazamiento.
Regla de Visual Basic de prefijo para nombre del objeto Caja de lista: lst.
a) Propiedades de cajas de lista
Propiedad Descripción
Columns Número de columnas de una lista.
ItemData Número específico para cada elemento de una lista.
List Elemento específico de una lista.
ListCount Cantidad de elementos dentro de una lista.

59 59
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

ListIndex Número del elemento seleccionado de una lista.

MultiSelect Modalidad de selección de una lista.

60 60
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Propiedad Descripción
NewListIndex Número del elemento agregado nuevo a una caja de lista.
Selected Si está o no seleccionado un elemento de una lista.
Sorted Si ordena o no los elementos de una lista.
Style Estilo gráfico de objetos.
Tabla 3.7.- Propiedades más importantes de listas.

ItemData es un vector que permite almacenar un número entero por cada

elemento de la lista. Se utiliza como campo de información adicional para
referencia o valor del un elemento de la lista.
La propiedad ListIndex devuelve la posición del elemento seleccionado dentro
de una caja de lista, y tiene valores desde -1 hasta ListCount-1. Si no se
encuentra seleccionado ningún elemento de la lista, el valor de la propiedad
ListIndex será automáticamente -1. Si el usuario selecciona el primer elemento
de la lista, ListIndex tiene valor 0, y para el último elemento ListIndex es igual
a ListCount-1. La propiedad List devuelve o establece los elementos contenidos
en la caja de lista en una posición específica. Por ejemplo, considere la caja de
lista lstMiLista, en la que se quiere escribir su primer y segundo elemento:

lstMiLista.List(0) = ”Primer elemento de lista”

lstMiLista.List(1) = ”Segundo elemento de lista”

Se pueden definir dos estilos de cajas de lista mediante la propiedad Style: 0-

Normal o 1-Verificación. La propiedad MultiSelect acepta tres valores: 0-None
(no permite selección múltiple), 1-Single y 2-Extended.
La propiedad Selected devuelve o establece el estado de selección de un
elemento de la lista. Por ejemplo, para seleccionar el primer elemento de
lstMiLista en tiempo de ejecución:
lstMiLista.Selected(0) = True

b) Métodos de cajas de lista

Método Sintaxis Acción
Agregar el Elemento a un control caja de lista o caja
AddItem Objeto.AddItem Elemento
combinada. NewListIndex tiene la posición.
Eliminar el elemento que se encuentra en la Posición de
RemoveItem Objeto.RemoveItem Posición
una caja de lista o caja combinada
Eliminar todos los elementos de una caja de lista o caja
Clear Objeto.Clear
combinada.

Tabla 3.8.- Métodos más importantes de las cajas de lista

3.2.9. Caja combinada (Clase: ComboBox)

El objeto de la clase ComboBox se conoce como caja combinada porque está

constituido por los objetos caja de texto y caja de lista; por lo tanto, incluye las
propiedades, métodos y eventos de ambos. La diferencia del ComboBox respecto
al ListBox es que las cajas combinadas no permiten selección múltiple, y obligan al
usuario a que escoja uno de los elementos de la lista. Una vez seleccionado el
ítem, se puede usar la propiedad Text y SelText para devolver el valor contenido

61 61
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

en el control. Para las cajas combinadas aplican los métodos AddItem,

RemoveItem y Clear de las cajas de lista. Es conveniente utilizar cajas combinadas
en lugar de cajas de lista cuando sea requerido ahorrar área del formulario.
Regla de Visual Basic de prefijo para nombre del objeto Caja combinada:
cbo.

62 62
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

3.2.10. Barra de desplazamiento (Clase: HScrollBar, VScrollBar)

Visual Basic provee tanto la barra de desplazamiento horizontal (HScrollBar) como
vertical (VScrollBar), con el objeto de generar un valor entero limitado entre un
mínimo y un máximo.
Regla de Visual Basic de prefijo para nombre del objeto Barra de desplazamiento: hsb,
vsb.
a) Propiedades de barras de desplazamiento
Propiedad Descripción
LargeChange Variación del valor de una barra de desplazamiento largo.
Max Valor máximo de una barra de desplazamiento.
Min Valor mínimo de una barra de desplazamiento.
SmallChange Variación del valor de una barra de desplazamiento en corto.
Value Valor del objeto.
Tabla 3.9.- Propiedades más importantes de la barra de desplazamiento.

El valor numérico de la barra se puede leer o establecer mediante su

propiedad Value, la cual varía desde el valor de la propiedad Min hasta el valor
de la propiedad Max. La propiedad Value cambia automáticamente cuando el
usuario manipula la barra de desplazamiento en ejecución. Cuando el usuario
usa las flechas, la variación de la propiedad Value depende de la propiedad
SmallChange; y cuando hace clic en la barra, la variación depende de la
propiedad LargeChange. Las propiedades Min, Max y Value aceptan valores
enteros desde –32768 hasta 32767. Otra forma de modificar el valor de la
barra de desplazamiento es moviendo directamente el bloque de desplazamiento,
lo que produce el evento Scroll. Tanto el evento Scroll como el evento Change
se pueden usar para actualizar los controles que utilizan el valor de la barra de
desplazamiento.
3.2.11. Temporizador (Clase: Timer)
No todos los eventos son producidos externamente por el usuario. El control
temporizador posee sólo un evento, el evento Timer, el cual se activa
automáticamente a intervalos periódicos. El control Timer es invisible para el
usuario en tiempo de ejecución ya que no tiene representación gráfica. Este objeto
resulta útil para el procesamiento de fondo, especialmente para las animaciones y
monitoreo automático de procesos. La propiedad Interval devuelve o establece el
tiempo en milisegundos en que se produce el evento Timer. La propiedad Enabled
activa (True) o detiene (False) el reloj del control. No existe ningún límite práctico
en cuanto al número de controles Timer activos (Enabled = True) ejecutándose
simultáneamente.
Regla de Visual Basic de prefijo para nombre del objeto Temporizador:
tmr.
3.2.12. Imagen (Clase: Image)
Utilice el control Image para mostrar un gráfico o imagen. Un control Image puede
mostrar un gráfico desde un mapa de bits, un icono o un metarchivo, así como un
metarchivo mejorado, un archivo JPEG o archivos GIF. La gran diferencia con el
control caja de imagen es que el control imagen no es un contenedor, además posee

63 63
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

la propiedad Stretch, la cual permite ajustar la imagen al tamaño del control,

y no es el control el que se ajusta al tamaño de la imagen como ocurre en el
PictureBox. Por otra parte, el control de la clase Image utiliza menos recursos del
sistema y se actualiza con más rapidez, por lo que se recomienda para animaciones
o funciones decorativas.

64 64
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

Para crear una animación o simulación, puede manipular las propiedades y

métodos gráficos en el código de un control Temporizador. Puede rellenar un
control imagen (propiedad Picture) con distintas imágenes donde cada una
muestre un estado consecutivo.
Private Sub tmrMiTimer_Timer()
If imgImagen.Picture = imgImagen2.Picture Then
imgImagen.Picture = imgImagen1.Picture
Else
imgImagen.Picture = imgImagen2.Picture
End If
End Sub

La imagen imgImagen cambiará su gráfico de fondo (propiedad Picture) cada

cierto tiempo, según el valor establecido en la propiedad Interval del objeto Timer.
La velocidad de cambio se establece mediante la propiedad Interval del Timer.
Regla de Visual Basic de prefijo para nombre del objeto Imagen: img
3.2.13. Figura (Clase: Shape)
El objeto Shape es un control gráfico que se muestra como un rectángulo, un
cuadrado, una elipse, un círculo, un rectángulo redondeado o un cuadrado
redondeado. Su función es decorativa es decorativa, para enmarcar otros objetos
o para dividir el formulario en varios sectores. Este tipo de objeto carece de eventos.
Se usa el control de la clase Shape en lugar de usar los métodos gráficos Line o Circle
para dibujar formas básicas sobre un formulario.
Regla de Visual Basic de prefijo para nombre del objeto Figura: shp.
3.2.14. Línea (Clase: Line)
Line es un control gráfico que se muestra como una línea horizontal, vertical o
diagonal, según sus propiedades X1, Y1, X2 y Y2. Permite reemplazar el uso del
método Line de los formularios y las cajas de imagen.
Regla de Visual Basic de prefijo para nombre del objeto Línea: lin.
3.2.15. Ubicación de los controles básicos
PictureBox TextBox CommandButton OptionButton ListBox VScrollBar DriveListBox FileListBox Line Data

Label Frame CheckBox ComboBox HScrollBar Timer DirListBox Shape Image OLE

Figura 3.3.- Caja de herramientas (Clases).

65 65
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
3.- Objetos
3.- Objetos
de Visual
de Visual
Basic Basic

3.2.16. Ejemplo de los controles básicos

Figura 3.4.- Ejemplo de los controles básicos.

66 66
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
3.- Objetos
de Visual
de Visual
Basic Basic

49
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Unidad 4

Código en Visual Basic

“La confusión es parte del proceso de aprendizaje”

.- Dr. Lair Ribeiro

4.1. Espacios de memoria

4.1.1. Identificadores
A menudo necesitará almacenar valores temporalmente en memoria cuando esté
realizando cálculos con Visual Basic. Por ejemplo, puede que desee calcular
diversos valores, compararlos y realizar distintas operaciones con ellos,
dependiendo de los resultados de la comparación. La manera de referir a esos
espacios de memoria donde se encuentran los valores es mediante identificadores.
Los identificadores son los nombres que se utilizan para referir en el programa a
espacios de memoria (variables, constantes, procedimientos y objetos). Estos
permiten identificar unívocamente cualquier elemento del programa. En Visual
Basic tienen las siguientes características:
a) Deben comenzar con caracter alfabético (una letra)
b) No deben contener caracteres especiales (guiones, espacios, puntos, etc.)
c) No pueden ser palabras reservadas (Private, End, Click, Sub, etc.)
d) Debería ser lo más mnemotécnicos posible, y no más de 25 caracteres.
4.1.2. Tipos de datos
Los tipos de datos especifican las características de la información que se almacenará
en memoria. De esta manera, cada tipo de datos requiere un espacio de memoria
determinado y una forma de manipulación específica. Una suma de números es
distinta a una suma de caracteres o de fechas. También, requeriría menos espacio
de memoria la edad de una persona que las distancias interestelares. Por esta
razón, es imprescindible que el programador conozca los tipos de datos disponibles
en Visual Basic, para que utilice el que menos requerimientos de memoria posea, y
el más apropiado para que cumpla su cometido. Aunque el lenguaje provee
muchos tipos de datos, estos también pueden ser definidos por el usuario.
También existen otros tipos de datos provistos por objetos específicos. En esta parte
trataremos los tipos de datos predefinidos en Visual Basic (ver Tabla 4.1) agrupados
como sigue:
a) Tipos de datos numéricos (Byte, Integer, Long, Single, Double y Currency):
Permiten efectuar operaciones aritméticas como suma, resta, multiplicación,

50 50
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

etc. Los tipos de datos numéricos pueden ser enteros o fraccionarios. Si se asigna
a un tipo de dato entero números con decimales, este se redondea al

51 51
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

entero inmediato superior. Se producirá un error de desbordamiento al

intentar cargar un tipo de dato numérico con valores superiores a su espacio
disponible (ver la columna Intervalo en la Tabla 4.1). Por ejemplo, el tipo de
datos Byte permite valores hasta 255. Si intentara asignar valores superiores a
255 para un dato tipo Byte, se producirá un error. Por otra parte, si la
intención del espacio de memoria es almacenar números con decimales, es
conveniente especificar los tipos de datos Single, Double o Currency. Se
recomienda utilizar el tipo de dato Currency para manipular cantidades
monetarias o cualesquiera otras que requieran cierto grado de precisión.
b) Tipo de dato lógico (Boolean): Este tipo de dato se establece a True (True
equivale a -1) cuando se le asigna cantidades distintas de cero; y, se establece
a False (False equivale a 0) cuando se le asigna cero.
c) Tipo de dato de cadenas de caracteres (String): Los espacios reservados para
cadenas de caracteres pueden ser de longitud fija o variable. Se escoge el tipo
de dato de cadena fija, sólo cuando se conoce con antelación y seguridad la
cantidad de caracteres que desea guardar. Si se asigna una cadena con más
caracteres que los admitidos por el tipo de dato de longitud fija, los caracteres
a la derecha de la cadena son truncados. La cantidad de caracteres para cadenas
fijas se especifica mediante el valor de L (ver Tabla 4.1). Las cadenas se delimitan
mediante comillas dobles, al principio y al final de la cadena.
Tipo Para Bytes Intervalo
Byte Desde 0
(entero positivo) 1 Hasta 255
Integer -32.768 hasta
(entero corto) Números enteros 2 +32.767
Long -2.147.483.648 a
(entero largo) 4 +2.147.483.647
Single -3,4028E38 a –1,4013E-45 (negativos)
(coma flotante) 4 +1,4013E-45 a +3,4028E38 (positivos))
Double Números con -1,7977E308 a -4,9407E-324 (negativos)
(coma flotante) decimales 8 +4,9407E-324 a +1,7977E308 (positivos)
Currency -922.337.203.685.477,5808 a
(coma fija) 8 +922.337.203.685.477,5807
True ó
Boolean Valores lógicos 2
False
1 de enero de 100 a
Date Fechas y horas 8
31 de diciembre de 9999
Cualquier referencia a tipo Object
Object Instancias de objetos 4
No importa la clase del objeto.
String Cadenas de caracteres Desde 0 hasta 2.000 millones de caracteres
(longitud variable) 10 + L
de longitud variable (L: Cantidad de caracteres)
String * L Cadenas de caracteres Desde 1 a 65.400 caracteres aprox.
(longitud fija) L
de longitud fija (L: Cantidad de caracteres)
Variant Cualquier valor numérico hasta
(con números) 16
el intervalo de un tipo Double
Datos variables
Variant Desde 0 hasta 2.000 millones
(con caracteres) 22 + L
(L: Cantidad de caracteres)
Tabla 4.1.- Tipos de datos provistos por Visual Basic.

d) Tipo de datos para fecha y hora (Date): Permite efectuar cálculos de fecha y
hora. El valor de una fecha u hora se delimita mediante los caracteres numerales

52 52
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

(#), y se utilizan los caracteres barra (/) o guión (-) para separar día, mes y
año, y el caracter dos puntos (:) para separar hora, minuto y segundo.

53 53
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

e) Tipo de dato para instancias de objetos (Object): Es posible crear un

identificador distinto al nombre de un objeto, pero que hace referencia a ese
objeto. Este un buen ejemplo de polimorfismo en Visual Basic.
f) Tipo de dato variable (Variant): Es el tipo de dato que más consume recursos
de memoria, ya que tiene la posibilidad de adaptarse o convertirse
automáticamente en cualquiera de los otros tipos de dato.
4.1.3. Declaración de espacios de memoria
Los espacios de memoria pueden estar sujetos a cambio, o estar protegidos para
que no puedan ser modificados. En cualquiera de los casos se debe crear un
apuntador (identificador) y especificar las características (tipo de dato) del espacio
de memoria. Los espacios de memoria temporales, con nombre y tipo de dato, se
conocen como Variables. Por otra parte, los espacios protegidos de memoria,
identificados y configurados a un tipo de dato, reciben el nombre de Constantes.
En la mayoría de los lenguajes de programación, el uso de un espacio de memoria
debe ser informado al sistema operativo de la computadora; es decir, debe ser
declarado. La declaración consiste en indicar el tipo de protección (variable o
constante), el identificador, y el tipo de dato de un espacio de memoria, teniendo así
declaración de variables y declaración de constantes.
a) Variables
Puede considerar una variable como un marcador de posición en memoria de
un valor desconocido. Por ejemplo, suponga que está creando un programa de
ventas. Aunque conociera el producto y el precio, no sabe la cantidad que se
ha vendido hasta que no se produce realmente la venta. En este caso debe
usar variables para almacenar los valores desconocidos: cantidad de producto
y precio total. Visual Basic permite utilizar las variables sin ser previamente
declaradas, lo que se conoce como declaración implícita, y es una práctica
indebida. Siempre se deben declarar las variables mediante instrucciones
adecuadas de manera explícita. Se recomienda utilizar la sentencia siguiente
en la sección declaraciones de cada módulo para detectar, durante la
compilación, aquellas variables que no hayan sido declaradas explícitamente.
Option Explicit

b) Constantes
Las constante generalmente se utilizan para presentar valores que aparecen
en muchas partes del código o para presentar valores numéricos difíciles de
recordar; de tal manera, que una modificación de la cadena o del número se
pueda efectuar en una sola parte del código del programa, y no sea necesario
navegar toda la aplicación efectuando la misma modificación. Por ejemplo, el
mensaje de error: “Ha ocurrido un error irrecuperable, debe abortar la
operación”, es una gran cantidad de caracteres que resultaría tedioso escribir
cada vez que se requiera para mostrar al usuario que ha ocurrido un error; y
también si el programador decide escribir este texto en varias zonas del
programa y desea cambiar el mensaje de error, tendrá que efectuar el cambio
en todas las secciones del código donde se encuentre el texto. Visual Basic
provee un conjunto de constantes denominadas constantes intrínsecas. Las
constantes creadas por el usuario se conocen como constantes simbólicas.

54 54
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

4.1.4. Alcance de variables y constantes

En esta parte conoceremos donde se deben efectuar las declaraciones. Las
declaraciones de variables y constantes pueden efectuarse en cualquier módulo y
en cualquier parte del módulo. La escogencia está sujeta al área del código, en el
cual, el analista desea que la variable o constante tenga vigencia; es decir, exista.
Una variable o constante comienza a existir en el momento de su declaración, y
estará disponible, existirá y conservará su valor sólo en las áreas del código que
abarque el sitio de su declaración. Por eso es importante conocer en que parte del
código declarar. De esta manera, se tienen tres tipos de variables y constantes, según
su alcance o vigencia.
a) Vigencia Local: La variable o constante que se declara dentro de un procedimiento,
existe sólo dentro de ese procedimiento. Cuando el procedimiento termina, la
variable o constante deja de existir, y no puede utilizarse nuevamente en otros
procedimientos. La vigencia de variables locales puede ser volátil o estática,
según la variable pierda o conserve su valor al terminar el procedimiento.
Aunque la variable estática conserva su valor al terminar el procedimiento, esta
no puede utilizarse en otros procedimientos.
b) Vigencia Limitada: La variable o constante se declara en la sección
declaraciones de cualquier módulo y se puede utilizar en cualquiera de los
procedimientos que se encuentran dentro del módulo donde se creó el espacio
de memoria. Una variable o constante de alcance limitado creada en el módulo
1, no se puede usar en el módulo2; pero si en cualquier procedimiento del
módulo 1.
c) Vigencia Pública (Global): Este tipo de variable o constante se puede acceder
desde cualquier módulo en cualquiera de sus procedimientos. Se dice que es una
variable o constante del proyecto en general, disponible para todos los módulos.
En este caso, la declaración se debe efectuar en la sección declaraciones de un
módulo estándar y con una sintaxis particular que veremos mas adelante.
4.1.5. Declaración de variables
Ahora veremos la sintaxis y las sentencias establecidas para efectuar los distintos
tipos de declaraciones de variables.
a) Variable local volátil: Se utiliza la sentencia Dim dentro de un procedimiento.
Private Sub Procedimiento()
Dim Edad As Byte
{Instrucciones}
End Sub

b) Variable local estática: Se utiliza la sentencia Static dentro de un

procedimiento.
Private Sub Procedimiento()
Static Edad As Byte
{Instrucciones}
End Sub

55 55
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

c) Variable limitada: Se utiliza la sentencia Private en la sección declaraciones de

Private
cualquierEdad As Byte
módulo.
Private Sub Procedimiento()
Dim VariableLocal As Tipo
{Instrucciones}
End Sub

) Variable pública: Se utiliza la sentencia Public en la sección declaraciones, pero

de un módulo estándar.
Public Edad As Byte

Private Sub Procedimiento()

Dim VariableLocal As Tipo
{Instrucciones}
End Sub

Declaración de constantes (simbólicas)

4.1.6. ara la declaración de constantes simbólicas (de usuario) se utiliza la sentencia
Const en todos los casos precedida del tipo de alcance si es limitada o pública.
P
) Constante local: (dentro de un procedimiento)
Const PI As Currency = 3.1416

) Constante limitada: (en la sección declaraciones de cualquier módulo)

Private Const PI As Currency = 3.1416

) Constante pública: (en la sección declaraciones de un módulo estándar)

Public Const PI As Currency = 3.1416

4.1.7. Constantes intrínsecas

Las constantes intrínsecas se conocen también como constantes definidas por el
sistema y son proporcionadas por aplicaciones y controles de Visual Basic. Ejemplo
de estas constantes son las de color: vbBlack, vbBlue, vbCyan, vbGreen,
vbMagenta, vbRed, vbWhite y vbYellow. Las constantes intrínsecas no requieren
ningún tipo de declaración. Para localizar, visualizar o copiar las constantes
incorporadas en Visual Basic, se puede acceder a la ventana “Examinador de objetos”
presionando F2 o mediante el menú “Ver | Examinador de objetos”. Otras
aplicaciones que proporcionan bibliotecas de objetos, como Microsoft Excel y
Microsoft Project, también proporcionan una lista de constantes que se puede usar
con sus objetos, métodos y propiedades. También se definen constantes en la
biblioteca de objetos de cada control ActiveX.
ActiveX™: Es un conjunto de tecnologías que habilitan componentes de software
para interactuar en un ambiente de red, sin tener en cuenta el lenguaje
en que fueron creados. En el capítulo 8, se verá con más detalle.

56 56
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Figura 4.1.- Diálogo Examinador de objetos.

4.1.8. Arreglos

Los arreglos permiten definir varios espacios de memoria del mismo tipo con un
solo identificador, pudiendo diferenciar cada espacio de memoria mediante
apuntadores o marcadores que se conocen como índices. Los arreglos pueden ser
de una dimensión (vectores), cuando utilizan un solo índice; o de varias
dimensiones (matrices), cuando utilizan varios índices. Mediante los índices se puede
acceder directamente a cada uno de los elementos de un arreglo. Para declarar
arreglos de una dimensión se usa:
Dim MiVector(Máximo) As tipo

Máximo es un valor que determina el máximo índice del vector, y tomando en cuenta
que el índice mínimo es cero, el número de elementos del vector será igual a Máximo
+ 1. Por ejemplo, suponga la siguiente declaración:
Dim MiVector(4) As Long

De esta manera se han creado 5 espacios de memoria tipo Long identificados por:
Mivector (0), Mivector (1), Mivector (2), Mivector (3) y Mivector (4).
También se puede especificar un rango de índices que inicie distinto de cero:
Dim MiArreglo (Mínimo To Máximo) As tipo

Mínimo determina en índice inferior e inicio del rango. Por ejemplo:

Dim Estudiantes (1 To 7) As String

Para declarar matrices, los rangos de cada dimensión se separan mediante comas:
Dim Nota (1 To 7, 1 To 5) As Single

57 57
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Finalmente, para usar la variable de un arreglo, se debe especificar el índice

correspondiente, tal como se muestra a continuación, donde se asigna la nota de
la tercera evaluación al quinto alumno:

58 58
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Alumno = 5
Evaluación = 3
Nota(Alumno, Evaluación) = 20.5

4.1.9. Objetos y espacios de memoria

Cada uno de los objetos requiere espacios de memoria para variables y
constantes. Estos espacios de memoria no requieren declaración, ya que los
mismos se crean automáticamente con la creación del objeto. Se puede decir que
estos espacios de memoria son de alcance público, ya que están disponibles en
toda la aplicación.
a) Identificadores:
Los espacios de memoria requeridos por un objeto se identifican mediante el
nombre del contenedor, el nombre del objeto y el nombre de la propiedad
separados por el operador punto.
b) Variables:
Cada propiedad del tipo lectura-escritura de un objeto se almacena en un espacio
de memoria variable. Por ejemplo la propiedad Enabled se almacena en un
espacio de memoria que se puede cambiar durante la ejecución y su tipo de
dato Boolean.
c) Constantes:
Las propiedades de solo lectura son constantes, como la propiedad Moveable
que se puede leer pero no cambiar durante la ejecución. También, los valores
de ciertas propiedades son constantes del objeto. Por ejemplo, los valores de
la propiedad BorderStyle de un formulario pueden ser 0-None, 1-FixedSingle,
2-Sizable, etc.
d) Arreglos:
Distintos espacios de memoria, pero bajo un mismo nombre de objeto, es posible
mediante los arreglos de objetos. Las colecciones son parecidas a los arreglos
de objetos, las cuales se basan en crear varios objetos con el mismo
identificador. La manera de diferenciar un objeto de otro es mediante su
propiedad Index, ya que cada objeto dentro del arreglo posee propiedades
individuales. Los arreglos de objetos son unidimensionales y muchas veces se
tratan como vectores de objetos. Para referirse a la propiedad de un objeto
específico, se hace referencia tanto al nombre del objeto como a su índice. En
un arreglo de 3 botones de comando se desea deshabilitar sólo al segundo botón,
y habilitar los otros dos botones:
Me.cmdBotón(0).Enabled = True
Me.cmdBotón(1).Enabled = False
Me.cmdBotón(2).Enabled = True

Utilizando colecciones o arreglos se optimiza el uso del sistema, ya que consumen

menos recursos que los controles creados independientemente. Los objetos de
un arreglo comparten el mismo procedimiento de evento, por lo tanto no es
necesario escribir código separado por cada objeto del vector. Los

59 59
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

procedimientos de evento de un objeto en un arreglo, incluyen el argumento

“Index”, el cual permite identificar o diferenciar al objeto causante del evento.

60 60
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Private Sub cmdBotón_Click(Index As Integer)

{Instrucciones}
End Sub

Como se puede observar, el evento clic incluye la variable Index. Si el usuario

hace clic en el primer, segundo o tercer botón, se ejecuta siempre este mismo
procedimiento de evento, pero la variable Index se carga con el valor de la
propiedad Index del objeto que desató el evento. Por ejemplo, si el usuario
hizo clic el cmdBotón (1), la variable Index se carga con el valor 1.
Puede crear un arreglo de controles estableciendo la propiedad Index del objeto.
Alternativamente, en forma gráfica, puede seleccionar, copiar y pegar el objeto,
y el sistema solicitará si desea crear un arreglo de controles. Seleccionando
“Sí”, el control original adopta índice 0, y el control copia se crea con las
mismas propiedades del control original y adopta índice 1. En adelante se pueden
seguir copiando otros controles sin que el sistema solicite confirmación, y se
incrementará automáticamente el valor de la propiedad Index. El número de
elementos de una colección o arreglo, se invoca mediante su propiedad Count.
Por ejemplo, a continuación se escribe en una caja de lista el rótulo de todos
los botones de comando de la colección cmdBotón.

Dim i As Integer
For i = 0 To Me.cmdBotón.Count - 1
Me.lstObjetos.AddItem Me.cmdBotón(i).Caption
Next i

En el ejemplo siguiente, se utilizan 15 botones de opción para establecer el

color de fondo del formulario mediante la función de color QBColor.

Private Sub optColor_Click(Index As Integer)

Me.BackColor = QBColor(Index)
End Sub

4.2. Operadores
4.2.1. Aritméticos
Los operadores aritméticos permiten efectuar los cálculos matemáticos mostrados
a continuación (ver Tabla 4.2).
Operación Operador
Suma o adición +
Resta o sustracción, e Inversión de signo -
Multiplicación o producto *
División o fraccionamiento /
División entera \
Módulo o resto Mod
Elevación a potencia ^
Tabla 4.2.- Operadores aritméticos de Visual Basic

La división entera (\) devuelve el valor de la parte entera del resultado de una
división. Por ejemplo, 5\2 es igual a 2, ya que 5/2 es igual a 2,5. Por otra parte, el
operador Mod permite obtener el resto o residuo de una división. Para el caso 5

61 61
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Mod 2, el resultado es igual a 1, ya que 2x2 es igual a 4 y falta 1 para 5.

62 62
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

4.2.2. Lógicos
Los operadores lógicos permiten obtener resultados lógicos (True o False)
mediante una comparación bit a bit de dos expresiones. En Visual Basic, False
representa al número 0, y True a cualquier otro valor distinto de 0 (cero). La tabla
4.3 muestra los operadores lógicos de Visual Basic y sus resultados según las
expresiones A y B.
A And A Xor A Eqv A Imp
A B B A Or B Not(A) Not(B) B B B
True True True True False False False True True
False True False True True False True False True
True False False True False True True False False
False False False False True True False True True

Tabla 4.3.- Resultados de operaciones lógicas.

4.2.3. Relacionales

Los operadores relacionales se utilizan para comparar dos condiciones lógicas de una
expresión. Por lo general se utilizan en las estructuras de control que veremos más
adelante. A continuación (ver Tabla 4.4) se muestra los operadores relacionales.
Operación Operador
Es igual a =
Es distinto de <>
Es menor que <
Es mayor que >
Es menor o igual que <=
Es mayor o igual que >=
Es como (el patrón de cadena) Like
Tabla 4.4.- Operadores relacionales de Visual Basic.

El operador relacional “igual a” utiliza el mismo signo que el operador de

asignación (=), y no se deben confundir. Considere el siguiente ejemplo, donde se
declara la variable Booleana “EsDivisorCero”, y se colocan las cajas de texto txtDiv,
txtDivisor y txtCoc, para el dividendo, divisor y cociente respectivamente de una
división en un formulario. Al hacer clic en el botón de comando cmdDividir, se efectúa
el cálculo. Después de declarar la variable se asigna a la variable EsDivisorCero el
resultado de comparar el contenido de la caja de texto del divisor con cero. Si se
cumple que el divisor es igual a cero; a la variable se le asigna True, de lo
contrario se le asigna False. Luego en la estructura If, se evalúa el valor de la
variable EsDivisorCero, la cual, si es verdadera se ejecuta la sentencia Exit Sub y
termina el procedimiento. En este mismo punto, si la variable EsDivisorCero es falso,
se continúa con la siguiente línea que finalmente calcula la división y se la asigna a
la caja de texto cociente.
Private Sub cmdDividir_Click() Dim
EsDivisorCero As Boolean EsDivisorCero
= Me.txtDivisor.Text = 0
If EsDivisorCero Then Exit Sub
Me.txtCoc.Text = Me.txtDiv.Text / Me.txtDivisor.Text
End Sub

63 63
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

El operador Like compara una cadena de caracteres con un patrón, el cual incluye
los siguientes caracteres comodines:

64 64
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

a) ¿: para representar un único caracter alfanumérico,

b) *: para representar un conjunto de caracteres alfanuméricos,
c) #: para representar un caracter numérico o dígito,
d) [A-Z]: para representar un rango de caracteres coincidentes
e) [¡A-Z]. para representar un rango de caracteres no coincidentes
Por ejemplo la variable P (de parecido) es tipo Boolean:
'Las siguentes P son True:
P = “aAGVFa” Like “a*a” 'Comienza y termina con a
P = “F” Like “[B-N]” 'La F está entre B y N
P = “F” Like “[¡A-D]” 'La F no está entre A y D
P = "BAT123" Like "B?T123" 'Entre B y T hay un caracter
'Las siguientes P son False:
P = “aAAjFas” Like “*a” 'No termina con a sino con s
P = “BT123” Like “B?T123” 'No hay caracter entre B y T

4.2.4. Operadores especiales

a) Operador de asignación (=): Se utiliza el signo “igual a“ (=) para transferir un
Valor desde el lado derecho del signo, hasta el Identificador del lado izquierdo.
Identificador = Valor

Nota: No confundir la asignación con la comparación

b) Operador de concatenación (&): Para unir dos cadena de texto en una sola, se
acostumbra a utilizar el operador &, aunque también se puede usar el operador
+. En el ejemplo siguiente, el título de un formulario es el resultado de una
concatenación. Si en la caja de texto se escribe el caracter “5”, el título del
formulario será “Ventana 5”. Observe que si no se dejara el espacio antes de
la comilla de cierre, el título resultante sería: “Ventana5”
Me.Caption = “Ventana ” & Me.txtNumero.Text

c) Operador punto (.): Este operador se usa para relacionar un objeto con su
propiedad, método u objeto dependiente. También aplica para hacer
referencia a variables de tipo de datos definidos por el usuario. Cada vez que
se escribe un punto después de la variable de objeto, se despliegan todos sus
miembros, permitiendo al usuario buscar y seleccionar el miembro requerido.
4.2.5. Precedencia de los operadores
La precedencia de los operadores se refiere al orden en que las operaciones
matemáticas se efectúan. En la tabla siguiente (ver Tabla 4.5) se muestra el orden
de precedencia de los operadores aritméticos, lógicos y relacionales.
Orden Aritméticos Lógicos Relacionales
1 Potencia (^) Igual a (=) Negación (Not)
2 Inversión de signo (-) Distinto de (<>) Conjunción (And)
3 Multiplicación (*) y división (/) Menor que (<) Disyunción (Or)
4 División entera (\) Mayor que (>) Exclusión (Xor)
5 Módulo (Mod) Menor o igual a (<=) Equivalencia (Eqv)
6 Suma (+) y Resta(–) Mayor o igual a (=>) Implicación (Imp)
Tabla 4.5.- Precedencia de operadores

65 65
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Los operadores que se encuentran en la misma línea, como suma y resta, y

multiplicación y división, se ejecutan de izquierda a derecha. Para controlar la
precedencia de manera adecuada se usan paréntesis. Por ejemplo:
Num = 4 + 3 * 2 ^ 2 - 1 'A Num se le asigna 15
Num = 4 + 3 * 2 ^ (2 - 1) 'A Num se le asigna 10
Num = (4 + 3) * 2 ^ 2 - 1 'A Num se le asigna 27
Num = 4 + (3 * 2) ^ 2 - 1 'A Num se le asigna 39
Num = (4 + 3 * 2) ^ 2 - 1 'A Num se le asigna 99
Num = (4 + 3 * 2) ^ (2 – 1) 'A Num se le asigna 100

4.3. Estructuras de control

4.3.1. Programación estructurada
Los lenguajes de programación secuencial incluían un apuntador por cada línea de
código, de tal manera que era posible saltar un conjunto de líneas hacia delante o
hacia atrás indicándole al programa el número de línea de salto explícitamente.
Los saltos de línea hacia delante evitaban que se ejecutaran las líneas intermedias
(bifurcación). Y los saltos hacia atrás permitían que las líneas intermedias se
ejecutaran varias veces (repetición). Con la aparición de los lenguajes
estructurados, se evita en lo posible hacer referencia explícita a las líneas de
código, y en su lugar existen sintaxis con inicio y fin de estructuras. Las
estructuras de control proporcionan al programa la posibilidad de que sus líneas de
instrucción no se ejecuten en forma secuencial. Para esto, las estructuras de
control evalúan resultados lógicos y toman decisiones para la ejecución, o no
ejecución, de las instrucciones controladas. Las estructuras de control permiten
controlar el flujo de ejecución del programa. Si no se controla el flujo, las líneas de
instrucción se leerán de arriba hacia abajo, y cada instrucción de izquierda a derecha.
La mayor parte del poder y utilidad de un lenguaje deriva de su capacidad
de cambiar el orden de las instrucciones mediante saltos y bucles.
4.3.2. Tipos de estructuras
Según el tipo de salto de instrucciones, hacia delante o hacia atrás, se tienen
estructuras bifurcativas o repetitivas respectivamente.
a) Las estructuras bifurcativas: permiten agrupar conjuntos de instrucciones para
activar selectivamente su ejecución. La selección de un conjunto de instrucciones
depende del resultado verdadero (True) de una expresión lógica o relacional.
b) Las estructuras repetitivas: por su parte agrupan sólo a un conjunto de
instrucciones que se pueden ejecutar varias veces. La ejecución del conjunto
de instrucciones también es controlada por expresiones lógicas o condiciones.
4.3.3. Estructura bifurcativa If-Then-ElseIf-Else
La sentencia “If” permite crear una estructura de decisión que se cierra mediante
la sentencia “End If”; sin embargo, cuando se trata de sólo una instrucción a
ejecutar, se puede obviar la sentencia de cierre “End If” y se escribe en una sola
línea. Se pueden tomar decisiones múltiples mediante “ElseIf” que evalúa una
expresión por cada instrucción o conjunto de instrucciones que se desea ejecutar.

66 66
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

A continuación se muestran algunos casos y sus diagramas de flujo.

67 67
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

a) Una sola línea de instrucción por una expresión:

If expresión Then UnaInstrucción1 Else UnaInstrucción2

If

False True
Expresión

Else Then

End If

Figura 4.2.- Estructura If-Then-Else simple.

b) Varias líneas de instrucción para varias expresiones lógicas:

If expresión1 Then
Instrucciones si expresión1 es True
ElseIf expresión2 Then
Instrucciones si expresión2 es True
Else
Instrucciones si expresión1 y expresión2 son False
End If

If

False True
Expresión 1

ElseIf Then

False True
Expresión 2

Then

ElseIf
False True
Expresión N

Else Then

End If

Figura 4.3.- Estructura If-Then-Else completa.

Observación: En cada bloque de instrucciones tipo Then o Else se pueden anidar

estructuras If
– Then – Else.
4.3.4. Estructura bifurcativa Select-Case

68 68
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Para la bifurcación con Select Case, la variable se evalúa de distintas maneras en

cada bloque Case, como se muestra en la figura 4.4. La expresión lógica (variables
y operadores relacionales) se construye internamente a diferencia de la estructura
If. Select Case se utiliza cuando la variable a evaluar es la misma en todos los puntos
de bifurcación. La sintaxis es la siguiente, donde se evalúa a la variable A:
Select Case A

69 69
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Case 0
'Instrucciones si A es 0
Case 3
'Instrucciones si A es 3
Case 4, 7
'Instrucciones si A es 4 ó 7
Case 8 To 10
'Instrucciones si A es 8, 9 ó 10
Case Is > 10
'Instrucciones si A es mayor a 10
Case Else
'Instrucciones para los otros casos
End Select

Select Case A

True
A=v1 ó A=v2

False Case v1, v2

True
A >=v3 y A<=v4

False Case v3 To v4

False True
A >vN

Case Else Case Is > vN

End Select

Figura 4.4.- Estructura Select Case

4.3.5. Estructura repetitiva For-Next

Se utiliza para repetir un conjunto de instrucciones un número determinado de veces;

es decir, cuando el usuario conoce exactamente cuantas veces repetir el conjunto de
instrucciones. Para esto, la estructura requiere una variable de Control tipo entera
que cambiará desde un valor de Inicio hasta un valor de Fin. La variación o
Paso de un valor a otro se puede establecer como un número positivo o negativo,
de tal manera que la variable cambie en forma ascendente o descendente con
incrementos uniformes. La sintaxis para el bucle For-Next es la siguiente:
For Control = Inicio To Fin Step Paso
'Instrucciones [Exit For]
Next Control

Cada vez que se ejecuta el ciclo For-Next, el sistema evalúa la relación entre el
valor de la variable Control y Fin. Para valores positivos de Paso se tiene variación

70 70
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

ascendente de Control, y siempre que Control sea menor o igual que Fin, el bucle
se repite, de lo contrario termina. Para valores negativos de Paso, la variación es
descendente y el bucle se mantiene mientras Control sea mayor que Fin. Para
interrumpir un ciclo For-Next, independientemente del valor de Control, se puede
usar la palabra Exit For. Los ciclos For-Next anidados están permitidos.

71 71
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

For Control

Control = Inicio

False
Control < Fin*Paso
True

Instrucciones del
Bucle
Next Next Control Control = Control + Paso

Figura 4.5.- Estructura For-Next.

4.3.6. Estructura repetitiva Do-Loop

Esta estructura repetitiva ejecuta un conjunto de instrucciones mientras evalúa

una condición como verdadera o falsa. La evaluación de la condición se puede
efectuar al principio o al final de la estructura. Si la evaluación es al principio de la
estructura, y no se cumple la condición predeterminada, el bloque de instrucciones
no se ejecuta. Por otra parte, si la condición se evalúa al final de la estructura, el
conjunto de instrucciones se ejecuta por lo menos una vez, aunque no se cumpla
la condición. Existen dos tipos de sentencia Do-Loop, la sentencia While que
mantiene el ciclo mientras una condición sea verdadera (True), y la sentencia Until
que mantiene el ciclo mientras la condición es falsa (False). La sintaxis para cada
uno de los casos se muestra a continuación:
a) Do While-Loop: Se evalúa al principio con While
Condición=True
Do While Condición
{Instrucciones} [Exit Do]
Loop

b) Do-Loop While: Se evalúa al final con While

Condición=True
Do
{Instrucciones} [Exit Do]
Loop While Condición

c) Do Until-Loop: Se evalúa al principio con Until

Condición=Flase
Do Until Condición
{Instrucciones} [Exit Do]
Loop

d) Do-Loop Until: Se evalúa al final con Until

Condición=Flase
Do
{Instrucciones} [Exit Do]
Loop Until Condición

72 72
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Do While Do Do Until Do

False True
¿Condición? Instrucciones ¿Condición? Instrucciones
True False
Loop While Loop Until
Instrucciones Instrucciones

True False
¿Condición? ¿Condición?
Loop Loop
False True

Loop Loop Loop Loop

Figura 4.6.- Estructuras Do-Loop.

Salir del Do: Se puede terminar el bucle Do-Loop mediante la sentencia Exit
Do.

4.4. Procedimientos
4.4.1. Procedimientos y subrutinas
Una de las características que definen a un lenguaje de programación estructurado
es que el código se encuentra agrupado en bloques de instrucciones con
sentencias de inicio y final del bloque. Estos bloques de instrucciones reciben el
nombre de procedimientos. Podríamos definir un procedimiento como una
secuencia de instrucciones para efectuar tareas específicas que se ejecutan como
una unidad que tiene nombre o identificador. La estructura básica del código de
Visual Basic es el procedimiento, de hecho todo el código ejecutable esta
contenido en procedimientos.
A diferencia de las estructuras de control, los procedimientos no se pueden anidar
dentro de otros procedimientos. Sin embargo, se pueden crear pequeñas
secciones de código enmarcados dentro de un procedimiento. Estos pequeños
bloques se conocen como Subrutinas, las cuales carecen de nombre o
identificador, y en su lugar, se accede a ellos mediante etiquetas de código. Las
etiquetas son marcadores de posición y están constituidas por un nombre seguido
de dos puntos en una línea de código libre dentro de un procedimiento. Las
subrutinas, en términos de lenguajes de programación en general, son porciones
lógicas de código que se encargan de resolver un problema específico. La
subrutina en términos de Visual Basic se aplica a la porción de código que se
ejecuta dentro de un procedimiento mediante las sentencias GoTo, GoSub y
Return. Por esta razón, no se deben confundir los “procedimientos” con las
“subrutinas” en Visual Basic. Aunque las subrutinas están disponibles, el analista
debe evitar al máximo su uso, ya que estas rompen con la definición de Lenguaje
Estructurado. En su lugar, se debe procurar la creación de procedimientos para
esas secciones de código necesarias por otros procedimientos.
La sentencia GoTo produce un salto incondicional a una etiqueta de línea, a partir
de la cual continúa el control del programa. Por su parte, la sentencia GoSub también
lleva el control del programa a una etiqueta de línea, pero mediante la sentencia

73 73
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Return, el control del programa puede regresar a la línea siguiente desde la

cual se efectuó el llamado de la subrutina. A continuación se muestra un ejemplo del
uso de subrutinas. En el ejemplo la instrucción GoTo Terminar es imprescindible, ya
que las etiquetas de línea sólo son marcadores de posición y no

74 74
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

ejercen ningún control de programa, es decir, de ninguna manera especifican el fin

del procedimiento. Más adelante veremos que la etiqueta “Terminar” y la
instrucción “GoTo Terminar” se pueden reemplazar por la sentencia Exit Sub ( Exit
Function), para salir del procedimiento.
Private Sub cmdBotón_Click()
'Instrucciones
GoSub SubRutina1
'Aquí retorna el control del programa
'Instrucciones
GoSub SubRutina2
'Aquí retorna de nuevo el control del programa
'Instrucciones
GoTo Terminar
'El control de programa nunca pasa por aquí
SubRutina1:
'Instrucciones de SubRutina1
Return
SubRutina2:
'Instrucciones de SubRutina2
Return
Terminar:
End Sub

4.4.2. Ventajas de los procedimientos

El desarrollo de una aplicación implica el diseño y la estructuración de las tareas
que debe efectuar la aplicación. Los procedimientos constituyen una herramienta que
facilita este proceso, ya que resultan muy útiles para condensar las tareas repetitivas
o compartidas, como cálculos utilizados frecuentemente, manipulación de texto y
controles, y operaciones con bases de datos. Básicamente, los procedimientos
ofrecen cinco ventajas al programador, las cuales se exponen a continuación.
a) Organización del código: al dividir el programa en pequeños módulos, una sola
línea de código del procedimiento principal le permite al programador ejecutar
un conjunto de líneas de código del procedimiento al que llama, sin necesidad
de llenar el procedimiento principal de líneas de código difíciles de interpretar
y manipular.
b) Simplifica problemas: un problema grande difícil de resolver se convierte en varios
problemas pequeños, pero fáciles de resolver.
c) Detección de fallas: Los procedimientos le permiten dividir los programas en
unidades lógicas discretas, cada una de las cuales se puede depurar más
fácilmente que un programa entero sin procedimientos. Para efectos de pruebas,
cada procedimiento se puede ejecutar por separado.
d) Código unitario: para las tareas que son comunes en varias secciones del
programa no es necesario repetir el código, pues basta con crear un
procedimiento general para esas tareas y llamar al procedimiento desde las
distintas secciones del programa cada vez que sea requerido.

75 75
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

e) Reutilización del código: Los procedimientos que se utilizan en un programa

pueden actuar como bloques de construcción de otros programas,
normalmente con pocas o ninguna modificación.

76 76
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

4.4.3. Clasificación de procedimientos

Visual Basic tiene tres tipos de procedimientos:
a) Procedimientos Sub:
Se caracterizan porque no devuelven un valor, y se conocen simplemente
como procedimientos. Existen dos tipos de procedimientos Sub.
Los procedimientos de evento, que se ejecutan como respuesta a un
evento y están asociados a un objeto.
Los procedimientos generales, que son creados por el usuario y se les
debe llamar específicamente desde un procedimiento de evento para su
ejecución. Los procedimientos generales se crean para proveer algún servicio
común a otros procedimientos. Es una buena estrategia de programación
colocar las instrucciones comunes en un procedimiento distinto (un
procedimiento general) y hacer que los procedimientos de evento lo llamen.
Esto elimina la necesidad de duplicar código y también hace que la aplicación
sea más fácil de mantener.
b) Procedimientos Function:
A diferencia de los procedimientos Sub, los procedimientos Function devuelven
un valor y se les conoce como funciones. Las funciones pueden ser de dos
tipos:
Las funciones intrínsecas, que están prediseñadas o provistas por el
lenguaje como Sqr(), Cos(), Asc(), etc., las cuales devuelven el valor de
raíz cuadrada, coseno, código ASCII, etc., respectivamente.
Las funciones simbólicas, creadas por el usuario cuando el lenguaje no provea
una función específica o especial. Por ejemplo, se puede crear una función
que calcule la longitud del cateto opuesto, o hipotenusa, de un triángulo
rectángulo, dado el cateto adyacente y el ángulo.
c) Procedimientos Property:
Son procedimientos que pueden devolver y asignar valores, así como
establecer referencias a objetos. Se conocen como procedimientos de
propiedad y permiten ejecutar código cuando se establece o se obtiene el
valor de una propiedad. Los procedimientos de propiedad permiten que un objeto
proteja y valide sus propios datos (propiedades), y se usan mayormente
a nivel de módulos de clase. Visual Basic proporciona tres tipos de
procedimientos de propiedad:
Property Get, que devuelve el valor de una propiedad.
Property Let, que establece el valor de una propiedad.
Property Set, que establece el valor de una propiedad de objeto, es decir, una
propiedad que contiene una referencia a un objeto.
Cada uno de estos procedimientos de propiedad desempeña un papel concreto
en la definición de una propiedad. La propiedad típica estará compuesta por
una pareja de procedimientos de propiedad: Property Get para obtener el
valor de la propiedad, y Property Let o Property Set para asignar un nuevo valor.

77 77
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

La razón por la que hay dos formas de procedimientos de propiedad (Let y Set)
para asignar un valor, es que Visual Basic permite la asignación de

78 78
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

referencias de objeto a variables de objeto previamente declaradas con una

sintaxis especial:
Dim cmd As Object
Set cmd = New CommandButton

4.4.4. Alcance de procedimientos

El alcance se refiere al ámbito donde el procedimiento está disponible. En cuanto a
su alcance, hay dos tipos de procedimientos
a) Procedimientos públicos
b) Procedimientos privados
Los procedimientos públicos están disponibles desde cualquier parte del código del
programa; es decir, se pueden llamar desde cualquier módulo del programa.,
aunque el consumo de recursos es mayor.
En cambio, los procedimientos privados sólo se pueden acceder desde el módulo
donde fueron creados. Para definir un procedimiento público se utiliza la palabra
reservada Public y para definir un procedimiento privado se utiliza la palabra
reservada Private.
Observación: Si no se especifica la palabra reservada (Public o Private), los procedimientos
son públicos de forma predeterminada, lo que significa que se les puede
llamar desde cualquier parte de la aplicación.
4.4.5. Trabajar con procedimientos
En esta parte trataremos la sintaxis requerida para manipular procedimientos Sub
y Function, ya sean públicos o privados. Veremos sólo los procedimientos
generales y las funciones simbólicas, ya que los procedimientos de evento fueron
tratados en la unidad 2 y las funciones intrínsecas no requieren de creación, ya
que están provistas por el sistema. En la unidad 5 veremos con detalle algunas de
las funciones del sistema. Los procedimientos de propiedad no se tratarán en esta
guía de estudio.
a) Sintaxis para la creación de procedimientos
Procedimiento tipo Sub privado (Procedimiento general privado)
Private Sub NombreProcedimiento([parámetros])
'{Instrucciones}
End Sub

Procedimiento tipo Sub público (Procedimiento general público)

Public Sub NombreProcedimiento([parámetros])
'{Instrucciones}
End Sub

Procedimiento tipo Function privado (Función simbólica privada)

79 79
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Private Function NombreFunción([parámetros]) As TipoDeDato

'{Instrucciones}
NombreFunción = ValorDevuelto
End Sub

80 80
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Procedimiento tipo Function público (Función simbólica pública)

Public Function NombreFunción([parámetros]) As TipoDeDato
'{Instrucciones}
NombreFunción = ValorDevuelto
End Sub

Como se explicó anteriormente, los procedimientos tipo Function, a diferencia

de los procedimientos tipo Sub, devuelven un valor. Observe que, justo antes
de terminar los procedimientos Function, se le asigna al nombre de la función
el valor que esta devuelve.
) Llamar a procedimientos
Una vez que se han creado los procedimientos, estos se pueden invocar, ejecutar
efectuando un llamado al procedimiento por su nombre.
Los procedimientos Function se utilizan como se utilizaría cualquier función del
sistema, por ejemplo la función QBColor, que es del sistema, se invoca de la
siguiente manera:

Me.BackColor = QBColor(7)

En forma general, las funciones simbólicas se invocan como sigue:

Variable = NombreFunción([Parámetros])

Respecto a los procedimientos tipo Sub, existen dos maneras de llamarlos.

Una forma es mediante la instrucción Call y el nombre del procedimiento.
Call NombreProcedimiento([Parámetros])

Y otra forma es directamente escribiendo el nombre del procedimiento.

NombreProcedimiento [Parámetros]
Observación: De la forma directa, los parámetros no se colocan entre paréntesis.
Recuerde: Una vez que termina el procedimiento, el control del programa continúa
en la línea de código siguiente a la que llamó al procedimiento.
c) Salir de procedimientos
Hemos visto en las estructuras de control repetitivas, que no es necesario esperar
a que termine el ciclo para salir de la estructura, ya que esta puede ser
interrumpida mediante la sentencia Exit seguida del nombre de la estructura.
Para salir de un ciclo For se utiliza Exit For, por ejemplo.
Los procedimientos, como estructuras, también permiten su terminación sin
necesidad de esperar alcanzar la línea de código donde se encuentra la
sentencia End Sub o End Function. Esto se logra mediante las sentencias Exit
Sub o Exit Function, según sea el caso.
Private Sub NombreProcedimiento([Parámetros])
'{Instrucciones que se ejecutan}
Exit Sub 'Termina el procedimiento

81 81
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

'{Instrucciones que no se ejecutarán}

End Sub

82 82
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

d) Conservar el valor de las variables

Ya se ha dicho que las variables locales son las que se declaran dentro de un
procedimiento y que estas pueden ser individualmente volátiles o estáticas. Se
puede hacer que todas las variables, declaradas dentro de un procedimiento,
sean estáticas, simplemente anteponiendo a la declaración del procedimiento
la palabra reservada Static como se muestra a continuación para un
procedimiento tipo Sub.
Static Private Sub NombreProcedimiento([Parámetros])
'Declaración de variables volátiles
'{Instrucciones}
End Sub

Aunque la declaración de las variables sea volátil, estas se convierten en estáticas

para el procedimiento de ejemplo anterior.
4.4.6. Transferencia de parámetros
En los ejemplos de sintaxis anteriores, hemos visto que se incluyen paréntesis ()
en la declaración de los procedimientos. Opcionalmente dentro de estos paréntesis
se pueden colocar parámetros. Los parámetros o argumentos son variables,
separadas por coma, que se utilizan para pasar o transferir valores útiles a los
procedimientos cuando estos son llamados. Los valores de estas variables se
pueden pasar por valor o por referencia.
a) Transferencia por valor
Cuando la variable se pasa por valor, se envía al procedimiento una copia de la
variable y el procedimiento reserva un espacio de memoria nuevo, de tal manera
que los cambios en el valor de la variable nueva no afectan el valor de la variable
original de la línea de código donde se efectuó la llamada. Para pasar variables
por valor se utiliza la palabra reservada ByVal en la declaración de parámetros.
Sub NombreProcedimiento (ByVal dato1 As tipo)
'{Instrucciones}
End Sub

b) Transferencia por referencia

Al pasar un argumento por referencia, tanto la variable del procedimiento,
como la variable original, comparten el mismo espacio de memoria; por esta
razón, al cambiar el valor de la variable dentro del procedimiento, la variable
original de la línea de código desde donde se hizo el llamado, adopta el nuevo
valor. Para pasar variables por valor se utiliza la palabra reservada ByRef.
Sub NombreProcedimiento (ByRef dato2 As tipo)
'{Instrucciones}
End Sub

En el ejemplo de sintaxis, “dato1” es el nombre de una variable nueva, y “dato2”

es la misma variable de la instrucción llamadora, sólo que con otro nombre. Por
defecto, si no se usa la palabra reservada (ByVal o ByRef), todos los datos se

83 83
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

envían por referencia. En el siguiente ejemplo, “dato2” se transfiere por

referencia.

84 84
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
4.- Código
4.- Código
de Visual
de Visual
Basic Basic

Sub NombreProcedimiento (dato2 As tipo)

'{Instrucciones}
End Sub

El siguiente ejemplo muestra como funciona la transferencia de parámetros:

Private Sub Botón_Click()
Dim X As Integer, Dim Y As Integer
X=5: Y=7
Duplicar X, Y 'Llama al procedimiento con 5 y 7
'X sigue siendo igual a 5, pero Y cambia a 14
End Sub

Sub Duplicar(ByVal D1 As Integer, ByRef D2 As Integer)

'D1 se carga con 5 y D2 con 7
D1 = D1 * 2 'D1 cambia a 10 de 5*2=10
D2 = D2 * 2 'D2 cambia a 14 de 7*2=14
End Sub 'Retorna a Botón_Click

4.4.7. Ejemplo completo de la unidad

85 85
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Unidad 5

Funciones intrínsecas

“El entusiasmo es la madre del esfuerzo, y sin este nunca se logró nada importante”
.- Emerson

5.1. Funciones en general

5.1.1. Expresiones
La expresión se define como cualquier combinación de variables, constantes,
operadores, funciones y nombres de campos, controles y propiedades que se
evalúa como un único valor. La evaluación consiste en la asignación de un valor a un
espacio de memoria, es decir a una variable. Así, una instrucción de asignación es
una expresión.
Me.txtPeso.Text = Me.txtMasa.Text * 10

5.1.2. Funciones
Una función es un cálculo preprogramado que se puede realizar bajo petición
desde cualquier lugar de un programa. Puesto que una función adopta uno o más
argumentos y devuelve un único valor, esta se puede incluir en una expresión. Por
ejemplo, se puede definir la función Licuar que permite el uso de una licuadora
para múltiples aplicaciones. Para preparar una Merengada fría, se debe escribir la
siguiente expresión:
Merengada = Hielo + Licuar(Leche, Fruta, Azúcar, Vainilla)
Leche
Fruta
Licuar Merengada caliente
Azúcar
Vainilla

Figura 5.1.- Función supuesta Licuar

Observe que la función Licuar no devuelve Merengada fría y se debe agregar Hielo
en una expresión completa. La merengada obtenida dependerá del tipo e fruta, y
cantidades de leche, azúcar y vainilla. Se dice que estos últimos son las variables
independientes de la función, mientras que la merengada es la variable dependiente.
En general todas las funciones se caracterizan por una serie de valores de
entrada conocidos como argumentos o variables independientes, y sólo un valor de
salida conocido como resultado o variable dependiente.

86 86
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

A
B
Función Y=Función(A, B, …, C)
C

Figura 5.2.- Función en general

Por ejemplo, “y = Sin(x)” es una expresión formada por la función “Sin”, un

argumento “x” como valor de un ángulo, y el resultado (cálculo del seno de “x”) es
asignado a “y”.

x Sin y

Figura 5.3.- Función Seno.

Para facilitar el estudio de las funciones, estás se han clasificado según su relación
con cadenas, números, fechas, objetos o archivos.
5.1.3. Instrucciones
Mientras que las funciones son operaciones sobre ciertos argumentos para obtener
o devolver un valor, las instrucciones consisten en órdenes para el sistema, y no
devuelven valor alguno. Las instrucciones prescinden del par de paréntesis que
caracterizan a todas las funciones. Podríamos comparar a las instrucciones con
procedimientos Sub intrínsecos del sistema. Según el ejemplo, la función Licuar
también podría utilizarse como una instrucción, en lugar que como una función, y
en este caso no existe devolución de un valor, sino que se ejecuta una orden y se
prescinde del par de paréntesis como se muestra a continuación:
Reunir ingredientes
Licuar Leche, Fruta, Azúcar, Vainilla
Agregar Hielo

En Visual Basic existen muchas funciones que se pueden utilizar como

instrucciones. El término “instrucciones” ha sido utilizado en capítulos anteriores para
hacer referencia a líneas de código, y en su lugar se ha utilizado el término
“sentencias”. Las instrucciones también se conocen como sentencias o comandos.

5.2. Funciones de cadena

5.2.1. Tratamiento de cadenas
Para el estudio de las funciones que admiten como argumento, o devuelven como
valor, cadenas de caracteres, es necesario conocer lo siguiente:
a) Las cadenas de caracteres se declaran tipo String. Por ejemplo, declaremos la
variable Cadena como una cadena de longitud variable.
Dim Cadena As String

b) Los valores de cadenas de caracteres se delimitan mediante “comillas dobles”.

Por ejemplo, asignemos a la variable Cadena el valor “Visual Basic”.
Cadena = “Visual Basic”

87 87
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

c) Cada caracter ocupa una posición comenzando desde la izquierda de la

cadena. Por ejemplo, en la posición 8 de la variable Cadena se encuentra el
caracter “B”.
V i s u a l B a s i c

1 2 3 4 5 6 7 8 9 10 11 12

Figura 5.4.- Posiciones de una cadena de caracteres

d) La longitud de una cadena es la cantidad de caracteres de la cadena. Por ejemplo,

la variable Cadena tiene una longitud de 12 caracteres. Observe que el “espacio”
entre las palabras, se cuenta como un caracter que ocupa la posición 7.
e) Las variables declaradas como cadenas de longitud fija truncan los caracteres
sobrantes a la derecha, o rellenan con espacios en blanco, para completar la
cantidad de caracteres especificados.
Dim K As String * 5
K = “Visual Basic” 'K se carga con “Visua” (5 caract.)
K = “Pan” 'K rellena con 2 espacios “Pan ”

5.2.2. Cambiar a mayúsculas y minúsculas

Para convertir todos los caracteres de una cadena a mayúsculas o minúsculas se
usa UCase o LCase respectivamente. Por ejemplo, la siguiente instrucción presenta
en la caja de texto txtCadena la palabra “VISUAL BASIC”
Me.txtCadena.Text = UCase(Cadena)

Mientras que la siguiente instrucción presenta la palabra “visual basic”

Me.txtCadena.Text = LCase(Cadena)

5.2.3. Determinar la longitud de una cadena

Se puede determinar la cantidad de caracteres contenidos en una cadena, incluyendo
los espacios, mediante la función Len. La siguiente instrucción presenta en la caja de
texto txtCadena el valor 8.
Me.txtNúmero.Text = Len(Cadena)

5.2.4. Buscar caracteres dentro de una cadena

Para determinar la posición de caracteres dentro de una cadena se usa InStr. La
sintaxis general se muestra a continuación.
InStr([Inicio, ]Cadena, Buscado)

“Inicio” es un entero opcional que representa la posición inicial de búsqueda, y si

se obvia la búsqueda comienza desde la posición 1. “Cadena” es la cadena
examinada, y “Buscado” son los caracteres buscados. Si los caracteres buscados
no se encuentran en la cadena, InStr devuelve el valor 0. Vea los ejemplos
siguientes:
Buscar la posición de “Ba” en la variable Cadena. Recuerde que Cadena = “Visual
Basic”. Se presenta el valor 8 en la caja de texto.

88 88
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Me.txtNúmero.Text = InStr(Cadena, “Ba”)

Buscar la posición de “es” en Cadena. Se presenta el valor 0 en la caja de texto,

indicando que no encontró la secuencia “es”.
Me.txtNúmero.Text = InStr(Cadena, “es”)

Buscar la posición de “a” en Cadena. Devuelve el valor 5 en la caja de texto.

Me.txtNúmero.Text = InStr(Cadena, “a”)

Buscar la posición de “a” en Cadena, pero desde la posición 6. En este caso,

devuelve el valor 9 en la caja de texto.
Me.txtNúmero.Text = InStr(6, Cadena, “a”)

5.2.5. Extraer e insertar caracteres a una cadena

Se pueden extraer tantos caracteres como desee del principio de la cadena, del
final de la cadena o de cualquier parte de la cadena, utilizando respectivamente
las funciones: Left, Right y Mid. La sintaxis general se muestra a continuación.
Left(Cadena, Longitud)
Right(Cadena, Longitud)
Mid(Cadena, Inicio, Longitud)

“Longitud” es un entero que define el número de caracteres que se extraerán, e

“Inicio” es la posición inicial de extracción dentro de la cadena. Veamos los siguientes
ejemplos:
Extraer los primeros seis caracteres a la izquierda de Cadena.
Me.txtCadena.Text = Left(Cadena, 6) 'Devuelve “Visual”

Extraer los últimos cinco caracteres a la derecha de Cadena.

Me.txtCadena.Text = Right(Cadena, 5) 'Devuelve “Basic”

Extraer los siete caracteres centrales de Cadena desde la posición 3.

Me.txtCadena.Text = Mid(Cadena, 3, 7)'Devuelve “sual Ba”

Para insertar caracteres en una cadena se usa la función Mid de la siguiente

manera:
Mid(Cadena, 8, 6) = “Studio”
Me.txtCadena.Text = Cadena 'Devuelve “Visual Studio”

Se lee como asignar a la variable Cadena los 6 caracteres de “Studio” desde la

posición 8. Así, la variable Cadena que contenía el valor “Visual Basic”, adopta
como nuevo valor “Visual Studio”, debido a la inserción, desde la posición ocho, de
los seis caracteres “Studio”.
5.2.6. Tratamiento de espacios en blanco

89 89
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

En algunos casos, nos podemos encontrar con cadenas que contienen espacios en
blanco innecesarios. Para eliminar los espacios al principio de la una cadena, se

90 90
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

usa Ltrim, para eliminar al final de la cadena se usa Rtrim, y para eliminar
cualquier espacio al principio y al final de la cadena, se usa simplemente Trim.
En el siguiente ejemplo se muestran estos tres casos:

Cadena = “ Visual Basic ”

txtCadena.Text = Ltrim(Cadena) 'Devuelve “Visual Basic ”
txtCadena.Text = Rtrim(Cadena) 'Devuelve “ Visual Basic”
txtCadena.Text = Trim(Cadena) 'Devuelve “Visual Basic”
Observe: No se eliminan los espacios intermedios; es decir, la separación entre
palabras de una frase.
Respecto a espacios en blanco, también existe la función Space, la cual permite crear
cadenas de caracteres con sólo espacios en blanco. En el siguiente ejemplo se crea
una cadena de 7 espacios en blanco:

txtCadena.Text = Space(7)

5.2.7. Convertir a número y a cadena

Una cadena se puede convertir a número usando Val, y un número se puede onvertir
ca cadena de caracteres usando Str. La función Str agrega un espacio en lanco al
b
principio de la cadena. La función Val devuelve cero si su argumento es no
numérico.

Dim Número As Single

Dim Cadena As String
Número = 10.24
Cadena = Str(Número) 'Devuelve la cadena “ 10.24”
Número = Val(Cadena) 'Devuelve el número 10,24
Cadena = “A”
Número = Val(Cadena) 'Devuelve el número 0
5.2.8. Obtener cadenas de caracteres con formato
La función Format permite controlar la forma en que aparecerán los resultados
numéricos, de fecha o de carácter. La sintaxis general es la siguiente:

Format(Número|Fecha|Cadena, Formato)
Esta función acepta números, fechas o cadenas de caracteres. El parámetro
“Formato” permite definir la forma en que se devuelve el resultado de texto, y puede
ser una constante de Visual Basic o un conjunto de caracteres especiales.
a) Formatos numéricos: para la presentación de valores numéricos se pueden
utilizar constantes intrínsecas (ver Tabla 5.1) o símbolos especiales (ver Tabla
5.2) para definir el formato.
Constante Descripción del formato
General
El número tal y como es, sin separadores de millar.
Number
Currency Separador de millar; muestra dos dígitos a la derecha del separador decimal.
Fixed Al menos un dígito a la izquierda y dos dígitos a la derecha del separador decimal.

91 91
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Separador de millar, al menos un dígito a la izquierda y dos a la derecha del separador

Standard
decimal.
Percent El número multiplicado por 100 con un signo de porcentaje (%) a la derecha.

92 92
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Constante Descripción del formato

Scientific Utiliza la notación científica estándar.
Yes/No Muestra No si el número es 0; de lo contrario, muestra Yes.
True/False Muestra False si el número es 0; de lo contrario, muestra True.
On/Off Muestra Off si el número es 0; de lo contrario, muestra On.
Tabla 5.1.- Constantes de formato para números
Símbolo Descripción del formato
0 Muestra 0 así no exista dígito en esa posición
# Muestra el dígito sólo si existe en una posición
, Lugar donde aparecerá coma decimal.
. Lugar donde aparecerá separado de miles.
% Multiplica por 100 el número y muestra el símbolo %.
E-,E+ Muestra el número en notación científica.

Tabla 5.2.- Símbolos especiales de formato para números

Veamos los siguientes ejemplos:

Cadena = Format(1980.326, “Fixed”) 'Devuelve “1980,33”

Cadena = Format(1980.326, “Standar”) 'Devuelve “1.980,33”
Cadena = Format(1980.326, “Percent”) 'Devuelve “198032,6%”
Cadena = Format(1980.326, “Yes/No”) 'Devuelve “Sí”
Cadena = Format(1980.326, “00000”) 'Devuelve “01980”
Cadena = Format(1980.326, “#.000.#”) 'Devuelve “1.980,3”
Cadena = Format(1980.326, “#.0”) 'Devuelve “980,3”
Cadena = Format(1980.326, “#%”) 'Devuelve “198033%”

b) Formatos de fecha: al igual que para valores numéricos, Visual Basic provee
constantes intrínsecas (ver Tabla 5.3) y símbolos especiales (ver Tabla 5.4)
para la presentación de valores de fecha y hora.
Constante Descripción
General Date Muestra la fecha y hora si están disponibles en la expresión.
Long Date Muestra día de la semana, día del mes, el mes y el año.
Médium Date Muestra día del mes, el mes en tres letras y el año.
Short Date Muestra día del mes, el mes y el año
Long Time Muestra la hora, minutos y segundos con indicación AM/PM
Médium Time Muestra la hora y minutos con indicación AM/PM
Short Time Sólo muestra hora y minutos
Tabla 5.3.- Constantes de formato para fechas y horas
Símbolo Descripción
: Separador de hora, minutos y segundos
/ Separador de día, mes y año.
“d” Día del mes 1-31
“dd” Día del mes 01-31
“ddd” Día de la semana Dom-Sáb
“dddd” Día de la semana Domingo-Sábado
“w” Día de la semana 1-7 (Dom = 1)
“ww” Semana del año 1-54
“m” Mes del año 1-12
“mm” Mes del año 01-12
“mmm” Mes del año Ene-Dic
“mmmm” Mes del año Enero-Diciembre

93 93
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

“q” Cuatrimestre del año 1-4

“y” Día del año 1-366
“yy” Año en dos dígitos 00-99
“yyyy” Año en cuatro dígitos 0100-9999

94 94
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Símbolo Descripción
“h” Hora del día 0-23
“hh” Hora del día 00-23
“n” Minuto de la hora 0-59
“nn” Minuto de la hora 00-59
“s” Segundo transcurrido 0-59
“ss” Segundo transcurrido 00-59
“AM/PM” Muestra AM o PM según corresponda
“am/pm” Muestra am o pm según corresponda

Tabla 5.4.- Símbolos para crear formatos de fecha y hora

Veamos los ejemplos siguientes:

Cadena = Format(#7/5/00#, “Médium Date”) '“07/May/2003”

Cadena = Format(#7/5/00#, “Short Date”) '“07/05/03”
Cadena = Format(#7/5/72#, “ddd/mm/yyyy”) '“Dom/05/1972”
Cadena = Format(#20:05:12#, “Médium Time”) '“08:05 PM”
Cadena = Format(#20:05:12#, “Long Time”) '“08:05:54 PM”
Cadena = Format(#20:05:12#, “HH:nn”) '“20:05”
Cadena = Format(#20:05:12#, “HH:n”) '“20:5”
Cadena = Format(#20:05:12#, “HH:n:s”) '“20:5:12”

c) Formatos de cadena: mediante los cuales la función Format se puede usar

para la presentación de mayúsculas y minúsculas según los caracteres especiales
“>” y “<” sin necesidad de cambiar el valor de la cadena de caracteres mediante
las funciones UCase y LCase. Format no tiene funciones de conversión, es sólo
para presentación.
Cadena = Format(“Simón Bolívar”, “>”) '“SIMÓN BOLÍVAR”
Cadena = Format(“Simón Bolívar”, “<”) '“simón bolívar”

5.2.9. Mapa de caracteres

Para obtener el código ASCII de un carácter, se usa la función Asc. Para obtener el
carácter dado un código ASCII se usa la función Chr. En el código ASCII (ver Tabla
5.5) a cada valor numérico le corresponde un caracter. El símbolo • indica que
Windows no lo admite para la mayoría de las fuentes predefinidas. La función Chr de
códigos ASCII 8, 9, 10 y 13 no devuelve caracter, sino que se traducen en
borrado hacia atrás, tabulación, avance de línea y retorno de carro, respectivamente.
Asc Chr Asc Chr Asc Chr Asc Chr
0 Nulo 32 [SPACE] 64 @ 96 `
1 • 33 ! 65 A 97 a
2 • 34 " 66 B 98 b
3 • 35 # 67 C 99 c
4 • 36 $ 68 D 100 d
5 • 37 % 69 E 101 e
6 • 38 & 70 F 102 f
7 • 39 ' 71 G 103 g
[BACKSPAC
8 40 ( 72 H 104 h
E]
9 [TAB] 41 ) 73 I 105 i

95 95
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

10 [AV. LINE] 42 * 74 J 106 j

11 • 43 + 75 K 107 k
12 • 44 , 76 L 108 l

96 96
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Asc Chr Asc Chr Asc Chr Asc Chr

13 [ENTER] 45 - 77 M 109 m
14 • 46 . 78 N 110 n
15 • 47 / 79 O 111 o
16 • 48 0 80 P 112 p
17 • 49 1 81 Q 113 q
18 • 50 2 82 R 114 r
19 • 51 3 83 S 115 s
20 • 52 4 84 T 116 t
21 • 53 5 85 U 117 u
22 • 54 6 86 V 118 v
23 • 55 7 87 W 119 w
24 • 56 8 88 X 120 x
25 • 57 9 89 Y 121 y
26 • 58 : 90 Z 122 z
27 • 59 ; 91 [ 123 {
28 • 60 < 92 \ 124 |
29 • 61 = 93 ] 125 }
30 • 62 > 94 ^ 126 ~
31 • 63 ? 95 _ 127 •
Tabla 5.5.- Juego de caracteres ASCII de 0 a 127

5.3. Funciones numéricas

5.3.1. Funciones matemáticas
Visual Basic provee todas las funciones necesarias para cálculos directos o para la
construcción de otras funciones matemáticas (ver Tabla 5.6).
Función Descripción
Sgn(número) Signo de un número
Log(número) Logaritmo natural de un número
Exp(número) Potencia neperiana “e”
Sqr(número) Raíz cuadrada de un número
Atn(número) Trigonometría Arco tangente de un triángulo
Cos(ángulo) Trigonometría Coseno del un ángulo en radianes
Sin(ángulo) Trigonometría Seno de un ángulo en radianes
Tan(ángulo) Trigonometría Tangente de un ángulo en radianes
Abs(número) Valor absoluto de un número

Tabla 5.6.- Funciones matemáticas

5.3.2. Funciones de ajuste decimal

Mientras que las funciones Fix e Int devuelven la parte entera de un número, la
función Round redondea a una cantidad de decimales. La función Fix trunca la
parte decimal de un número de manera indistinta. Para valores negativos la
función Int ajusta al valor entero inmediato superior. Para valores positivos Fix e
Int operan de la misma manera.
Función Devuelve
Fix(número) Parte entera superior negativa de un número
Int(número) Parte entera inferior negativa de un número

97 97
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Round(número,
Número redondeado de un número con n decimales
n)

Tabla 5.7.- Funciones de ajuste numérico

Veamos los siguientes ejemplos:

98 98
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Número = Fix(99,8) 'Devuelve 99

Número = Fix(-99,8) 'Devuelve -99
Número = Fix(-99,2) 'Devuelve -99
Número = Int(99,8) 'Devuelve 99
Número = Int(-99,8) 'Devuelve -100
Número = Int(-99,2) 'Devuelve -100
Número = Round(99.8,0) 'Devuelve 100
Número = Round(-99.8,0) 'Devuelve -100
Número = Round(-99.2,0) 'Devuelve -99
Número = Round(99.56,0) 'Devuelve 100
Número = Round(99.56,1) 'Devuelve 99.6
Número = Round(99.56,2) 'Devuelve 99.56
Número = Round(99.56,3) 'Devuelve 99.560

5.3.3. Función de número aleatorio

La función Rnd devuelve un número aleatorio menor que 1, pero mayor o igual a
cero. Rnd se usa en conjunción con la instrucción Randomize, la cual inicializa el
generador de números aleatorios para devolver valores entre 0 y 1. Para obtener
un rango de números aleatorios enteros entre un límite Inferior y Superior se
puede aplicar la siguiente fórmula o procedimiento:
Randomize 'Instrucción que inicializa Rnd
Aleatorio = Int((Superior-Inferior + 1)*Rnd + Inferior)

5.4. Funciones de fecha y hora

5.4.1. Obtener la fecha y hora del sistema
La función Date devuelve la fecha del sistema, Time devuelve la hora y Now devuelve
tanto la fecha como la hora del sistema. A menudo se utiliza el evento del control
Timer para mostrar fechas y horas.
En el ejemplo siguiente suponga que la fecha del sistema es 12 de octubre del año
2000 y son las 6:45 pm.
Private Sub Timer1_Timer()
lblFecha.Caption = Date 'Devuelve #12/10/2000#
lblHora.Caption = Time 'Devuelve #18:45:00#
lblHoy.Caption = Now 'Devuelve #12/10/2000 18:45:00#
End Sub

En combinación con la función Format se pueden establecer los campos de fecha y

hora que se desean visualizar.
5.4.2. Establecer la fecha y hora del sistema
Para establecer la fecha y hora del sistema se utilizan Date y Time como
instrucciones.
Date = #12/10/2003#
Time = #18:10:00#

5.4.3. Realizar cálculos con fechas y horas

99 99
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

a) Calcular una fecha dado un intervalo de tiempo

10 100
0
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Se pueden calcular fechas futuras o pasadas a una fecha de referencia,

agregando o sustrayendo intervalos de tiempo en días, meses, años, horas,
segundos, etc., a la fecha de referencia. Cuando utilizamos el término
“fechas”, nos referimos a instantes de tiempo; o sea, pueden ser desde
segundos hasta años. Para obtener una fecha dado un intervalo de tiempo, se
usa la función DateAdd:
FechaFutura = DateAdd(Intervalo, Número, FechaRef)
FechaPasada = DateAdd(Intervalo,-Número, FechaRef)

El argumento “Intervalo” es una cadena de caracteres que indica el tipo de

intervalo de tiempo para el cálculo (ver Tabla 5.8); es decir, si el cálculo se
efectúa en días, meses, horas, etc.
Intervalo Descripción
Yyyy Cálculo en Años
Q Cálculo en Trimestres
M Cálculo en Meses
Y Cálculo en Días
D Cálculo en Días
W Cálculo de Días de la semana
Ww Cálculo en Semanas
H Cálculo en Horas
N Cálculo en Minutos
S Cálculo en Segundos
Tabla 5.8.- Valores del parámetro Intervalo de funciones de fecha y hora

El argumento “Número” es un número entero que representa el número de

intervalos de tiempo seleccionado con “Intervalo”. Por ejemplo, para calcular
la fecha de vencimiento de facturas a treinta días, se puede escribir el código:
Dim Fecha As Date
Fecha = FechaDeFactura
FechaVencimineto = DateAdd(“d”, 30, Fecha)

Para conocer fechas pasadas, suponga que desea conocer la fecha de una
mercancía la cual tiene 10 meses en almacén:

FechaArribo = DateAdd(“m”, -10, Date)

Observe que se recurre a la función Date para obtener la fecha actual del sistema,
y así utilizarla como argumento.
) Calcular el intervalo de tiempo entre dos fechas
Este tipo de cálculo es muy útil para determinar la duración, el retardo o la
cantidad de tiempo transcurrido entre dos fechas u horas. Para este efecto se
usa la función DateDiff:

Duración = DateDiff(Intervalo, Anterior, Posterior)

El parámetro “Intervalo” se regirá por la tabla 5.8 ya que también es una cadena
de caracteres que indica el tipo de intervalo de tiempo. El argumento “Anterior”
es un literal de fecha correspondiente a un momento anterior al valor de

10 101
1
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

fecha del argumento “Posterior”. Si el argumento “Anterior” corresponde a un

momento posterior, la función DateDiff devuelve un número

10 102
2
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

negativo y no se produce error. Por ejemplo, para calcular la cantidad de días

de vida, se puede usar la siguiente línea de código:
Días = DateDiff(“d”, FechaNacimiento, Date)

La variable “FechaNacimiento” contiene la fecha de nacimiento, y Date es la

función vista anteriormente que devuelve la fecha actual del sistema. Veamos
otros ejemplos, donde se define la variable D como entero y se aplica la
función DateDiff a fechas establecidas:
Dim D As Integer
D = DateDiff(“yyyy”, #31/12/1999#, #31/12/2000#) '1 año
D = DateDiff(“m”, #31/12/1999#, #31/12/2000#) '12 meses
D = DateDiff(“w”, #31/12/1999#, #31/12/2000#) '52 días
D = DateDiff(“ww”, #31/12/1999#, #31/12/2000#) '53 sem.
D = DateDiff(“d”, #31/12/1999#, #31/12/2000#) '366 días
Observación: A diferencia de la función DateAdd, que devuelve una fecha, DateDiff
devuelve un número entero.
c) Calcular parte de una fecha
En algunos casos es necesario conocer el valor numérico de sólo parte de una
fecha. Utilizando la función DatePart se puede calcular el número del día, mes,
año, trimestre o semana de una fecha, según el valor del argumento “Intervalo”:
ParteDeFecha = DatePart(Intervalo, Fecha)

Veamos los siguientes ejemplos, donde una vez más se ha definido la variable
D como entero para albergar el resultado de DatePart:
Dim D As Integer
D = DatePart(“yyyy”, #31/12/1999#) 'Devuelve 1999
D = DatePart(“m”, #31/12/1999#) 'Devuelve 12
D = DatePart(“w”, #31/12/1999#) 'Devuelve 6 (viernes)
D = DatePart(“ww”, #31/12/1999#) 'Devuelve 53
D = DatePart(“d”, #31/12/1999#) 'Devuelve 31

Además de DatePart, Visual Basic dispone de un conjunto de funciones

destinadas a obtener parte de una fecha u hora, sin necesidad del parámetro
Intervalo. Estas funciones se detallan en la tabla siguiente:
Función Devuelve la parte de fecha
Year(fecha) Año de 100 a 9999
Month(fecha) Mes de 1 a 12
Day(fecha) Día de 1 a 31
WeekDay(fecha) Día de 1 a 7
Hour(hora) Hora de 0 a 23
Minute(hora) Minuto de 0 a 59
Second(hora) Segundo de 0 a 59
WeekDayName(fecha) Día de Lunes a Domingo
Tabla 5.9.- Funciones que devuelven parte de una fecha

10 103
3
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

5.4.4. Devolver fechas y horas

Existen funciones para convertir números o cadenas en fechas. Las funciones
DateSerial y TimeSerial conforman una fecha a partir de valores numéricos enteros
correspondientes a día, mes, año, hora, minuto y segundo.
Fecha = DateSerial(Día, Mes, Año)
Hora = TimeSerial(Hora, Min, Seg)

Por su parte, las funciones DateValue y TimeValue convierten una cadena con
formato de fecha y hora a un tipo de dato Date.
Fecha = DateValue(Cadena)
Hora = TimeValue(Cadena)

Veamos los ejemplos:

Dim Fecha As Date, Hora As Date
Fecha = DateSerial(12, 10, 3) 'Devuelve #12/10/2003#
Fecha = DateValue(“12/10/2003”) 'Devuelve #12/10/2003#
Hora = TimeSerial(12, 10, 3) 'Devuelve #12:10:03#
Hora = TimeValue(“12:10:3”) 'Devuelve #12:10:03#

5.4.5. Cronometrar procesos

Los procesos en Visual Basic se pueden cronometrar utilizando una función que
devuelve el número de segundos del sistema transcurridos desde la medianoche.
Esta función se llama Timer y se utiliza según la siguiente estructura:
Dim Inicio, Fin As Long
Dim DuraciónDelProceso As Integer
Inicio = Timer
{Proceso}
Fin = Timer
DuraciónDelProceso = Fin – Inicio

La función Timer también suele usarse para hacer una pausa temporal en la
secuencia del programa. Para este caso es imperante utilizar la instrucción DoEvents,
mediante la cual, durante la pausa causada en un ciclo, el programa no acapara los
recursos del sistema. Veamos esto con un ejemplo donde se crea un retardo de 20
segundos.
Dim Inicio As Long
Inicio = Timer
Do While Timer < (Inicio + 20)
DoEvents
Loop

5.5. Funciones de Objetos

5.5.1. Cuadro de diálogo de entrada InputBox
La función InputBox presenta un cuadro de diálogo (ver Figura 5.5) con una leyenda,
dos botones de comando (Aceptar, Cancelar) y una Caja de texto. Si el usuario hace

10 104
4
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

clic en el botón Aceptar, la función devuelve el contenido de la Caja de Texto como

un valor tipo cadena, y si el usuario hace clic sobre el botón

10 105
5
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Cancelar, la función devuelve una cadena vacía (“”). La sintaxis general es la

siguiente:
InputBox(Leyenda, Título, Texto, X, Y)

Figura 5.5.- Cuadro de diálogo InputBox

Los argumentos “X” y “Y” especifican la posición en la que aparecerá el cuadro de

diálogo. “X” y “Y” son opcionales, y si no se especifican, el cuadro de diálogo aparece
en el centro de la pantalla. El parámetro “Texto” también es opcional y por lo
general no se coloca, ya que se supone que la caja de texto es para que el usuario
escriba los datos a procesar por la aplicación.
5.5.2. Cuadro de diálogo de mensajes MsgBox
La función MsgBox permite mostrar un cuadro de diálogo con un mensaje
específico y puede devolver valores tipo Integer de acuerdo a su configuración y al
botón que reciba el clic del usuario. La sintaxis general es la siguiente:
MsgBox(Mensaje, Botones, Título)

Se puede utilizar MsgBox como instrucción cuando no se espera valor de retorno:

MsgBox Mensaje, Botones, Título

Figura 5.6.- Cuadro de diálogo MsgBox

El argumento “Botones” es el resultado de una suma binaria de enteros que

definen la cantidad y tipo de botones del cuadro de diálogo, así como también el
icono a mostrar. Los posibles valores que se pueden asignar al parámetro “Botones”,
están disponibles en forma de constantes intrínsecas (ver Tabla 5.10).
Constante Valor Descripción
VbOKOnly 0 Muestra solamente el botón Aceptar.
VbOKCancel 1 Muestra los botones Aceptar y Cancelar.
VbAbortRetryIgnore 2 Botones Anular, Reintentar e Ignorar.
VbYesNoCancel 3 Muestra a los botones Sí, No y Cancelar.
VbYesNo 4 Muestra a los botones Sí y No.

10 106
6
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

VbRetryCancel 5 Muestra a los botones Reintentar y Cancelar.

VbCritical 16 Muestra el icono de mensaje crítico.

10 107
7
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Constante Valor Descripción

VbQuestion 32 Muestra el icono de pregunta de advertencia.
VbExclamation 48 Muestra el icono de mensaje de advertencia.
VbInformation 64 Muestra el icono de mensaje de información.
Tabla 5.10.- Estilos de cajas de mensajes MsgBox

A continuación veremos algunos ejemplos de cuadros de mensajes con diferentes

estilos, como resultado de su respectiva línea de código.
MsgBox "Ejemplo 1", vbInformation, "Información..."
a) Mensaje de información para sólo aceptar

Figura 5.7.- Cuadro de mensaje de Información

) Mensaje crítico para sólo aceptar

MsgBox "Ejemplo 2", vbCritical, "Crítico..."

Figura 5.8.- Cuadro de mensaje de Crítico

) Mensaje de exclamación para sólo aceptar

MsgBox "Ejemplo 3", vbExclamation, "Exclamación..."

Figura 5.9.- Cuadro de mensaje de Exclamación

) Mensaje de pregunta para sólo aceptar

MsgBox "Ejemplo 4", vbQuestion, "Pregunta..."
d

10 108
8
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Figura 5.10.-Cuadro de mensaje de Pregunta

e)MsgBox
Mensaje"Ejemplo 5",SivbYesNo,
sin icono para o No "Si y No..."

Figura 5.11.-Cuadro de mensaje Si y No

f) MsgBox
Mensaje"Ejemplo 6",Aceptar
sin icono para vbOkCancel,
o Cancelar"Aceptar y Cancelar..."

Figura 5.12.-Cuadro de mensaje Aceptar y Cancelar

) Mensaje con icono para Aceptar o Cancelar

MsgBox "Ejemplo 7", vbOkCancel + vbCritical, "Aceptar y_
Cancelar, Crítico..."

Figura 5.13.-Cuadro de mensaje Crítico Aceptar y Cancelar

Por otra parte, el cuadro de mensaje como toda función devuelve valores. Los
valores devueltos por un cuadro de mensaje se detallan en la Tabla 5.11.
Constante Valor Si se hace clic en el botón
vbOK 1 Aceptar
vbCancel 2 Cancelar

10 109
9
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

vbAbort 3 Anular
vbRetry 4 Reintentar

11 110
0
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
5.- Funciones
5.- Funciones
del intrínseca
del intrínseca

Constante Valor Si se hace clic en el botón

vbIgnore 5 Ignorar
vbYes 6 Sí
vbNo 7 No
Tabla 5.11.- Valores devueltos por MsgBox

Por ejemplo, se puede preguntar al usuario, antes de cerrar una ventana, si

realmente desea cerrar la ventana:

Private Sub Form_QueryUnload(Cancel As Integer, UnloadM…)

If MsgBox("Cerrar...?", vbYesNo)=vbNo Then Cancel=1
End Sub

11 111
1
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Unidad 6

Archivos

“El secreto del éxito es la constancia en el propósito”

.- Disraeli

6.1. Nociones básicas

6.1.1. Unidades
Como es de nuestro conocimiento, los sistemas de cómputo incluyen en su
arquitectura unidades de almacenamiento o memorias donde se albergan los unos
y ceros que representan instrucciones o datos para el microprocesador. Las
memorias se clasifican en memorias primarias y memorias secundarias, de
acuerdo a la forma de conexión con la unidad central de procesamiento (CPU) o
microprocesador. Las memorias primarias corresponden a los circuitos integrados
ROM y RAM en sus diferentes versiones que se conectan al CPU a través de los buses
internos impresos en la placa o tarjeta madre. Las memorias ROM contienen
programas y tablas de datos esenciales para la operación general del sistema, y no
es posible escribir en ellas. A diferencia de las ROM, las memorias RAM permiten
ser escritas de parte del usuario con la información que actualmente desea
procese la CPU, pero con la gran desventaja que el almacenamiento es volátil; es
decir, la información se pierde sino se mantiene energizado al equipo. De esta
manera surgen las unidades de almacenamiento secundario, las cuales se
encuentra fuera de la placa base, se pueden escribir de parte del usuario, y no
requieren de energía para mantener la información. Dentro de esta categoría se
encuentran la unidades de disco magnéticas, ya sean flexibles (por lo general las
unidades A y B de 3½ pulgadas) o rígidas (por lo general el disco duro C).
También se incluyen las unidades de disco lógicas o de red (H, J, K,…), las
unidades de disco óptico (D, E) y las unidades de chip de memoria portátil. En la
Unidad 4, objetivo 4.1 tratamos el tema de administración de la memoria primaria
RAM; y a continuación conoceremos sobre la administración de la memoria
secundaria para el almacenamiento de información permanente o no volátil; de allí
su importancia.

11 112
2
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Figura 6.1.- Memorias de un sistema de cómputo

6.1.2. Archivos

Los archivos se pueden definir como un conjunto de bytes relacionados mediante

un identificador y almacenados en una unidad de disco. El sistema operativo
define la estructura mediante la cual los archivos son etiquetados, almacenados y
organizados en el disco, para lo cual crea y mantiene en cada unidad de disco a su
disposición, una tabla de asignación de archivos conocida como FAT (File
Allocation Table), que actúa como un índice si la unidad fuera un libro. La FAT es
una tabla que contiene el estatus de varios segmentos, de espacio de disco,
usados para el almacenamiento de archivos. Cada vez que se copian, borran o
modifican archivos, la FAT es actualizada automáticamente por el sistema
operativo. En las nuevas versiones de Windows la FAT se ha reemplazado por
estructuras más eficientes como FAT32 y NTSF.
Los archivos son decodificados o interpretados por otros archivos con instrucciones
llamados programas, para lo cual se requiere transferir o copiar la información del
archivo desde la memoria secundaria hasta la memoria primaria RAM. La acción de
abrir un archivo consiste en crear una copia del archivo en memoria RAM para su
manipulación directa de parte del microprocesador. Al cerrar un archivo se libera toda
traza del mismo de la memoria RAM, pero la memoria secundaria permanece intacta
si no se guardan los cambios. Si se toma la previsión de guardar los cambios, los
cuales se efectúan en memoria RAM, la información es actualizada, transferida o
copiada a la unidad de disco correspondiente.
Visual Basic permite manipular tres tipos de archivos según el modo de acceso:
secuencial, aleatorio y binario. Los archivos secuenciales, carecen de estructura y
deben ser recorridos en su totalidad para acceder a un dato intermedio. Los
archivos aleatorios se organizan en registros de longitud fija, por lo que se puede
acceder directamente a cualquier dato intermedio. Los archivos binarios también
permiten acceso directo, pero los registros son de longitud variable. En esta
unidad sólo trataremos a los archivos de acceso secuencial y aleatorio.
La Coruña, 2003
Señores
Microsoft
101111010

010011111
101111010
101000011
100110111
101111111
100111010

CompuSoft, S.A.
Word Ciudad.-

Estimados señores
Figura 6.2.- Archivo de documento de W ord

6.1.3. Directorios

11 113
3
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Los directorios, o carpetas como también se les conocen, representan una

estructura organizativa soportada por la mayoría de los sistemas operativos que

11 114
4
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

permite agrupar archivos en una unidad de disco. Windows, como sistema operativo,
soporta esta facilidad. En lugar de almacenar todos los archivos en la raíz de la
unidad, el usuario puede crear múltiples directorios para contener grupos de
archivos, y en cada directorio puede crear otros subdirectorios para un agrupamiento
interno, y así sucesivamente. Archivos Archivos
Archivos Archivos
Subdirectorio 1 Subdirectorio 2
Archivos
Directorio 1 Directorio 2
Unidad de disco Raíz

Figura 6.3.- Estructura de directorios y archivos

Instrucciones de archivos
6.2.
Instrucciones para manipular directorios
6.2.1.
a ) Establecer
Cuando una la unidad activa se enciende, esta ejecuta un programa primario
computadora
almacenado en ROM o BIOS, el cual contiene las directivas básicas de
inicialización. El proceso de inicialización incluye la búsqueda del programa del
Sistema Operativo en una unidad de memoria secundaria, es decir, en un
disco local o de red. Una vez detectado el sistema operativo, se procede a la
carga o ejecución del mismo; y se establece inicialmente como unidad de disco
activa, aquella donde se encuentra el sistema operativo. La unidad activa es
donde se crean, borran, listan o modifican archivos y directorios. Para cambiar
la unidad activa, Visual Basic cuenta con la instrucción ChDrive. Por ejemplo,
suponga que desea cambiar a la unidad de disco “A”:

ChDrive “A:\”

) Establecer el directorio activo

También se puede establecer el directorio activo, con la instrucción ChDir:

ChDir directorio 'cambia directorio

Por ejemplo, si desea establecer “Mis documentos” como directorio activo:

ChDir “C:\Mis documentos”

) Crear y eliminar directorios

Los directorios o carpetas pueden ser creados y borrados mediante las siguientes
instrucciones. Para borrar un directorio, este debe ser previamente vaciado.

MkDir directorio 'crea directorio

RmDir directorio 'borra directorio

11 115
5
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

6.2.2. Instrucciones para manipular archivos

a) Abrir o crear archivos

11 116
6
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Para abrir o crear un archivo se utiliza la función Open con la sintaxis

siguiente:
Open archivo For tipo Access acceso As #NúmeroDeArchivo

El parámetro “archivo” es una cadena que representa la ruta y el nombre de

un archivo. “tipo” es una palabra reservada que indica el tipo de archivo a
abrir o crear, y el modo de apertura, según la tabla siguiente. El “acceso” se
refiere al tipo de acceso; es decir, el tipo de operaciones que se puede
efectuar sobre el archivo: lectura (Read), escritura (Write), y lectura-escritura
(ReadWrite). Cuando se abre o crea un archivo, este se identifica en el sistema
mediante un número entero, este número es el parámetro “NúmeroDeArchivo”
precedido por el signo #.
Tipo Descripción
Append Abre o crea un archivo de texto para agregarle información.
Input Abre un archivo de texto para lectura. Si el archivo no existe, se produce un error.
Output Crea un archivo de texto. Si el archivo existe, este se borra para dar lugar al nuevo.
Random Abre o crea un archivo de acceso aleatorio. Archivo directo a registros de longitud fija.
Binary Abre o crea un archivo binario. Archivo de longitud variable por registro.

Tabla 6.1.- Especificaciones del parámetro “Tipo” de la instrucción Open

b) Cerrar archivos abiertos

Una vez que se han abierto archivos con la función Open, estos se pueden
cerrar mediante la instrucción Close.

Close #5 'Cierra el archivo abierto número 5

Close 'Cierra todos los archivos
abiertos

c) Copiar archivos
Para copiar un archivo, este debe estar cerrado. La instrucción es FileCopy:

FileCopy archivo_origen, archivo_destino

Para copiar el archivo “Carta.doc” desde la unidad “A:\” hasta “Mis

documentos” en la unidad “C:\” con el nombre de “Pedido.doc”, se utilizaría el
siguiente código:

FileCopy “A:\Carta.doc”, “C:\Mis documentos\Pedido.doc”

Los comodines dispuestos inicialmente por el sistema operativo MSDOS, como

el asterisco y el signo de interrogación, mantienen vigencia en Microsoft
Windows, y se pueden utilizar desde Visual Basic. Estos comodines definen un
patrón de búsqueda que facilita la operación por lotes sobre un conjunto de
archivos. El asterisco indica la presencia o no de cualquier cantidad de caracteres
en el nombre de los archivos; y el signo de interrogación indica la presencia de
un caracter cualquiera obligatorio en una posición específica en el nombre del
archivo. Por ejemplo, suponga que desea copiar todos los archivos
.doc que comiencen con las letras “Car” desde la unidad “A:\” hasta la carpeta
““C:\Mis documentos”:
11 117
7
FileCopy “A:\Car*.doc”, “C:\Mis documentos\”
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

De esta manera se copiarán los archivos “Carta.doc”, “Carros.doc”,

“Cariño.doc”,…
FileCopy “A:\C?????.*”, “C:\Mis documentos\”

Así sólo se copiarían los archivos “Carros.doc” y “Cariño.doc. Además podrían

copiarse “Cremas.xls” o “Comida.ppt”, ya que la extensión es un asterisco.
) Renombrar archivos
También es posible cambiar el nombre de un archivo utilizando el siguiente
código:

Name nombre_viejo As nombre_nuevo

Por ejemplo, para cambiar el nombre de “Carta.doc” en la unidad “A:\” por

“Pedido.doc”, la instrucción se utilizaría de la siguiente manera:

Name “A:\Carta.doc” As “A:\Pedido.doc”

e) Borrar archivos
Finalmente, para eliminar o borrar un archivo existente del disco se utiliza Kill:

Kill nombre_archivo
Observación: Las instrucciones para copiar, renombrar y eliminar archivos, se deben
aplicar solamente a archivos cerrados; de lo contrario, se produce un error.

6.3. Funciones de archivos

6.3.1. Funciones para manipular directorios
a) Contenido de un directorio
Para ver el primer archivo contenido en un directorio se puede usar la función
Dir:
Archivo = Dir(ruta)

El parámetro “ruta” es una cadena que especifica la unidad y el directorio cuyo

contenido desea listar o examinar. La función Dir devuelve una cadena con el
nombre del archivo encontrado según la ruta especificada. Si en la ruta
especificada no se encuentran archivos, la función Dir devuelve una cadena
vacía. Para listar todo el contenido de un directorio, se utiliza la función Dir, pero
sin el parámetro de “ruta”. Por ejemplo, si se desea listar los archivos con
extensión .txt que se encuentran en el directorio “C:\Mis documentos” en una
caja de lista lstArchivo, se pueden usar las siguientes líneas de código en
algún procedimiento:
Dim Archivo As String
Archivo = Dir(“C:\Mis documentos\*.txt”)

11 118
8
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Do While Archivo <> “”

Me.lstArchivo.AddItem Archivo
Archivo = Dir
Loop

11 119
9
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Observación: La función Dir se usa sin argumentos para repetirse con la última
ruta especificada.
b) Directorio activo
Como vimos anteriormente, la unidad y el directorio activo se establecen
mediante las instrucciones ChDrive y ChDir. Es posible visualizar el directorio
activo de una unidad con la función CurDir según la siguiente sintaxis:

Dim Directorio As String

Directorio = CurDir(“D:\”)

6.3.2. Funciones de archivos cerrados

a) Tamaño de un archivo cerrado
La función FileLen devuelve el tamaño en bytes de un archivo. El valor
devuelto es tipo Long. El nombre del archivo es un parámetro tipo cadena de
caracteres que podría incluir la ruta del archivo. Por ejemplo se puede conocer
el tamaño del archivo Win.ini mediante la siguiente instrucción:

Tamaño = FileLen(archivo)
Dim Tamaño As Long
Tamaño = FileLen(“C:\Windows\Win.ini”)

) Número disponible de archivo

Si se intenta abrir un archivo especificando un número ya utilizado por otro
archivo abierto, se producirá un error. La función FreeFile permite obtener el
próximo número de archivo disponible, y así se evita el error en tiempo de
ejecución.

Dim NúmeroDeArchivo As Integer

NúmeroDeArchivo = FreeFile

6.3.3. Funciones de archivos abiertos

a) Tamaño de un archivo abierto
Una vez que se ha abierto un archivo, no es posible utilizar FileLen para
determinar el tamaño del archivo, ya que sólo se puede hacer referencia a
este mediante un número de archivo. Visual Basic proporciona la función LOF
para determinar el tamaño de un archivo abierto y se usa de la siguiente manera:

Dim Tamaño As Long

Tamaño = LOF(NúmeroDeArchivo)

En archivos de acceso aleatorio, donde la longitud de los registros es fija, la

función LOF permite recalcular la cantidad de registros dentro del archivo cada
vez que se agregan o eliminan registros.

CantidadDeReg = LOF(NúmeroDeArchivo) / LongitudDeUnReg

b) Indicador de final de archivo

12 120
0
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

La función EOF devuelve un valor lógico True si el puntero se encuentra al

final del archivo. El puntero es la posición de lectura o escritura dentro del
archivo. Al abrir un archivo, el puntero se ubica al principio del archivo; luego,

12 121
1
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

debido a instrucciones de lectura o escritura, se desplaza a lo largo del mismo,

y la función (EOF) nos indica si se ha alcanzado la posición del registro final. Esta
función es muy útil para efectuar la lectura completa de un archivo, ya que
es la condición que se evalúa para detener el ciclo de instrucciones de lectura.
Dim FinDeArchivo As Boolean
FinDeArchivo = EOF(NúmeroDeArchivo)

6.4. Objetos de archivos

6.4.1. Caja de lista de archivos (Clase: FileListBox)
El control FileListBox encuentra y muestra los archivos contenidos en un directorio
determinado en tiempo de ejecución, mediante una lista de los archivos
seleccionados por atributo o patrón. Mencionaremos algunas de las propiedades y
eventos más importantes de este objeto.
La propiedad FileName devuelve el nombre del archivo seleccionado de la caja de
lista de archivos. La propiedad Path determina la ruta (unidad y directorio) de los
archivos que se muestran. Se dispone de las propiedades List, ListIndex,
ListCount, etc., de las cajas de lista estudiadas anteriormente. Además se cuenta con
propiedades Booleanas que funcionan como un filtro, y determinan si se muestran o
no los archivos según su atributo, como son: Archive (Modificado), Hidden (Oculto),
Normal (Normal), ReadOnly (Sólo Lectura), y System (del Sistema). Otra de las
propiedades de las cajas de lista de archivos, es la propiedad Pattern, que define el
patrón de búsqueda. Si la propiedad Pattern se establece, por ejemplo a “*.doc”
o “*.txt”, en la caja de lista sólo se mostrarán los archivos de documento o los
archivos de texto. Inicialmente Pattern es igual a “*.*”, permitiendo que se muestren
todos los archivos. Al producir un Click en la lista, se selecciona uno de sus elementos
de la lista, el cual se corresponde con un archivo. El nombre del archivo seleccionado
se puede capturar mediante la propiedad FileName. También son importantes los
eventos PathChanged y PatternChanged. Estos dos últimos se ejecutan al cambiar
respectivamente la ruta y el patrón de búsqueda.
6.4.2. Caja de lista de directorio (Clase: DirListBox)
La caja de lista de directorio muestra los directorios y subdirectorios de una unidad
determinada en forma de árbol de jerarquía. La propiedad Path se refiere al
nombre del directorio seleccionado en la caja de lista. Están disponibles las
propiedades de cajas de lista convencionales List, ListIndex, ListCount, etc. El evento
Change es utilizado para actualizar el contenido de la caja de lista de archivos
mediante su propiedad Path.

Private Sub DirListBox1_Change()

Me.FileListBox1.Path = Me.DirListBox1.Path
End Sub

6.4.3. Caja de lista de unidades (Clase: DriveListBox)

El control gráfico muestra y permite seleccionar la unidad de disco activa. La
propiedad Drive de este control determina la unidad de disco. Se pueden
manipular las propiedades de cajas de lista List, ListIndex, ListCount, etc. El

12 122
2
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

evento Change es utilizado para actualizar el contenido de las cajas de lista de

directorio al establecer su propiedad Path.

Private Sub DriveListBox1_Change()

Me.DirListBox1.Path = Me.DriveListBox1.Drive
End Sub

En la figura siguiente se muestran los tres controles de archivo para acceder a las
unidades de almacenamiento secundario.

DriveListBox

FileListBox

DirListBox

Figura 6.4.- Objetos de archivos.

6.4.4. Cuadro de diálogo común (Clase: CommonDialog)

El control ActiveX de la clase CommonDialog proporciona un conjunto de cuadros

de diálogo estándar para realizar operaciones como abrir y guardar archivos,
establecer las opciones de impresión y seleccionar colores y fuentes. Este diálogo
común proporciona una interfaz entre Visual Basic y las funciones de la biblioteca
de vínculos dinámicos Commdlg.dll de Microsoft Windows. Para crear un cuadro de
diálogo utilizando este control, el archivo commdlg.dll debe encontrarse en el
directorio SYSTEM de Microsoft Windows.
a) Insertar el objeto CommonDialog
Para usar el control CommonDialog en una aplicación, previamente se debe
agregar a la caja de herramientas. Esto se puede hacer seleccionando el menú
“Proyecto | Componentes” o presionando “Ctrl+T”. De esta manera aparece el
cuadro de diálogo “Componentes”, donde se debe activar la casilla
correspondiente a “Microsoft Common Dialog Control 6.0“ (ver Figura 6.5).
El Common Dialog no tiene representación gráfica en tiempo de diseño, ya
que sólo aparece en tiempo de ejecución mediante métodos que veremos mas
adelante.

12 123
3
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Figura 6.5.- Diálogo Componentes (Control Diálogo Común)

b) Propiedades del diálogo común

Propiedad Descripción
CancelError Si genera o no un error al usuario presionar el botón Cancelar.
DefaultExt Extensión predeterminada de nombre de archivo.
DialogTitle Título del cuadro de diálogo.
FileName Nombre y ruta del archivo seleccionado que se va a abrir o guardar.
FileTitle Nombre (sin la ruta) del archivo seleccionado que se va a abrir o guardar.
Filter Filtros presentados en el cuadro de lista “Tipo” de un cuadro de diálogo.
Flags Opciones para mostrar u ocultar elementos del cuadro de diálogo.
InitDir Ruta inicial de ubicación de los archivos.
MaxFileSize Tamaño máximo del nombre de archivo abierto mediante el control.
Tabla 6.2.- Propiedades del objeto Diálogo Común

En tiempo de ejecución, cuando el usuario elige un archivo, la propiedad

FileName se utiliza para obtener el nombre de archivo seleccionado. Se puede
establecer la propiedad Filter de forma que el cuadro de diálogo presente sólo
ciertos tipos de archivos. Filter es una cadena de caracteres con la sintaxis
siguiente:
"descripción1 |filtro1 |descripción2 |filtro2..."

Por ejemplo, para mostrar sólo archivos de texto .txt, y de imágenes .bmp e
.ico:
"Archivos de texto |*.txt |Imágenes e iconos |*.bmp;*.ico"

12 124
4
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

La propiedad Flags se puede usar para cambiar varios elementos del cuadro
de diálogo, así como para avisar al usuario cuando pueden producirse ciertas
situaciones, tal como la escritura en un archivo existente, o la apertura de uno

12 125
5
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

inexistente. A continuación se muestran algunos de los valores que puede

adoptar la propiedad Flags (ver Tabla 6.3).
Constante
cdlOFNReadOnly
cdlOFNOverwritePrompt
cdlOFNHideReadOnly
cdlOFNNoChangeDir
cdlOFNHelpButton
cdlOFNAllowMultiselect
cdlOFNPathMustExist
cdlOFNFileMustExist
cdlOFNCreatePrompt
cdlOFNNoReadOnlyReturn
cdlOFNExplorer
Descripción
Hace que la casilla de verificación Sólo lectura esté activada
inicialmente.
El diálogo Guardar como, genera un mensajes si el archivo ya existe.
Oculta la casilla de verificación Sólo lectura.
Restablece como directorio al que lo era en el momento de abrirse el
diálogo.
Hace que el cuadro de diálogo presente el botón Ayuda.
El cuadro de lista Nombre de archivo permite varias selecciones.
Sólo se pueden escribir rutas de acceso válidas o existentes.
Sólo puede introducir nombres de archivos existentes.
El cuadro de diálogo requiere la creación de un archivo que no exista.
El archivo devuelto no tendrá establecido el atributo de Sólo lectura.
Usa la plantilla del cuadro de diálogo Abrir archivo de tipo Explorador.

Tabla 6.3.- Valores de la propiedad Flags.

c) Métodos de diálogos común

El tipo de cuadro de diálogo presentado está determinado por el tipo de

método del objeto. En tiempo de ejecución se presenta un cuadro de diálogo,
cuando se invoca el método apropiado; en tiempo de diseño, el control
CommonDialog se presenta como un icono dentro del formulario. El
CommonDialog puede presentar distintos cuadros de diálogo utilizando los
siguientes métodos.
Método Cuadro de diálogo presentado
ShowOpen Abrir
ShowSave Guardar como
ShowColor Color
ShowFont Fuente
ShowPrinter Imprimir u Opciones de impresión
ShowHelp Invoca el motor de Ayuda de Windows
Tabla 6.4.- Métodos del objeto Diálogo Común.

En el siguiente ejemplo, se muestra como se invoca el cuadro de diálogo Abrir.

Private Sub cmdBotón_Click()
Dim Archivo As String, Dim NúmeroDeArchivo As Integer
Me.Diálogo.CancelError = False
Me.Diálogo.Filter = "Office|*.doc;*.xls;*.ppt"
Me.Diálogo.Flags = cdlOFNHideReadOnly
Me.Diálogo.ShowOpen
Archivo = Me.Diálogo.FileName
If Archivo <> “” Then
NúmeroDeArchivo = FreeFile
Open Archivo For Output As #NúmeroDeArchivo
End If
End Sub

12 126
6
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

6.5. Archivos secuenciales

6.5.1. Abrir archivos secuenciales
Los archivos secuenciales se pueden abrir de tres maneras, según el parámetro “tipo”
de Open, y para archivos secuenciales puede ser Input, Output o Append. (1)
Input se usa para abrir archivos existentes, a ser leídos, en el sistema. Si el archivo
que intenta abrir no existe, se produce un error en tiempo de ejecución. (2) Output
es para crear archivos nuevos en el sistema a ser escritos. Es exclusivo para crear
e ingresar datos a archivos nuevos. Si el archivo existe, este se sobrescribe.
(3) Append se usa para abrir archivos existentes o no en el sistema con el objeto
de agregarle información sin sobrescribirlos. Si el archivo a abrir no existe, se crea
como archivo nuevo; pero si existe, sólo se abre y se dispone para añadirle más
datos de los que posee.
6.5.2. Leer archivos secuenciales
Para leer archivos secuenciales, estos se deben abrir utilizando el parámetro Input
de la instrucción Open. La información de los archivos secuenciales se puede leer
por línea o por campos separados por coma. Para leer una línea completa se usa
la instrucción “Line Input”, y para leer campos separados por coma se usa la
instrucción “Input”.

Private Sub cmdBotón_Click()

Dim Línea As String
Open "A:\Estados.txt" For Input As #1
Do While Not EOF(1)
Line Input #1, Línea
txtMiCaja.Text = txtMiCaja.Text & chr(13) & Línea
Loop
Close #1
End Sub

Ahora suponga que el archivo de texto “Estados.txt” contiene los estados de

Venezuela y sus códigos de área separados por coma: Caracas, 0212, Valencia,
0241, Lara, 0251, etc. A continuación, se abre el archivo y se muestran los estados
de Venezuela y sus códigos de área en las cajas de lista lstEstado y lstCódigo.

Private Sub cmdBotón_Click()

Dim ElEstado, ElCódigo As String
Open "A:\Estados.txt" For Input As #2
Do While Not EOF(2)
Input #2, ElEstado, ElCódigo
lstEstado.AddItem ElEstado
lstCódigo.AddItem ElCódigo
Loop
Close #2
End Sub

6.5.3. Escribir en archivos secuenciales

Para escribir en archivos secuenciales se utilizan como parámetros de “tipo” de la
instrucción Open los valores Output o Append. Existen dos métodos para ingresar

12 127
7
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

información en archivos secuenciales. Se pueden ingresar cadenas por línea del

archivo con la función “Print”; o por campos separados por coma mediante la

12 128
8
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

función “Write”. El ejemplo a continuación muestra el uso de la función “Print”

para agregar el contenido de tres cajas de texto del arreglo txtMiCaja al archivo de
texto “Estados.txt”.
Private Sub cmdBoton_Click()
Open "A:\Estados.txt" For Append As #2
Print #2, txtMiCaja(0).Text
Print #2, txtMiCaja(1).Text; txt.MiCaja(2).Text
Close #2
End Sub

Suponiendo que txtMiCaja (0) contiene “Carabobo”, txtMiCaja (1) contiene “0241”
y txtMiCaja (2) contiene “Valencia”; la forma como se almacenan es:
Carabobo
0241
Valencia

Como se observa, Print dispone de una línea completa por cada campo. Si usamos
la Instrucción “Write”, tanto la sintaxis como el resultado son diferentes. Los
campos se separan con comas, y no se usa punto y coma, como en el caso de
Print.
Private Sub cmdBotón_Click()
Open "A:\Estados.txt" For Append As #3
Write #3, txtDato(0).Text
Write #3, txtDato(1).Text, txtDato(2).Text
Close #3
End Sub

A continuación observe que cada campo se enmarca entre comillas

automáticamente. Además cada instrucción Write produce un salto de línea en el
archivo, a menos que los campos se separen con coma.

“Carabobo”
“0241”, “Valencia”

Para que todos los campos queden en una sola línea se debe escribir la
instrucción:
Write #3, txtDato(0).Text, txtDato(1).Text, txtDato(2).Text

Observación: La instrucción Line Input se utiliza para leer un archivo que se ha escrito
con la instrucción Print. Por otra parte, la instrucción Input se utiliza para
leer un archivo que se ha escrito con la instrucción Write.

6.6. Archivos aleatorios

6.6.1. Abrir archivos aleatorios
Para abrir archivos de acceso aleatorio el parámetro tipo de la instrucción Open debe
establecerse a Random, aunque previamente se deben tener en cuenta ciertas
consideraciones. Cada registro posee una estructura que se le confiere mediante un

12 129
9
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

tipo de dato definido por el usuario. En la unidad 4 se estudiaron los tipos de datos
provistos por el sistema. Resulta obligatoria para archivos directos

13 130
0
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

la definición de tipos de datos que le confieran una estructura. De esta manera se

establece una serie de pasos para crear o abrir archivos aleatorios. Se desarrollará,
como ejemplo, un archivo para almacenar los estados, código de área telefónicos y
las capitales de un país.
a) Crear la estructura del registro
El código para crear tipos de datos personalizados, por lo general, se escribe
en la sección declaraciones de cualquier módulo, según el alcance que desee
el analista. La palabra reservada para definir tipos de datos es Type, la cual
puede ser pública o privada. Para los archivos directos es fundamental definir
un tamaño específico para los registros el cual debe ser menor a 32767. Por lo
tanto, en la definición de tipo de dato, las cadenas de caracteres deben ser de
longitud fija.
Private Type T_Estado
Nombre As String * 15
CódigoDeArea As String * 4
Capital As String * 20
End Type

Observación: Por simple regla de Visual Basic, se acostumbra a comenzar el nombre

del tipo de datos con la letra T mayúscula
b) Declarar las variables de registro
La variable de registro representa una colección de cada uno de los campos
que conforman al registro. Esta se declara de la misma manera como se
estudió en la unidad 4, y se recomienda escoger la sección declaraciones,
siempre posterior a la declaración Type. Para tener control del archivo, es
necesario declarar otras variables para conocer la longitud de cada registro y
la cantidad de registros almacenados en el archivo.
Dim Estado As T_Estado 'Variable de registro
Dim Longitud As Integer 'Longitud de un registro
Dim Registros As Long 'Cantidad de registros

c) Determinar la longitud de cada registro y abrir el archivo

Se recomienda utilizar el evento Load del objeto Form para efectuar es paso, y
de esta manera el archivo se abre desde el principio de la aplicación; aunque
se puede escoger cualquier otro evento y objeto del proyecto. Para calcular la
longitud del registro se utiliza la función Len, y para el tamaño del archivo se
utiliza LOF.

Private Sub Form_Load()

Longitud = Len(Estado)
Open “A:\Estados.dat” For Random As #1 Len = Longitud
Registros = LOF(1) / Longitud
End Sub

6.6.2. Leer registros de archivos aleatorios

13 131
1
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

La operación de lectura requiere que se especifique la posición de lectura dentro

del archivo, para lo cual se utiliza una variable para la posición en la instrucción
Get: La operación de lectura consiste en: (1) Leer una posición específica para la

13 132
2
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

variable de registro, y (2) Operar cada uno de los campos de la variable de

registro. El siguiente procedimiento general, donde la variable “Posición” ha sido
declarada previamente, Lee un registro y lo muestra en cajas de texto.
Public Sub Leer()
Get #1, Posición, Estado
txtMicaja(0).Text = Estado.Nombre
txtMicaja(1).Text = Estado.CódigoDeArea
txtMicaja(2).Text = Estado.Capital
End Sub

6.6.3. Escribir registros en archivos directos

Para colocar información en el archivo directo se usa la instrucción Put. Así como
para la operación de lectura, la escritura también requiere la especificación de la
posición. La operación de escritura consiste en: (1) Cargar cada uno de los campos
de la variable de registro, y (2) Escribir la variable de registro en una posición
específica. El siguiente procedimiento permite almacenar el contenido de las cajas
de texto txtMiCaja.
Public Sub Escribir()
Estado.Nombre = txtMicaja(0).Text
Estado.CódigoDeArea = txtMicaja(1).Text
Estado.Capital = txtMicaja(2).Text
Put #1, Posición, Estado
End Sub

6.6.4. Localizar una posición de registro

Si no se especifica la posición en la instrucción Get; el sistema lee el registro
activo. Al abrir un archivo, la posición inicial es 1 (principio del archivo), y esta se
va incrementando automáticamente cada vez que se efectúa una lectura.
Get #1, , Estado 'Lee el registro activo
Put #1, , Estado 'Escribe al final del archivo

El apuntador se puede llevar a una posición específica dentro del archivo de

acceso aleatorio mediante la instrucción Seek. Para ubicar el cuarto registro,
escribimos:
Seek #1, 4
Observación: Si no se especifica una posición en la instrucción de escritura Put, el
registro siempre se escribe al final del archivo, a pesar de efectuar
previamente un Seek.
6.6.5. Tareas comunes de archivos aleatorios
a) Avanzar registros
Private Sub cmdAvanzar()
If Posición < Registros Then I = 1 Else I = 0
Posición = Posición + I
If Posición = Registros Then cmdAvanzar.Enabled = False
If Registros > 1 Then cmdRetroceder.Enabled = True

13 133
3
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Leer
End Sub

13 134
4
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

b) Retroceder registros
Private Sub cmdRetroceder()
If Posición > 1 Then I = 1 Else I = 0
Posición = Posición – I
If Posición = 1 Then cmdRetroceder.Enabled = False
If Registros > 1 Then cmdAvanzar.Enabled = True
Leer
End Sub

) Buscar un registro
Private Sub Buscar(ByVal Buscado As String)
Dim I As Long
For I = 1 To Registros + 1
Get #1, I, Estado
If Trim(Estado.Nombre) Like Buscado + “*” Then Exit For
Next I
If I > Registros Then 'No se encontró
txtMicaja(0).Text = “”
txtMicaja(1).Text = “”
txtMicaja(2).Text = “”
Else 'Si se encontró
txtMicaja(0).Text = Estado.Nombre
txtMicaja(1).Text = Estado.CódigoDeArea
txtMicaja(2).Text = Estado.Capital
End If
End Sub

) Eliminar un registro
Private Sub Buscar(ByVal Buscado As String)
Dim I As Long
Estado.Nombre = “”
Put #1, Posición, Estado
Open “Temporal.tmp” For Random As #2 Len = Len(Estado)
For I = 1 To Registros
Get #1, I, Estado
If Trim(Estado.Nombre) <> “” Then Put #2, , Estado
Next I
Close #1, #2
Kill “A:\Estados.dat”
Name “A:\Temporal.tmp” As “A:\Estados.dat”
Open “A:\Estados.dat” For Random As #1 Len = Len(Estado)
Posición = Posición – 1
cmdAvanzar
End Sub

En resumen, el código anterior para eliminar un registro de un archivo, sigue

el siguiente procedimiento:
Hacer blanco uno de los campos del registro a eliminar.
Crear un archivo temporal

13 135
5
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Agregar todos los registros, excepto los blancos, al archivo temporal.

13 136
6
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
6.- Archivos
6.- Archivos

Cerrar los dos archivos.

Eliminar el archivo original
Renombrar el archivo temporal para que se convierta en el original.
Volver a abrir el archivo original.
Retomar la posición del registro anterior al eliminado.
Ejecutar un avance para mostrar el registro siguiente al eliminado.

13 137
7
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Unidad 7

Bases de Datos

“Es prudente tener presente que ni el éxito ni el fracaso son definitivos”

.- Roger Babson

7.1. Introducción a Bases de Datos

7.1.1. Nociones básicas
Las bases de datos permiten almacenar y mantener una gran cantidad de
información de una manera bien organizada, de forma que sea posible devolver dicha
información rápidamente. La estructura que trataremos es la de bases de datos
relacionales, en la que se concibe una base de datos como un espacio de trabajo
(WorkSpace) donde coexisten y se relacionan varios conjuntos de datos llamadas
tablas, las cuales contienen filas, columnas e índices.
a) Las Tablas son conjuntos de datos del mismo tema. Por ejemplo, Clientes,
Proveedores, Ventas, Compras y Productos, son temas que se agrupan en
tablas de una base de datos administrativa.
b) Las Columnas son los Campos que representan características del tema de una
tabla. Por ejemplo, de la tabla Productos se tienen los campos o características
siguientes: Código, Descripción, Serial, Precio, Existencia, etc.
c) Las Filas representan el registro en sí; es decir, un elemento de la tabla con
todas sus características. Por ejemplo, un elemento de la tabla Productos
sería: Monitor Compaq, serial 1102212221987, precio 215.000 Bs. y existencia
14.
d) Finalmente, los Índices son números enteros en un campo especial auto-
numérico de la tabla y se utilizan para acceder rápidamente a un registro en
una base de datos relacional, ordenar los registros y permitir las relaciones
entre varias tablas. El campo de una tabla A puede requerir los datos de otra
tabla B, y según el concepto de bases de datos relacional, el índice funciona
como un apuntador o valor en la tabla A que hace referencia a un registro
(fila) de la tabla B.

13 138
8
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.1.- Tabla “Productos” de una base de datos.

7.1.2. Arquitectura de bases de datos

Básicamente los datos de una base de datos se almacenan en un archivo de disco

local o remoto, y se conoce como la fuente u origen de datos (DataSource). Como
se observa en la figura siguiente, las peticiones de servicios, de parte del usuario o
una aplicación externa, no se realizan directamente sobre el origen de datos, sino
que existe un motor de administración de la base de datos.

Interfaz
de
Usuario

Motor de
Base de
Datos

Origen de
Datos

Figura 7.2.- Arquitectura de Bases de Datos

En la figura anterior se pueden apreciar las peticiones mediante las flechas

gruesas en el sentido hacia el origen de datos. Este motor de base de datos es
una librería de funciones, las cuales ejecutan las operaciones necesarias sobre el
origen de datos para responder a las solicitudes de servicio. Las librerías de funciones
son archivos con extensión DLL o EXE, y no existen exclusivamente para el manejo
de bases de datos; por el contrario, el sistema Windows se basa justamente en
librerías de funciones, o DLL (Dynamic Link Library) como comúnmente se les
nombra. La interfaz de usuario se define como la aplicación para presentar y
actualizar los registros de una base de datos, para lo cual debe interactuar con el
motor de base de datos. Los programas que integran a estos tres elementos
fundamentales se conocen como Sistemas de Administración de Bases de Datos
(DBSM), como lo son Microsoft Access, SQL Server, Oracle, Fox Pro, Clipper,
Dbase, Paradox, etc.
7.1.3. Tecnologías de bases de datos
Cada tipo de base de datos posee un motor diferente; es decir, un conjunto diferente
de funciones, sólo compatibles con un origen de datos en particular. Los motores de
bases de datos constan de (1) Proveedores de datos, que contienen y exponen los

13 139
9
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

datos; (2) Clientes de datos, que utilizan los datos; y (3) Componentes de
servicio, que procesan y transportan datos. Visual Basic, como lenguaje de
programación, permite crear las aplicaciones de usuario; pero carece

14 140
0
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

de un motor de base de datos intrínseco, por lo que no se considera un manejador

de bases de datos (DBSM). De esta manera, se han diseñado tecnologías de
acceso a datos para la administración de bases de datos desde aplicaciones de Visual
Basic. Estas tecnologías incluyen:
a) Interfaces para orígenes de datos
Visual Basic debe acceder a los motores de bases de datos apropiados según
los orígenes de datos que el usuario desee manipular; es así como dispone de
diversos proveedores de datos basados en una tecnología llamada OLE DB
(OLE Data Base). OLE DB define una colección de interfaces que encapsulan
varios servicios de los sistemas de administración de bases de datos (DBMS).
Estas interfaces permiten crear componentes de software que implementen
dichos servicios. Los clientes obtienen acceso a un objeto a través de
interfaces implementadas en el objeto. Existe un servidor OLE DB por cada
tipo de origen de datos.
b) Modelos de objetos de bases a datos
La variedad y complejidad de las interfaces OLE DB no permite el acceso
directo desde Visual Basic. En vez de esto, existen tecnologías intermedias, entre
OLE DB y Visual Basic, destinadas a ofrecer modelos de objetos de acceso
a datos que encapsulan y exponen prácticamente toda la funcionalidad de OLE
DB a las aplicaciones; de esta manera, se logra uniformidad en las tareas de
programación sin importar el tipo de servidor o proveedor OLE DB. En Visual
Basic existen tres modelos de objetos, los cuales proveen un conjunto de
objetos y mecanismos necesarios en la conexión con la base de datos a través
de OLE DB. El primer modelo de objetos fue implementado en la versión 3 de
Visual Basic y se conoce como DAO (Data Access Objects), el cual posee la gran
desventaja de no permitir el acceso a datos ubicados en servidores remotos, y
además está dedicado al motor Microsoft Jet que utiliza Access. Para responder
a estas limitaciones, en la versión siguiente de Visual Basic, se incluyó el modelo
RDO (Remote Data Objects) como una interfaz exclusiva para el acceso a datos
remotos. A partir de la versión 6, se comienza a utilizar el modelo ADO (ActiveX™
Data Objects), el cual encapsula la funcionalidad de las tecnologías DAO y
RDO, reduciendo la cantidad de objetos, propiedades, métodos y eventos.
Visual Basic
Origen de Datos 1
Proveedor 1
OLE DB Modelo Interfaz
Origen de Datos 2 de de
Proveedor 2 Objetos Usuario
OLE DB

Proveedor 3
Origen de Datos 3
OLE DB
Figura 7.3.- Acceso de Visual Basic a Bases de Datos

7.1.4. Proveedores OLE DB

Para Visual Basic están disponibles los proveedores de Microsoft OLE DB para los
siguientes tipos de bases de datos:

14 141
1
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

a) Microsoft Index Server

b) Microsoft Active Directory Service Interfaces (ADSI)

14 142
2
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

c) Microsoft SQL Server

d) Microsoft Jet (Microsoft Access)
e) Bases de datos de Oracle
f) Orígenes de datos ODBC (Open DataBase Connectivity)
Los orígenes de datos ODBC corresponden a bases de datos compatibles con la
tecnología ODBC. Esta tecnología permite el acceso a distintos tipos de bases de
datos adicionales a los que proporciona OLE DB. De esta manera se incrementa el
espectro de orígenes de datos que se pueden acceder desde Visual Basic.
Utilizando Microsoft OLE DB para ODBC es posible manipular datos provenientes
de: Dbase (*.dbf), Excel (*.xls), FoxPro (*.dbf), Visual Foxpro (*.dbf), Paradox
(*.db) y Archivos de texto separados por coma (*.csv). Aunque también es posible
acceder a datos de Microsoft Access, Microsoft SQL Server y Oracle mediante OLE
DB para ODBC, se recomienda utilizar el controlador correspondiente OLE DB Jet,
SQL y Oracle.
Convención: En adelante, para los ejemplos presentados en esta guía se ha escogido
el proveedor OLE DB para Microsoft Jet para manejar bases de datos de
Microsoft Access, y se utilizará ADO como modelo de objetos de acceso a
datos.
7.1.5. Lenguajes de bases de datos
El motor de base de datos ejecuta un conjunto de tareas sobre el origen de datos
mediante las funciones almacenadas en archivos DLL, las cuales son activadas desde
la interfaz de usuario. De esta manera, la interfaz de usuario debe proveer los
mecanismos necesarios para la configuración y puesta en marcha de la base de
datos. Los mecanismos antes mencionados, se agrupan o se clasifican en dos tipos
de lenguaje, según la respuesta del motor de base de datos al servicio solicitado.
a) Lenguaje de definición de datos (DDL):
El DDL consta de las propiedades y métodos utilizados para definir y crear la
propia base de datos, incluyendo sus tablas, campos, índices, relaciones, etc.
Este lenguaje agrupa a todas las instrucciones relacionadas al diseño de la
base de datos. DML incluye facilidades para consultar, actualizar, agregar y
eliminar tablas, campos, índices y relaciones.
b) Lenguaje de manipulación de datos (DML):
El DML consta de las propiedades y los métodos utilizados para escribir la sección
de las aplicaciones que tienen acceso a los registros de bases de datos existentes.
DML incluye facilidades para consultar, desplazar, actualizar, ordenar, agregar y
eliminar registros.
Atención: Esta clasificación no significa que existan dos lenguajes separados;
es simplemente una forma de agrupar los elementos del lenguaje
según su funcionalidad.

Las tareas de definición y configuración de las bases de datos, por lo general, se

realizan utilizando los respectivos DBMS; es decir, no se crean aplicaciones
destinadas a DDL aunque los lenguajes de programación, como Visual Basic, incluyan
esta facilidad. La razón de esta práctica radica en el hecho que los DBMS poseen las

14 143
3
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

herramientas más adecuada para el diseño de las bases de datos. Por otra parte, en
la mayoría de los casos el sistema de base de datos ya se encuentra instalado, y lo
que se requiere es la interfaz de usuario para acceder a los datos.

14 144
4
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Observación: En esta guía de estudio no se consideran los métodos y propiedades para

el diseño de bases de datos DDL, salvo algunos comandos SQL para el
manejo de tablas.
7.1.6. Modos de manipulación de registros
El lenguaje de manipulación de datos (DML) está relacionado con las operaciones
(modificar, agregar, guardar, eliminar, ordenar) sobre los registros de una base de
datos, y se puede aplicar de dos maneras según los siguientes modos.
a) Modo de desplazamiento
Basado en el movimiento a través de los registros de una tabla de la base de
datos; y donde las operaciones se efectúan sobre un solo registro, que se
corresponde al registro activo o seleccionado de la base de datos. Por
ejemplo; la operación eliminar, sólo eliminará al registro activo.
b) Modo relacional
Basado en el Lenguaje de Consulta Estructurado (SQL), donde las operaciones
pueden afectar a uno, varios o a todos los registros de una tabla de base de
datos, según una definición de parámetros de selección. Por ejemplo; se
pueden eliminar todos los registros de la tabla Productos cuyo campo
Existencia sea nulo, y esto sin necesidad de hacer activos todos los registros a
eliminar.

7.2. Objetos de acceso a datos ADO

7.2.1. Modelo de objetos de ADO
El modelo de objetos de ADO define una colección de objetos programables para
aprovechar la eficaz tecnología denominada OLE DB. Uno de los puntos fuertes de
ADO es que puede exponer y utilizar las propiedades únicas de cada proveedor de
datos. Independientemente del origen de datos utilizado, ADO es totalmente
flexible y adaptable a los requisitos de acceso a datos de su aplicación. El modelo
de objetos ADO, en su versión 2.0, consta de siete objetos y cuatro colecciones:
Connection
Objeto
Command
Properties Property
Colección
Parameters Parameter

Rercorset
Properties Property

Fields Field
Properties Property

Properties Property

Errors Error

Figura 7.4.- Modelo de objetos ADO.

14 145
5
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

a) Objeto Connection: Contiene información acerca de un proveedor de datos y la

su conexión, como el tipo de cursor, la cadena de conexión, el tiempo de

14 146
6
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

espera de la consulta, el tiempo de espera de la conexión y la base de datos

predeterminada.
b) Objeto Command: Contiene información acerca de un comando, como una
cadena de consulta, nombre de una tabla, una definición de parámetro y
otros. Puede ejecutar una cadena de comando en un objeto Connection de
una cadena de consulta como parte de la apertura de un objeto Recordset, sin
definir un objeto Command. El objeto Command es útil cuando desee definir
parámetros de consultas o ejecutar procedimientos almacenados que devuelva
parámetros de resultados. Los objetos Command admiten varias propiedades
para describir el tipo y el propósito de la consulta y para ayudar a ADO a
optimizar la operación.
c) Objeto Recordset: Contiene los registros devueltos por una tabla o consulta,
así como un cursor para dichos registros. Puede abrir un objeto Recordset (por
ejemplo, al realizar una consulta) sin abrir explícitamente un objeto
Connection. No obstante, si opta por crear un objeto Connection, puede abrir
múltiples objetos Recordset con la misma conexión.
d) Objeto Property: Contiene las características definidas por el proveedor de un
objeto ADO. Los objetos ADO tienen dos tipos de características: Integradas y
Dinámicas. Las propiedades integradas son las que están implementadas en ADO
y se encuentran disponibles para cualquier objeto nuevo de ADO. Las
propiedades dinámicas están definidas por el proveedor de datos subyacente y
aparecen en la colección Properties para el objeto de ADO apropiado. Por
ejemplo, una propiedad puede indicar si un objeto Recordset admite
transacciones o actualizaciones. Ésta es una de las principales características
de ADO, que permite al proveedor de servicios de ADO presentar interfaces
especiales. Cada uno de los objetos Connection, Command, Recordset y Field
tiene una colección Properties.
e) Objeto Error: Contiene información ampliada acerca de condiciones de error
producida por el proveedor de datos. Como una única instrucción puede
generar dos o más errores, la colección Errors puede contener más de un
objeto Error al mismo tiempo. La colección Errors está en el objeto
Connection.
f) Objeto Parameter: Es un parámetro individual asociado a un objeto Command.
El objeto Command utiliza la colección Parameters para que contenga a todos
sus objetos Parameter. Los objetos Parameter de ADO se pueden generar
automáticamente enviando consultas a la base de datos. Sin embargo,
también puede generar esta colección mediante programación para mejorar el
rendimiento en tiempo de ejecución.
g) Objeto Field: Contiene información acerca de una única columna de datos en
el conjunto de registros (Recordset). El objeto Recordset utiliza la colección Fields
para que contenga a todos sus objetos Field. Esta información de Field incluye
el tipo de datos, la precisión y la escala numérica.
7.2.2. El objeto Connection
Regla de Visual Basic de prefijo para nombre del objeto Connection: cnn.

14 147
7
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

a) Propiedades
Propiedad Descripción
ConnectionString Cadena que contiene la información que se utiliza para establecer una conexión a un

14 148
8
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Propiedad Descripción
origen de datos.
Provider Indica el nombre del proveedor de la base de datos en una conexión.
DefaultDatabase Indica el nombre de la base de datos predeterminada en una conexión.
Indica el intervalo de espera mientras se establece una conexión antes de que se genere
ConnectionTimeout
un error.
Establece o devuelve la posición de un motor de cursores. (AdUseNone, adUseClient,
CursorLocation adUseServer).
Indica los permisos disponibles para modificar datos en un objeto Connection. (Lectura,
Mode
escritura...).
State Indica el estado de la conexión: abierta, cerrada.
Tabla 7.1.- Propiedades del objeto Connection de ADO

La propiedad ConnectionString permite especificar un origen de datos

mediante una cadena de conexión detallada que contiene una serie de
expresiones (argumento = valor) separadas con punto y coma.
Dim C As Cadena
C=“Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\bd.mdb”

El argumento Provider especifica el nombre del proveedor que se usa en la

conexión, es decir, el motor de la base de datos y su versión. El argumento
DataSource se refiere a la ruta y nombre de la base de datos que se desea
acceder.
También se puede especificar sólo al proveedor mediante la propiedad
Provider; o sólo el nombre de la base de datos mediante la propiedad
DefaultDatabase.
Las opciones de la propiedad CursorLocation se describen en la tabla
siguiente:
Opción Descripción
adUseNone No se usan servicios de cursor.
adUseClient Usa cursores del lado del cliente suministrados por una biblioteca de cursores locales.
Predeterminado. Usa cursores suministrados por el controlador o por el proveedor de
adUseServer
datos.
Tabla 7.2.- Opciones de la propiedad CursorLocation.

El valor de la propiedad CursorLocation afecta solamente a las conexiones

establecidas después de que se haya establecido la propiedad. Los cambios en
la propiedad CursorLocation no afectan a las conexiones existentes. Se
recomienda utilizar la opción adUseClient si se esta trabajando con una base
de datos local.
b) Métodos
Propiedad Descripción
Open Abre una conexión a un origen de datos.
Ejecuta una consulta, instrucción SQL, procedimiento almacenado o texto específico del
Execute
proveedor.
Close Cierra un objeto de conexión a un origen de datos y los objetos dependientes.
Cancel Cancela la ejecución de una llamada asíncrona pendiente a un método Execute u Open.
Tabla 7.3.- Métodos del objeto Connection de ADO

14 149
9
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

El método Open sólo establece una conexión física con la base de datos, para
lo cual requiere el establecimiento de las propiedades ConnectionString,
ConnectionTimeout y CursorLocation. La propiedad ConnectionTimeout esta

15 150
0
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

predefinida en 15 segundos, por lo tanto, algunas veces no es necesario

establecer. El método Execute puede o no devolver filas. En el caso que devuelva
filas (registros), el valor devuelto es una referencia a un objeto Recordset.
7.2.3. El objeto Recordset
Regla de Visual Basic de prefijo para nombre del objeto Recordset: rst.

a) Propiedades
Propiedad Descripción
AbsolutePosition Especifica la posición ordinal del registro actual.
ActiveConnection Indica a qué objeto Connection pertenece actualmente el objeto.
BOF Indica que la posición del registro actual está antes del primer registro.
EOF Indica que la posición del registro actual está después del último registro.
CursorLocation Establece o devuelve la posición de un motor de cursores.
CursorType Indica el tipo de cursor que se usa en el objeto.
EditMode Indica el estado de modificación del registro actual.
Filter Indica un filtro para los datos del conjunto de registros.
LockType Indica el tipo de bloqueo que se pone en los registros durante el proceso de edición.
RecordCount Indica el número actual de registros del objeto.
Indica el origen de los datos (una instrucción SQL, un nombre de tabla o un
Source
procedimiento almacenado).
State Describe el estado del objeto: abierto o cerrado.
Indica el estado del registro actual referente a las actualizaciones por lotes u otras
Status
operaciones masivas.
Tabla 7.4.- Propiedades del objeto Recordset de ADO

La propiedad CursorLocation del Recordset es heredada del objeto Connection,

aunque se puede cambiar en el objeto Recordset. Use la propiedad
CursorType para especificar el tipo de cursor que se debe utilizar al abrir el objeto
Recordset. La propiedad CursorType es de lectura/escritura cuando el Recordset
está cerrado y de sólo lectura cuando está abierto. CursorType especifica los
desplazamientos permitidos a través del conjunto de registros (ver Tabla 7.5)
Opción Descripción
Predeterminado. Sólo permite desplazarse hacia delante en los registros. Esto mejora el
adOpenForwardOnly
rendimiento en situaciones en las que sólo se quiere pasar una vez por cada registro.
Son inaccesibles los registros que agregan o eliminan otros usuarios. Los cambios que
adOpenKeyset otros usuarios hacen en los datos permanecen visibles. Se admiten todo tipo de
movimientos entre registros.
Las incorporaciones, cambios y eliminaciones que hacen otros usuarios permanecen
adOpenDynamic
visibles, y se admiten todo tipo de movimientos entre registros.
Una copia estática de un conjunto de registros que se puede usar para buscar datos o
adOpenStatic generar informes. Las incorporaciones, cambios o eliminaciones que hacen otros
usuarios no son visibles.
Tabla 7.5.- Opciones de la propiedad CursorType

La propiedad LockType se establece antes de abrir un Recordset para especificar

qué tipo de bloqueo debe usar el proveedor al abrirlo. LockType es de
lectura/escritura cuando el Recordset está cerrado y de sólo lectura cuando está
abierto. Los tipos de bloqueo se especifican en la tabla siguiente.
Valor de LockType Descripción
adLockReadOnly Predeterminado. Sólo lectura—no puede modificar los datos.

15 151
1
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Valor de LockType Descripción

Bloqueo pesimista, registro a registro: el proveedor hace lo necesario para asegurar
adLockPessimistic la modificación correcta de los registros, generalmente bloqueando registros en el
origen de datos.
Bloqueo optimista, registro a registro: el proveedor usa bloqueo optimista,
adLockOptimistic
bloqueando registros sólo cuando llama al método Update.
Actualizaciones optimistas por lotes: requerido para el modo de actualización por
adLockBatchOptimistic
lotes como contraposición al modo de actualización inmediata.
Tabla 7.6.- Opciones de la propiedad LockType

La propiedad EditMode se puede usar evaluar el estado de edición de un registro,

y así determinar la ejecución o no de acciones de guardado de registros.
EditMode puede tener uno de los siguientes valores:
Devuelve Descripción
Indica que no hay ninguna operación de modificación en ejecución sobre el registro
adEditNone actual.
Indica que los datos del registro actual se han modificado pero que no se han guardado
adEditInProgress
aún.
Indica que se ha invocado el método AddNew y que no se ha guardado aún el registro
adEditAdd
actual nuevo.
adEditDelete Indica que el registro actual se ha eliminado.
Tabla 7.7.- Valores que devuelve la propiedad EditMode

La propiedad Filter se utiliza para descartar de manera selectiva registros de

un objeto Recordset. El Recordset filtrado se convierte en el cursor actual. Esto
afecta a otras propiedades, como AbsolutePosition y RecordCount, que
devuelven valores basados en el cursor actual. Filter se basa en una cadena de
criterio que se compone de cláusulas con el formato “[Nombre campo] -
Operador – Valor”; por ejemplo, la siguiente instrucción devuelve sólo
registros cuyo apellido sea Smith:
MiRecordset.Filter = "LastName = 'Smith'"

Se pueden crear cláusulas compuestas mediante la concatenación de cláusulas

individuales con operadores lógicos (por ejemplo, "LastName = 'Smith' AND
FirstName = 'John'"). Si el nombre de campo contiene espacios, deberá
encerrar el nombre entre corchetes (por ejemplo, “[Last Name] = ‘Smith’”). Se
utilizan comillas simples para las cadenas y el símbolo de numeral (#) para las
fechas. Si el operador es LIKE, se podrán utilizar comodines para el valor de
comparación. Los únicos comodines que se admiten son el asterisco (*) y el signo
de porcentaje (%) y deben ser el último carácter de la cadena.
b) Métodos
Método Descripción
AddNew Crea un nuevo registro
UpdateBatch Escribe en disco todas las actualizaciones pendientes de proceso por lotes.
CancelBatch Cancela una actualización por lotes pendiente.
Update Guarda los cambios realizados en el registro actual de un objeto Recordset.
Cancela las modificaciones al registro actual o a un registro nuevo antes de invocar a
CancelUpdate Update.
Abre un cursor que representa los registros de una base de datos o los resultados de una
Open
consulta.

15 152
2
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Cancel Cancela la ejecución de una llamada asíncrona pendiente a un método Open.

Cierra un objeto Recordset, libera los datos asociados y los accesos exclusivos que
Close
pudiera tener.

15 153
3
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Método Descripción
MoveFirst Pasa al primer registro y lo convierte en el registro actual.
MoveNext Pasa al siguiente registro y lo convierte en el registro actual.
MovePrevious Pasa al anterior registro y lo convierte en el registro actual.
MoveLast Pasa al último registro y lo convierte en el registro actual.
Actualiza los datos de un objeto Recordset volviendo a ejecutar la consulta en que se
Requery
basa el objeto.
Elimina el registro actual o al grupo de registros especificados mediante la propiedad
Delete Filter.

Tabla 7.8.- Métodos del objeto Recordset de ADO

c) Eventos

Eventos Descripción
FetchProgress, Estado de recuperación: notificación del progreso de una operación de
FetchComplete recuperación de datos, o de que la operación de recuperación ha concluido.
WillChangeField, Administración de cambio de campo: Notificación de que el valor del campo
FieldChangeComplete actual cambiará o ha cambiado.
WillMove, MoveComplete, Administración de exploración: Notificación de que la posición de fila (registro)
EndOfRecordset actual en un Recordset cambiará, ha cambiado o ha llegado al final del
Recordset.
WillChangeRecord, Administración de cambios en la fila: Notificación de que algo en la fila
RecordChangeComplete (registro) actual del Recordset cambiará o ha cambiado.
WillChangeRecordset, Administración de cambios en el Recordset: Notificación de que algo en el
RecordsetChangeComplete Recordset actual cambiará o ha cambiado.

Tabla 7.9.- Eventos del objeto Recordset de ADO

7.2.4. Procedimiento para utilizar el modelo ADO

Una aplicación típica basada en ADO utiliza un conjunto de procedimientos u

operaciones establecidas para tener acceso a un origen de datos. El modelo de datos
ADO requiere obligatoriamente el establecimiento de una conexión antes de
cualquier operación sobre la base de datos. El procedimiento se detalla en los
siguientes pasos:
a) Crear y abrir la conexión (objeto Connection)
Se especifica la cadena de conexión con información como el nombre del
origen de datos, la identificación del usuario, la contraseña, el tiempo de
espera de la conexión, la base de datos predeterminada y la ubicación del cursor.
Establecidos estos parámetros se procede a abrir la conexión mediante el método
Open del objeto Connection.
b) Ejecutar el comando (objeto Command y Recordset)
Se especifica el tipo de comando (tabla, consulta o procedimiento almacenado)
y los registros afectados del origen de datos. El tipo de comando determina
básicamente el tipo de origen de datos. El comando puede ser de selección de
registros o de acción sobre los registros. Cuando el comando es de selección
de registros, es necesario establecer el objeto Recordset que contendría al
conjunto de registros. A continuación, según sea el comando de selección o de
acción, se sigue uno de los siguientes procedimientos:

15 154
4
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Ejecutando un comando de selección: Se crea y se abre el objeto

Recordset para obtener el conjunto de registros provenientes de una tabla,
del resultado de una consulta SQL o procedimiento almacenado. Para este
paso, primeramente se definen las características del cursor, el nombre de
la tabla, la instrucción de selección SQL, o nombre del procedimiento

15 155
5
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

almacenado; para posteriormente invocar el método Open del objeto

Recordset.
Ejecutando un comando de acción: Consiste en ejecutar el método
Execute del objeto Connection sin devolución de filas. Este método actúa
sobre un conjunto de registros del origen de datos mediante instrucciones
de acción SQL, pero no devuelve registros.
c) Utilizar el conjunto de resultados (objeto Recordset)
Aplica si el comando es de selección. En función del tipo de cursor
(CursorType), se pueden examinar y modificar los datos de las filas en el servidor
o en el cliente, mediante métodos y propiedades del objeto Recordset.
d) Finalizar la conexión (objeto Connection)
Cancela la conexión con el origen de datos. Se utiliza el método Close del
objeto Connection.

7.3. Acceso a datos mediante Visual Basic y ADO

7.3.1. Métodos para utilizar ADO
El modelo ADO se puede implementar de varias maneras desde Visual Basic,
usando (a) El control de datos ADO, (b) ADO mediante código, o (c) El entorno de
datos.
a) El control de datos ADO
Este control de datos permite efectuar una conexión con la base de datos y
define un conjunto de filas (Recordset) provenientes de una tabla, del
resultado de una consulta o de un procedimiento almacenado. Tiene la ventaja
que es fácil y rápidamente configurable, provee los botones para desplazarse a
través de los registros y se puede reconfigurar durante la ejecución. Pero por
otra parte, no se tiene suficiente control sobre la conexión, de tal manera que
se pueden producir errores durante la carga, si la base de datos es movida de
su ubicación original.
b) ADO mediante código
Creando los objetos ADO mediante código, el control de la conexión y del
origen de datos es total; pero se deben crear por código todos los
procedimientos, lo que puede resultar un poco tedioso para el programador. Una
vez que se han creado los objetos Recordset, se acostumbra a asignar estas
referencias de objeto al control de datos ADO, con el fin de aprovechar su
funcionalidad.
c) El entorno de datos
El entorno de datos es un objeto de la clase DataEnvironment que contiene las
conexiones (DEConnection), comandos (DECommand) y campos de una o
varias bases de datos. El diseñador de entorno de datos permite definir uno o
varios objetos conexión (DEConnection); y de cada conexión, el objeto Recordset
se define mediante objetos comando (DECommand). Si bien presenta la
ventaja de crear los controles enlazados de manera sencilla

15 156
6
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

(arrastrar desde el diseñador y colocar en el formulario), el acceso a los datos

se debe codificar haciendo referencia al nombre del objeto DataEnvironment.
Estos procedimientos, aunque se estudian de manera separada, se pueden combinar
o complementar entre sí para obtener una máxima eficiencia de la interfaz de
base de datos y su configuración. Por otra parte, la visualización de los datos de un
Recordset se realiza enlazando estos a objetos receptores de datos que se conocen
como Controles Enlazados a un campo o al Recordset completo.
7.3.2. Controles enlazados a datos
Los objetos receptores de datos son controles que pueden ser enlazados con
orígenes de datos. Estos son de la clase TextBox, ListBox, ComboBox, CheckBox,
PictureBox, Image y Label; y además controles no estándar como el DataGrid,
DataCombo y DataList. Según los métodos para utilizar ADO (7.3.1), los controles
se pueden enlazar de las siguientes maneras:
a) Control de datos ADO: En tiempo de diseño, en la propiedad DataSource del
objeto se indica el nombre del control de datos ADO, y en la propiedad DataField
del objeto se escoge el nombre de uno de los campos del Recordset.
b) ADO mediante código: Se enlaza en tiempo de ejecución mediante una
referencia del objeto Recordset a la propiedad DataSource del objeto receptor
utilizando la sentencia SET. También se debe establecer la propiedad DataField
con una instrucción de asignación del nombre del campo como cadena en
forma explícita.
c) Entorno de datos: En tiempo de diseño, en la propiedad DataSource del objeto
se indica el nombre del entorno de datos, en la propiedad DataMember se coloca
el nombre del comando (DECommand), y luego se especifica el nombre del
campo en la propiedad DataField. Para este caso, también es posible arrastrar y
colocar.
7.3.3. El control de datos ADO
a) Agregar el control de datos en la caja de herramientas: Este se debe agregar
mediante el cuadro de diálogo Componentes (Ctrl+T), seleccionando el objeto
Microsoft ADO Data Control 6.0 (OLEDB), como se muestra en la figura 7.5.

15 157
7
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.5.- Diálogo de componentes (Control de datos ADO)

b) Crear la conexión con la base de datos: Una vez dibujado el control de datos
ADO, se utiliza su propiedad ConnectionString para crear la cadena de
conexión, la cual despliega un diálogo que facilita este procedimiento (ver
Figura 7.6).

Figura 7.6.- Ventana de la propiedad ConnectionString

Seleccionado la opción “Usar cadena de conexión”, y el botón “Generar…”,

aparece el asistente que se muestra en la figura 7.7, el cual permite
seleccionar, tanto el motor (Proveedor), como el nombre de la base de datos
(Conexión).

15 158
8
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.7.- Asistente para crear una conexión a un origen de datos ADO

c) Establecer el conjunto de registros: La propiedad CommandType define el tipo

de origen de datos. La propiedad RecordSource, abre el diálogo que se
muestra a continuación para seleccionar una tabla o escribir un texto SQL.

Figura 7.8.- Diálogo de propiedades para establecer el origen de registros

15 159
9
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

d) Enlazar controles a los datos del Recordset: Los controles enlazados se crean
estableciendo las propiedades DataSource y DataField en tiempo de diseño; pero
también se pueden establecer en tiempo de ejecución de la siguiente

16 160
0
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

manera. Suponga que el control de datos ADO tiene como nombre MiAdoDC, y
que se desea enlazar una caja de texto MiCaja al campo Apellido de una tabla
de datos (Recordset con CommandType = adCmdTable):
Set Me.MiCaja.DataSource = Me.MiAdoDC.Recordset
Me.MiCaja.DataField = "Apellido"

También es posible mostrar todos los campos y registros utilizando el objeto

DataGrid. Para lo cual, primero debe agregarse a la caja de herramientas
mediante el diálogo de Componentes (Ctrl+T) seleccionado la opción Microsoft
DataGrid Control 6.0 (OLEDB). En este caso sólo se especifica la propiedad
DataSource, ya que no es necesario especificar un campo en particular. Suponga
que el objeto DataGrid tiene el nombre MiDataGrid:

Set Me.MiDataGrid.DataSource = Me.MiAdoDC.Recordset

e) Utilizar el conjunto de registros: La propiedad Recordset del control de datos ADO

hace referencia al conjunto de registros especificados mediante las propiedades
CommandType y RecordSource. Suponga que el control de datos ADO tiene
como nombre MiAdoDC:
Agregar un registro nuevo
MiAdoDC.Recordset.AddNew

Guardar modificaciones del registro activo o del registro nuevo

MiAdoDC.Recordset.Update

Cancelar una modificación o agregado de registro

MiAdoDC.Recordset.CancelUpdate

Buscar un registro cuyo Apellido comience con el contenido de una caja de

texto
Dim Buscar As String
Me.MiAdoDC.Recordset.MoveFirst
Buscar = "Apellido Like '" & Me.Text4.Text & "*'"
Me.MiAdoDC.Recordset.Find Buscar
If Me.MiAdoDC.Recordset.EOF Then
Me.Label1.Caption = "No se encontró"
Me.MiAdoDC.Recordset.MoveFirst
End If

Borrar el registro activo

MiAdoDC.Recordset.Delete

Desplazarse al último registro

MiAdoDC.Recordset.MoveLast

Mostrar la cantidad de registros del Recordset en un objeto etiqueta

16 161
1
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Me.label1.Caption = MiAdoDC.Recordset.RecordCount

16 162
2
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

7.3.4. Creación de objetos ADO en código

a) Crear la referencia a la biblioteca de tipos ADO: Las referencias se establecen
a través del menú Proyecto | Referencias, el cual despliega el diálogo que se
muestra a continuación. Debe seleccionar Microsoft ActiveX Data Object 2.X
Library.

Figura 7.9.- Ventana de referencias a librerías de objetos

b) Crear las variables de objeto: Para crear eventos en una variable tipo objeto se
utiliza la sentencia WithEvents después de Dim, Public o Static.
Dim WithEvents Cnn As ADODB.Connection
Dim WithEvents Rst As ADODB.Recordset

c) Crear los objetos Connection y Recordset: Se recomienda utilizar el evento

Form_Load para este fin. Se utiliza la sentencia Set para la referencia a objeto.
Set Cnn = New ADODB.Connection
Set Rst = New ADODB.Recordset

d) Abrir el objeto Connection: Es conveniente chequear previamente el estado de

la conexión, ya que si esta se encuentra abierta, y se intenta abrir
nuevamente, se producirá un error. Antes de abrir la conexión, se debe
establecer la cadena de conexión mediante la asignación de la propiedad
ConnectionString.
If Cnn.State Then Cnn.Close
Cnn.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;_
Data Source=C:\Notas.mdb"
Cnn.Open

e) Abrir el objeto Recordset: Al igual que el objeto Connection, es conveniente

verificar previamente el estado del Recordset, ya se produce un error al
16 163
3
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

intentar abrir un Recordset que ya está abierto. Para abrir el conjunto de

registros (Recordset) se debe especificar la localización del cursor

16 164
4
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

(CursorLocation), el tipo de cursor (CursorType), el tipo de bloqueo de

registros (LockType), la conexión activa, y el origen de registros. En el ejemplo
siguiente, las propiedades CursorLocation y LockType se establecen de manera
explícita, y el resto de las propiedades van implícitas en la misma línea de
ejecución del método Open.
If Rst.State Then Rst.Close
Rst.CursorLocation = adUseClient
Rst.LockType = adLockOptimistic
Rst.Open "Alumnos", Cnn, adOpenDynamic

f) Enlazar los datos del Recordset a un control: Una vez mas, basta con
establecer las propiedades DataSource y DataField del objeto que se desea
enlazar, en este caso una caja de texto llamada MiCaja en la que se quieren
mostrar los valores del campo Apellido:
Set Me.MiCaja.DataSource = Rst
Me.MiCaja.DataField = "Apellido"

Si se desea mostrar todos los campos y registros utilizando el objeto DataGrid

se debe especificar sólo la propiedad DataSource:

Set Me.MiDataGrid.DataSource = Rst

g) Utilizar el conjunto de registros: El objeto Rst (Recordset) hace referencia al

conjunto de registros especificados en la ejecución del método Open.
Agregar un registro nuevo
Rst.AddNew

Guardar modificaciones del registro activo o del registro nuevo

Rst.Update

Cancelar una modificación o agregado de registro

Rst.CancelUpdate

Buscar un registro cuyo Apellido comience con lo que esté en una caja de
texto
Dim Buscar As String
Rst.MoveFirst
Buscar = "Apellido Like '" & Me.Text4.Text & "*'"
Rst.Find Buscar
If Rst.EOF Then
Me.Label1.Caption = "No se encontró"
Rst.MoveFirst
End If

Borrar el registro activo

Rst.Delete

Desplazarse al último registro

Rst.MoveLast 16 165
5
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Mostrar la cantidad de registros del Recordset en un objeto etiqueta

Me.label1.Caption = Rst.RecordCount

7.3.5. El diseñador de entorno de datos

a) Agregar el diseñador de entorno de datos: Se debe visualiza el diálogo
componentes (Ctrl+T) y seleccionar Data Environment de la pestaña
Diseñadores:

Figura 7.10.-Diálogo Componentes (Diseñadores)

b) Agregar un entorno de datos: Al hacer clic en el menú Proyecto | Agregar Data

Environment, se despliega el diseñador del entorno de datos como se muestra
en la figura 7.11. Este diseñador permite configurar el objeto Entorno de datos
con múltiples conexiones (Control, Escuelas) u objetos DEConnection, y para
cada conexión se pueden especificar conjuntos de registros (Alumnos,
Exámenes, Asistencia, Materias, etc.) u objetos DECommand.

16 166
6
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.11.-Diseñador del objeto Entorno de datos

) Crear los objetos DEConnection y DECommand: Estos objetos se crean

haciendo clic derecho sobre el objeto correspondiente. Por ejemplo para crear
conexiones se hace clic derecho sobre el objeto de entorno de datos
MiEntornoDeDatos.
) Crear los controles enlazados: Esta es una de las grandes ventajas de usar el
diseñador del entorno de datos. Con la operación de arrastrar y colocar, los
d objetos enlazados se crean automáticamente sobre el formulario. Si no se
desea utilizar esta facilidad, o si desea reconfigurar los controles enlazados en
tiempo de diseño, se deben establecer las propiedades DataSource (Nombre
del objeto entorno de datos: MiEntornoDeDatos), DataMember (Nombre de un
objeto DECommand: Alumnos), y DataField (Nombre de uno de los campos de
dataMember). Ahora en tiempo de ejecución, sólo se hace referencia al objeto
Recordset correspondiente a un comando. Por ejemplo, el comando Alumnos
crea automáticamente el objeto rsAlumnos de la clase Recordset.
Set Me.MiCaja.DataSource = MiEntornoDeDatos.rsAlumnos
Me.MiCaja.DataField = "Apellido"

Igualmente para el control DataGrid, en tiempo de diseño habría que

especificar las propiedades Datasource y DataMember; pero en tiempo de
ejecución basta con hacer referencia al objeto Recordset relacionado al
comando:

Set Me.MiDataGrid.DataSource = MiEntornoDeDatos.rsAlumnos

e) Utilizar el conjunto de registros: Los objetos rsAlumnos, rsExamenes,

rsMaterias, etc., son de la clase Recordset, por lo tanto permiten manipular el
conjunto de registros.
Agregar un registro nuevo
MiEntornoDeDatos.rsAlumnos.AddNew

Guardar modificaciones del registro activo o del registro nuevo

MiEntornoDeDatos.rsAlumnos.Update

Cancelar una modificación o agregado de registro

MiEntornoDeDatos.rsAlumnos.CancelUpdate

121 121
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Buscar un registro cuyo Apellido comience con lo que esté en una caja de
texto
Dim Buscar As String
MiEntornoDeDatos.rsAlumnos.MoveFirst
Buscar = "Apellido Like '" & Me.Text4.Text & "*'"
MiEntornoDeDatos.rsAlumnos.Find Buscar
If MiEntornoDeDatos.rsAlumnos.EOF Then
Me.Label1.Caption = "No se encontró"
MiEntornoDeDatos.rsAlumnos.MoveFirst
End If

Borrar el registro activo

MiEntornoDeDatos.rsAlumnos.Delete

Desplazarse al último registro

MiEntornoDeDatos.rsAlumnos.MoveLast

Mostrar la cantidad de registros del Recordset en un objeto etiqueta

Me.label1.Caption = MiEntornoDeDatos.rsAlumnos.RecordCount

7.4. Lenguaje de consulta estructurado SQL

7.4.1. Introducción a SQL
Como hemos visto, el modelo relacional se basa en el Lenguaje de Consulta
Estructurado, mejor conocido como SQL. El lenguaje de consulta estructurado
(SQL) es un lenguaje de base de datos normalizado, utilizado o incluido en el
motor de base de datos para crear objetos RecordSet. También se puede utilizar con
el método Execute del objeto Connection de ADO para manipular directamente lotes
de registros de las bases de datos. Es posible crear “consultas SQL de paso a través”
para manipular bases de datos remotas cliente-servidor. SQL es un lenguaje
de programación, cuyos orígenes están estrechamente relacionados con la
invención de las bases de datos relacionales por E. F. Codd a principios de los años
70. Un antecedente del actual SQL fue el lenguaje Sequel, razón por la cual SQL
todavía se pronuncia en inglés como “Sequel” en vez de “letra a letra”, aunque
las dos pronunciaciones son aceptables. El SQL moderno ha evolucionado hasta ser
un estándar utilizado ampliamente en casi todas las bases de datos relacionales y se
encuentra definido en la norma ANSI. La mayoría de las implementaciones de SQL
tienen pocas variaciones respecto al estándar, incluyendo la versión admitida por
el motor de base de datos Microsoft Jet. SQL tiene la ventaja de ser una interfaz de
bases de datos normalizada, por lo que conocer los comandos SQL permite acceder
y manipular una gran variedad de productos de bases de datos procedentes de
distintos fabricantes.
Para utilizar SQL desde Visual Basic, se debe construir la instrucción SQL en una
variable tipo cadena de caracteres, la cual sirve de argumento para objetos de
ADO. El lenguaje permite efectuar dos tipos de consultas:

122 122
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

a) Consultas de selección: devuelven un conjunto de registros que se pueden

manipular mediante el objeto RecordSet de ADO. Por ejemplo, habiendo

123 123
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

creado los objetos Cnn (Connection) y Rst (Recordset), se utiliza el método

Open del objeto Recordset para obtener registros de la tabla Alumnos:
Dim CadSQL As String
CadSQL = “SELECT [Apellido], [Nombre] FROM Alumnos;”
If Rst.State Then Rst.Close
Rst.CursorLocation = adUseClient
Rst.LockType = adLockOptimistic
Rst.Open CadSQL, Cnn, adOpenDynamic

b) Consultas de acción: realizan una operación sobre la base de datos o sobre

uno o más registros de una tabla. Para este caso no es necesario crear el
objeto Recordset, ya que las consultas de acción no devuelven registros. En su
lugar se utiliza el método Execute del objeto Connection. El siguiente ejemplo
elimina los registros de la tabla Alumnos con más de 25 inasistencias:
Dim CadSQL As String
CadSQL = “DELETE * FROM Alumnos WHERE [Inasistencia] > 25”
If Cnn.State Then Cnn.Close
Cnn.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;_
Data Source=C:\Notas.mdb"
Cnn.Execute CadSQL

Como se observa en los ejemplos anteriores, lo único nuevo es la construcción de

la instrucción SQL, ya que los objetos ADO se siguen utilizando de la misma
manera. A continuación veremos los elementos y sintaxis del lenguaje de consulta
estructurado SQL.
7.4.2. Elementos del lenguaje SQL
El lenguaje SQL está compuesto por (a) Comandos, (b) Cláusulas, (c) Operadores
y (d) Funciones de agregado. Estos componentes, se combinan en instrucciones
completas para seleccionar, actualizar, agregar o borrar registros de bases de
datos.
a) Comandos SQL
Los comandos corresponden a las órdenes que se especifican mediante SQL, y
en la sintaxis constituyen el inicio de cada instrucción.
Comando Utilizado para
SELECT Seleccionar un conjunto de registros de la base de datos y crear un Recordset.
UPDATE Modificar los valores de los campos de uno o más registros.
INSERT Agregar uno o más registros a una tabla de base de datos.
DELETE Eliminar uno o más registros de una tabla de base de datos.

Tabla 7.10.- Algunos comandos de SQL

b) Cláusulas SQL

Las cláusulas son condiciones de modificación utilizadas para definir los datos
que desean seleccionar o manipular, y la forma como estos se presentan.
Cláusula Descripción
FROM Especifica las tablas de las cuales se van a seleccionar los registros.

124 124
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

WHERE Especifica las condiciones de los registros que se van a seleccionar.

GROUP BY Separa los registros seleccionados en grupos específicos.
HAVING Especifica las condiciones que deben satisfacer cada grupo generado por GROUP BY.
ORDER BY Indica los campos para el ordenamiento de los registros.

125 125
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Tabla 7.11.- Algunas cláusulas de SQL

c) Operadores SQL

Existen dos tipos de operadores en el lenguaje SQL, operadores lógicos y

operadores relacionales. Los operadores lógicos se usan para conectar
expresiones lógicas, normalmente dentro de una cláusula WHERE o HAVING.
Para SQL los operadores lógicos son: AND, OR y NOT. Por otra parte, los
operadores relacionales (ver Tabla 7.12) se usan para comparar valores relativos
de dos expresiones.
Operador Significado/Uso
< Menor que
> Mayor que
= Igual que
BETWEEN Especifica un intervalo de valores
IN Especifica registros de una base de datos
<= Menor o igual que
>= Mayor o igual que
<> Distinto de
LIKE Utilizado en la comparación de un modelo

Tabla 7.12.- Operadores de comparación SQL

d) Funciones de agregado SQL

Las funciones de agregado (ver Tabla 7.13) se usan dentro de una cláusula
SELECT para devolver un único valor que se aplica a un conjunto de registros
agrupados según cierto criterio.
Función Descripción
COUNT Calcula el número de veces que aparece un valor en un campo especificado.
MAX Devuelve los registros con el valor más alto de un campo especificado.
AVG Calcula el promedio de todos los valores de un campo especificado.
SUM Calcula la suma de todos los valores de un campo especificado.
MIN Devuelve los registros con el valor más bajo de un campo especificado.

Tabla 7.13.- Funciones de agregado SQL

7.4.3. Consultas de selección (SELECT)

La instrucción SELECT se utiliza para recuperar registros de una base de datos en

forma de un conjunto de registros, almacenándolos en un nuevo objeto Recordset.
Las instrucciones SELECT no modifican los datos de la base de datos; sólo los
recuperan. La sintaxis general de la consulta SELECT es la siguiente:
SELECT listaCampos
FROM nombresTablas IN nombreBaseDatos
WHERE criteriosDeSelección
GROUP BY listaCampos
HAVING criteriosDeGrupo
ORDER BY listaCampos [ASC|DESC]

La consulta SELECT más simple, seleccionando sólo los campos Nombre y Apellido
es:
126 126
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

SELECT [Nombre], [Apellido]

FROM Empleados;

Sintaxis SQL: Los nombres de campos se colocan entre corchetes y se separan con
comas. Las instrucciones SQL terminan con punto y coma.

127 127
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Para seleccionar todos los campos de la tabla Empleados:

SELECT *
FROM Empleados;
Sintaxis SQL: El asterisco en SQL indica todos los campos. Para el operador LIKE el
comodín asterisco se sustituye por el caracter porcentaje %.
La cláusula WHERE especifica una condición para el filtrado de los registros. La
cláusula GROUP BY permite agrupar el conjunto de registros, y HAVING determina
los registros a filtrar una vez efectuado el agrupamiento. Mientras GROUP BY
ordena los registros por el campo especificado, ORDER BY permite seleccionar otro
campo de ordenamiento. Por ejemplo se pueden obtener todos los empleados
contratados después del año 2000, cuyo apellido comienza con las letras “Ro”
(Rodriguez, Román, Rosales,…), agrupados por el departamento al que
pertenecen, y con sueldo inferior o igual a 500 mil Bolívares, además ordenado por
apellido:

SELECT [Nombre], [Apellido], [Departamento]

FROM Empleados
WHERE [Ingreso] > #31/12/2000# AND [Apellido] LIKE 'R%'
GROUP BY [Departamento]
HAVING [Sueldo] <= 500000
ORDER BY [Apellido] ASC;
Sintaxis SQL: Las cadenas de caracteres se especifican entre apóstrofes. Las
fechas se delimitan con el signo numeral. Los valores numéricos no utilizan
delimitadores.
Las funciones de agregado se utilizan en la definición de campos de la consulta
SELECT. El resultado de las funciones de agregado se adjudica a un alias mediante
la palabra reservada AS. Por ejemplo, se puede calcular la suma de los sueldos de
todos los empleados por departamento:

SELECT [Departamento], SUM([Sueldo]) AS CostoDepartamento

FROM Empleados;

7.4.4. Consultas de acción (DELETE, INSERT, UPDATE)

a) Consulta de eliminación (DELETE)
DELETE [tabla.*]
FROM expresiónTabla
WHERE criterios

En el siguiente ejemplo se eliminan los registros de la tabla Empleados cuyo

campo Estatus es igual Despedido.

DELETE *
FROM Empleados
WHERE [Estatus] = 'Despedido';

b) Consulta de datos añadidos (INSERT)

Se puede ejecutar una consulta de datos añadidos con registros múltiples:
INSERT INTO destino [IN
128 baseDatosExterna]
128
SELECT [origen.]campo1[, campo2[, ...]
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

FROM expresiónTabla

Sería conveniente almacenar los registros de empleados despedidos en una

tabla antes de ejecutar la consulta de eliminación en la tabla de empleados:

INSERT INTO Despedidos

SELECT *
FROM Empleados
WHERE [Estatus] = 'Despedido';

Se puede ejecutar una consulta de datos añadidos sobre un único registro:

INSERT INTO destino [(campo1[, campo2[, ...]])]
VALUES (valor1[, valor2[, ...])

Por ejemplo, para agregar un nuevo empleado a la tabla empleados:

INSERT INTO Empleados ([Nombre], [Apellido], [Sueldo])

VALUES ('Pedro', 'Pérez', 500000)

) Consulta de actualización (UPDATE)

UPDATE tabla
SET Campo1 = nuevoValor1, Campo2 = nuevoValor2
WHERE criterios;

UPDATE es especialmente útil cuando desea cambiar numerosos registros o

cuando los registros que quiere cambiar están en múltiples tablas. Puede cambiar
varios campos simultáneamente. El siguiente ejemplo incrementa el sueldo de
todos empleados con 5 o más de 5 años de antigüedad en un 10 por ciento.
Simultáneamente, se actualiza la edad del empleado.

UPDATE Empleados
SET [Sueldo] = [Sueldo]*1.1,
[Edad] = DateDiff('yyyy', [Nacimiento], Date()),
WHERE [Antiguedad] >= 5;

7.5. Reportes de bases de datos

7.5.1. Introducción a reportes
Como instrumento de administración, el reporte o informe es usado para
proporcionar a la gerencia los elementos necesarios para controlar una
organización de forma efectiva. Los informes presentan los datos de una base de
datos de una manera organizada, comprensiva y atractiva al usuario. Es posible
generar pedidos, facturas, cartas, etiquetas de correos y otros de salida de datos.
Los generadores de informe son programas especializados que cuentan con, además
de motores de bases de datos, motores de impresión que se encargan de controlar
todo lo relacionado al formato de las hojas de reporte. Visual Basic en su versión 6.0
incluye un generador de informes integrado como objeto de la clase DataReport. En
versiones anteriores, y en la nueva versión .NET, se incluye un programa generador
de informes conocido como Crystal Report. Dada la eficiencia de Crystal Report y su

129 129
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

vigencia en nuevas versiones de Visual Basic, en esta guía se tratará este generador
de informes.

130 130
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

7.5.2. Pasos para crear un reporte

Para crear un informe con Crystal Report, previamente debe asegurarse que esté
incluido en la lista de Diseñadores en la ventana de Componentes (Ctrl+T). De
esta manera aparece como una de las opciones dentro del menú Proyecto del IDE
de Visual Basic. Aunque es posible crear el reporte utilizando por separado el
programa Crystal Report, y luego anexarlo al proyecto; los pasos que veremos a
continuación se refieren al uso del generador de informes en forma integrada.
a) Seleccione el menú Proyecto | Agregar Crystal Report 9. Aparece el cuadro de
diálogo “Crystal Report Gallery”.

Figura 7.12.-Diálogo Crystal Report Gallery

b) Seleccione la opción correspondiente al tipo de creación de reporte, es decir;

“Using the Report Expert”, “As a Blank Report” o “From an Existing Report”. En
nuestro caso utilizaremos la primera opción, para la cual se habilita la lista de
asistentes según el tipo de reporte, de la cual escogeremos “Standard”; y al
presionar el botón OK se abre el asistente que se muestra en la figura 7.13.

131 131
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.13.-Diálogo de selección de Tablas para reportes

c) La opción “Create New Connection” incluye OLEDB (ADO), el cual despliega un

sencillo asistente, parecido al del control de datos ADO, para seleccionar el motor
y el archivo de base de datos. Al presionar el botón siguiente se abre el diálogo
de selección de campos.

Figura 7.14.-Diálogo de selección de Campos para reportes

d) El siguiente cuadro de diálogo permite elegir uno o varios campos mediante

los cuales se agrupan los datos en la presentación del reporte. Para nuestro
ejemplo, los productos podrían agruparse por el campo fabricante.
132 132
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.15.-Diálogo para agrupar los registros de un reporte

e) El siguiente cuadro de diálogo permite elegir uno o varios campos mediante

los cuales se filtran los datos con el objeto de mostrar sólo ciertos registros.
Por ejemplo, se podrían mostrar sólo los productos cuyo campo Existencia
tenga el valor de cero con el objeto de generar un listado de fallas o faltantes.
Es importante hacer notar que al seleccionar un campo determinado, aparecen
el en cuadro de diálogo dos cajas combinadas, una para seleccionar el
operador relacional, y otra para seleccionar el valor de comparación.

Figura 7.16.-Diálogo para filtrar los registros de un reporte

133 133
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

f) A continuación se presenta un cuadro de diálogo con los estilos o plantillas de

reporte disponibles, lo que facilita en gran medida la tarea de diseño.

134 134
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.17.-Diálogo para seleccionar la plantilla de diseño de un reporte

g) Finalmente el asistente consulta al usuario sobre dos aspectos. El primero

solicita confirmación para crear automáticamente el formulario donde se
presentará el reporte, y se recomienda tildar este aspecto positivamente. La
segunda consulta es sobre la modificación automática de las propiedades del
proyecto, la cual debe indicarse en NO para evitar que Crystal Report cambie
el objeto inicial que se carga al ejecutarse la aplicación.

Figura 7.18.-Diálogo de confirmación para crear un reporte

h) A continuación, en el proyecto se crea un formulario nuevo y un objeto Crystal

Report. También se puede observar el reporte en vista de diseño. Lo que

135 135
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

queda es escribir el código necesario para mostrar el nuevo formulario

(método Show).

136 136
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

7.5.3. Partes del generador de reportes

En la vista de diseño, el generador de reportes presenta tres secciones básicas:
Encabezado de página, Detalle y Pie de página. Tanto el encabezado como el pie
de página albergan etiquetas, membretes, títulos de las columnas y cualquier otra
información propia del informe. La sección que contiene los datos es la de detalle.
En esta sección se colocan los campos de la base de datos.

Figura 7.19.-Vista de diseño de un reporte de Crystal Report

Cuando el informe se muestra en vista preliminar, el cuerpo de la página muestra

los datos almacenados en la base de datos; y los campos especiales, como la
fecha, se actualizan a la fecha del computador.

137 137
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.20.-Vista preliminar de un reporte de Crystal Report

138 138
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

7.5.4. Campos de un reporte

Toda la información que aparece en un reporte está contenida en objetos gráficos
denominados campos. Además de estos campos, la herramienta de diseño ofrece
dos objetos gráficos para la creación de líneas y cuadros. A continuación veremos
los tipos de campos más importantes que se pueden colocar en un reporte de Crystal
Report.

Figura 7.21.-Tipos de campos de Crystal Report

a) Campos de base de datos:

Son los campos que contienen información de las columnas de una tabla o
Recordset de la base de datos activa. Se caracterizan porque se colocan en la
sección Detalle del generador de informe y se corresponden con cada uno de
los registros de la base de datos.
Observación: Sólo deben arrastrase los campos seleccionados hasta la sección
correspondiente del generador de informe.
b) Campos de texto:
Estos campos se corresponden al objeto etiqueta conocido de Visual Basic. Un
campo de texto es simplemente un campo que contiene texto independiente.
Puede contener un único carácter, una palabra, frases completas o párrafos.
Este es un comando usado para agregar etiquetas, títulos, notas al pie,
disculpas, explicaciones, comentarios o cualquier otra clase de texto que fuera
necesario. Para agregar un campo de texto, este se debe escoger de la clase
TextObject en la caja de herramientas, para dibujarlo luego en la sección
correspondiente.
Observación: Como el tamaño máximo de un campo de texto es 32K (incluyendo
los caracteres retorno de carro y salto de línea), se recomienda que los
campos de texto se usen sólo con bloques de texto de tamaño más
manejable.
c) Campos de fórmula:

139 139
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Los campos de fórmula permiten crear un objeto de datos calculados. Una

fórmula es una instrucción que establece ciertas acciones sobre determinados
datos antes de imprimirlos en el informe. Crystal Report ofrece un editor de
ecuaciones, el cual se activa automáticamente con el botón derecho del ratón
y seleccionar New. El editor de ecuaciones contiene un conjunto de funciones

140 140
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

matemáticas, de cadena y otras, operadores de varios tipos y los campos de la

base de datos activa para construir expresiones de cálculo.

Figura 7.22.-Editor de ecuaciones de Crystal Report

d) Campos especiales:

La información adicional de un informe referida a fecha, número de página,

número de registros, etc., se puede insertar utilizando los campos especiales.
Los campos especiales son como los campos de fórmula, pero están predefinidos
en el sistema.

141 141
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
7.- Bases
7.- Bases
de datos
de datos

Figura 7.23.-Campos especiales de Crystal Report

142 142
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Unidad 8

Tecnología OLE

“A pocos hombres les falta capacidad; si fracasan es porque les falta dedicación”
.- Calvin Coolidge

8.1. Teoría de OLE

8.1.1. Estándar COM
Visual Basic proporciona las herramientas que le permiten combinar objetos de
distintos orígenes mediante la visión evolucionada de componentes de software,
que se basa un estándar abierto y extensible conocido como el Modelo de Objetos
Componentes (COM, Component Object Model). COM es una arquitectura o
modelo de programación de plataforma independiente, distribuida y orientada a
objeto para la creación de componentes de software (objetos) que puedan
interactuar. Gracias a este estándar binario se pueden diseñar aplicaciones a partir
de componentes que se comunican entre sí, que interactúan unos con otros, a través
de un conjunto común de interfaces, con la velocidad y la sencillez de uso que
caracteriza a Visual Basic. El Modelo de Objetos Componentes (COM), incluye la
Automatización como el estándar de interoperabilidad, y ha permitido el
desarrollo de las tecnologías que habilitan la interoperabilidad, conocidas como
ActiveX. La Automatización es una característica del Modelo de Objetos Componentes
(COM), y este a su vez forma la infraestructura de la especificación ActiveX.
8.1.2. Automatización
La Automatización, antes denominada Automatización OLE, es un estándar usado
por las aplicaciones para proveer objetos de una forma consistente a otras
aplicaciones; en otras palabras, la norma que permite la comunicación entre
objetos de las aplicaciones se conoce como Automatización. Se puede decir que la
automatización es la parte de OLE que define, no sólo cómo se comparte el código
entre las aplicaciones, sino también cómo se pueden compartir servicios públicos
entre las mismas. La Automatización se usa típicamente para crear aplicaciones
que ofrecen objetos a herramientas de programación y lenguajes de macros, para
crear y manipular los objetos de una aplicación desde otra aplicación, o para crear
herramientas para tener acceso a objetos y manipularlos. El uso de la Automatización
en Visual Basic permite "tomar prestada" la funcionalidad de otras aplicaciones, al
controlar sus objetos desde el interior de la aplicación de Visual Basic. Si se trata de
un objeto de Automatización, se pueden emplear sus propiedades y métodos en el
código. Cada objeto de Automatización es un bloque que puede utilizarse en código
para recopilar y exponer información y funciones de otras aplicaciones, de forma

143 143
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

que tengan sentido en la aplicación actual. Por ejemplo, se puede generar una
aplicación que utilice Excel de Microsoft como

144 144
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

motor de cálculo, y cuyos informes se generen como documentos de Microsoft Word.

Muchas de las aplicaciones actuales han aprovechado la Automatización para
usar el código de otras aplicaciones.
8.1.3. Tecnología OLE y ActiveX
Una aplicación completa se puede ofrecer como componente (objeto) a otra
aplicación mediante una parte de ActiveX conocida como OLE. Se dice que la
tecnología ActiveX incluye a la tecnología OLE, pero que no está limitada a ella.
Mientras ActiveX se utiliza en forma general, OLE se enmarca en la creación y
manipulación de documentos compuestos; es decir, documentos con distintos
formatos. A pesar de esta diferenciación muchos autores coinciden en que OLE era
la forma tradicional de referirse a lo que ahora se conoce como ActiveX. La palabra
ActiveX es el nombre de marca de Microsoft para agrupar a las tecnologías que
habilitan la interoperabilidad usando el Modelo de Objetos Componentes (COM).
La interoperabilidad permite a componentes de software interactuar unos con
otros sin tener en cuenta el lenguaje en que fueron escritos. Así, ActiveX
(anteriormente OLE) facilita la integración de aplicaciones permitiendo que los
programadores definan juegos de interfaces, grupos de métodos y propiedades a
través de los cuales una aplicación accede a los servicios de objetos de otra
aplicación. El concepto de ofrecer funcionalidad mediante interfaces estándar hace
de ActiveX una tecnología abierta y extensible, ya que todas las aplicaciones basadas
en ActiveX pueden definir y usar estas interfaces. La tecnología ActiveX permite
ensamblar componentes software reutilizables en aplicaciones y servicios, conocidos
como Componentes ActiveX.
8.1.4. Componentes ActiveX
Un componente ActiveX es un fragmento reutilizable de código de programación y
datos compuesto por uno o más objetos creados mediante la tecnología ActiveX.
Un componente ActiveX es una unidad de código ejecutable, como un archivo
.exe, .dll u .ocx, que sigue la especificación ActiveX para proporcionar objetos. Los
componentes ActiveX le ofrecen al programador la capacidad de ensamblar
aplicaciones sofisticadas a partir de piezas que ya existen, dentro de las cuales se
encuentran:
a) Componentes incluidos en las aplicaciones habilitadas para ActiveX
Las aplicaciones compatibles con la tecnología ActiveX, como Microsoft Excel,
Microsoft Word y Microsoft Access, proporcionan objetos que se puede manipular
mediante programación desde la aplicación de Visual Basic. Por ejemplo, puede
usar en su aplicación propiedades, métodos y eventos de una hoja de cálculo de
Microsoft Excel o de un documento de Microsoft Word.
b) Componentes de código ActiveX
Los componentes de código (antes Servidores OLE) son bibliotecas de objetos
programables que proporcionan una forma fácil de empaquetar el código para
su reutilización. A diferencia de un objeto contenido en una aplicación
habilitada para ActiveX, un objeto contenido en el componente de código se
puede ejecutar en el mismo proceso que la aplicación, lo que permite un
acceso más rápido al objeto.

145 145
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

c) Controles ActiveX

146 146
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Puede agregar características sin necesidad de crearlas, utilizando controles

ActiveX como componentes. Un control ActiveX es una extensión del cuadro de
herramientas de Visual Basic. Los controles ActiveX se usan como cualquiera
de los controles estándar incorporados, como el control CheckBox.
Cuando se agrega un control ActiveX, este pasa a formar parte del entorno de
desarrollo y del tiempo de ejecución, y proporciona nueva funcionalidad a la
aplicación. Los controles ActiveX incrementan la capacidad del programador
conservando algunos métodos, propiedades y eventos ya familiares, como la
propiedad Name, que se comportan como cabría esperar. Pero además, los
controles ActiveX incorporan métodos y propiedades adicionales que aumentan
enormemente la flexibilidad y capacidad del programador en Visual Basic.
Existen controles ActiveX de diversos proveedores que ofrecen muchas
características especializadas, como mostrar un calendario en un formulario o
leer datos con un determinado formato. Por ejemplo, las ediciones Profesional
y Empresarial de Visual Basic incluyen los controles Windows® Common, que
permiten crear aplicaciones totalmente compatibles con las barras de
herramientas, barras de estado y modos de ver de las estructuras de
directorios de Windows en sus diferentes versiones.
d) Documentos ActiveX
Los documentos ActiveX le permiten crear aplicaciones interactivas para Internet.
Se pueden definir formularios que pueden aparecer en ventanas de los
exploradores de Internet. Los documentos ActiveX pueden mostrar cuadros de
mensajes y formularios secundarios, y pueden contener controles ActiveX. Los
documentos ActiveX también pueden funcionar como componentes de código.
Además de los tipos de componentes ActiveX existentes antes expuestos, Visual Basic
también permite al programador crear sus propios componentes. El desarrollo
de componentes software mediante la tecnología ActiveX no se debe confundir con
la programación orientada a objetos (OOP); ya que esta se ocupa de crear objetos,
mientras que ActiveX se ocupa de que los objetos funcionen juntos.
8.1.5. Componentes en proceso y fuera de proceso
Los componentes ActiveX interactúan con la aplicación y entre sí mediante una
relación cliente-servidor. El cliente es el código de aplicación que utiliza las
características de un componente. El servidor es el componente y sus objetos
asociados. Dependiendo de la forma en que esté implementado, un componente
ActiveX se puede ejecutar en el mismo proceso que las aplicaciones cliente o en
un proceso diferente. En general, si un componente ActiveX se ha implementado
como parte de un archivo ejecutable (.exe), se trata de un servidor fuera de
proceso y se ejecuta en su propio proceso. Si se ha implementado como una
biblioteca de vínculos dinámicos (.dll u .ocx), se trata de un servidor en proceso y
se ejecuta en el mismo proceso que la aplicación cliente.

147 147
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

8.2. Aplicaciones habilitadas para ActiveX

8.2.1. Objetos insertables
Hay tres categorías generales de controles en Visual Basic: los controles
intrínsecos, los controles ActiveX, y los objetos insertables. Estos últimos son el
caso de los componentes compatibles con la vinculación e incrustación de objetos
admitido tradicionalmente por OLE. Se pueden insertar objetos componentes
(como documentos de Word, u Hojas de cálculo de Excel) en una aplicación sin
necesidad de escribir código, utilizando la interfaz visual del componente. Hay dos
maneras de usar la interfaz visual de un componente:
a) Agregando un control contenedor OLE a la aplicación, e insertando después un
objeto en el control contenedor OLE.
b) Agregando la clase del objeto al cuadro de herramientas, y después,
agregando un objeto de esa clase a la aplicación, como lo haría con un control
TextBox sobre el formulario. La clase es de un control de aplicación habilitada
para ActiveX.
8.2.2. Control contenedor OLE
El control contenedor OLE proporciona la máxima flexibilidad para usar la interfaz
visual de un objeto. Un control contenedor OLE sólo puede contener un objeto
cada vez. Hay varias formas de crear un objeto vinculado o incrustado en el
control contenedor OLE una vez que se ha dibujado sobre el formulario. El método
elegido dependerá de si va a crear el objeto vinculado o incrustado en tiempo de
diseño o en tiempo de ejecución. A continuación veremos detalles de interés
relacionados al control contenedor OLE, como incrustación y vinculación, formas
de insertar objetos, las propiedades y métodos mas resaltantes del control, y algunas
utilidades básicas.
a) Incrustación y vinculación
Si un objeto esta vinculado, se crea una referencia o apuntador al documento
fuente, de tal manera que las modificaciones de los datos durante la ejecución
se efectúan en el documento original. Si el objeto esta incrustado, se crea una
copia del documento original en la aplicación, las modificaciones se efectúan sólo
en y durante la aplicación de Visual Basic, y en consecuencia los cambios no son
persistentes, ya que se pierden al terminar o detener la ejecución. El control
contenedor OLE dispone de métodos para guardar los cambios de los datos de
objetos incrustados mediante archivos binarios.
b) Insertar objetos en tiempo de diseño
Para insertar objetos en tiempo de diseño se utiliza el cuadro de diálogo
Insertar objeto, o el cuadro de diálogo Pegado especial.
El cuadro de diálogo Insertar objeto (ver Figura 8.1) aparece automática e
inmediatamente después de dibujar el control contenedor OLE sobre el
formulario. Este permite escoger entre crear un nuevo objeto, o utilizar un
documento ya existente. Si se activa la casilla “Vincular”, el objeto que se crea
es vinculado. También es posible escoger si se muestra el contenido del

148 148
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

documento o el icono de la interfaz del documento. Si se cancela el cuadro de

diálogo, el control OLE quedará vacío. En este caso las propiedades SourceDoc

149 149
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

y SourceItem en la ventana de propiedades permiten activar una vez más el

cuadro de diálogo.

Figura 8.1.- Diálogo Insertar objeto

Por su parte, el cuadro de diálogo Pegado especial está disponible si se ha

copiado algo en el portapapeles, y se puede activar haciendo clic derecho
sobre el control contenedor OLE. La apariencia de este diálogo se muestra a
continuación.

Figura 8.2.- Diálogo Pegado especial

c) Insertar objetos en tiempo de ejecución

Se puede crear un objeto vinculado o incrustado desde un archivo, en tiempo

de ejecución, con los métodos CreateLink o CreateEmbed del objeto
contenedor OLE. Estos métodos requieren el argumento “documento fuente”,
que es la ruta de acceso y el nombre del archivo desde el cual se crea el
objeto. Opcionalmente, para objetos vinculados, se puede indicar el
argumento “elemento fuente”, que especifica los datos que se desean vincular
o incrustar del documento fuente. También, para objetos incrustados, es
opcional indicar el argumento “clase”, para especificar el nombre de la interfaz
que provee el objeto. El siguiente fragmento de código crea un objeto

150 150
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

vinculado proveniente de la hoja de cálculo activa del archivo “prueba1.xls”, y

consiste de las primeras 15 filas y 8 columnas:

151 151
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

OLE1.CreateLink "C:\EXCEL\PRUEBA1.XLS", "L1C1:L15C8"

Para el caso de incrustación se especifica la clase, como se muestra:

OLE1.CreateEmbed " C:\EXCEL\PRUEBA2.XLS", "Excel.Sheet"

d) Propiedades del control contenedor OLE

La siguiente tabla enumera las propiedades del control OLE.
Propiedad Descripción
Class Identifica el objeto contenido en el control contenedor OLE.
DisplayType Presentación con su contenido o como un icono.
Object Propiedad de sólo lectura, en ejecución, que indica la clase activa.
OLEType Determina si un objeto se puede vincular o incrustar en el control OLE.
OLETypeAllowed Determina el tipo de objeto que puede crear (vinculado, incrustado).
SizeMode Determina el tipo de ajuste de tamaño de la imagen de los datos.
SourceDoc Esta propiedad determina el archivo de origen del vínculo o la plantilla.
SourceItem Especifica los datos que se van a vincular dentro de un archivo.
Tabla 8.1.- Propiedades del control contenedor OLE

La propiedad Class determina el tipo de objeto que contiene el control OLE.

Por ejemplo, si contiene datos de una hoja de cálculo de Microsoft Excel
versión 5.0, la propiedad Class es “Excel.Sheet.5”. Object es la propiedad que
representa al objeto contenido en el control OLE, y se utiliza para realizar
tareas de Automatización, que incluyen la manipulación por programa de las
propiedades y métodos que el objeto admite. Mediante la propiedad
SourceDoc se especifica la ubicación y el nombre del archivo de documento
ActiveX.
e) Métodos del control contenedor OLE
La siguiente tabla muestra los métodos más importantes que dispone el
control contenedor OLE.
Método Descripción
CreateEmbed Crea un objeto incrustado.
CreateLink Crea un objeto vinculado.
Ejecuta el verbo especificado (o predeterminado) sobre el objeto; es decir: Abrir, Editar,
DoVerb
Imprimir, etc.
Muestra el cuadro de diálogo Insertar objeto, para escoger el objeto que contendrá el control
InsertObjDlg
OLE.
Muestra el cuadro de diálogo Pegado especial, para pegar el contenido del Portapapeles en
PasteSpecialDlg
el control OLE.
SaveToFile Guarda los datos de objetos incrustados en archivos binarios.
ReadFromFile Recupera los datos guardados en archivos binarios de objetos incrustados.
Tabla 8.2.- Métodos del control contenedor OLE

f) Guardar y recuperar datos de objetos incrustados

Los datos asociados con un objeto incrustado no son persistentes; es decir,
cuando se cierra un formulario que contiene un control contenedor OLE, los
cambios efectuados sobre los datos asociados al control se pierden si no se
guardan previamente. Una vez que los datos se han guardado en un archivo,
posteriormente puede abrir el archivo y restaurar los datos del objeto. Para
esto sólo se pueden utilizar archivos binarios abiertos, y los métodos

152 152
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

SaveToFile o ReadFromFile según corresponda. El procedimiento de guardado

se ilustra a continuación:

153 153
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Private Sub cmdGuardarOLE_Click()

Open "PRUEBA.BIN" For Binary As #1 'Abrir archivo
OLE1.SaveToFile 1 'Guardar arch.
Close #1 'Cerrar arch.
End Sub

Y el procedimiento de evento siguiente permite la recuperación de los datos:

Private Sub cmdRecuperarOLE_Click()
Open "PRUEBA.BIN" For Binary As #1 'Abrir archivo
OLE1.ReadFromFile 1 'Leer archivo
Close #1 'Cerrar arch.
End Sub

Cada vez que se modifica el contenido de un objeto se llama al evento

Updated. Este evento es útil para determinar si los datos de un objeto se han
modificado antes de guardarlos. Para ello, establezca en el evento Updated
una variable global que indique si es necesario guardar el objeto.
) Ejecutar el verbo predeterminado de un objeto
Una vez que se ha cargado un objeto en el contenedor OLE, se puede ejecutar
la acción o verbo predeterminado del objeto mediante el método DoVerb con
argumento 0. La acción o verbo predeterminado es la operación que se lleva a
cabo cuando se efectúa un doble clic sobre el documento fuente en una
ventana o Explorador de Windows. En la mayoría de los casos, el verbo
predeterminado es Editar. Otros verbos comunes son Abrir, Mostrar, Imprimir,
etc. Por ejemplo, el siguiente fragmento de código activa la acción
predeterminada del objeto contenido en OLE1:

OLE1.DoVerb 0 'Cero para verbo predeterminado

8.2.3. Control de aplicación ActiveX

De la misma forma que se utiliza el cuadro de herramientas para agregar a un
formulario uno de los controles incorporados de Visual Basic, también puede
usarse para agregar un objeto de aplicación habilitada para ActiveX. En primer lugar,
se agrega la clase del objeto al cuadro de herramientas y, después, se agrega
el objeto a un formulario. Para agregar la clase de un objeto al cuadro de
herramientas se debe:
a) Elegir Componentes en el menú Proyecto, o presionar Ctrl+T.
b) Del diálogo Componentes, seleccionar la ficha Objetos insertables (ver Figura
8.3).

154 154
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Figura 8.3.- Diálogo Componentes (Objetos insertables)

c) Seleccionar la clase que se desea agregar al cuadro de herramientas. Visual

Basic agregará un botón de esa clase al cuadro de herramientas (ver Figura
8.4).

Excel W ord W ordPad Paint Graph

Figura 8.4.- Cuadro de herramientas (Objetos insertables)

Por ejemplo, para agregar al cuadro de herramientas un botón Hoja de cálculo

de Excel, seleccione Hoja de cálculo de Microsoft Excel en la ficha Objetos
insertables del cuadro de diálogo Componentes. Una vez agregada la clase del
objeto al cuadro de herramientas, puede dibujarla en un formulario para crear
un objeto de esa clase, es decir una hoja de cálculo de Excel sobre el
formulario.

8.3. Componentes de código

8.3.1. Referencias a un objeto

155 155
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Si un componente ActiveX proporciona una biblioteca de tipos, es necesario

agregar una referencia a la biblioteca de tipos en el proyecto de Visual Basic antes
de poder usar los objetos de la biblioteca. Una biblioteca de tipos de un
componente Active X contiene definiciones de todos los objetos que proporciona el

156 156
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

componente, incluidas definiciones para todos los métodos, propiedades y eventos

disponibles.
8.3.2. Crear referencias a objetos
Para crear una referencia a un objeto definido en una biblioteca de tipos es
necesario:
a) Elegir Referencias, en el menú Proyecto. En el cuadro de diálogo Referencias (ver
Figura 7.9), seleccionar el nombre del componente ActiveX que contiene los
objetos que desea usar en la aplicación. Se puede usar el botón Examinar para
buscar el archivo de biblioteca de tipos que contiene el objeto que se necesita.
Las bibliotecas pueden tener una extensión de archivo .olb (librería de objetos)
o .tlb (librería de tipos). Los archivos ejecutables (.exe) y de biblioteca de vínculos
dinámicos (.dll) también pueden proporcionar bibliotecas de tipos, por lo que
también se pueden buscar archivos que tengan estas extensiones de archivo.
b) Elegir Examinador de objetos, en el menú Ver, para ver la biblioteca de tipos a
la que se ha hecho referencia, seleccionando la biblioteca de tipos apropiada
en la lista Proyecto/Biblioteca del cuadro de diálogo Examinador de objetos
(ver Figura 4.1). Se pueden usar todos los objetos, métodos y propiedades
que se enumeran en el Examinador de objetos de la aplicación.
c) Declarar una variable de objeto de la clase del objeto. Por ejemplo, se podría
declarar una variable de la clase Excel.Chart para hacer referencia a un objeto
Chart de Microsoft Excel.
Dim xlChart As Excel.Chart

) Asignar una referencia de objeto a la variable utilizando la palabra clave New,

CreateObject o GetObject en una instrucción Set. Si el objeto es dependiente
(una hoja es dependiente de un libro en Excel), se debe asignar una referencia
de objeto utilizando un método de un objeto de nivel superior en una instrucción
Set. La asignación de referencia de objeto crea propiamente al objeto. En el
ejemplo siguiente se abre el archivo Ingresos.xls como un libro de Microsoft
Excel:
Dim Libro As Excel.Workbook
Set Libro = GetObject("C:\Cuentas\Ingresos.xls")

Observe que antes de usar la instrucción Set, se aplica el punto (c) de declaración
de la variable de objeto; en este caso se declara Libro como libro de Excel.
Utilizar las propiedades y métodos de un objeto
8.3.3.Después de asignar una referencia de objeto a una variable de objeto (después de
rear el objeto), puede usar la variable para manipular las propiedades y los
métodos del objeto. Se mantiene la sintaxis objeto.propiedad para establecer y
evolver los valores de la propiedad de un objeto o la sintaxis objeto.método para
usar los métodos del objeto. Por ejemplo, para cerrar el objeto Libro, mediante su
d
método Close.

Libro.Close

157 157
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

8.3.4. Responder a los eventos de un objeto

Para hacer que una aplicación responda a los eventos de un objeto proporcionado
por componentes ActiveX, primero se debe declarar la variable de objeto mediante
la palabra clave WithEvents, ya que los procedimientos de evento para los objetos
proporcionados por componentes no están disponibles automáticamente. Después
de declarar una variable de objeto mediante WithEvents, en la ventana de código
la variable se utiliza para presentar procedimientos de evento para el objeto.
Entonces se puede agregar código a estos procedimientos para responder a los
eventos del objeto.
En forma detallada, para crear un procedimiento de evento para un objeto
proporcionado por un componente, se siguen los pasos a continuación:
a) La declaración descrita en el punto (c) de 8.3.2, debe hacerse en la sección de
declaraciones de un formulario o módulo de clase, utilizando la palabra reservada
WithEvents de la siguiente manera:
Dim WithEvents Libro As Excel.Workbook

b) Al efectuar la declaración anterior, Visual Basic agrega y muestra el nombre de

la variable de objeto al cuadro de lista Objeto de la ventana de código. Cuando
selecciona la variable de objeto, Visual Basic muestra los procedimientos de
evento del objeto en el cuadro de lista Eventos de la ventana de código (ver
Figura 8.5).

Figura 8.5.- Ventana de código con eventos de un objeto componente

c) Finalmente, sólo resta seleccionar un procedimiento de evento y agregarle el

código que se desea ejecutar cuando se produzca el evento.
Por ejemplo, suponga que una aplicación de Visual Basic se basa en los datos
presentados en un libro de trabajo de Microsoft Excel y que ya ha declarado una
variable de objeto Libro con WithEvents para el libro de trabajo. Es necesario que
cuando un usuario intente cerrar el libro de trabajo, la aplicación muestre un mensaje

158 158
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

explicativo, y evite que se cierre el libro de trabajo, tomando en cuenta que los datos
del libro son vitales en el normal funcionamiento de la aplicación. En

159 159
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

este sentido, el procedimiento de evento idóneo del objeto componente es

Libro_BeforeClose. El fragmento de código siguiente muestra este procedimiento
de evento y las líneas de instrucción que se ejecutarán al intentar cerrar el libro de
trabajo.
Private Sub Libro_BeforeClose(Cancel As Boolean)
Libro.Application.Visible = False
' Oculta la ventana de Microsoft Excel.
MsgBox "Este libro de trabajo debe seguir abierto..."
' Muestra el mensaje explicativo.
Libro.Application.Visible=True
' Muestra nuevamente la ventana de Microsoft Excel.
Cancel = True
' El argumento Cancel a True cancela el cierre.
End Sub

8.3.5. Ejemplo completo usando componente de código

Suponga que ha creado un formulario con tres cuadros de texto (Text1, Text2 y
Text3) y un botón de comando (Command1), y ha agregado al proyecto una
referencia a la biblioteca de objetos de Microsoft Excel (Microsoft Excel 11.0 Object
Library). Se agregará código al procedimiento de evento Command1_Click del
botón de comando que utilice el método Formula de Microsoft Excel para sumar
dos números introducidos en Text1 y Text2, y que muestre el resultado en Text3, tal
como se muestra:
Private Sub Command1_Click()
' Declarar variables de objeto para Microsoft Excel.
Dim Aplicación As Excel.Application
Dim Libro As Excel.Workbook
Dim Hoja As Excel.Worksheet

' Asignar referencias de objeto a las variables.

Set Aplicación = New Excel.Application
Set Libro = xlApp.Workbooks.Add
Set Hoja = xlBook.Worksheets.Add

' Asignar los valores de las cajas de texto a celdas.

Hoja.Cells(1, 1).Value = Text1.Text
Hoja.Cells(2, 1).Value = Text2.Text

' Usar el método Formula para sumar los valores

Hoja.Cells(3, 1).Formula = "=L1C1 + L2C1"
Text3.Text = Hoja.Cells(3, 1)

' Guardar la hoja de cálculo (si lo desea).

Hoja.SaveAs "C:\Temp.xls"

' Cerrar el libro de trabajo con el método Close.

Libro.Close

160 160
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

' Cerrar Microsoft Excel con el método Quit.

Aplicación.Quit

161 161
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

' Liberar los objetos.

Set Aplicación = Nothing
Set Libro = Nothing
Set Hoja = Nothing
End Sub

8.4. Controles ActiveX

8.4.1. Cargar controles ActiveX
Los controles ActiveX tienen la extensión de archivo .ocx. Se pueden usar los
controles ActiveX suministrados con Visual Basic o bien puede conseguir controles
adicionales desarrollados por otros programadores en la Web o por otros medios.
Los controles ActiveX de Visual Basic son controles de 32 bits. Algunos
programadores ofrecen controles ActiveX de 16 bits, que no son compatibles para
Visual Basic 6.0. Al igual que los objetos insertables, para usar controles ActiveX es
necesario cargarlos previamente al cuadro de herramientas. Para agregar un
control al cuadro de herramientas de un proyecto se siguen los siguientes pasos:
a) En el menú Proyecto, haga clic en Componentes para mostrar el cuadro de
diálogo Componentes, como se ve en las figuras 6.5 y 7.5. También se puede
ver el cuadro de diálogo Componentes si hace clic con el botón secundario del
Mouse (ratón) en el cuadro de herramientas, o presionando Ctrl+T.
b) Los elementos que se muestran en este cuadro de diálogo incluyen todos los
controles ActiveX registrados. Marque la casilla de verificación que hay a la
izquierda del nombre del control.
c) Haga clic en Aceptar para que todos los controles ActiveX que haya
seleccionado aparezcan ahora en el cuadro de herramientas.
Para agregar controles ActiveX al cuadro de diálogo Componentes, haga clic en el
botón Examinar y busque los archivos que tengan la extensión .ocx. Estos archivos
suelen estar instalados en el directorio \Windows\System o System32.
8.4.2. Archivos de controles ActiveX
En la tabla siguiente se muestran los nombres de los componentes más comunes
que del cuadro diálogo Componentes, sus archivos y los controles ActiveX que
contienen.
Nombre del
Nombre del componente Controles ActiveX
archivo
Microsoft ADO Data Control 6.0 MSADODC.OCX ADO Data Control
Microsoft Chart Control 5.5 MSCHART.OCX Microsoft Chart
Microsoft Comm Control 6.0 MSCOMM32.OCX MSComm
Microsoft Common Dialog Control 6.0 COMDLG32. OCX CommonDialog
Microsoft Data Bound Grid Control 5.0 DBGRID32.OCX DBGrid
Microsoft Data Bound List Controls 6.0 DBLIST32.OCX DBList, DBCombo
Microsoft Data Grid Control 6.0 MSDATGRD.OCX DataGrid
Microsoft Data List Controls 6.0 MSDATLST.OCX DataList, DataCombo
Microsoft FlexGrid Control 6.0 MSFLXGRD.OCX MSFlexGrid
Microsoft Grid Control GRID32.OCX Grid

162 162
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Microsoft Hierarchical Flex Grid

Control 6.0 MSHFLXGD.OCX MSHFlexGrid
Microsoft MaskedEdit Control 6.0 MSMASK32.OCX MaskedEdit
Microsoft Multimedia Control 6.0 MCI32.OCX Multimedia MCI

163 163
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Nombre del
Nombre del componente Controles ActiveX
archivo
Microsoft PictureClip Control 6.0 PICCLP32.OCX PictureClip
Microsoft RichTextBox Control 6.0 RICHTX32.OCX RichTextBox
Microsoft SysInfo Control 6.0 SYSINFO.OCX SysInfo
Microsoft TabbedDialog Control 6.0 TABCTL32.OCX Microsoft Tab Control
Microsoft Windows Common Controls- Animation, UpDown, MonthView, DTPicker,
2 6.0 MSCOMCT2.OCX
FlatScrollbar
Microsoft Windows Common Controls-
3 6.0 COMCT332.OCX CoolBar
Microsoft Winsock Control 6.0 MSWINSCK.OCX WinSock
TabStrip, Toolbar, StatusBar, ProgressBar,
Microsoft Windows Common Controls MSCOMCTL.OCX TreeView, ListView, ImageList, Slider,
6.0
ImageCombo
Tabla 8.3.- Archivos de controles ActiveX

En adelante se verá una introducción de algunos de los controles ActiveX de la

tabla anterior, refiriéndose a los mismos por su nombre de clase.
8.4.3. Control ActiveX Animation
El control Animation reproduce secuencias de vídeo AVI sin sonido. Una secuencia
AVI está formada por una serie de marcos de mapas de bits, como una película.
Un ejemplo es la hoja de papel que "vuela" de una carpeta a otra al copiar
archivos en el sistema Windows.

Figura 8.6.- Ejemplo del control ActiveX Animation

Aunque las secuencias AVI pueden tener sonido, cuando lo tienen no pueden
usarse con el control Animation y se producirá un error si intenta cargar un archivo
de ese tipo. Sólo puede usar secuencias AVI sin sonido. Para reproducir archivos
.avi con sonido, utilice el control Multimedia (MCI).
Nota: Encontrará diversos archivos .avi sin sonido en el directorio \Graphics\ AVI
del
CD-ROM de Visual Basic.
En tiempo de ejecución, el control Animation no tiene un marco visible. El control
Animation mantiene un subproceso de ejecución independiente mientras se
reproduce la secuencia. Por tanto, la aplicación no se bloquea y puede continuar la
ejecución dentro de su proceso.
Al usar el control, el archivo .avi se abre con el método Open, se reproduce con el
método Play y se detiene con el método Stop. Una vez terminada la reproducción
de un vídeo, puede usar el método Close para cerrar el archivo. No es necesario
164 164
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

cerrar un archivo para poder abrir otro. En el código siguiente se utilizan dos
controles CommandButton, cmdPlay y cmdStop. Como título de cmdPlay,

165 165
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

establezca "Abrir y reproducir". El título del control CommandButton cmdStop es

Private Sub cmdPlay_Click()
"Detener".
anmAvi.Open "C:\Videos\FILECOPY.AVI"
anmAVI.Play
End Sub

Este código detiene la reproducción del vídeo:

Private Sub cmdStop_Click()

anmAVI.Stop
End Sub

Control ActiveX CoolBar

El control CoolBar (Comctl332.ocx) permite crear barras de herramientas
8.4.4.onfigurables por el usuario similares a las de Microsoft Internet Explorer. El
ontrol CoolBar es un control contenedor, capaz de contener otros controles
ecundarios. Consta de una o más zonas dimensionables conocidas como bandas.
Cada banda puede albergar un único control secundario, como se muestra en la
igura 8.7.

Figura 8.7.- Ejemplo de control ActiveX CoolBar

El método para agregar controles secundarios a un control CoolBar varía ligeramente

del método para agregar controles a otros contenedores. El control se debe asociar
primero con un objeto Band; el límite de controles secundarios por banda es de uno,
de tal manera que el control CoolBar contendrá tantos objetos como bandas. Para
agregar un objeto a un CoolBar:
a) Con el control CoolBar seleccionado, seleccione un control del Cuadro de
herramientas y dibújelo sobre el control CoolBar.
b) Abra la Página de propiedades de CoolBar y seleccione la ficha Bandas.
c) Use los botones Index para seleccionar el índice del objeto Band en el que
desea que aparezca el control.
d) Seleccione el control de la lista Secundario.
El control secundario se desplazará y se dimensionará con el objeto Band en
tiempo de ejecución.

166 166
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Nota: Si agrega simplemente un control sin asociarlo a una banda, aparecerá como
un control flotante sobre el control CoolBar en tiempo de ejecución. Para
evitarlo, establezca la propiedad Visible del control a False.

167 167
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Puede modificar los controles contenidos en un CoolBar en tiempo de ejecución

con la propiedad Child del objeto Band.
8.4.5. Control ActiveX DTPicker
El control DateTimePicker muestra información de fecha, de hora o ambas a la vez
y actúa como una interfaz en la que los usuarios pueden modificar la información
de fecha y de hora. Cuando el control DateTimePicker está desplegado, aparece
un calendario.

Figura 8.8.- Ejemplo del control ActiveX DTPicker

El control tiene dos modos de funcionamiento diferentes:

a) En el modo Calendario desplegable (predeterminado, ver Figura 8.8) se
muestra al usuario un calendario en el que puede selecciona una fecha.
b) En el modo Formato de hora, el usuario selecciona un campo en la fecha u
hora mostrada (por ejemplo el mes, el día, el año, hora, minuto, etc.) y establece
su valor con la flecha hacia arriba o hacia abajo situada a la derecha del control.
Puede usar el control para mostrar la fecha en los varios formatos preestablecidos,
entre los cuales están: fecha corta (14/11/97), fecha larga (Viernes, 14 de noviembre
de 1997) y hora (7:00:00 PM). También es posible especificar formatos
personalizados mediante el uso de cadenas de formato.
8.4.6. Control ActiveX ImageList
Un control ImageList contiene una colección de imágenes que pueden usar otros
controles comunes de Windows, específicamente los controles ListView, TreeView,
TabStrip y ToolBar. El uso del control ImageList como almacén único de imágenes
le ahorrará tiempo de desarrollo, pues le permite escribir código que se refiera a
un catálogo de imágenes único y coherente. En lugar de escribir código que
cargue mapas de bits o iconos (con la función LoadPicture), puede llenar el control
ImageList una única vez, asignar valores a la propiedad Key si lo desea y escribir
código que utilice las propiedades Key o Index para hacer referencia a cada una
de las imágenes. El objeto ListImage pertenece a la colección ListImages, y tiene
las propiedades estándar de las colecciones: Key, Index y Count. También dispone
de métodos estándar, como Add, Remove y Clear. Por último, el control presenta

168 168
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

los métodos Overlay, Draw y ExtractIcon, que permiten crear imágenes

compuestas, dibujar imágenes en los objetos que tengan la propiedad hDC y crear

169 169
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

un icono a partir de un mapa de bits almacenado en el control. Para agregar una

imagen (objetos ListImage) en tiempo de diseño, utilice el cuadro de diálogo Páginas
de propiedades del control ImageList:
a) Haga clic con el botón secundario del Mouse (ratón) en el control ImageList y
seleccione Propiedades.
b) Haga clic en la ficha Imágenes para mostrar las páginas de propiedades del
control ImageList, como se ilustra en la figura siguiente.

Figura 8.9.- Propiedades del control ActiveX ImageList

c) Haga clic en el botón Insertar imagen para mostrar el cuadro de diálogo

Seleccionar imagen.
d) Utilice el cuadro de diálogo para buscar los archivos de mapa de bits o de
icono, y después haga clic en Abrir.
e) Asigne un valor único a la propiedad Key. Para esto, haga clic en el cuadro Key
y escriba una cadena.
f) Repita los pasos 3 a 6 hasta que haya llenado el control con las imágenes
deseadas.
8.4.7. Control ActiveX TreeView
El control TreeView está diseñado para mostrar datos de naturaleza jerárquica, como
árboles organizativos, las entradas de un índice, o los archivos y directorios de un
disco. Como veremos en forma detallada, un TreeView está formado por nodos u
objetos Node (ver Figura 8.10).

170 170
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Figura 8.10.-Ejemplo del control ActiveX TreeView

) Establecer las propiedades del objeto Node

Un "árbol" se compone de ramas sucesivas de "nodos" y cada nodo consta
normalmente de una imagen (establecida con la propiedad Image) y una etiqueta
(establecida con la propiedad Text). Un control ImageList asociado al control
TreeView proporciona las imágenes para los nodos. Un nodo puede expandirse
o contraerse dependiendo de si tiene o no nodos secundarios (nodos hijos
que parten de él). En el nivel superior están los nodos "raíz" (padre), y cada
nodo raíz puede tener cualquier número de nodos secundarios. El número
total de nodos no está limitado (salvo por las restricciones del sistema).
Cada nodo de un árbol es en realidad un objeto Node programable que pertenece
a la colección Nodes. Como en otras colecciones, cada miembro de la colección
tiene un valor único en las propiedades Index y Key, lo que permite el
acceso a las propiedades del nodo. Por ejemplo, el código siguiente utiliza el
índice de un nodo determinado ("7") para establecer sus propiedades Image y
Text:

tvwMiÁrbol.Nodes(7).Image = "cerrado"
tvwMiÁrbol.Nodes(7).Text = "IEEE"

Sin embargo, si se ha asignado al nodo una clave única (propiedad Key), por
ejemplo "7 ID", el mismo código se podría escribir de esta forma:

tvwMiÁrbol.Nodes("7 ID").Image = "cerrado"

tvwMiÁrbol.Nodes("7 ID").Text = "IEEE"

) Relaciones entre nodos y referencias a nodos relativos

Cada nodo puede ser secundario (hijo) o primario (padre), según su relación con
otros nodos. El objeto Node cuenta con varias propiedades que devuelven
distintos datos sobre los nodos secundarios o primarios. Por ejemplo, el código
siguiente utiliza la propiedad Children para devolver el número de nodos
secundarios (hijos) que tiene un nodo (el nodo 10):

MsgBox tvwMiÁrbol.Nodes(10).Children

171 171
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Algunas de las propiedades no devuelven información numérica o de dato

como lo hace Children, sino que devuelven una referencia a otro objeto Node.
Por ejemplo, la propiedad Parent devuelve una referencia al nodo primario

172 172
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

(padre) de un nodo específico (hijo). Con esta referencia se puede manipular

el nodo primario, como se muestra en el código siguiente para Text e Index
del nodo primario de nodo 10:
MsgBox tvwMiÁrbol.Nodes(10).Parent.Text
MsgBox tvwMiÁrbol.Nodes(10).Parent.Index

Puede usar la instrucción Set con una variable de objeto de tipo Node para
manipular referencias a otros objetos Node. Por ejemplo, el código siguiente
establece una variable de objeto Node con la referencia que devuelve la
propiedad Parent. Después se utiliza la variable de objeto en lugar del objeto:

Dim tempNode As Node ' Declara una variable de objeto.

Set tempNode = tvwMiÁrbol.Nodes(10).Parent
MsgBox tempNode.Text ' Devuelve la propiedad Text.
MsgBox tempNode.Index ' Devuelve la propiedad Index.

) Agregar objetos Node a la colección Nodes

Para agregar un objeto Node al árbol, utilice el método Add (colección Nodes).
Este método tiene dos argumentos, relative y relationship, que determinan dónde
se agregará el nodo. El primer argumento, relative, indica el nombre de un nodo,
mientras que el segundo, relationship, especifica la relación entre el nuevo nodo
y el indicado en relative. Por ejemplo, el código siguiente agrega un nodo
denominado "nodo 11" como un nodo secundario de otro llamado "nodo 7". La
constante intrínseca tvwChild especifica que el nuevo nodo es un nodo
secundario (hijo) del indicado en el primer argumento. El tercer argumento
asigna la propiedad Key al nuevo nodo.

tvwMiÁrbol.Nodes.Add "nodo 7", tvwChild, "nodo 11"

Otras relaciones posibles, además de tvwChild son las siguientes:

Constante Valor Relación
El nodo se coloca después de todos los nodos que están al mismo nivel que el
tvwLast 1
indicado en relative.
tvwNext 2 El nodo se coloca después del indicado en relative.
tvwPrevious 3 El nodo se coloca delante del indicado en relative.
tvwChild 4 El nodo pasa a ser un nodo secundario del indicado en relative.
Tabla 8.4.- Constantes del argumento relationship

Por ejemplo, suponga que hay tres nodos y que desea colocar un cuarto nodo
entre el segundo y el tercero. El código sería el siguiente:
tvwMiÁrbol.Nodes.Add "nodo 2", tvwNext

Otros argumentos del método Add son key, text e image. Con estos
argumentos puede asignar las propiedades Key, Text e Image al crear el
nuevo objeto Node.
8.4.8. Control ActiveX ListView
El control ListView muestra datos en forma de objetos ListItem. Cada objeto ListItem
puede tener un icono opcional asociado con la etiqueta del objeto. Este control es

173 173
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

idóneo para representar subconjuntos de datos (como los miembros de una base de
datos) u objetos discretos (como plantillas de documentos). Puede

174 174
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

funcionar junto con un control TreeView, para dar al usuario una visión ampliada
de un nodo del control TreeView.
El control ListView puede mostrar los datos en cuatro vistas diferentes:
a) Iconos: permite arrastrar y colocar cada objeto y reorganizar los objetos.

Figura 8.11.-Ejemplo del control ActiveX ListView Vista Iconos grandes

) Iconos pequeños: igual que iconos, pero permite que se vean más objetos
ListItem.

Figura 8.12.-Ejemplo del control ActiveX ListView Vista Iconos pequeños

) Lista: muestra una vista ordenada del objeto ListItems.

Figura 8.13.-Ejemplo del control ActiveX ListView Vista Lista

175 175
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

d) Informe: muestra una vista ordenada, donde los elementos secundarios

permiten que aparezca información adicional.

176 176
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Figura 8.14.-Ejemplo del control ActiveX ListView Vista Reporte

Para cambiar la vista, puede usar la propiedad View. Con la propiedad View puede
permitir al usuario cambiar dinámicamente la vista. En el código siguiente se
establece la propiedad View a vista de Informe (3), mediante la constante
intrínseca lvwReport:
ListView1.View = lvwReport

Un objeto ListItem consta de una etiqueta (la propiedad Text) y una imagen opcional
suministrada por un control ImageList. Sin embargo, el control ListView, a diferencia
de otros controles, puede usar dos controles ImageList, que se establecen a
través de las propiedades Icons y SmallIcons. En las vistas de: Lista, Iconos
pequeños e Informe, puede usar iconos pequeños suministrados por un control
ImageList, para representar cada objeto ListItem. Por el contrario, cuando está en
vista de Iconos, el control utiliza un conjunto de imágenes distinto, suministrado por
un segundo control ImageList. Para establecer las propiedades Icons y SmallIcons
en tiempo de diseño, utilice el cuadro de diálogo Páginas de propiedades.
Nota: El control ImageList determina el tamaño de los iconos empleados. Los
tamaños disponibles son 16 x 16, 32 x 32, 48 x 48 y Personalizado.
En el código siguiente se declara primero una variable de objeto de tipo ListItem y
después se establece esa variable a un único objeto ListItem agregado a la colección
con el método Add. A continuación se establecen las propiedades SmallIcon e Icon
con la referencia de la variable de objeto:
Dim itmX as ListItem
Set itmX = ListView1.ListItems.Add()
itmX.SmallIcon = "LibroPequeño"
itmX.Icon = "LibroGrande"

Una vez establecida las imágenes de un ListItem con las propiedades SmallIcon e
Icon, estas aparecerán automáticamente al cambiar de vista con la propiedad
View. En la vista Reporte, existen los objetos ColumnHeader y ListSubItem. Tanto
la presencia como el número de objetos ListSubItem dependen de la presencia y el
número de objetos ColumnHeader. Es decir, no puede crear ningún objeto
ListSubItem si no hay presentes objetos ColumnHeader. Además, el número de
objetos ColumnHeader determina el número de objetos ListSubItem que puede
establecer para el objeto ListItem, que serán siempre uno menos que el número
177 177
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

de objetos ColumnHeader. Esto se debe a que el primer objeto ColumnHeader

siempre está asociado a la propiedad Text del objeto ListItem.
8.4.9. Control ActiveX ToolBar
Un control Toolbar contiene una colección de objetos Button con los que se crea una
barra de herramientas que puede asociar a una aplicación. Normalmente, una barra
de herramientas contiene botones que corresponden a elementos de algún menú de
la aplicación, lo que proporciona una interfaz gráfica para que el usuario tenga un
acceso rápido a las funciones y comandos utilizados con más frecuencia (ver Figura
8.15).

Figura 8.15.-Ejemplo del control ActiveX ToolBar

Para crear una barra de herramientas, debe agregar objetos Button a una
colección Buttons. Cada objeto Button puede tener un texto y una imagen opcionales,
indicados por un control ImageList asociado. El texto se establece con la propiedad
Caption y la imagen con la propiedad Image de cada objeto Button. En tiempo de
diseño, puede agregar objetos Button al control en el cuadro de diálogo Página de
propiedades de Toolbar. Al hacer doble clic en una barra de herramientas en tiempo
de ejecución se invoca el cuadro de diálogo Personalizar barra de herramientas, que
permite al usuario ocultar, mostrar o reorganizar los botones de la barra de
herramientas. También puede abrir el cuadro de diálogo Personalizar barra de
herramientas si invoca el método Customize. Esto es posible siempre que se
establezca la propiedad AllowCustomize en True. Si desea guardar y restaurar el
estado de una barra de herramientas o permitir que el usuario final lo haga, utilice
los métodos SaveToolbar y RestoreToolbar.
La propiedad Style del objeto Button determina su comportamiento. A
continuación se indican los cinco estilos de botones, con sus usos posibles:
Constante Valor Uso posible
Predeterminado. Puede usar el estilo Default cuando la función que representa el
tbrDefault 0 botón no depende de otras funciones. Además, al hacer clic en el botón, vuelve a
su posición normal cuando la función ha terminado.
Verificación. Debe usar el estilo Check cuando el botón representa una alternancia
TbrCheck 1 de algún tipo. De esta forma, cuando el botón está presionado, continuará así hasta
que se presione de nuevo y queda liberado.
Grupo de botones. Puede usar este estilo ButtonGroup cuando un grupo de
tbrButtonGroup 2 funciones se excluyan mutuamente. Es decir, en un momento dado sólo una de las
funciones que representa el grupo de botones puede estar activada.

178 178
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Separador. Este estilo Separator no tiene otra función que crear un botón de ocho
tbrSeparator 3 píxeles de ancho. Puede usarlo para separar otros dos botones o para agrupar
varios botones que tengan el estilo ButtonGroup.

179 179
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

Constante Valor Uso posible

Marcador de posición. Este estilo Placeholder funciona como un botón "ficticio".
tbrPlaceholder 4 Puede usarlo para crear un espacio en el control Toolbar donde desee que
aparezca otro control (por ejemplo, un control ComboBox o ListBox).
Tabla 8.5.- Estilos del objeto Button de ToolBar

El evento ButtonClick ocurre siempre que se hace clic en un botón (excepto en

aquéllos con el estilo marcador de posición o separador). Puede identificar el botón
en el que se ha hecho clic por sus propiedades Index o Key. Con cualquiera de
estas dos propiedades, puede usar la instrucción Select Case para programar la
función del botón, como ilustra el código del ejemplo siguiente:

Private Sub tlbRTF_Click(ByVal Button As Button)

Select Case Button.Key
Case "AbrirArchivo"
OpenFile
Case "Guardar"
SaveFile
Case Else
' Otros casos.
End Select
End Sub

8.4.10. Control ActiveX TabStrip

Un control TabStrip actúa como los separadores de un cuaderno o las etiquetas de
un grupo de carpetas de archivador. Con el control TabStrip puede definir
múltiples páginas en la misma área de una ventana o un cuadro de diálogo de una
aplicación. El control consta de uno o más objetos Tab de una colección Tabs. En
tiempo de diseño y en tiempo de ejecución puede modificar la apariencia de los
objetos Tab si establece sus propiedades y además, en tiempo de ejecución, si invoca
métodos para agregar y quitar objetos Tab o Ficha como se muestra en la Figura
8.16.

Figura 8.16.-Ejemplo del control ActiveX TabStrip

Para identificar la función de una ficha, puede asignar una imagen del control
ImageList al objeto Tab. Para ello, primero debe asociar un control ImageList al
control TabStrip, lo que puede hacer en tiempo de diseño o en tiempo de
ejecución. Para crear objetos Tab en tiempo de diseño haga clic con el botón
secundario del Mouse en el control TabStrip y, después, haga clic en Propiedades
para abrir el cuadro de diálogo Páginas de propiedades.

180 180
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
8.- Tecnología
8.- Tecnología
OLE OLE

8.4.11. Conclusiones sobre ActiveX

Gracias a la tecnología ActiveX se ha logrado desarrollar componentes software, cuya
característica principal es la interoperabilidad para su reutilización, lo que ha facilitado
enormemente las tareas de programación de alto nivel. Estos fragmentos de código
se han establecidos el nombre de Componentes ActiveX, dentro de los cuales se
encuentran las aplicaciones habilitadas para ActiveX, los componentes de código, los
controles ActiveX y los documentos ActiveX. Este último tipo de componente no se
trata en esta guía, ya que involucra la creación de aplicaciones para Internet, lo que
requiere a su vez la creación de componentes ActiveX, y esto corresponde a un curso
de programación avanzada de objetos con Visual Basic. En todo caso, para usar los
objetos de documentos ActiveX ya creados, se sigue el procedimiento descrito en el
punto 8.4.1, como si fueran controles ActiveX.

181 181
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

Unidad 9

Funciones API

“Tu destino no es sólo saber, sino obrar de acuerdo a tus conocimientos”

.- Fichte

9.1. Teoría de funciones API

9.1.1. Funciones API
Las API son funciones externas a Visual Basic que se encuentran almacenadas y
compiladas en archivos de extensión DLL y EXE. Las siglas API corresponden a
Application Programming Interface o en español, Interfaz para la Programación de
Aplicaciones. Estas funciones API están disponibles en diversos archivos,
incluyendo los archivos DLL o EXE creados por el usuario con lenguajes de nivel
intermedio como C++. Aunque existen incontables funciones API de distintos
proveedores, en esta guía, nos dedicaremos al estudio de algunas de las funciones
del sistema operativo Windows® exclusivamente.
9.1.2. Las API de Windows
Como se explicó anteriormente, las funciones API del sistema operativo Windows
están disponibles para efectuar tareas que Visual Basic no contempla dentro de
sus funciones predefinidas o intrínsecas. Estas funciones del sistema operativo se
encuentran almacenadas en archivos indispensables para Windows, conocidos
como bibliotecas o librerías de vínculos dinámicos. Algunas de estas bibliotecas se
muestran en la tabla siguiente.
Biblioteca de vínculo
dinámico Descripción
Advapi32.dll Servicios, incluidas llamadas de seguridad y del Registro.
Comdlg32.dll Biblioteca de la API de diálogos comunes.
Gdi32.dll Biblioteca de la API para dispositivos gráficos.
Kernel32.dll Soporte común de la API base de 32 bits de Windows.
Lz32.dll Rutinas de compresión de 32 bits.
Mpr.dll Enrutadores de múltiples proveedores.
Netapi32.dll Biblioteca de la API para redes de 32 bits.
Shell32.dll Biblioteca de la API para Shell de 32 bits.
User32.dll Rutinas para interfaces de usuario.
Winmm.dll Multimedia de Windows.
Winspool.drv Contiene las llamadas de la API a la cola de impresión.

Tabla 9.1.- Archivos contenedores de funciones API

9.1.3. Declarar funciones API

182 182
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

Para usar una función API en Visual Basic tal como se usa normalmente una
función del sistema Basic, se deben efectuar tres pasos previos:

183 183
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

a) Declarar la función mediante la sentencia “Declare” en un módulo estándar

previamente creado.
Declare Function NOM Lib “LIB” (Par1, Par2…) As Tipo

b) Declarar las constantes públicas en el módulo estándar. Este paso es opcional

y depende si la función utiliza alguna constante.
Public Const Constante1 = Valor1
Public Const Constante2 = Valor2

c) Declarar las estructuras en forma pública en el módulo estándar. Este paso es

opcional y depende si la función requiere de alguna estructura.
Public Type ESTRUCTURA
Campo1 As Tipo
Campo2 As Tipo
...
End Type

La razón de utilizar un módulo estándar para efectuar las declaraciones, es que de

esta manera la función API implementada quedaría disponible en forma pública
para todos los módulos del proyecto.
9.1.4. Utilizar funciones API
Una vez efectuadas las declaraciones correspondientes para hacer accesible una
función API, esta podrá usarse como cualquier otra función a lo largo de su
programa.
En el ejemplo siguiente, se ha creado un módulo estándar en el cual se escribe el
código necesario para declarar la función API de Windows “ExitWindowsEx”. Esta
función permite apagar, reiniciar y cerrar la sesión del sistema Windows.
ExitWindowsEx reside en el archivo USER32 que se mostró en la tabla 9.1, carece
de estructuras y posee cuatro constantes, las cuales determinan el procedimiento
a ejecutar por la función. Como se observa en el fragmento de código, la función
ExitWindowsEx posee dos parámetros, uFlags que indica en tipo de procedimiento,
y dwReserved que se coloca a cero por tratarse de un parámetro reservado.
Public Const EWX_FORCE = 4
Public Const EWX_LOGOFF = 0
Public Const EWX_REBOOT = 2
Public Const EWX_SHUTDOWN = 1
Public Declare Function ExitWindowsEx Lib "USER32" (ByVal_
uFlags As Long, ByVal dwReserved As Long) As Long

Luego, en cualquier parte del código del programa, se puede llamar a la función.
En este caso, para el ejemplo, se utiliza el procedimiento de evento Click de un botón
de comando para reiniciar el equipo (se usa la constante EWX_REBOOT):

Private Sub cmdBotón_Click()

Dim Ret As Long
Ret = ExitWindowsEx (EWX_REBOOT, 0)
End Sub

184 184
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

También se puede apagar por completo el equipo, pero esta vez se deberá usar la
constante EWX_SHUTDOWN:

Private Sub cmdBotón_Click()

Dim Ret As Long
Ret = ExitWindowsEx (EWX_SHUTDOWN, 0)
End Sub

9.1.5. Visor de texto API

En el paquete de Visual Basic está incluida una utilidad para escribir rápidamente,
de una manera sencilla y evitando errores humanos, las declaraciones, constantes
y estructuras de las funciones API de Windows. Esta utilidad se conoce como el visor
de texto API y su interfaz se muestra en la figura siguiente.

Figura 9.1.- Visor de texto API

La utilidad principal del visor de texto API consiste en que le evita al programador
la tediosa tarea de tener que escribir las declaraciones necesarias para hacer
accesible una función API. El programador selecciona la función, las constantes y
estructuras, las copia y luego las pega en módulos del proyecto.
Los elementos de la interfaz del visor de texto API se describen a continuación:
a) En Tipo de API se selecciona el tipo de elemento que se buscará en el Cuadro
de búsqueda, sólo escribiendo las primeras letras del nombre de la función, es
decir, puede ser la declaración, las constantes o las estructuras.

185 185
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

b) En elementos disponibles aparecerán las declaraciones, constantes o

estructuras disponibles según se halla escogido en Tipo de API.

186 186
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

c) En la sección Elementos seleccionados, aparecerán las declaraciones de la

función, constantes o estructuras agregadas con el botón Agregar. Los
elementos se pueden agregar públicos o privados.
d) Mientras que el botón Quitar permite eliminar un elemento de la sección
Elementos seleccionados, el botón Borrar elimina todos los elementos.
e) Finalmente, se debe presionar el botón Copiar para colocar el contenido de la
sección Elementos seleccionados en el portapapeles del sistema, esto con el
objeto de pegar las declaraciones en el módulo estándar creado para tal fin.

9.2. Técnicas para usar funciones API

9.2.1. Resolver conflictos de nombre de API
Ocasionalmente, los procedimientos de DLL tienen un nombre que no es un
identificador válido, ya sea por un carácter inválido (por ejemplo, un guión) o porque
coincida con una palabra clave de Visual Basic (por ejemplo, GetObject). En este
caso, se utiliza la palabra clave Alias para especificar el nombre del procedimiento
no válido.
9.2.2. Enviar cadenas a funciones API
Visual Basic emplea un tipo de datos String conocido como BSTR, que es un tipo
de datos definido por Automatización, y está formado por un encabezado, que
contiene información acerca de la longitud de la cadena. Este tipo de datos se
pasa como un puntero, por lo que el procedimiento de DLL es capaz de modificar
la cadena. (Un puntero es una variable que contiene la ubicación en memoria de otra
variable, en lugar de los datos reales.) Los datos BSTR son Unicode, lo que significa
que cada carácter ocupa dos bytes. Por otra parte, los procedimientos de la mayoría
de los archivos DLL reconocen los tipos LPSTR, que son punteros de cadenas de C
terminadas con un carácter nulo. Los tipos LPSTR no tienen encabezado. Si un
procedimiento de DLL espera un LPSTR (un puntero a una cadena terminada con un
carácter nulo) como argumento, se pasa el tipo de datos de Visual Basic BSTR por
valor. Puesto que los punteros del tipo BSTR son punteros al primer byte de
datos de la cadena terminada con un carácter nulo, parecerá un tipo LPSTR para el
procedimiento de DLL. Por ejemplo, la función sndPlaySound acepta una cadena que
asigna nombre a un archivo de sonido digitalizado (.wav) y reproduce ese archivo.
Private Declare Function sndPlaySound Lib "winmm.dll" _
Alias "sndPlaySoundA" (ByVal lpszSoundName As String, _
ByVal uFlags As Long) As Long

Puesto que el argumento de cadena para este procedimiento se declara mediante

ByVal, Visual Basic pasa un tipo BSTR que apunta al primer byte de datos:
Dim SoundFile As String, ReturnLength As Long
SoundFile = Dir("c:\Windows\System\" & "*.wav")
Result = sndPlaySound(SoundFile, 1)

9.2.3. Recibir cadenas de funciones API

187 187
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

La función GetWindowsDirectory verifica la instalación del sistema operativo y

devuelve en una cadena la ruta completa del directorio donde se almacena Windows.
No requiere de constantes ni de estructuras; sin embargo, el hecho de

188 188
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

devolver una cadena, implica un tratamiento especial a la misma, y la necesidad

de implementar una función auxiliar, tal como se estudió en el objetivo 4.4. Este
trato especial se debe a que las funciones API están desarrolladas en lenguaje C,
donde las cadenas poseen un carácter Nulo que indica fin de cadena; y en Visual
Basic este carácter no existe. Por lo tanto, el caracter nulo de la cadena devuelta
debe ser truncado o eliminado.
El proceso se inicia declarando variables tipo cadena con longitud fija, y rellenando
cada posición con espacios vacíos, para luego utilizar la función API. A la cadena
devuelta se le extirpa el carácter nulo y los subsiguientes espacios vacíos
sobrantes. A continuación tenemos la declaración de la función API
GetWindowsDirectory:
Public Declare Function GetWindowsDirectory Lib "kernel32"
Alias "GetWindowsDirectoryA" (ByVal lpBuffer As String, ByVal
nSize As Long) As Long

hora una función personalizada se encarga de ejecutar todo el proceso,

incluyendo la llamada de la función API:

Public Function DirWindows() As String

Dim ret As Long
Dim Cadena As String * 200
Cadena = Space(200)
ret = GetWindowsDirectory(Cadena, 200)
If ret <> 0 Then
Cadena = Left(Cadena, InStr(Cadena, vbNullChar) - 1)
DirWindows = Trim(Cadena)
Else
DirWindows = "No existe directorio Windows"
End If
End Function

En adelante, para obtener el directorio de Windows, bastará con utilizar la función

DirWindows de la siguiente manera:

Text1.Text = DirWindows()

9.2.4. Utilizar procedimientos generales auxiliares

Para determinar el estado de ocupación y espacio libre de un disco, se puede
utilizar la función API GetDiskFreeSpaceEx, la cual se declara a continuación:

Public Declare Function GetDiskFreeSpace Lib "kernel32" Alias

"GetDiskFreeSpaceA" (ByVal lpRootPathName As String,
lpSectorsPerCluster As Long, lpBytesPerSector As Long,
lpNumberOfFreeClusters As Long, lpTotalNumberOfClusters As
Long) As Long

Como se observa, el nombre de la función resulta bastante extenso, además de la

cantidad de parámetros. En esta circunstancia es oportuno utilizar un
procedimiento general que facilite el uso de esta función cada vez que se requiera.

189 189
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

El procedimiento general Espacio cumple con esta función:

190 190
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

Sub Espacio(Ruta As String, Cap As String, Libre As String)

Dim ret As Long
Dim P1 As Currency 'Bytes libres
Dim P2 As Currency 'Capacidad del disco
Dim P3 As Currency 'Espacio libre total
ret = GetDiskFreeSpaceEx(Ruta, P1, P2, P3)
Libre = Format(P1 * 1000)
Cap = Format(P2 * 1000)
End Sub

La próxima vez que se deseen determinar las condiciones de capacidad del disco,
basta con utilizar el procedimiento general Espacio:
Dim Tamaño As String
Dim Libre As String
Espacio "C:\", Tamaño, Libre
lblCapacidadDeDisco.Caption = Tamaño
lblEspacioLibreDeDisco.Caption = Libre

9.2.5. Utilizar funciones API sin parámetros

Existe una función API que devuelve el tiempo en milisegundos desde que se
encendió el PC, denominada GetTickCount. Esta función no posee parámetros, ni
constantes, ni estructuras, y es muy útil para generar retardos de tiempo para
programas de juegos u otras aplicaciones. La declaración es la siguiente:
Public Declare Function GetTickCount Lib "kernel32" Alias
"GetTickCount" () As Long

A diferencia del punto anterior (9.2.4), en estos casos se debe evitar el uso de
funciones o procedimientos auxiliares como este:
Function Tiempo()
Tiempo = GetTickCount()
End Sub

Lo anterior no ofrece alguna ventaja significativa, y lo que realmente si ocasiona

es más tiempo de procesamiento. Se puede pensar en un procedimiento que
encapsule un conjunto de pasos para logra un objetivo en particular donde la función
API intervenga. Tal es el caso del procedimiento siguiente para generar un retardo
de tiempo:

Sub Retardo(Tiempo As Long)

Dim Inicio As Long
Inicio = GetTickCount()
Do While Not(GetTickCount >= Inicio + Tiempo)
DoEvents
Loop
End Sub

Luego, cuando sea necesario detener la ejecución de un programa (por alguna razón
operativa) durante 10 segundos por ejemplo, bastará incluir la siguiente línea de
código en la parte del programa donde se desea el retardo:

191 191
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

Retardo (10000)

192 192
VisualVisual
Basic Basic
6.0 6.0 Unidad
Unidad
9.- Funciones
9.- Funciones
API API

Consideración final
En esta guía sólo se han mostrado algunos ejemplos de utilidades de las funciones
API. En realidad existe una enorme cantidad de funciones API y controles ActiveX,
tanto en el sistema operativo Windows, como en otros; siendo Internet la principal
fuente de ellos. Este es el inicio para el desarrollo de aplicaciones más robustas y
profesionales.
El programador mas destacado es aquel que aprovecha, no sólo las herramientas
intrínsecas de Visual Basic, sino las provistas a través de la API y los componentes
ActiveX. Esta es la línea divisoria que separa a los novatos, de los programadores
avanzados. Aún queda algo de camino que recorrer: crear nuestros propios
objetos, diseñar aplicaciones para redes incluyendo Internet con DHTML, agregar
ayuda a las aplicaciones, controlar puertos u otro hardware del PC para desarrollos
SCADA o similares, etc.; pero estamos armados con los fundamentos necesarios para
alcanzar, muy pronto, el nivel de expertos.
¡Suerte programadores!

193 193