Está en la página 1de 159

Curso Visual Basic 5.

Qué es Visual Basic ? ----------------------------------------------------------------------------- 9


Ediciones de Visual Basic--------------------------------------------------------------------------------------- 9
1- Introducción: -------------------------------------------------------------------------------- 10
1.1- Programación orientada a objetos. ---------------------------------------------------------- 10
1.1.1- Objetos. ---------------------------------------------------------------------------------------------------10
1.1.2- Propiedades. ----------------------------------------------------------------------------------------------10
1.1.3- Métodos. --------------------------------------------------------------------------------------------------10
1.1.4- Eventos. ---------------------------------------------------------------------------------------------------10
1.1.5- Explicación integrada y ejemplo de Objetos, Propiedades, Métodos y Eventos.----------------10
1.1.6- Diferencias entre la programación procedural y la programación bajo Windows. --------------11
1.3- Proyecto. ------------------------------------------------------------------------------------------ 12
1.3.1- Definición de Proyecto en Visual Basic. -------------------------------------------------------------12
1.3.2-Componentes de un Proyecto. --------------------------------------------------------------------------13
1.4-Entorno de Desarrollo.-------------------------------------------------------------------------- 14
1.4.1-Barra de menú. y 1.4.2-Barra de Herramientas. ------------------------------------------------------14
1.4.3-Ventana de Proyecto. ------------------------------------------------------------------------------------14
1.4.4- Formulario. -----------------------------------------------------------------------------------------------14
1.4.5- Ventana de Propiedades.--------------------------------------------------------------------------------15
1.4.6- Caja de Herramientas.-----------------------------------------------------------------------------------15
2-Programación: --------------------------------------------------------------------------------- 16
2.1- Fundamentos de la Programación. ---------------------------------------------------------- 16
2.1.1- Como funciona una aplicación controlada por eventos. --------------------------------------------16
2.2- Variables. ----------------------------------------------------------------------------------------- 16
2.2.1- Alcance de las variables.--------------------------------------------------------------------------------16
Establecimiento del alcance de las variables ------------------------------------------------ 17
Variables utilizadas en un procedimiento-------------------------------------------------------- 17
Variables utilizadas en un módulo ---------------------------------------------------------------- 17
Variables utilizadas por todos los módulos ------------------------------------------------------ 17
2.2.2- Declaración -----------------------------------------------------------------------------------------------17
2.2.3- Tipos de variables ---------------------------------------------------------------------------------------18
2.2.4- Matrices---------------------------------------------------------------------------------------------------18
2.3- Procedimientos y funciones.------------------------------------------------------------------- 19
2.3.1-Introducción a los Procedimientos. --------------------------------------------------------------------19
2.3.2- Procedimientos. ------------------------------------------------------------------------------------------20
Procedimientos generales --------------------------------------------------------------------------- 20
Procedimientos de evento --------------------------------------------------------------------------- 20
2.3.3- Funciones. ------------------------------------------------------------------------------------------------21
2.3.4- Llamadas a Procedimientos.----------------------------------------------------------------------------22
2.3.5- Llamadas a Funciones. ----------------------------------------------------------------------------------22
2.3.6- Pasaje de argumentos a los procedimientos y funciones.-------------------------------------------22
Tipos de datos de los argumentos------------------------------------------------------------------ 22
Paso de argumentos por valor---------------------------------------------------------------------- 23
Paso de argumentos por referencia --------------------------------------------------------------- 23
2.4- Estructuras de Control (Repetición y Decisión). ------------------------------------------ 23

Página 2 de 159
Curso Visual Basic 5.0

2.4.1-Do While – Loop / Do – Loop While. -----------------------------------------------------------------23


2.4.2- For – Next.------------------------------------------------------------------------------------------------24
2.4.3- If – Else – End If.------------------------------------------------------------------------------ 25
If...Then...Else ----------------------------------------------------------------------------------------- 26
2.4.4- Select - Case----------------------------------------------------------------------------------------------26
3- Controles-------------------------------------------------------------------------------------- 27
3.1- Controles básicos -------------------------------------------------------------------------------- 27
3.1.1- APLICACION DE EJEMPLO-------------------------------------------------------------------------32
4 -Formularios. ----------------------------------------------------------------------------------- 34
4.1- Estableciendo las Propiedades más importantes de los formularios.------------------ 34
4.2- Eventos y Métodos de los formularios. ------------------------------------------------------ 34
4.3- Establecer el formulario de arranque de la aplicación. ---------------------------------- 35
5 -Combo Box (lista combo)-------------------------------------------------------------------- 36
6- List Box (lista). -------------------------------------------------------------------------------- 37
7- Timer (cronómetro)--------------------------------------------------------------------------- 38
Propiedades:------------------------------------------------------------------------------------------- 38
8- Shape (figura). -------------------------------------------------------------------------------- 38
9- Line (línea). ------------------------------------------------------------------------------------ 38
Método Refresh --------------------------------------------------------------------------------------- 39
Método ZOrder --------------------------------------------------------------------------------------- 39
10- Image (imagen) ------------------------------------------------------------------------------ 39
11- Data (acceso a bases de datos) ------------------------------------------------------------ 40
12- Controles enlazados------------------------------------------------------------------------- 40
12.1 Funcionamiento --------------------------------------------------------------------------------- 40
12.2 Validación ---------------------------------------------------------------------------------------- 41
12.3 Objetos de acceso a datos --------------------------------------------------------------------- 41
12.4 Ediciones Profesional y Empresarial-------------------------------------------------------- 41
12.5 Consultas almacenadas ------------------------------------------------------------------------ 41
12.6 Tratamiento de BOF/EOF -------------------------------------------------------------------- 41
13 -Eventos más importantes de los controles estándares.-------------------------------- 42
13.1-Change-------------------------------------------------------------------------------------------- 42
Ejemplo del evento Change ------------------------------------------------------------------------- 43
13.2-Click ---------------------------------------------------------------------------------------------- 44
Ejemplo del Evento Click -------------------------------------------------------------------------- 45
13.3- GotFocus ---------------------------------------------------------------------------------------- 45

Página 3 de 159
Curso Visual Basic 5.0

13.4- KeyPress----------------------------------------------------------------------------------------- 46
13.5- Load ---------------------------------------------------------------------------------------------- 47
13.6- LostFocus---------------------------------------------------------------------------------------- 47
Ejemplo del evento LostFocus---------------------------------------------------------------------- 48
13.7- MouseMove ------------------------------------------------------------------------------------- 48
13.8- Timer--------------------------------------------------------------------------------------------- 49
13.9- Unload ------------------------------------------------------------------------------------------- 51
13.10- QueryUnload---------------------------------------------------------------------------------- 52
13.11- Validate ---------------------------------------------------------------------------------------- 53
Ejemplo de la propiedad DataChanged y del evento Validate ------------------------------- 54
14- Métodos más importantes de los controles estándares. ------------------------------- 54
14.1- AddItem ----------------------------------------------------------------------------------------- 54
Ejemplo del método AddItem ---------------------------------------------------------------------- 55
14.2- AddNew (Objeto Recordset)----------------------------------------------------------------- 55
14.3- CancelUpdate (Objeto Recordset) --------------------------------------------------------- 56
14.4- Clear (Clipboard, Combo Box, List Box) ------------------------------------------------- 57
14.5- Close (Objetos Database, Recordset o Workspace) ------------------------------------- 58
14.6- Cls ------------------------------------------------------------------------------------------------ 59
Sintaxis ------------------------------------------------------------------------------------------------- 59
Comentarios ------------------------------------------------------------------------------------------- 59
14.7- CompactDatabase (Objeto DBEngine) ---------------------------------------------------- 59
Sintaxis ------------------------------------------------------------------------------------------------- 59
Ejemplo de método CompactDatabase ----------------------------------------------------------- 61
14.8- Delete (Objeto Recordset) -------------------------------------------------------------------- 61
Comentarios ------------------------------------------------------------------------------------------- 61
Ejemplo de método Delete -------------------------------------------------------------------------- 62
14.9- Edit (Objeto Recordset) ---------------------------------------------------------------------- 62
Comentarios ------------------------------------------------------------------------------------------- 62
Ejemplo de método Edit----------------------------------------------------------------------------- 63
14.10- Hide --------------------------------------------------------------------------------------------- 63
Comentarios ------------------------------------------------------------------------------------------- 64
14.11-MoveFirst - MoveLast - MoveNext – MovePrevious (Objeto Recordset) ---------- 64
Sintaxis ------------------------------------------------------------------------------------------------- 64
Comentarios ------------------------------------------------------------------------------------------- 64
14.12- OpenDatabase (Objeto Workspace) ------------------------------------------------------ 65

Página 4 de 159
Curso Visual Basic 5.0

14.13- OpenRecordset (Objeto Database)-------------------------------------------------------- 66


Ejemplo del método OpenRecordset -------------------------------------------------------------- 68
14.14- RemoveItem ----------------------------------------------------------------------------------- 68
14.15- RepairDatabase (Objeto DBEngine)------------------------------------------------------ 69
Ejemplo del método RepairDatabase ------------------------------------------------------------- 70
14.16- SetFocus---------------------------------------------------------------------------------------- 70
Sintaxis ------------------------------------------------------------------------------------------------- 70
Ejemplo del método SetFocus ---------------------------------------------------------------------- 70
14.17- Show -------------------------------------------------------------------------------------------- 71
14.18- Update (Objeto recordset) ------------------------------------------------------------------ 71
Sintaxis ------------------------------------------------------------------------------------------------- 72
Comentarios ------------------------------------------------------------------------------------------- 72
15- Propiedades más importantes de los controles estándares. -------------------------- 72
15.1- ActiveControl----------------------------------------------------------------------------------- 73
15.2- BackColor, ForeColor ------------------------------------------------------------------------ 73
15.3- BackStyle ---------------------------------------------------------------------------------------- 74
15.4-BOF. EOF (Objeto Recordset)--------------------------------------------------------------- 75
15.5-BOFAction, EOFAction----------------------------------------------------------------------- 76
15.6-BorderStyle -------------------------------------------------------------------------------------- 77
Valores-------------------------------------------------------------------------------------------------- 77
15.7-Caption ------------------------------------------------------------------------------------------- 77
Ejemplo de la propiedad Caption ----------------------------------------------------------------- 78
15.8-DatabaseName ---------------------------------------------------------------------------------- 78
String--------------------------------------------------------------------------------------------------------------79
15.9-DataChanged------------------------------------------------------------------------------------ 79
Sintaxis ------------------------------------------------------------------------------------------------- 80
Tipo de datos ------------------------------------------------------------------------------------------ 80
15.10-DataField --------------------------------------------------------------------------------------- 80
15.11-DataSource ------------------------------------------------------------------------------------- 81
Comentarios ------------------------------------------------------------------------------------------- 81
15.12-Enabled ----------------------------------------------------------------------------------------- 81
Ejemplo de la propiedad Enabled ----------------------------------------------------------------- 82
15.13-FontBold, FontItalic, FontStrikethru, FontUnderline. -------------------------------- 82
15.14-FontName -------------------------------------------------------------------------------------- 83
15.15-FontSize----------------------------------------------------------------------------------------- 84

Página 5 de 159
Curso Visual Basic 5.0

Comentarios ------------------------------------------------------------------------------------------- 85
15.16-Heigth, Width---------------------------------------------------------------------------------- 85
15.17-Icon ---------------------------------------------------------------------------------------------- 86
Sintaxis ------------------------------------------------------------------------------------------------- 86
15.18-Index (Matriz de Controles) ---------------------------------------------------------------- 87
Ejemplo de la propiedad Index -------------------------------------------------------------------- 87
15.19-ListCount --------------------------------------------------------------------------------------- 88
15.20-ListIndex---------------------------------------------------------------------------------------- 89
Sintaxis ------------------------------------------------------------------------------------------------- 89
Comentarios ------------------------------------------------------------------------------------------- 89
15.21-Locked ------------------------------------------------------------------------------------------ 90
15.22-MousePointer ---------------------------------------------------------------------------------- 90
Sintaxis ------------------------------------------------------------------------------------------------- 90
Comentarios ------------------------------------------------------------------------------------------- 91
15.23-Multiline ---------------------------------------------------------------------------------------- 91
Sintaxis ------------------------------------------------------------------------------------------------- 92
Comentarios ------------------------------------------------------------------------------------------- 92
15.24-Name -------------------------------------------------------------------------------------------- 92
Sintaxis ------------------------------------------------------------------------------------------------- 92
15.25-NewIndex --------------------------------------------------------------------------------------- 93
Comentarios ------------------------------------------------------------------------------------------- 93
15.26-ItemData---------------------------------------------------------------------------------------- 93
Ejemplo de la propiedad ItemData---------------------------------------------------------------- 94
15.27-PassWordChar -------------------------------------------------------------------------------- 94
Ejemplo de la propiedad PasswordChar--------------------------------------------------------- 95
15.28-Picture------------------------------------------------------------------------------------------- 95
Comentarios ------------------------------------------------------------------------------------------- 95
15.29-Recordset --------------------------------------------------------------------------------------- 96
15.30-RecordsetType--------------------------------------------------------------------------------- 97
15.31-RecordSource ---------------------------------------------------------------------------------- 99
Sintaxis ------------------------------------------------------------------------------------------------- 99
String------------------------------------------------------------------------------------------------------------ 100
15.32-Shape -------------------------------------------------------------------------------------------100
Valores-------------------------------------------------------------------------------------------------100
15.33-SQL (Objeto QueryDef) --------------------------------------------------------------------101

Página 6 de 159
Curso Visual Basic 5.0

Comentarios ------------------------------------------------------------------------------------------101
15.34-Stretch------------------------------------------------------------------------------------------102
Comentarios ------------------------------------------------------------------------------------------102
15.35-Style---------------------------------------------------------------------------------------------103
15.36-TabIndex --------------------------------------------------------------------------------------105
Ejemplo de la propiedad TabIndex --------------------------------------------------------------105
15.37-TabStop ----------------------------------------------------------------------------------------106
15.38-Tag----------------------------------------------------------------------------------------------106
15.39-Text ---------------------------------------------------------------------------------------------107
Comentarios ------------------------------------------------------------------------------------------107
15.40-ToolTipText-----------------------------------------------------------------------------------108
15.41-Value -------------------------------------------------------------------------------------------108
15.42-Visible ------------------------------------------------------------------------------------------109
15.43-WindowState----------------------------------------------------------------------------------110
16- Operadores.---------------------------------------------------------------------------------- 111
16.1-Operadores Aritméticos. ---------------------------------------------------------------------111
Operador ^: Se utiliza para elevar un número a la potencia del exponente. -------------112
16.2-Operadores de Comparación. ---------------------------------------------------------------112
Sintaxis ------------------------------------------------------------------------------------------------112
16.3-Operadores de Concatenación. -------------------------------------------------------------113
16.4-Operadores Lógicos. --------------------------------------------------------------------------113
17- Funciones más importantes de Visual Basic. ----------------------------------------- 113
17.1-Asc. -----------------------------------------------------------------------------------------------113
17.2-Date ----------------------------------------------------------------------------------------------114
Date ---------------------------------------------------------------------------------------------------------- 114
17.3-DateDiff -----------------------------------------------------------------------------------------114
17.4-DoEvents ----------------------------------------------------------------------------------------115
17.5-Format-------------------------------------------------------------------------------------------116
17.6-Iif -------------------------------------------------------------------------------------------------117
17.7-InputBox ----------------------------------------------------------------------------------------118
17.8-Int, Fix -------------------------------------------------------------------------------------------119
Sintaxis ------------------------------------------------------------------------------------------------119
Comentarios ------------------------------------------------------------------------------------------119
17.9-IsDate --------------------------------------------------------------------------------------------119
Sintaxis ------------------------------------------------------------------------------------------------119

Página 7 de 159
Curso Visual Basic 5.0

Comentarios ------------------------------------------------------------------------------------------119
17.10-IsNull -------------------------------------------------------------------------------------------120
Sintaxis ------------------------------------------------------------------------------------------------120
Comentarios ------------------------------------------------------------------------------------------120
17.11-Left ---------------------------------------------------------------------------------------------120
Ejemplo de la función Left-------------------------------------------------------------------------121
17.12-Len ----------------------------------------------------------------------------------------------121
Sintaxis ------------------------------------------------------------------------------------------------121
Comentarios ------------------------------------------------------------------------------------------121
17.13-LoadPicture -----------------------------------------------------------------------------------121
17.14-Ltrim, Rtrim y Trim ------------------------------------------------------------------------122
Sintaxis ------------------------------------------------------------------------------------------------122
17.15-Mid ---------------------------------------------------------------------------------------------123
Comentarios ------------------------------------------------------------------------------------------123
Ejemplo de la función Mid-------------------------------------------------------------------------123
17.16-MsgBox ----------------------------------------------------------------------------------------123
17.17-Right--------------------------------------------------------------------------------------------125
17.18-Str-----------------------------------------------------------------------------------------------126
Comentarios ------------------------------------------------------------------------------------------126
17.19-Ucase -------------------------------------------------------------------------------------------126
17.20-Val ----------------------------------------------------------------------------------------------126
Comentarios ------------------------------------------------------------------------------------------127
Ejemplo de la instrucción MkDir-----------------------------------------------------------------128
Sintaxis ------------------------------------------------------------------------------------------------128
Option Explicit --------------------------------------------------------------------------------------------- 130
Figura: Barras separadoras ----------------------------------------------------------------------134
Comentarios ------------------------------------------------------------------------------------------146
Sintaxis ------------------------------------------------------------------------------------------------146
Importante --------------------------------------------------------------------------------------------148
Sintaxis ------------------------------------------------------------------------------------------------152
Comentarios ------------------------------------------------------------------------------------------153

Página 8 de 159
Curso Visual Basic 5.0

Qué es Visual Basic ?


¿Qué es Visual Basic? La palabra "Visual" hace referencia al método que se utiliza para crear la interfaz
gráfica de usuario (GUI). En lugar de escribir numerosas líneas de código para describir la apariencia y la
ubicación de los elementos de la interfaz, simplemente puede arrastrar y colocar objetos prefabricados en su
lugar dentro de la pantalla. Si ha utilizado alguna vez un programa de dibujo como Paint, ya tiene la mayor
parte de las habilidades necesarias para crear una interfaz de usuario efectiva.
La palabra "Basic" hace referencia al lenguaje BASIC (Beginners All-Purpose Symbolic Instruction Code), un
lenguaje utilizado por más programadores que ningún otro lenguaje en la historia de la informática o
computación. Visual Basic ha evolucionado a partir del lenguaje BASIC original y ahora contiene centenares
de instrucciones, funciones y palabras clave, muchas de las cuales están directamente relacionadas con la
interfaz gráfica de Windows. Los principiantes pueden crear aplicaciones útiles con sólo aprender unas
pocas palabras clave, pero, al mismo tiempo, la eficacia del lenguaje permite a los profesionales acometer
cualquier objetivo que pueda alcanzarse mediante cualquier otro lenguaje de programación de Windows.
El lenguaje de programación Visual Basic no es exclusivo de Visual Basic. La Edición para aplicaciones del
sistema de programación de Visual Basic, incluida en Microsoft Excel, Microsoft Access y muchas otras
aplicaciones Windows, utilizan el mismo lenguaje. El sistema de programación de Visual Basic, Scripting
Edition (VBScript) para programar en Internet es un subconjunto del lenguaje Visual Basic. La inversión
realizada en el aprendizaje de Visual Basic le ayudará a abarcar estas otras áreas.
Si su objetivo es crear un pequeño programa para su uso personal o para su grupo de trabajo, un sistema
para una empresa o incluso aplicaciones distribuidas de alcance mundial a través de Internet, Visual Basic
dispone de las herramientas que necesita.
• Las características de acceso a datos le permiten crear bases de datos y aplicaciones cliente para los
formatos de las bases de datos más conocidas, incluidos Microsoft SQL Server y otras bases de datos
de ámbito empresarial.
• Las tecnologías ActiveX™ le permiten utilizar la funcionalidad proporcionada por otras aplicaciones, como
el procesador de textos Microsoft Word, la hoja de cálculo Microsoft Excel y otras aplicaciones Windows.
Puede incluso automatizar las aplicaciones y los objetos creados con la Edición profesional o la Edición
empresarial de Visual Basic.
• Las capacidades de Internet facilitan el acceso a documentos y aplicaciones a través de Internet desde
su propia aplicación.
• La aplicación terminada es un auténtico archivo .exe que utiliza una biblioteca de vínculos dinámicos
(DLL) de tiempo de ejecución que puede distribuir con toda libertad.

Ediciones de Visual Basic


Visual Basic se encuentra disponible en tres versiones, cada una de las cuales está orientada a unos
requisitos de programación específicos.
• La Edición de aprendizaje de Visual Basic permite a los programadores crear robustas aplicaciones para
Microsoft Windows 95 y Windows NT®. Incluye todos los controles intrínsecos, además de los controles
de cuadrícula, de fichas y los controles enlazados a datos. La documentación que se proporciona con
esta edición incluye Learn VB Now (un CD-ROM multimedia), un Manual del programador impreso, la
Ayuda en pantalla y los Libros en pantalla de Visual Basic.
• La Edición profesional proporciona a los profesionales un completo conjunto de herramientas para
desarrollar soluciones para terceros. Incluye todas las características de la Edición de aprendizaje, así
como controles ActiveX adicionales, incluidos controles para Internet y el Generador de informes de
Crystal Reports. La documentación que se proporciona con la Edición profesional incluye el Manual del
programador, la Ayuda en pantalla, la Guía de herramientas componentes y el Manual del usuario de
Crystal Reports para Visual Basic.

Página 9 de 159
Curso Visual Basic 5.0

• La Edición empresarial permite a los profesionales crear sólidas aplicaciones distribuidas en un entorno
de equipo. Incluye todas las características de la Edición profesional, asó como el Administrador de
automatización, la Galería de objetos, las herramientas de administración de bases de datos, el sistema
de control de versiones orientado a proyectos Microsoft Visual SourceSafe™, etc. La documentación
impresa que se proporciona con la Edición empresarial incluye toda la documentación de la Edición
profesional, y la Guía para la creación de aplicaciones cliente-servidor con Visual Basic y el Manual del
usuario de SourceSafe.

1- Introducción:

1.1- Programación orientada a objetos.

1.1.1- Objetos.

Un objeto es una entidad que tiene asociado un conjunto de métodos, eventos y propiedades. Ejemplo : Una caja de texto
(TextBox) en la cual podemos escribir cualquier línea es un objeto.

1.1.2- Propiedades.

Son las características que posee un objeto o un formulario (ventana de Windows).


Ejemplo : Color de fondo del formulario, Fuente de texto de un TextBox, ….

1.1.3- Métodos.

Los métodos son funciones internas de un determinado objeto que permite realizar funciones sobre él o sobre otro objeto.
Ejemplo : Deseamos poner en la ventana Windows de nuestra aplicación "Hola mundo", por tanto pondremos el método ->
Ventana.Print "Hola mundo"

1.1.4- Eventos.

Los eventos son acciones que se pueden realizar en cualquier control: click, doble click, movimiento del ratón. A estos
eventos se les puede asociar código para que se ejecute al producir el evento.
Un programa Visual Basic es un POE (Programa orientado a eventos).
Todo lo que hacemos en un programa Visual Basic está generado por medio de eventos

1.1.5- Explicación integrada y ejemplo de Objetos, Propiedades, Métodos y Eventos.

Los formularios y controles de Visual Basic son objetos que exponen sus propios métodos, propiedades y eventos. Las
propiedades se pueden considerar como atributos de un objeto, los métodos como sus acciones y los eventos como sus
respuestas.
Un objeto de uso diario como el globo de un niño tiene también propiedades, métodos y eventos. Entre las propiedades
de un globo se incluyen atributos visibles como el peso, el diámetro y el color. Otras propiedades describen su estado
(inflado o desinflado) o atributos que no son visibles, como su edad. Por definición, todos los globos tienen estas
propiedades; lo que varía de un globo a otros son los valores de estas propiedades.
Un globo tiene también métodos o acciones inherentes que puede efectuar. Tiene un método inflar (la acción de llenarlo
de helio) o un método desinflar (expeler su contenido) y un método elevarse (si se deja escapar). De nuevo, todos los
globos pueden efectuar estos métodos.

Página 10 de 159
Curso Visual Basic 5.0

Los globos tienen además respuestas predefinidas a ciertos eventos externos. Por ejemplo, un globo respondería al
evento de pincharlo desinflándose o al evento de soltarlo elevándose en el aire.
Los objetos tienen propiedades, responden a eventos y ejecutan métodos:

Si se pudiera programar un globo, el código de Visual Basic podría ser como el siguiente. Para establecer las
propiedades del globo:
Globo.Color = Rojo
Globo.Diámetro = 10
Globo.Inflado = True

Observe la sintaxis del código: el objeto (Globo) seguido de la propiedad (Color) seguida de la asignación del valor
(Rojo). Podría modificar el color del globo desde el código si repitiera esta instrucción y sustituyera el valor por otro
diferente. Las propiedades también se pueden establecer en la ventana Propiedades mientras se está diseñando la
aplicación.
Los métodos de un globo se invocan de esta forma:
Globo.Inflar
Globo.Desinflar
Globo.Elevar 5

La sintaxis es similar a la sintaxis de las propiedades: el objeto (un nombre) seguido de un método (un verbo). En el
tercer ejemplo hay un elemento adicional, llamado argumento, que indica la distancia que se eleva. Algunos métodos
tendrán uno o más argumentos para describir más a fondo la acción que se va a ejecutar.
El globo puede responder a un evento como se muestra a continuación:
Sub Globo_Pinchazo()
Globo.Desinflar
Globo.HacerRuido "Bang"
Globo.Inflado = False
Globo.Diámetro = 1
End Sub

En este caso, el código describe el comportamiento del globo cuando se produce un evento Pinchazo: invoca el método
Desinflar y luego invoca el método HacerRuido con un argumento “Bang” (el tipo de ruido que se va a hacer). Como el
globo ya no está inflado, la propiedad Inflado tiene el valor False y la propiedad Diámetro adopta un nuevo valor.
Si bien no puede programar un globo, sí puede programar un formulario o un control de Visual Basic. Como programador,
tiene el control: decide qué propiedades se deben modificar, qué métodos se deben invocar o a qué eventos hay que
responder para conseguir la apariencia y el comportamiento deseados

1.1.6- Diferencias entre la programación procedural y la programación bajo Windows.

Página 11 de 159
Curso Visual Basic 5.0

Un estudio profundo del funcionamiento interno de Windows necesitaría un libro completo. No es necesario tener un
profundo conocimiento de todos los detalles técnicos. Una versión reducida del funcionamiento de Windows incluye
tres conceptos clave: ventanas, eventos y mensajes.
Una ventana es simplemente una región rectangular con sus propios límites. Probablemente ya sabe que hay varios tipos
de ventanas: una ventana Explorador en Windows 95, una ventana de documento dentro de su programa de proceso de
textos o un cuadro de diálogo que emerge para recordarle una cita. Aunque éstos son los ejemplos más comunes,
realmente hay otros muchos tipos de ventanas. Un botón de comando es una ventana. Los iconos, cuadros de texto,
botones de opción y barras de menús son todos ventanas.
El sistema operativo Microsoft Windows administra todas estas ventanas asignando a cada una un único número
identificador (controlador de ventana o hWnd). El sistema controla continuamente cada una de estas ventanas para ver si
existen signos de actividad o eventos. Los eventos pueden producirse mediante acciones del usuario, como hacer clic
con el mouse (ratón) o presionar una tecla, mediante programación o incluso como resultado de acciones de otras
ventanas.
Cada vez que se produce un evento se envía un mensaje al sistema operativo. El sistema procesa el mensaje y lo
transmite a las demás ventanas. Entonces, cada ventana puede realizar la acción apropiada, basándose en sus propias
instrucciones para tratar ese mensaje en particular (por ejemplo, volverse a dibujar cuando otra ventana la ha dejado al
descubierto).
Como puede imaginar, tratar todas las combinaciones posibles de ventanas, eventos y mensajes podría ser interminable.
Afortunadamente, Visual Basic le evita tener que tratar con todos los controladores de mensajes de bajo nivel. Muchos
de los mensajes los controla automáticamente Visual Basic, mientras que otros se tratan como procedimientos de evento
para su comodidad. Esto le permite crear rápidamente eficaces aplicaciones sin tener que tratar detalles innecesarios.
En las aplicaciones tradicionales o "por procedimientos", la aplicación es la que controla qué partes de código y en qué
secuencia se ejecutan. La ejecución comienza con la primera línea de código y continúa con una ruta predefinida a
través de la aplicación, llamando a los procedimientos según se necesiten.
En una aplicación controlada por eventos, el código no sigue una ruta predeterminada; ejecuta distintas secciones de
código como respuesta a los eventos. Los eventos pueden desencadenarse por acciones del usuario, por mensajes del
sistema o de otras aplicaciones, o incluso por la propia aplicación. La secuencia de estos eventos determina la secuencia
en la que se ejecuta el código, por lo que la ruta a través del código de la aplicación es diferente cada vez que se ejecuta
el programa.
Puesto que no puede predecir la secuencia de los eventos, el código debe establecer ciertos supuestos acerca del "estado
del mundo" cuando se ejecute. Cuando haga suposiciones (por ejemplo, que un campo de entrada debe contener un valor
antes de ejecutar un procedimiento para procesar ese valor), debe estructurar la aplicación de forma que asegure que esa
suposición siempre será válida (por ejemplo, deshabilitando el botón de comando que inicia el procedimiento hasta que
el campo de entrada contenga un valor).
El código también puede desencadenar eventos durante la ejecución. Por ejemplo, cambiar mediante programación el
texto de un cuadro de texto hace que se produzca el evento Change del cuadro de texto. Esto causaría la ejecución del
código (si lo hay) contenido en el evento Change. Si supone que este evento sólo se desencadenará mediante la
interacción del usuario, podría ver resultados inesperados. Por esta razón es importante comprender el modelo
controlado por eventos y tenerlo en cuenta cuando diseñe su aplicación.

1.3- Proyecto.

1.3.1- Definición de Proyecto en Visual Basic.

Para crear una aplicación con Visual Basic se trabaja con proyectos. Un proyecto es una colección de archivos que se
usan para generar una aplicación. Este tema describe cómo generar y administrar proyectos.
Al crear una aplicación probablemente creará nuevos formularios; también puede volver a usar o modificar formularios
creados en proyectos anteriores. Esto también se aplica a otros módulos o archivos que pueda incluir en su proyecto. Los
controles ActiveX y los objetos de otras aplicaciones también se pueden compartir entre proyectos.
Después de ensamblar todos los componentes de un proyecto y escribir el código, puede compilar el proyecto para crear
un archivo ejecutable.

Página 12 de 159
Curso Visual Basic 5.0

1.3.2-Componentes de un Proyecto.

Cuando desarrolla un aplicación, trabaja con un archivo de proyecto para administrar todos los diferentes archivos que
crea. Un proyecto consta de lo siguiente:
• Un archivo de proyecto que realiza el seguimiento de todos los componentes (.vbp)
• Un archivo para cada formulario (.frm).
• Un archivo de datos binario para cada formulario que contenga datos sobre propiedades de controles del formulario
(.frx). Estos archivos no se pueden modificar y los genera automáticamente cualquier archivo .frm que tenga
propiedades en formato binario, como Picture o Icon.
• Opcionalmente, un archivo para cada módulo de clase (.cls).
• Opcionalmente, un archivo para cada módulo estándar (.bas).
• Opcionalmente, uno o más archivos con controles ActiveX (.ocx).
• Opcionalmente, un único archivo de recursos (.res).

El archivo de proyecto es simplemente una lista de todos los archivos y objetos asociados con el proyecto, así como
información sobre las opciones de entorno establecidas. Esta información se actualiza cada vez que guarda el proyecto.
Todos los archivos y objetos también se pueden compartir con otros proyectos.
Cuando ha completado todos los archivos del proyecto puede convertir el proyecto en un archivo ejecutable (.exe): en el
menú Archivo, elija el comando Generar proyecto.exe.

1.3.2.1-Formularios.

Un formulario es una ventana. La ventana Windows de cualquier aplicación.


Podemos abrir tantas ventanas como queramos en nuestro proyecto, pero el nombre de las ventanas debe ser distinto. Por
defecto como ya hemos visto, la ventana que se abre en Visual Basic tiene el nombre de Form1. Ya veremos como cambiar
estas "Propiedades" más adelante.
Los módulos de formularios (extensión de nombre de archivo .frm) pueden contener descripciones en forma de texto del
formulario y sus controles, incluyendo los valores de sus propiedades. También pueden contener declaraciones a nivel
de formulario de constantes, variables y procedimientos externos, procedimientos de evento y procedimientos generales.

1.3.2.2-Módulos de clase.

Los módulos de clase (extensión de nombre de archivo .cls) son similares a los módulos de formulario, excepto en que
no tiene interfaz de usuario visible. Puede usar módulos de clase para crear sus propios objetos, incluyendo código para
métodos y propiedades.

1.3.2.3-Módulos estándar.

Un módulo es un archivo Visual Basic donde escribimos parte del código de nuestro programa, y digo parte, porque puede
haber código en el formulario también.
Las rutinas incluidas dentro de los módulos pueden ser ejecutadas desde los formularios de la aplicación.
Los módulos estándar (extensión de nombre de archivo .bas) pueden contener declaraciones públicas o a nivel de
módulo de tipos, constantes, variables, procedimientos externos y procedimientos públicos.

1.3.2.4-Archivos de Recursos.

Los archivos de recursos (extensión de nombre de archivo .res) contienen mapas de bits, cadenas de texto y otros datos
que puede modificar sin volver a modificar el código. Por ejemplo, si piensa traducir su aplicación a un idioma
extranjero, puede guardar todas las cadenas de texto de la interfaz de usuario y los mapas de bits en un archivo de
recursos, y simplemente traducir el archivo de recursos en vez de la aplicación completa. Un proyecto sólo puede
contener un archivo de recursos.

1.3.2.5-Controles Active X.

Página 13 de 159
Curso Visual Basic 5.0

Los controles ActiveX (extensión de nombre de archivo .ocx) son controles opcionales que se pueden agregar al cuadro
de herramientas y se pueden usar en formularios. Cuando instala Visual Basic, los archivos que contienen los controles
incluidos en Visual Basic se copian a un directorio común (el subdirectorio \Windows\System en Windows 95). Existen
controles ActiveX adicionales disponibles en diversas fuentes. También puede crear sus propios controles mediante las
ediciones Profesional y Empresarial de Visual Basic.

1.3.2.6-Controles estándar.

Los controles estándar los proporciona Visual Basic. Los controles estándar, como CommandButton (botón de
comando) o Frame (marco), siempre están incluidos en el cuadro de herramientas, al contrario de lo que ocurre con los
controles ActiveX y los objetos insertables, que se pueden agregar y quitar del cuadro de herramientas.

1.4-Entorno de Desarrollo.

1.4.1-Barra de menú. y 1.4.2-Barra de Herramientas.

En la ventana del programa, podemos hacer todas las funciones normales que nos permite el compilador Visual Basic.

1.4.3-Ventana de Proyecto.

Pulse "Ctrl+R" (Ver -> Proyecto) y se abrirá la ventana de proyectos (3).


En esta ventana tenemos todos los ficheros del proyecto Visual Basic en el que vamos a trabajar.

1.4.4- Formulario.

Página 14 de 159
Curso Visual Basic 5.0

Al principio y por defecto, el programa abre un formulario con el nombre Form1 que es la ventana Windows de nuestra
aplicación.

1.4.5- Ventana de Propiedades.

Pulsando la tecla "F4", aparecerá la ventana de propiedades . Esta ventana es fundamental, ya que contiene todas las
propiedades de cada objeto que insertaremos en nuestro formulario, así como las propiedades del formulario en sí.

1.4.6- Caja de Herramientas.

Página 15 de 159
Curso Visual Basic 5.0

La ventana caja de herramientas contiene todos los objetos que podemos incluir en nuestro formulario. Esta ventana se
puede abrir en el menú principal (Ver -> Caja de herramientas).

2-Programación:

2.1- Fundamentos de la Programación.


Cada módulo de formulario contiene procedimientos de evento (secciones de código donde se colocan las instrucciones
que se ejecutarán como respuesta a eventos específicos). Los formularios pueden contener controles. Por cada control de
un formulario, existe el correspondiente conjunto de procedimientos de evento en el módulo de formulario. Además de
procedimientos de evento, los módulos de formulario pueden contener procedimientos generales que se ejecutan como
respuesta a una llamada desde cualquier procedimiento de evento.
El código que no esté relacionado con un control o un formulario específico se puede colocar en un tipo diferente de
módulo, un módulo estándar (.bas). Se deben colocar en un módulo estándar los procedimientos que se puedan utilizar
como respuesta a eventos de diversos objetos, en lugar de duplicar el código en los procedimientos de evento de cada
objeto.

2.1.1- Como funciona una aplicación controlada por eventos.

Un evento es una acción reconocida por un formulario o un control. Las aplicaciones controladas por eventos ejecutan
código Basic como respuesta a un evento. Cada formulario y control de Visual Basic tiene un conjunto de eventos
predefinidos. Si se produce uno de dichos eventos y el procedimiento de evento asociado tiene código, Visual Basic
llama a ese código.
Aunque los objetos de Visual Basic reconocen automáticamente un conjunto predefinido de eventos, usted decide
cuándo y cómo se responderá a un evento determinado. A cada evento le corresponde una sección de código (un
procedimiento de evento). Cuando desea que un control responda a un evento, escribe código en el procedimiento de ese
evento.
Los tipos de eventos reconocidos por un objeto varían, pero muchos tipos son comunes a la mayoría de los controles.
Por ejemplo, la mayoría de los objetos reconocen el evento Click: si un usuario hace clic en un formulario, se ejecuta el
código del procedimiento de evento Click del formulario; si un usuario hace clic en un botón de comando, se ejecuta el
código del procedimiento de evento Click del botón. El código en cada caso será diferente.
He aquí una secuencia típica de eventos en una aplicación controlada por eventos:
1. Se inicia la aplicación y se carga y muestra un formulario.
2. El formulario (o un control del formulario) recibe un evento. El evento puede estar causado por el usuario (por
ejemplo, por la pulsación de una tecla), por el sistema (por ejemplo, un evento de cronómetro) o, de forma indirecta, por
el código (por ejemplo, un evento Load cuando el código carga un formulario).
3. Si hay código en el procedimiento de evento correspondiente, se ejecuta.
4. La aplicación espera al evento siguiente.

2.2- Variables.

2.2.1- Alcance de las variables.

El alcance de una variable define qué partes del código son conscientes de su existencia. Cuando declara una variable en
un procedimiento, sólo el código de dicho procedimiento puede tener acceso o modificar el valor de la variable; tiene un
alcance que es local al procedimiento. A veces, sin embargo, se necesita utilizar una variable con un alcance más
general, como aquella cuyo valor está disponible para todos los procedimientos del mismo módulo o incluso para todos

Página 16 de 159
Curso Visual Basic 5.0

los procedimientos de toda la aplicación. Visual Basic le permite especificar el alcance de una variable cuando la
declara.

Establecimiento del alcance de las variables

Dependiendo de cómo se declara, una variable tiene como alcance un procedimiento (local) o un módulo.
Alcance Privado Público
Nivel de procedimiento Las variables son privadas del No es aplicable. No puede
procedimiento en el que declarar variables públicas
aparecen. dentro de un procedimiento.
Nivel de módulo Las variables son privadas del Las variables están disponibles
módulo en el que aparecen. para todos los módulos.

Variables utilizadas en un procedimiento


Las variables a nivel de procedimiento sólo se reconocen en el procedimiento en el que se han declarado. Se las conoce
también como variables locales. Se declaran mediante las palabras clave Dim o Static. Por ejemplo:
Dim intTemp As Integer
– o bien –
Static intPermanent As Integer

Los valores de variables locales declaradas con Static existen mientras se ejecuta la aplicación, mientras que las
variables declaradas con Dim sólo existen mientras se ejecuta el procedimiento.
Las variables locales resultan una elección apropiada para cálculos temporales. Por ejemplo, puede crear una docena de
procedimientos distintos que contengan una variable llamada intTemp. Como cada intTemp se ha declarado como una
variable local, cada procedimiento sólo reconoce su propia versión de intTemp. Cualquier procedimiento puede alterar el
valor de su intTemp local sin que ello afecte a las variables intTemp de los demás procedimientos.

Variables utilizadas en un módulo


De forma predeterminada, una variable a nivel de módulo está disponible para todos los procedimientos del módulo,
pero no para el código de otros módulos. Cree variables a nivel de módulo declarándolas con la palabra clave Private en
la sección Declaraciones al principio del módulo. Por ejemplo:

Private intTemp As Integer

A nivel de módulo, no hay diferencia entre Private y Dim, pero es preferible Private porque contrasta con Public y
hace que el código sea más fácil de comprender.

Variables utilizadas por todos los módulos


Para hacer que una variable a nivel de módulo esté disponible para otros módulos, utilice la palabra clave Public para
declarar la variable. Los valores de las variables públicas están disponibles para todos los procedimientos de la
aplicación. Al igual que todas las variables a nivel de módulo, las variables públicas se declaran en la sección
Declaraciones al principio del módulo. Por ejemplo:
Public intTemp As Integer

Nota No puede declarar variables públicas en un procedimiento, sólo en la sección Declaraciones de un módulo.

2.2.2- Declaración
La forma de declarar las variables es la siguiente:

Página 17 de 159
Curso Visual Basic 5.0

Dim| Public| Static nombre_variable As tipo


Dim: Al declarar una variable con esta palabra estamos diciendo que la variable sea local al ámbito en que se
declara. Puede ser dentro de un procedimiento o dentro de un formulario, de esta forma no sería accesible desde los demás
procedimientos o formularios.

Public: Las variables declaradas serán publicas y podrán estar accesibles desde todos los formularios de la
aplicación. Para conseguirlo tendremos que declararlas en un módulo de código, no en la sección declarations de cualquier
formulario de los que conste la aplicación. Para crear un módulo de código en el menú principal de Visual Basic marcamos
en PROYECTO/INSETAR MÓDULO y aparecerá junto a los demás formularios de la ventana de proyecto aunque con un
icono distinto indicando que se trata de un módulo de código.

Static: Con esta forma de declarar variables conseguiremos que las variables locales no se creen y se destruyan al
entrar y salir de los procedimientos donde fueron declaradas sino que se mantenga su valor durante todo el periodo de
ejecución de la aplicación. De esta forma a entrar en algún procedimiento las variables recuerdan el valor que tenían
cuando se salió de él.

2.2.3- Tipos de variables

TIPO COMENTARIO
BOOLEAN Sólo admite 2 valores TRUE o FALSE
BYTE admite valores entre 0 y 255
INTEGER admite valores entre -32768 y 32767
admite valores entre -2.147.483.648 y
LONG
2.147.483.647
admite valores decimales con precisión
SINGLE
simple
admite valores decimales de doble
DOUBLE
precisión
CURRENCY válido para valores de tipo moneda
STRING cadenas de caracteres
DATE fechas, permite operar con ellas

2.2.4- Matrices
Para declarar matrices debemos colocar entre paréntesis el número de elementos de los que constará a
continuación del nombre de la variable:

Dim medidas(9) as integer

De esta forma tenemos una matriz de 10 elementos identificados del 0 al 9

Podemos obligar a que el primer elemento de una matriz tenga el índice con valor 1.

Esto lo haremos colocando la instrucción option base 1 en la sección declarations de nuestro formulario.

También podemos indicar los límites inferior y superior de la matriz:

Dim medidas(5 to 14) as integer

es una matriz de 10 elementos cuyos indices van del 5 al 14

Las matrices multidimensionales se declaran de la siguiente forma:

Página 18 de 159
Curso Visual Basic 5.0

Dim medidas(1 to 10, 1 to 10) as integer

CONSIDERACIONES
Al trabajar con Visual Basic es preferible que activemos la opción que nos obligue a declarar todas las variables
que utilicemos, de esta forma nos ahorraremos errores inesperados como el de trabajar con una variable ya utilizada
anteriormente produciéndose un conflicto díficil de resolver. En cambio si intentamos declarar 2 variables con el mismo
nombre, en el mismo formulario o procedimiento se produce un error en tiempo de edición avisándonos de la situación.

Para activar esta opción debemos ir a la opción del menú Herramientas y Opciones para que aparezca un cuadro
de dialogo como este.

La opción que nos interesa activar es Requerir declaración de variables que en este caso ya lo está. De esta forma
en cada sección declarations de cada formulario aparecerá la sentencia option explicit

Otra opción que es interesante activar, es la de Guardar los cambios en la ficha entorno, la cual te guarda una
copia del código antes de ejecutarlo por si acaso luego no podemos, se bloquea la aplicación etc... no suele pasar pero
nunca se sabe. De esta forma te aseguras que lo último que hayas ejecutado lo tienes guardado en el disco.

La opción Comprobación automática de sintaxis normalmente viene activada por defecto, no conviene
desactivarla puesto que te avisa de errores de sintaxis conforme vas escribiendo el código: Si te falta el then después del if,
el do antes del while etc...

2.3- Procedimientos y funciones.

2.3.1-Introducción a los Procedimientos.

Página 19 de 159
Curso Visual Basic 5.0

Puede simplificar las tareas de programación si divide los programas en componentes lógicos más pequeños. Estos
componentes, llamados procedimientos, pueden convertirse en bloques básicos que le permiten mejorar y ampliar Visual
Basic.
Los procedimientos 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.
Hay dos ventajas principales cuando se programa con procedimientos:
• 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.
• 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.

En Visual Basic se utilizan varios tipos de procedimientos:


• Procedimientos Sub que no devuelven un valor.
• Procedimientos Function que devuelven un valor (normalmente conocidos como funciones).

2.3.2- Procedimientos.

Un procedimiento Sub es un bloque de código que se ejecuta como respuesta a un evento. Al dividir el código de un
módulo en procedimientos Sub, es más sencillo encontrar o modificar el código de la aplicación.
La sintaxis de un procedimiento Sub es la siguiente:
[Private|Public][Static]Sub nombre_procedimiento (argumentos)
instrucciones
End Sub

Cada vez que se llama al procedimiento se ejecutan las instrucciones que hay entre Sub y End Sub. Se pueden colocar
los procedimientos Sub en módulos estándar, módulos de clase y módulos de formulario. De forma predeterminada, los
procedimientos Sub son Public en todos los módulos, lo que significa que se les puede llamar desde cualquier parte de
la aplicación.
Los argumentos de un procedimiento son como las declaraciones de variables; se declaran valores que se pasan desde el
procedimiento que hace la llamada.
Resulta muy útil en Visual Basic distinguir entre dos tipos de procedimientos Sub, procedimientos generales y
procedimientos de evento.

Procedimientos generales
Un procedimiento general indica a la aplicación cómo realizar una tarea específica. Una vez que se define un
procedimiento general, se le debe llamar específicamente desde la aplicación. Por el contrario, un procedimiento de
evento permanece inactivo hasta que se le llama para responder a eventos provocados por el usuario o desencadenados
por el sistema.
¿Por qué crear procedimientos generales? Una razón es que muchos procedimientos de evento distintos pueden necesitar
que se lleven a cabo las mismas acciones. 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.

Procedimientos de evento
Cuando un objeto en Visual Basic reconoce que se ha producido un evento, llama automáticamente al procedimiento de
evento utilizando el nombre correspondiente al evento. Como el nombre establece una asociación entre el objeto y el
código, se dice que los procedimientos de evento están adjuntos a formularios y controles.

Página 20 de 159
Curso Visual Basic 5.0

• Un procedimiento de evento de un control combina el nombre real del control (especificado en la propiedad Name),
un carácter de subrayado (_) y el nombre del evento. Por ejemplo, si desea que un botón de comando llamado
cmdPlay llame a un procedimiento de evento cuando se haga clic en él, utilice el procedimiento cmdPlay_Click.
• Un procedimiento de evento de un formulario combina la palabra "Form", un carácter de subrayado y el nombre del
evento. Si desea que un formulario llame a un procedimiento de evento cuando se hace clic en él, utilice el
procedimiento Form_Click. (Como los controles, los formularios tienen nombres únicos, pero no se utilizan en los
nombres de los procedimientos de evento.)

Todos los procedimientos de evento utilizan la misma sintaxis general.

Sintaxis de un evento de control Sintaxis de un evento de formulario

Private Sub nombrecontrol_nombreevento (argumentos )


instrucciones
End Sub

Private Sub Form_nombreevento (argumentos)


instrucciones
End Sub

Aunque puede escribir procedimientos de evento nuevos, es más sencillo utilizar los procedimientos de código que
facilita Visual Basic, que incluyen automáticamente los nombres correctos de procedimiento. Puede seleccionar una
plantilla en la ventana Editor de código si selecciona un objeto en el cuadro Objeto y selecciona un procedimiento en el
cuadro Procedimiento.
También es conveniente establecer la propiedad Name de los controles antes de empezar a escribir los procedimientos
de evento para los mismos. Si cambia el nombre de un control tras vincularle un procedimiento, deberá cambiar también
el nombre del procedimiento para que coincida con el nuevo nombre del control. De lo contrario, Visual Basic no será
capaz de hacer coincidir el control con el procedimiento. Cuando el nombre de un procedimiento no coincide con el
nombre de un control, se convierte en un procedimiento general.

2.3.3- Funciones.

La sintaxis de un procedimiento Function es la siguiente:


[Private|Public][Static]Function nombre_procedimiento (argumentos) [As tipo]
instrucciones
End Function

Al igual que un procedimiento Sub, un procedimiento Function es un procedimiento diferente que puede tomar
argumentos, realizar una serie de instrucciones y cambiar el valor de los argumentos. A diferencia de los procedimientos
Sub, los procedimientos Function pueden devolver un valor al procedimiento que realiza la llamada. Hay tres
diferencias entre los procedimientos Sub y Function:
• Generalmente, se llama a una función incluyendo el nombre y los argumentos del procedimiento en la parte derecha
de una instrucción o expresión mayor (valor_retorno = función()).
• Los procedimientos Function tienen tipos de datos, al igual que las variables. Esto determina el tipo del valor de
retorno. (En ausencia de la cláusula As, el tipo es el tipo predeterminado Variant.)
• Se devuelve un valor asignándole al propio nombre_procedimiento. Cuando el procedimiento Function devuelve
un valor, se puede convertir en parte de una expresión mayor.

Por ejemplo, podría escribir una función que calculara el tercer lado, o hipotenusa, de un triángulo rectángulo, dados los
valores de los otros dos lados:
Function Hipotenusa (A As Integer, B As Integer) As String
Hipotenusa = Sqr(A ^ 2 + B ^ 2)

Página 21 de 159
Curso Visual Basic 5.0

End Function

Se llama a un procedimiento Function de la misma forma que a las funciones incorporadas en Visual Basic:
Label1.Caption = Hipotenusa(CInt(Text1.Text),CInt(Text2.Text))
strX = Hipotenusa(Width, Height)

2.3.4- Llamadas a Procedimientos.

Un procedimiento Sub difiere de un procedimiento Function en que al procedimiento Sub no se le puede llamar
mediante su nombre en una expresión. La llamada a un procedimiento Sub es una instrucción única. Además, un
procedimiento Sub no devuelve un valor en su nombre como hace una función. Sin embargo, al igual que Function, un
procedimiento Sub puede modificar los valores de las variables que se le pasan.
Hay dos formas de llamar a un procedimiento Sub:
' Ambas instrucciones llaman a un Sub denominado MiProc.
Call MiProc (PrimerArgumento, SegundoArgumento)
MiProc PrimerArgumento, SegundoArgumento

Observe que cuando utiliza la sintaxis Call, debe poner los argumentos entre paréntesis. Si omite la palabra clave Call,
deberá también omitir los paréntesis alrededor de los argumentos.

2.3.5- Llamadas a Funciones.

Normalmente se llama a un procedimiento de función que se ha escrito de la misma forma en que se llama a una función
intrínseca de Visual Basic como Abs; es decir, utilizando su nombre en una expresión:
' Las instrucciones siguientes llamarían a una función _
' llamada ToDec.
Print 10 * Adec
X = Adec
If Adec = 10 Then Debug.Print "Fuera del intervalo"
X = OtraFunción(10 * Adec)

También es posible llamar a una función igual que se llama a un procedimiento Sub. Las instrucciones siguientes llaman
a la misma función:
Call Year(Now)
Year Now

Cuando llama a una función de esta manera, Visual Basic desecha el valor de retorno.

2.3.6- Pasaje de argumentos a los procedimientos y funciones.

Normalmente el código de un procedimiento necesita cierta información sobre el estado del programa para realizar su
trabajo. Esta información consiste en variables que se pasan al procedimiento cuando se le llama. Cuando se pasa una
variable a un procedimiento, se llama argumento.

Tipos de datos de los argumentos


Los argumentos de los procedimientos que escriba tienen el tipo de dato Variant de forma predeterminada. Sin
embargo, puede declarar otros tipos de datos para los argumentos. Por ejemplo, la función siguiente acepta una cadena y
un entero:

Página 22 de 159
Curso Visual Basic 5.0

Function QuéComer (DíaSemana As String, Hora As Integer) As String


' Devuelve el menú del almuerzo basándose en el día y la hora.
If DíaSemana = "Viernes" then
QuéComer = "Pescado"
Else
QuéComer = "Pollo"
End If
If Hora > 4 Then QuéComer = "Demasiado tarde"
End Function

Paso de argumentos por valor


Sólo se pasa una copia de la variable cuando se pasa un argumento por valor. Si el procedimiento cambia el valor, el
cambio afecta sólo a la copia y no a la variable propiamente dicha. Utilice la palabra clave ByVal para indicar un
argumento pasado por valor.
Por ejemplo:

Sub Cuentas (ByVal intNumCuenta as Integer)


.
. ' Ponga aquí sus instrucciones.
.
End Sub

Paso de argumentos por referencia


Pasar argumentos por referencia le da al procedimiento acceso al contenido real de la variable en su ubicación de
dirección de memoria. Como resultado, el procedimiento al que se ha pasado el valor de la variable se puede modificar
de forma permanente. La forma predeterminada de pasar valores en Visual Basic es por referencia.
Si especifica el tipo de dato de un argumento que se pasa por referencia, debe pasar un valor de ese tipo para el
argumento. Puede eludirlo si pasa una expresión en vez de un tipo de dato como argumento. Visual Basic evalúa la
expresión y la pasa como el tipo requerido si puede.
La forma más sencilla de convertir una variable en una expresión es ponerla entre paréntesis. Por ejemplo, para pasar
una variable declarada como entero a un procedimiento que espera una cadena como argumento, debería hacer lo
siguiente:

Sub ProcedimientoQueLlama ()
Dim intX As Integer
intX = 12 * 3
Foo(intX)
End Sub

Sub Foo(Bar As String)


MsgBox Bar 'El valor de Bar es la cadena "36".
End Sub

2.4- Estructuras de Control (Repetición y Decisión).

2.4.1-Do While – Loop / Do – Loop While.

Utilice el bucle Do para ejecutar un bloque de instrucciones un número indefinido de veces. Hay algunas variantes en la
instrucción Do...Loop, pero cada una evalúa una condición numérica para determinar si continúa la ejecución. Como

Página 23 de 159
Curso Visual Basic 5.0

ocurre con If...Then, la condición debe ser un valor o una expresión que dé como resultado False (cero) o True (distinto
de cero).
En el ejemplo de Do...Loop siguiente, las instrucciones se ejecutan siempre y cuando condición sea True:

Do While condición
instrucciones
Loop

Cuando Visual Basic ejecuta este bucle Do, primero evalúa condición. Si condición es False (cero), se salta todas las
instrucciones. Si es True (distinto de cero), Visual Basic ejecuta las instrucciones, vuelve a la instrucción Do While y
prueba la condición de nuevo.
Por tanto, el bucle se puede ejecutar cualquier número de veces, siempre y cuando condición sea distinta de cero o True.
Nunca se ejecutan las instrucciones si condición es False inicialmente. Por ejemplo, este procedimiento cuenta las veces
que se repite una cadena de destino dentro de otra cadena repitiendo el bucle tantas veces como se encuentre la cadena
de destino:

Function ContarCadenas (cadenalarga, destino)


Dim posición, contador
posición = 1
Do While InStr(posición, cadenalarga, destino)
posición = InStr(posición, cadenalarga, destino) +1
contador = contador + 1
Loop
ContarCadenas = contador
End Function

Si la cadena de destino no está en la otra cadena, InStr devuelve 0 y no se ejecuta el bucle.


Otra variante de la instrucción Do...Loop ejecuta las instrucciones primero y prueba condición después de cada
ejecución. Esta variación garantiza al menos una ejecución de instrucciones:

Do
instrucciones
Loop While condición

Hace el bucle cero o más veces Hace el bucle al menos una vez
Do Until condición Do
instrucciones instrucciones
Loop Loop Until condición

2.4.2- For – Next.

Los bucles Do funcionan bien cuando no se sabe cuántas veces se necesitará ejecutar las instrucciones del bucle. Sin
embargo, cuando se sabe que se van a ejecutar las instrucciones un número determinado de veces, es mejor elegir el
bucle For…Next. A diferencia del bucle Do, el bucle For utiliza una variable llamada contador que incrementa o reduce
su valor en cada repetición del bucle. La sintaxis es la siguiente:

For contador = iniciar To finalizar [Step incremento]


instrucciones
Next [contador]

Los argumentos contador, iniciar, finalizar e incremento son todos numéricos.

Página 24 de 159
Curso Visual Basic 5.0

Nota El argumento incremento puede ser positivo o negativo. Si incremento es positivo, iniciar debe ser menor o igual
que finalizar o no se ejecutarán las instrucciones del bucle. Si incremento es negativo, iniciar debe ser mayor o igual que
finalizar para que se ejecute el cuerpo del bucle. Si no se establece Step, el valor predeterminado de incremento es 1.

Al ejecutar el bucle For, Visual Basic:


1. Establece contador al mismo valor que iniciar.
2. Comprueba si contador es mayor que finalizar. Si lo es, Visual Basic sale del bucle.
(Si incremento es negativo, Visual Basic comprueba si contador es menor que finalizar.)
3. Ejecuta instrucciones.
4. Incrementa contador en 1 o en instrucciones, si se especificó.
5. Repite los pasos 2 a 4.

Este código imprime los nombres de todas las fuentes de pantalla disponibles:

Private Sub Form_Click ()


Dim I As Integer
For i = 0 To Screen.FontCount
Print Screen.Fonts(i)
Next
End Sub

En la aplicación de ejemplo VCR, el procedimiento HighlightButton utiliza un bucle For...Next para pasar por la
colección de controles del formulario VCR y mostrar el control Shape apropiado:

Sub HighlightButton(MyControl As Variant)


Dim i As Integer
For i = 0 To frmVCR.Controls.Count - 1
If TypeOf frmVCR.Controls(i) Is Shape Then
If frmVCR.Controls(i).Name = MyControl Then
frmVCR.Controls(i).Visible = True
Else
frmVCR.Controls(i).Visible = False
End If
End If
Next
End Sub

2.4.3- If – Else – End If.


Use la estructura If...Then para ejecutar una o más instrucciones basadas en una condición. Puede utilizar la sintaxis de
una línea o un bloque de varias líneas:

If condición Then instrucción


If condición Then
instrucciones
End If

Condición normalmente es una comparación, pero puede ser cualquier expresión que dé como resultado un valor
numérico. Visual Basic interpreta este valor como True o False; un valor numérico cero es False y se considera True
cualquier valor numérico distinto de cero. Si condición es True, Visual Basic ejecuta todas las instrucciones que siguen
a la palabra clave Then. Puede utilizar la sintaxis de una línea o de varias líneas para ejecutar una instrucción basada en
una condición (estos dos ejemplos son equivalentes):
If cualquierFecha < Now Then cualquierFecha = Now

Página 25 de 159
Curso Visual Basic 5.0

If cualquierFecha < Now Then


cualquierFecha = Now
End If

Observe que el formato de una única línea de If...Then no utiliza la instrucción End If. Si desea ejecutar más de una
línea de código cuando condición sea True, debe utilizar la sintaxis de bloque de varias líneas If...Then...End If.

If cualquierFecha < Now Then


cualquierFecha = Now
Timer1.Enabled = False ' Desactiva el control Timer.
End If

If...Then...Else
Utilice un bloque If...Then...Else para definir varios bloques de instrucciones, uno de los cuales se ejecutará:

If condición1 Then
[bloque de instrucciones 1]
[Else
[bloque de instrucciones n]]
End If

Visual Basic evalúa primero condición1. Si es False, Visual Basic ejecuta el bloque de instrucciones correspondientes a
Else y después ejecuta el código que sigue a End If.
Por ejemplo, la aplicación podría realizar distintas acciones dependiendo del control en que se haya hecho clic de una
matriz de controles de menú:

Private Sub mnuCut_Click (Index As Integer)


If Index = 0 Then ' Comando Cortar.
CopyActiveControl
ClearActiveControl
Else ' Comando Pegar.
PasteActiveControl
End If
End Sub

2.4.4- Select - Case

Visual Basic proporciona la estructura Select Case como alternativa a If...Then...Else para ejecutar selectivamente un
bloque de instrucciones entre varios bloques de instrucciones. La instrucción Select Case ofrece posibilidades similares
a la instrucción If...Then...Else, pero hace que el código sea más legible cuando hay varias opciones.
La estructura Select Case funciona con una única expresión de prueba que se evalúa una vez solamente, al principio de
la estructura. Visual Basic compara el resultado de esta expresión con los valores de cada Case de la estructura. Si hay
una coincidencia, ejecuta el bloque de instrucciones asociado a ese Case:

Select Case expresión_prueba


[Case lista_expresiones1
[bloque de instrucciones 1]]
[Case lista_expresiones2
[bloque de instrucciones 2]]
.
.

Página 26 de 159
Curso Visual Basic 5.0

.
[Case Else
[bloque de instrucciones n]]
End Select

Cada lista_expresiones es una lista de uno o más valores. Si hay más de un valor en una lista, se separan los valores con
comas. Cada bloque de instrucciones contiene cero o más instrucciones. Si más de un Case coincide con la expresión de
prueba, sólo se ejecutará el bloque de instrucciones asociado con la primera coincidencia. Visual Basic ejecuta las
instrucciones de la cláusula (opcional) Case Else si ningún valor de la lista de expresiones coincide con la expresión de
prueba.
Por ejemplo, suponga que agrega otro comando al menú Edición en el ejemplo If...Then...Else. Podría agregar otra
cláusula ElseIf o podría escribir la función con Select Case:

Private Sub mnuCut_Click (Index As Integer)


Select Case Index
Case 0 ' Comando Cortar.
CopyActiveControl ' Llama a procedimientos generales.
ClearActiveControl
Case 1 ' Comando Copiar.
CopyActiveControl
Case 2 ' Comando Borrar.
ClearActiveControl
Case 3 ' Comando Pegar.
PasteActiveControl
Case Else
frmFind.Show ' Muestra el cuadro de diálogo Buscar.
End Select
End Sub

Observe que la estructura Select Case evalúa una expresión cada vez al principio de la estructura.

3- Controles

3.1- Controles básicos


Vamos a ver los siguientes puntos:
• Introducción al uso de controles

• Control TextBox.

• Control Label

• Control CommandButton

• Control OptionButton

• Realizacíon de una pequeña aplicación de ejemplo

Antes de empezar a conocer los controles básicos veamos cuales son sus características generales:
• Propiedades:Todos los controles disponen de una serie de propiedades las cuales
podemos cambiar al incluirlos en nuestras aplicaciones. Ejemplos de propiedades son el

Página 27 de 159
Curso Visual Basic 5.0

color, el tipo de letra, el nombre, el texto, etc...

• Metodos: Son procedimientos asociados a los controles, es decir, rutinas ya


establecidas que podemos invocar desde nuestras aplicaciones para que se realice
alguna operación sobre el control. Por ejemplo el control ListView ( la lista de archivos
que aparece en el explorador de windows) dispone del método order que te ordena los
datos aparecidos en la lista.

• Eventos: Son acciones que pueden ser motivadas por el propio usuario o por mismo
sistema operativo. Ejemplos pueden ser el movimiento del ratón o hacer click sobre su
botón. En Visual Basic digamos que se utiliza la programación orientada a eventos, lo
cual es una de las diferencias más importantes respecto a la programación lineal de MS
DOS. No necesitamos detectar cuando se ha producido un evento determinado,
Windows lo detecta automáticamente. Los eventos ya estan definidos, son bastantes y
cada control cuenta con los suyos propios, aunque son muy parecidos. Lo único que
tendremos que hacer es asociar el código necesario al evento que necesitemos tratar.

TextBox
Mediante este control podremos realizar tanto la entrada como la salida de datos en nuestras aplicaciones.
No hace falta que indiquemos las coordenadas de la situación del formulario en pantalla, simplemente tendremos que
marcar sobre el control de la caja de herramientas y dibujarlo con el tamaño que queramos en nuestro formulario.

PROPIEDADES
Las propiedades de las que dispone el control son las siguientes:(para obtener el cuadro de propiedades, seleccionar el
control y pulsar F4 o pulsar con el boton derecho para obtener el menú contextual y marcar Propierties)
Text: Aquí indicamos el texto que aparecerá en el control. Podemos asignarle cualquier texto
en tiempo de diseño o ejecución. También podemos tomar el texto que haya introducido el
usuario para tratarlo durante la ejecución.
Name: Esta propiedad la tienen todos los controles, el nombre que viene por defecto en este
caso Text1 y es el nombre con el que se conocerá el control cuando lo utilicemos en el código.
En un mismo formulario no puede haber 2 controles con el mismo nombre. Conviene poner un
nombre que represente la función que tiene el control en la aplicación para que el código quede
más claro. Ejemplo, si en el textbox vamos a introducir la dirección de una persona podemos
asignarle a esta propiedad el valor Dirección.
MultiLine: Permite que introduzcamos varias lineas de texto en el control en lugar de sólo una.

Alignment: Alineación que tendrá el texto dentro del control: izquierda, centro o derecha. Para
que funcione la propiedad MultiLine debe estar con el valor true.

Locked: Si esta con valor true bloquea el control, es decir, el usuario no puede introducir ni
modificar el texto que contenga. Nos puede servir para utilizar el control como salida de datos
sin que el usuario pueda modificarlos por error.
Otras propiedades que son comunes a la mayoria de los controles:
Backcolor: color de fondo.
Forecolor: color de letra.

Página 28 de 159
Curso Visual Basic 5.0

Font: tipo y tamaño de letra.

METODOS
Recordemos que por métodos se entienten los procedimientos o funciones asociados a un control, los cuales nos permiten
realizar ciertas operaciones útiles sobre dicho control: Ej. ordenar sus elementos, buscar un dato, etc..
Pues bien, los controles básicos que vamos a ver en este capítulo únicamente contienen métodos avanzados que no vamos a
analizar por ahora, ya que son métodos que no se suelen utilizar. Más adelante cuando veamos otros tipos de controles
estudiaremos cuales son los métodos que nos podrán servir. Si alguien está interesado en conocer todas las características
de los controles puede hacerlo mirando en la ayuda que proporciona VB, haciendo click sobre cualquier control de la caja
de herramientas y pulsando a continuación F1 obtendrá ayuda referente a ese control donde aparecerán todas sus
propiedades, metodos y eventos.

EVENTOS
Los eventos son acciones que se pueden realizar en cualquier control: click, doble click, movimiento del ratón. A estos
eventos se les puede asociar código para que se ejecute al producir el evento.
MouseMove: al mover el raton por encima del control.
Mousedown: al pulsar cualquier boton del raton
Change: al cambiar el contenido del control
Click: al hacer click con el botón izquierdo del ratón sobre el control
Doubleclick: al hacer doble click con el con el botón izquierdo del ratón sobre el control
Getfocus: este evento se activa cuando el control recibe el enfoque, es decir, cuando se activa
el control en tiempo de ejecución para introducir datos en él o realizar alguna operación.
Lostfocus: Es el contrario del anterior evento, se activa cuando el control pierde el enfoque, es
decir, se pasa a otro control para seguir introduciendo datos.

EJEMPLO
Vamos a probar el uso del control TextBox mediante un pequeño ejemplo en el que teniendo un único control de este tipo
en un formulario, lo programaremos de forma que al pasar el ratón sobre el control (evento mousemove) aparecerá en el
formulario el texto que contenga.

Observamos que al situar el control en el formulario aparece por defecto el texto Text1. Para que no aparezca ese texto al
ejecutar la aplicación, debemos cambiar la propiedad Text pulsando F4 y colocar el texto que queramos o no colocar nada.
Lo que queremos hacer es que cada vez que movamos el raton por el control aparezca su contenido en el formulario.
Entonces lo que habrá que hacer abrir la ventana de código, seleccionando el control y pulsando F7, o con el botón derecho
del ratón y la opción View code del menú contextual. Este proceso nos llevará al cuadro de la imagen siguiente.

Página 29 de 159
Curso Visual Basic 5.0

Lo que tendremos que hacer es seleccionar el evento que necesitemos de la sección Proc, en nuestro caso mousemove y a
continuación teclear el codigo correspondiente: La instrucción print visualiza un texto en el formulario y si le ponemos
text1.text le decimos que nos muestre la propiedad Text del control Text1 que ese será el nombre que tendrá el control por
defecto si no lo hemos cambiado en la propiedad name.
Al ejecutar esta pequeña aplicación pulsando F5 observaremos como aparece en el formulario lo que hayamos tecleado en
el control cada vez que movemos el raton sobre el Textbox.
Podemos modificar el programa para que responda a cualquier otro evento sin más que seleccionarlo en la sección Proc e
introduciendo el codigo que sea necesario.

Label
Este control es también uno de los más utilizados, aunque su utilidad queda restringida a la visualización de datos en el
mismo, no permitiendo la introducción de datos por parte del usuario.
La forma de utilizarlo es similar a la del control anterior, dibujar el control en el formulario con el tamaño que queramos y
asignarle un texto en tiempo de diseño o de ejecución esta vez sin utilizar la propiedad text puesto que no la incorpora, sino
utilizando la propiedad caption.
Este control sirve para mostrar mensajes en nuestro formulario que orienten al usuario sobre la utilidad de los demás
controles que tengamos en la aplicación o para indicarnos acciones que podemos realizar. En el ejemplo anterior donde
aparecía un textbox en el formulario, hubiera quedado mejor con un mensaje aclaratorio contenido en un control label:

PROPIEDADES
Caption: Es el texto que contendrá el control.
Alignment: Alineación del texto contenido en el control, no necesita que esté activada ninguna
otra propiedad.
BorderStyle: Si queremos que aparezca un borde alrededor del control activaremos esta
propiedad.

Para este control no se suelen utilizar los eventos ya que su contenido suele cambiar poco a lo largo de la ejecución de la
aplicación. De todas formas los eventos son casi los mismos del control textbox excepto que no dispone de los eventos
GetFocus y LostFocus ya que a este control no se le puede dar el enfoque.

Página 30 de 159
Curso Visual Basic 5.0

En la parte final de este capitulo veremos un ejemplo donde se muestra el funcionamiento de todos los controles que vamos
a ir viendo.Por ahora a ver si conseguis que ahora el mensaje no aparezca en el formulario sino en un segundo label situado
en el formulario, dejando un control label que muestre el mensaje aclaratorio que hemos visto antes.

CommandButton
Este control es el típico botón que aparece en todas las aplicaciones y que al hacer click sobre él nos permite realizar alguna
operación concreta, normalmente Aceptar o Cancelar. Aunque según el código que le asociemos podremos realizar las
operaciones que queramos.
En el ejemplo anterior podemos añadir un control de este tipo para salir de la aplicación sin tener pulsar sobre la equis de la
esquina superior derecha.

Pero sólo con introducir un control de este tipo con el texto salir que se introduce a traves de la propiedad caption no basta.
Habrá que asociarle un código que nos permita salir de la aplicación en el evento adecuado. Y el evento por excelencia de
este control es click. Así pues accederemos al código del control y la sentencia nos permitirá salir de la aplicación es End,
simplemente tecleamos esa palabra en el evento click y comprobar que realmente finalizaremos nuestra aplicación al pulsar
sobre dicho botón.
PROPIEDADES
Caption: Aqui pondremos el letrero que queremos que apaezca en el botón: aceptar, cancelar,
salir, etc...
Enabled: Esta es una nueva propiedad, cuando su valor es true el botón funciona normalmente,
cuando su valor es false el boton se encuentra desactivado, no responde a los eventos
producidos sobre él y el texto aparece en un gris claro advirtiendonos de su estado. Podemos
utilizar esta propiedad para activar o desactivar un boton dependiendo del estado de otros
controles. Por ejemplo, en un boton Aceptar, no activarlo hasta que se haya introducido una
cantidad en un control textbox, ya que ese botón nos calculará el IVA de la cantidad.
EVENTOS
Click: Es el evento tipico de este control y el que más se utiliza.
MouseMove: Como sabemos detecta el movimiento del raton sobre el control. Puede servir
para que aparezca un mensaje en un control Label que nos aporte información sobre la utilidad
del control ampliando el texto que hayamos colocado como caption del commandbutton.

OptionButton
Este control nos permite elegir una opción entre varias de las que se nos plantean. Cada opción será un control optionbutton
diferente.
Facilita la introducción de datos por parte del usuario:

Página 31 de 159
Curso Visual Basic 5.0

De todas las opciones que se nos ofrece, en este caso los 4 colores, sólo podremos activar una. Si activamos cualquier otra
opción, se desactivará automáticamente la última que teníamos activada.
El marco que está alrededor de los 4 controles optionbutton se trata del control Frame , es opcional, aunque es
conviente colocarlo siempre que hagamos uso de las opciones. No sólo por motivos de presentación sino porque de esta
manera podremos establecer grupos de controles optionbutton independientes en los que en cada grupo sólo pueda haber
una opcioón activada a la vez. También, al mover el marco se moverán los controles incluidos en él facilitándonos las
modificaciones.
Para que los controles Optionbutton queden englobados dentro de un control Frame, primero tendremos que colocar el
control Frame en el formulario con el tamaño adecuado y despues ir colocando los controles Optionbutton dentro del
Frame.
Del control Frame la única propiedad que nos interesará es caption, que es el texto que aparecerá en el encabezado, en el
ejemplo anterior: colores.
PROPIEDADES DE OPTIONBUTTON
Caption: El texto que aparecerá al lado del control: Rojo, verde, etc...

Value: Es el valor que tendrá el control: True si se encuentra activado y False si no lo está.
Para comprobar que opcion ha activado el usuario comprobaremos el estado de esta propiedad.

Alignment: Alineación del texto respecto al control: Left Justify: el control aparece a la
izquierda del texto. Es el ejemplo anterior.Right Justify: el control aparece a la derecha del
texto.

Los eventos del control son los mismos que en anteriores controles, aunque no se suele asociar código a los eventos de este
tipo de controles, sino únicamente conocer el valor que tienen: true o false.

3.1.1- APLICACION DE EJEMPLO


Para practicar con los controles que hemos visto vamos a realizar una pequeña aplicación que consistirá en realizar con 2
números que introduzcamos, una operación que seleccionemos y mostrar el resultado.
El formulario donde estarán todos los controles es el siguiente:

Página 32 de 159
Curso Visual Basic 5.0

La propiedad Caption de cada uno de los controles es la que se muestra en el formulario.


He modificado la propiedad Name de cada control para que al utilizarlos desde el codigo sepamos cual es el control con el
que trabajamos:
• Los controles TextBox tienen los nombres: Num1, Num2 y Resul.
• Los controles Optionbutton tienen cada uno de ellos el mismo nombre que su caption
• Los controles CommandButton tienen los nombres: Calcular, Limpiar y Salir.
• A los controles Label y al Frame no have falta cambiarles el nombre.

Lo que habrá que hacer ahora es asociar codigo a cada uno de los botones que es de donde se van a realizar las operaciones:
• Para el botón Calcular que es el que nos mostrará el resultado según la operación seleccionada, he utilizado la
instrucción If Then Else que vimos en el capítulo anterior:

• El botón Limpiar Datos nos va a servir para borrar de una forma rápida los datos introducidos por el usuario y el
resultado preparando los controles para introducir nuevos datos. El código que tendremos que introducir es muy
simple:

Página 33 de 159
Curso Visual Basic 5.0

El botón Salir únicamente contendrá la sentencia End.

4 -Formularios.
Los formularios tienen sus propios eventos, propiedades y métodos con los que se puede controlar su apariencia y
comportamiento.
El primer paso para diseñar un formulario consiste en establecer sus propiedades. Puede establecer las propiedades de un
formulario en tiempo de diseño en la ventana Propiedades o en tiempo de ejecución, escribiendo código.
Nota En tiempo de diseño, que es cualquier momento mientras está desarrollando una aplicación en el entorno de
Visual Basic, se trabaja con formularios y controles, se establecen propiedades y se escribe código para los eventos.
Tiempo de ejecución es cualquier momento mientras se ejecuta realmente la aplicación y se interactúa con ella como lo
haría un usuario.

4.1- Estableciendo las Propiedades más importantes de los formularios.


Muchas propiedades de un formulario afectan a su apariencia física. La propiedad Caption determina el texto que
muestra la barra de título del formulario y la propiedad Icon establece el icono que aparece cuando se minimiza un
formulario. Las propiedades MaxButton y MinButton determinan si el formulario se puede maximizar o minimizar.
Cambiando la propiedad BorderStyle puede controlar el comportamiento de cambio de tamaño del formulario.
Las propiedades Height y Width determinan el tamaño inicial de un formulario, mientras que las propiedades Left y
Top determinan la ubicación del formulario en relación con la esquina superior izquierda de la pantalla. Con la
propiedad WindowState puede establecer si el formulario se inicia en estado maximizado, minimizado o normal.
La propiedad Name establece el nombre con el que hará referencia al formulario en el código. De forma
predeterminada, cuando se agrega un formulario por primera vez a un proyecto, su nombre es Form1, Form2, etc. Es
conveniente establecer la propiedad Name a algo más significativo, como “frmEntry” para un formulario de entrada de
pedidos.
La mejor manera de familiarizarse con las numerosas propiedades de los formularios es experimentar. Cambie algunas
propiedades de un formulario en la ventana Propiedades y ejecute la aplicación para ver su efecto. Puede aprender más
sobre cada propiedad si la selecciona y presiona F1 para ver Ayuda contextual.

4.2- Eventos y Métodos de los formularios.


Como objetos que son, los formularios pueden ejecutar métodos y responder a eventos.
El evento Resize de un formulario se desencadena siempre que se cambia el tamaño de un formulario, ya sea por una
acción del usuario o a través del código. Esto permite realizar acciones como mover o cambiar el tamaño de los
controles de un formulario cuando han cambiado sus dimensiones.
El evento Activate se produce siempre que un formulario se convierte en el formulario activo; el evento Deactivate se
produce cuando otro formulario u otra aplicación se convierte en activo. Estos eventos son adecuados para iniciar o
finalizar acciones del formulario. Por ejemplo, en el evento Activate podría escribir código para resaltar el texto de un

Página 34 de 159
Curso Visual Basic 5.0

determinado cuadro de texto; con el evento Deactivate podría guardar los cambios efectuados en un archivo o en una
base de datos.
Para hacer visible un formulario se invoca el método Show:

Form2.Show

Para descargar un formulario (cerrarlo), se invoca al método Unload:

Form2.Unload
Unload Me ‘Me significa el Formulario activo.

Para ocultar un formulario (pero dejarlo activo en memoria) se invoca al método Hide:

Form2.Hide

Invocar el método Show tiene el mismo efecto que establecer a True la propiedad Visible del formulario.
Muchos métodos de un formulario implican texto o gráficos. Los métodos Print, Line, Circle y Refresh son útiles para
imprimir o dibujar directamente en la superficie de un formulario.

4.3- Establecer el formulario de arranque de la aplicación.


De forma predeterminada, el primer formulario de la aplicación es el formulario inicial. Cuando la aplicación inicia la
ejecución, se presenta este formulario (el primer código que se ejecuta es el del evento Form_Initialize de dicho
formulario). Si quiere presentar un formulario diferente cuando se inicie la aplicación, debe cambiar el formulario
inicial.

Para cambiar el formulario inicial

1. En el menú Proyecto, elija Propiedades del proyecto.


2. Elija la ficha General.
3. En el cuadro de lista Objeto inicial, seleccione el formulario que desee que sea el nuevo formulario inicial.
4. Elija Aceptar.

Inicio sin formulario inicial

Algunas veces puede desear que la aplicación se inicie sin cargar ningún formulario. Por ejemplo, puede que desee
ejecutar código que cargue un archivo de datos y después presentar uno de entre varios formularios, según el contenido
de dicho archivo. Puede hacerlo creando un procedimiento Sub llamado Main en un módulo estándar, como en el
siguiente ejemplo:

Sub Main()
Dim intStatus As Integer
' Llamar a un procedimiento de función para comprobar el estado
' del usuario.
intStatus = GetUserStatus
' Mostrar un formulario inicial distinto según el estado.
If intStatus = 1 Then
frmMain.Show
Else
frmPassword.Show
End If

Página 35 de 159
Curso Visual Basic 5.0

Este procedimiento tiene que ser un procedimiento Sub y no puede estar en un módulo de formulario. Para establecer el
procedimiento Sub Main como objeto inicial, en el menú Proyecto elija Propiedades del proyecto, seleccione la ficha
General y seleccione Sub Main en el cuadro Objeto inicial.

5 -Combo Box (lista combo)


Un control ComboBox combina las características de un control TextBox y un control ListBox; los usuarios pueden
introducir información en la parte del cuadro de texto o seleccionar un elemento en la parte de cuadro de lista del
control.
Para agregar o eliminar elementos en un control ComboBox, use el método AddItem o RemoveItem. Establezca las
propiedades List, ListCount y ListIndex para permitir a un usuario tener acceso a los elementos de un control
ComboBox. Como alternativa, puede agregar elementos a la lista mediante la propiedad List en tiempo de diseño.
Nota Un evento Scroll ocurrirá en un control ComboBox sólo cuando se desplace el contenido de la parte desplegable
del ComboBox, no cada vez que cambie el contenido del ComboBox. Por ejemplo, si la parte desplegable de un
ComboBox contiene cinco elementos y el elemento superior está resaltado, no ocurrirá un evento Scroll hasta que
presione seis veces la flecha hacia abajo (o una vez la tecla AV PÁG). Después de eso, ocurrirá un evento Scroll por cada
pulsación de la tecla de flecha hacia abajo. Sin embargo, si después presiona la tecla de flecha hacia arriba, no ocurrirá
un evento Scroll hasta que presione seis veces la tecla de flecha hacia arriba (o una vez la tecla RE PÁG). Después de eso,
cada vez que presione la tecla de flecha hacia arriba se producirá un evento Scroll.

Eventos:
Evento Change Evento LostFocus
Evento Click Evento OLECompleteDrag
Evento DblClick Evento OLEDragDrop
Evento DragDrop Evento OLEDragOver
Evento DragOver Evento OLEGiveFeedback
Evento DropDown Evento OLESetData
Evento GotFocus Evento OLEStartDrag
Eventos KeyDown y KeyUp Evento Scroll
Evento KeyPress

Métodos:
Método AddItem Método Refresh
Método Clear (Clipboard, ComboBox, ListBox) Método RemoveItem
Método Drag Método SetFocus
Método Move Método ShowWhatsThis
Método OLEDrag Método ZOrder

Propiedades:
Propiedad Appearance Propiedad ListIndex
Propiedades BackColor y ForeColor Propiedad Locked
Propiedad Container Propiedad MouseIcon
Propiedad DataChanged Propiedad MousePointer
Propiedad DataField Propiedad Name
Propiedad DragIcon Propiedad NewIndex
Propiedad DragMode Propiedad OLEDragMode
Propiedad Enabled Propiedad OLEDropMode
Propiedad Font Propiedad Parent
Propiedades FontBold, FontItalic, FontStrikethru y FontUnderline
Propiedad FontName Propiedades SelLength, SelStart y SelText (Controles ActiveX)
Propiedad FontSize Propiedad Sorted
Propiedades Height y Width Propiedad Style
Propiedad HelpContextID Propiedad TabIndex
Propiedad hWnd Propiedad TabStop

Página 36 de 159
Curso Visual Basic 5.0

Propiedad Index (Control Array) Propiedad Tag


Propiedad IntegralHeight Propiedad Text
Propiedad ItemData Propiedad ToolTipText
Propiedades Left y Top Propiedad TopIndex
Propiedad List Propiedad Visible
Propiedad ListCount Propiedad WhatsThisHelpID
Propiedades SelLength, SelStart y SelText

6- List Box (lista).


Un control ListBox muestra una lista de elementos entre los cuales el usuario puede seleccionar uno o más. Si el número
de elementos supera el número que puede mostrarse, se agregará automáticamente una barra de desplazamiento al
control ListBox.
Si no se selecciona ningún elemento, el valor de la propiedad ListIndex será -1. El primer elemento de la lista es
ListIndex 0 y el valor de la propiedad ListCount siempre es uno más que el mayor valor de ListIndex.
Para agregar o eliminar elementos de un control ListBox, use el método AddItem o RemoveItem. Establezca las
propiedades List, ListCount y ListIndex para permitir que un usuario tenga acceso a elementos del ListBox. También
puede agregar elementos a la lista mediante la propiedad List en tiempo de diseño.

Eventos
Evento Click Eventos MouseDown y MouseUp
Evento DblClick Evento MouseMove
Evento DragDrop Evento OLECompleteDrag
Evento DragOver Evento OLEDragDrop
Evento GotFocus Evento OLEDragOver
Evento ItemCheck Evento OLEGiveFeedback
Eventos KeyDown y KeyUp Evento OLESetData
Evento KeyPress Evento OLEStartDrag
Evento LostFocus Evento Scroll

Métodos
Método AddItem Método Refresh
Método Clear (Clipboard, ComboBox, ListBox) Método RemoveItem
Método Drag Método SetFocus
Método Move Método ShowWhatsThis
Método OLEDrag Método ZOrder

Propiedades
Propiedad Appearance Propiedad MousePointer
Propiedades BackColor y ForeColor Propiedad MultiSelect
Propiedad Columns (ListBox) Propiedad Name
Propiedad Container Propiedad NewIndex
Propiedad DataChanged Propiedad OLEDragMode
Propiedad DataField Propiedad OLEDropMode
Propiedad DataSource Propiedad Parent
Propiedad DragIcon Propiedad SelCount
Propiedad DragMode Propiedad Selected
Propiedad Enabled Propiedad Sorted
Propiedad Font Propiedad Style
Propiedades FontBold, FontItalic, FontStrikethru y FontUnderline
Propiedad FontName Propiedad TabStop
Propiedad FontSize Propiedad Tag
Propiedades Height y Width Propiedad Text
Propiedad HelpContextID Propiedad ToolTipText

Página 37 de 159
Curso Visual Basic 5.0

Propiedad hWnd Propiedad TopIndex


Propiedad Index (Control Array) Propiedad Visible
Propiedad ItemData Propiedad WhatsThisHelpID
Propiedades Left y Top Propiedad TabIndex
Propiedad List Propiedad ListCount
Propiedad ListIndex Propiedad MouseIcon

7- Timer (cronómetro)
Un control Timer puede ejecutar código a intervalos periódicos produciendo un evento Timer.
El control Timer, invisible para el usuario, resulta útil para el procesamiento de fondo.
No puede establecer la propiedad Enabled de un Timer para una selección múltiple de controles que no sean controles
Timer.
No existe ningún límite práctico en cuanto al número de controles Timer activos que puede tener en Visual Basic 5.0
ejecutándose en Windows 95 o en Windows NT.

Eventos:
Evento Timer
Propiedades:
Propiedad Enabled Propiedad Name
Propiedad Index (Control Array) Propiedad Parent
Propiedad Interval Propiedad Tag
Propiedades Left y Top

8- Shape (figura).
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.
Utilice controles Shape en tiempo de diseño en lugar de o además de invocar los métodos Circle y Line en tiempo de
ejecución. Puede dibujar un control Shape en un contenedor, pero no puede actuar como contenedor. El efecto de
establecer la propiedad BorderStyle depende del valor de la propiedad BorderWidth. Si BorderWidth no es 1 y
BorderStyle no es 0 ó 6, BorderStyle se establece a 1.

Métodos:
Método Move Método ZOrder
Método Refresh

Propiedades:
Propiedades BackColor y ForeColor Propiedades Height y Width
Propiedad BackStyle Propiedad Index (Control Array)
Propiedad BorderColor Propiedades Left y Top
Propiedad BorderStyle Propiedad Name
Propiedad BorderWidth Propiedad Parent
Propiedad Container Propiedad Shape
Propiedad DrawMode Propiedad Tag
Propiedad FillColor Propiedad Visible
Propiedad FillStyle

9- Line (línea).

Página 38 de 159
Curso Visual Basic 5.0

Line es un control gráfico que se muestra como una línea horizontal, vertical o diagonal.
Puede utilizar un control Line en tiempo de diseño para dibujar líneas en formularios. En tiempo de ejecución puede
utilizar un control Line en lugar del método Line, o además de él. Las líneas dibujadas con el control Line permanecen
en el formulario aunque la propiedad AutoRedraw sea False. Los controles Line pueden mostrarse en formularios, en
cuadros de imagen y en marcos. No puede utilizar el método Move para mover un control Line en tiempo de ejecución,
pero sí se puede mover o cambiar de tamaño alterando sus propiedades X1, X2, Y1 e Y2. El efecto de establecer la
propiedad BorderStyle depende del valor de la propiedad BorderWidth. Si BorderWidth no es 1 y BorderStyle no es
0 ó 6, BorderStyle se establecerá a 1.

Métodos:
Método Refresh
Método ZOrder
Propiedades:
Propiedad BorderColor Propiedad Name
Propiedad BorderStyle Propiedad Parent
Propiedad BorderWidth Propiedad Tag
Propiedad Container Propiedad Visible
Propiedad DrawMode Propiedades X1, Y1, X2 y Y2
Propiedad Index (Control Array)

10- Image (imagen)


Utilice el control Image para mostrar un gráfico. 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.
El control Image utiliza menos recursos del sistema y actualiza con más rapidez que un control PictureBox, pero sólo
admite un subconjunto de las propiedades, los eventos y los métodos de PictureBox. Use la propiedad Stretch para
determinar si el gráfico se escala para ajustarse al control o viceversa. Aunque puede colocar un control Image dentro de
un contenedor, un control Image no puede actuar como contenedor.

Eventos:
Evento Click Evento OLECompleteDrag
Evento DblClick Evento OLEDragDrop
Evento DragDrop Evento OLEDragOver
Evento DragOver Evento OLEGiveFeedback
Eventos MouseDown y MouseUp Evento OLESetData
Evento MouseMove Evento OLEStartDrag

Métodos:
Método Drag Método Refresh
Método Move Método ShowWhatsThis
Método OLEDrag Método ZOrder

Propiedades:
Propiedad Appearance Propiedad MouseIcon
Propiedad BorderStyle Propiedad MousePointer
Propiedad Container Propiedad Name
Propiedad DataChanged Propiedad OLEDragMode
Propiedad DataField Propiedad OLEDropMode
Propiedad DataSource Propiedad Parent
Propiedad DragIcon Propiedad Picture
Propiedad DragMode Propiedad Stretch
Propiedad Enabled Propiedad Tag
Propiedades Height y Width Propiedad ToolTipText

Página 39 de 159
Curso Visual Basic 5.0

Propiedad Index (Control Array) Propiedad Visible


Propiedades Left y Top Propiedad WhatsThisHelpID

11- Data (acceso a bases de datos)

Proporciona acceso a datos almacenados en bases de datos mediante uno de los tres tipos de objetos Recordset. El
control Data le permite desplazarse de un registro a otro, así como presentar y manipular datos de los registros en
controles enlazados. Sin un control Data los controles enlazados a datos (vinculados) de un formulario no pueden tener
acceso a los datos automáticamente.
Puede realizar la mayoría de las operaciones de acceso a datos utilizando el control Data sin escribir código. Los
controles enlazados a datos vinculados a un control Data presentan automáticamente los datos de uno o varios campos
del registro actual o, en algunos casos, de un conjunto de registros situado a ambos lados del registro actual. El control
Data realiza todas sus operaciones sobre el registro actual.
Si el control Data recibe instrucciones para desplazarse a un registro diferente, todos los controles enlazados pasan
automáticamente los posibles cambios al control Data para que los guarde en la base de datos. Después, el control Data
se desplaza al registro solicitado y pasa los datos del registro actual a los controles enlazados, en los que se presentan.
El control Data administra automáticamente una serie de contingencias entre las que se incluyen los conjuntos de
registros vacíos, la inserción de nuevos registros, la modificación y actualización de registros existentes, y la
administración de ciertos tipos de errores. Sin embargo, en aplicaciones más sofisticadas es necesario interceptar algunas
condiciones de error que el control Data no puede administrar. Por ejemplo, si el motor de base de datos Microsoft Jet
tiene un problema al tener acceso al archivo de base de datos, no tiene el permiso adecuado o no puede ejecutar la
consulta, se producirá un error interceptable. Si el error se produce antes de que se inicien los procedimientos de la
aplicación o se trata de errores internos, se desencadenará el evento Error.

12- Controles enlazados


Los controles DBList, DBCombo, DBGrid y MSFlexGrid son capaces de administrar conjuntos de registros cuando
están enlazados a un control Data. Todos estos controles permiten presentar o manipular varios registros a la vez.
Los controles incorporados Picture, Label, TextBox, CheckBox, Image, OLE, ListBox y ComboBox también son
controles enlazados a datos y se pueden enlazar a un único campo de un Recordset administrado por un control Data.
En las ediciones Profesional y Empresarial se encuentran disponibles otros controles enlazados a datos como
MaskedEdit y RichTextBox; otros proveedores también ofrecen controles adicionales.

12.1 Funcionamiento
Una vez iniciada la aplicación, Visual Basic utiliza las propiedades del control Data para abrir la base de datos
seleccionada, crear un objeto Database y crear un objeto Recordset. Las propiedades Database y Recordset del control
Data hacen referencia a los objetos Database y Recordset recién creados, que se pueden manipular de forma
independiente del control Data, con o sin controles enlazados. El control Data se inicializa antes del evento Form_Load
inicial del formulario en el que se encuentra. Si se producen errores durante esta fase de inicialización, se produce un
error no interceptable.
Cuando Visual Basic utiliza el motor de base de datos Jet para crear un Recordset, no se pueden producir otras
operaciones o eventos de Visual Basic hasta que se termine la operación. Sin embargo, otras aplicaciones basadas en
Windows pueden seguir en ejecución mientras se está creando el Recordset. Si el usuario presiona CTRL+INTER mientras
el motor Jet está generando un Recordset, la operación termina, se produce un error interceptable y la propiedad
Recordset del control Data se establece a Nothing. En tiempo de diseño, la segunda vez que se presiona CTRL+INTER
hace que Visual Basic presente la ventana
Depuración.
Puede manipular el control Data con el mouse (ratón), desplazándose de un registro a otro, o al principio o al final del
Recordset. Las propiedades EOFAction y BOFAction determinan lo que ocurre cuando el usuario se desplaza al
principio o al final de un Recordset con el mouse. No puede establecer el enfoque en un control Data.

Página 40 de 159
Curso Visual Basic 5.0

12.2 Validación
El evento Validate y la propiedad DataChanged se utilizan para realizar comprobaciones de última hora sobre los
registros que se van a escribir en la base de datos.

12.3 Objetos de acceso a datos


En los procedimientos puede utilizar los objetos de acceso a datos Database y Recordset creados por el control Data.
Cada objeto Database y Recordset tiene sus propias propiedades y métodos, y puede escribir procedimientos que
utilicen dichas propiedades y métodos para manipular sus datos.
Por ejemplo, el método MoveNext de un objeto Recordset desplaza el registro actual al siguiente registro dentro del
Recordset. Para invocar este método, podría utilizar el código siguiente:
Data1.Recordset.MoveNext

El control Data puede tener acceso a cualquiera de los tres tipos de objetos Recordset del motor Jet versión 3.0. Si no
selecciona el tipo de conjunto de registros, se crea un Recordset de tipo dynaset.
En muchos casos, el tipo predeterminado y la configuración del objeto Recordset creado son muy ineficientes. Es decir,
puede que no necesite un cursor actualizable totalmente desplazable de conjunto de claves para tener acceso a los datos.
Por ejemplo, un Recordset de tipo snapshot, de sólo lectura y unidireccional se crearía con más rapidez que el cursor
predeterminado. Asegúrese de elegir el tipo más eficiente, así como las propiedades Exclusive, Options y ReadOnly
adecuadas a su situación.

Para seleccionar un tipo de Recordset específico, establezca la propiedad RecordsetType del control Data a:
RecordsetType Valor Constante
Table 0 vbRSTypeTable
Dynaset 1 vbRSTypeDynaset (Predeterminado)
Snapshot 2 vbRSTypeSnapshot

12.4 Ediciones Profesional y Empresarial


En lo que concierne al acceso a datos, la principal diferencia entre las ediciones de Aprendizaje, Profesional y
Empresarial de Visual Basic es la capacidad de crear nuevos objetos de acceso a datos. En la Edición estándar no puede
declarar (con la palabra clave Dim) variables como objetos de acceso a datos dentro del código. Esto significa que sólo
el control Data puede crear objetos Database y Recordset.
En las ediciones Profesional y Empresarial de Visual Basic versión 5.0 puede crear un objeto Recordset y asignarlo a la
propiedad Recordset de un control Data. Cualquier control enlazado que esté conectado al control Data permitirá
manipular los registros del Recordset que ha creado. Asegúrese de que las propiedades DataField de los controles
enlazados estén establecidas a nombres de campo válidos dentro del nuevo Recordset.

12.5 Consultas almacenadas


Otra opción importante al utilizar el control Data es la posibilidad de ejecutar consultas almacenadas. Si antes ha creado
un objeto QueryDef, el control Data puede ejecutarlo y crear un Recordset mediante las propiedades SQL, Connect y
otras del objeto QueryDef. Para ejecutar un QueryDef, establezca la propiedad RecordSource del control Data al
nombre del QueryDef y utilice el método Refresh.
Si el QueryDef almacenado contiene parámetros, tiene que crear el Recordset y pasarlo al control Data.

12.6 Tratamiento de BOF/EOF


El control Data también puede administrar lo que ocurre cuando se encuentre con un Recordset sin registros.
Modificando la propiedad EOFAction puede programar el control Data para que pase al modo AddNew de forma
automática.

Página 41 de 159
Curso Visual Basic 5.0

Puede programar el control Data para que se ajuste automáticamente a la parte superior o inferior del formulario
primario utilizando la propiedad Align. En cualquiera de los casos, el control Data cambia de tamaño horizontalmente
para llenar todo el ancho de su formulario primario, siempre que éste cambie de tamaño.

Eventos:
Evento DragDrop Evento OLEDragOver
Evento DragOver Evento OLEGiveFeedback
Evento Error Evento OLESetData
Eventos MouseDown, MouseUp Evento OLEStartDrag
Evento MouseMove Evento Reposition
Evento OLECompleteDrag Evento Resize
Evento OLEDragDrop Evento Validate

Métodos
Método Drag Método ShowWhatsThis
Método Move Método UpdateControls
Método OLEDrag Método UpdateRecord
Método Refresh Método ZOrder

Propiedades
Propiedad Align Propiedad FontSize
Propiedad Appearance Propiedades Height, Width
Propiedades BackColor, ForeColor Propiedad Index (Matriz de controles)
Propiedad BOFAction, EOFAction Propiedades Left, Top
Propiedad Caption Propiedad MouseIcon
Propiedad Connect Propiedad MousePointer
Propiedad Database Propiedad Name
Propiedad DatabaseName Propiedad OLEDropMode
Propiedad DefaultCursorType Propiedad Options
Propiedad DefaultType Propiedad Parent
Propiedad DragIcon Propiedad ReadOnly (Aceso de datos)
Propiedad DragMode Propiedad Recordset
Propiedad EditMode Propiedad RecordsetType
Propiedad Enabled Propiedad RecordSource
Propiedad Exclusive Propiedad Tag
Propiedad Font Propiedad ToolTipText
Propiedades FontBold, FontItalic, FontStrikethru, FontUnderline
Propiedad FontName Propiedad WhatsThisHelpID
Propiedad Visible

13 -Eventos más importantes de los controles estándares.

13.1-Change
Aplicable a:
Control ComboBox, Controles HScrollBar y VScrollBar, Control Label, Control PictureBox, Control TextBox

Indica que el contenido de un control ha cambiado. Cómo y cuándo ha ocurrido este evento varía según el control:
• ComboBox: cambia el texto de la parte de cuadro de texto del control. Ocurre sólo si la propiedad Style está
establecida a 0 (Dropdown Combo) o 1 (Simple Combo) y el usuario cambia el texto o usted cambia la
configuración de la propiedad Text mediante código.

Página 42 de 159
Curso Visual Basic 5.0

• DirListBox: cambia el directorio seleccionado. Ocurre cuando el usuario hace doble clic en un nuevo directorio o
cuando usted cambia la configuración de la propiedad Path mediante código.
• DriveListBox: cambia la unidad seleccionada. Ocurre cuando el usuario selecciona una nueva unidad o cuando
usted cambia la configuración de la propiedad Drive mediante código.
• HScrollBar y VScrollBar (barras de desplazamiento horizontal y vertical): mueven la parte de cuadro de
desplazamiento de la barra de desplazamiento. Ocurre cuando el usuario desplaza o cuando usted cambia la
configuración de la propiedad Value mediante código.
• Label: cambia el contenido del control Label. Ocurre cuando un vínculo DDE actualiza los datos o cuando usted
cambia la configuración de la propiedad Caption mediante código.
• PictureBox: cambia el contenido del control PictureBox. Ocurre cuando un vínculo DDE actualiza los datos o
cuando usted cambia la configuración de la propiedad Picture mediante código.
• TextBox: cambia el contenido del cuadro de texto. Ocurre cuando un vínculo DDE actualiza los datos, cuando un
usuario cambia el texto o cuando usted cambia la configuración de la propiedad Text mediante código.

Sintaxis
Private Sub objeto_Change([índice As Integer])

La sintaxis del evento Change consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Un entero que identifica únicamente a un control si está en una matriz de controles.

Comentarios
El procedimiento del evento Change puede sincronizar o coordinar la presentación de datos entre controles. Por ejemplo,
puede utilizar un procedimiento de evento Change de una barra de desplazamiento para actualizar la configuración de la
propiedad Value de la barra de desplazamiento de un control TextBox. O bien, puede utilizar un procedimiento de
evento Change para mostrar datos y fórmulas en un área de trabajo y los resultados en otra área.
Los procedimientos de evento Change son también útiles para actualizar propiedades de controles del sistema de
archivos (DirListBox, DriveListBox y FileListBox). Por ejemplo, puede actualizar la configuración de la propiedad
Path para que un control DirListBox refleje un cambio en la configuración de la propiedad Drive de un control
DriveListBox.
Nota Un procedimiento de evento Change puede algunas veces causar un evento en cascada. Esto ocurre cuando el
procedimiento de evento Change del control altera el contenido del control, por ejemplo, estableciendo una propiedad en
el código que determina el valor del control, como el valor de la propiedad Text para un control TextBox. Para impedir
un evento en cascada:
• Si es posible, evite escribir un procedimiento de evento Change para un control que altere el contenido de ese
control. Si escribe un procedimiento así, asegúrese de establecer un indicador que impida cambios posteriores
mientras el cambio actual está en curso.
• Evite crear dos o más controles cuyos procedimientos de evento Change se vean afectados entre sí, por ejemplo, dos
controles TextBox que se actualicen entre sí durante sus eventos Change.
• Evite utilizar una función o una instrucción MsgBox en este evento para los controles HScrollBar y VScrollBar.

Ejemplo del evento Change


Este ejemplo muestra la configuración numérica de la propiedad Value de una barra de desplazamiento horizontal en un
control TextBox. Para probar este ejemplo, cree un formulario con un control TextBox y un control HScrollBar y
después pegue el código en la sección Declaraciones de un formulario que contenga una barra de desplazamiento
horizontal (control HScrollBar) y un control TextBox. Presione F5 y haga clic en la barra de desplazamiento horizontal.

Private Sub Form_Load ()


HScroll1.Min = 0 ' Establece Min.
HScroll1.Max = 1000 ' Establece Max.
HScroll1.LargeChange = 100 ' Establece LargeChange.
HScroll1.SmallChange = 1 ' Establece SmallChange.
End Sub

Página 43 de 159
Curso Visual Basic 5.0

Private Sub HScroll1_Change ()


Text1.Text = HScroll1.Value
End Sub

13.2-Click
Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Objeto Form, Control Frame, Control Image,
Control Label, Control ListBox, Control Menu, Control OptionButton, Control PictureBox, Control TextBox.
Ocurre cuando el usuario presiona y suelta un botón del mouse (ratón) en un objeto. También puede ocurrir cuando se
cambia el valor de un control.
Para un objeto Form, este evento ocurre cuando el usuario hace clic en un área en blanco o en un control desactivado.
Para un control, este evento ocurre cuando el usuario:
• Hace clic en un control con el botón primario o secundario del mouse. Con un control CheckBox,
CommandButton, ListBox o OptionButton, el evento Click sólo ocurre cuando el usuario hace clic con el botón
primario del mouse.
• Selecciona un elemento de un control ComboBox o ListBox, ya sea presionando las teclas de dirección o haciendo
clic con el botón del mouse.
• Presiona la BARRA ESPACIADORA cuando un control CommandButton, OptionButton o CheckBox tiene el
enfoque.
• Presiona ENTRAR cuando un formulario tiene un control CommandButton con su propiedad Default establecida
a True.
• Presiona ESC cuando un formulario tiene un botón Cancelar, un control CommandButton con su propiedad
Cancel establecida a True.
• Presiona una tecla de acceso para un control. Por ejemplo, si el título de un control CommandButton es "&Ir", al
presionar ALT+I se desencadena este evento.

También puede desencadenar el evento Click en el código si:


• Establece la propiedad Value de un control CommandButton a True.
• Establece la propiedad Value de un control OptionButton a True.
• Cambia el valor de la propiedad Value de un control CheckBox.

Sintaxis
Private Sub Form_Click( )
Private Sub objeto_Click([índice As Integer])

La sintaxis del evento Click consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Un entero que identifica únicamente a un control si está en una matriz de controles.

Comentarios
Por lo general se adjunta un procedimiento de evento Click a un control CommandButton, un objeto Menu o un
control PictureBox para realizar comandos y acciones similares a comandos. Para los demás controles aplicables, utilice
este evento para desencadenar acciones como respuesta a un cambio en el control.
Puede utilizar la propiedad Value de un control para comprobar el estado del control desde el código. Hacer clic en un
control genera los eventos MouseDown y MouseUp además del evento Click. El orden en que ocurren estos tres eventos
varía de un control a otro. Por ejemplo, para los controles ListBox y CommandButton, los eventos ocurren en este
orden: MouseDown, Click, MouseUp. Pero para los controles FileListBox, Label o PictureBox, los eventos ocurren en
este otro orden: MouseDown, MouseUp y Click. Cuando está adjuntando procedimientos para estos eventos
relacionados, asegúrese de que sus acciones no entran en conflicto. Si el orden de los eventos es importante en la
aplicación, pruebe el control para determinar el orden de los mismos.

Página 44 de 159
Curso Visual Basic 5.0

Nota Para distinguir entre los botones primario, secundario y central del mouse, utilice los eventos MouseDown y
MouseUp.

Si hay código en el evento Click, nunca se activará el evento DlbClick ya que de los dos eventos, Click es el primero
que se activa. Como resultado, el evento Click intercepta el clic del mouse, por lo que DblClick nunca se producirá.

Ejemplo del Evento Click


En este ejemplo, cada vez que se hace clic en un control PictureBox se mueve diagonalmente por un formulario. Para
probar este ejemplo, pegue el código en la sección Declaraciones de un formulario que contenga un control PictureBox
en la esquina inferior izquierda del mismo, después presione F5 y haga clic en el control PictureBox.
Private Sub Picture1_Click ()
Picture1.Move Picture1.Left + 750, Picture1.Top - 550
End Sub

13.3- GotFocus
Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, , Objeto Form Controles HScrollBar y VScrollBar,
Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Ocurre cuando un objeto recibe el enfoque, ya sea mediante una acción del usuario, como tabular o hacer clic en el
objeto, o cambiando el enfoque en el código mediante el método SetFocus. Un formulario recibe el enfoque sólo cuando
todos los controles visibles están desactivados.
Sintaxis
Private Sub Form_GotFocus( )
Private Sub objeto_GotFocus([índice As Integer])

La sintaxis del evento GotFocus consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Un entero que identifica de manera única a un control si está en una matriz de controles.

Comentarios

Normalmente, el procedimiento de evento GotFocus se utiliza para especificar las acciones que ocurren cuando un
control o un formulario recibe primero el enfoque. Por ejemplo, si adjunta un procedimiento de evento GotFocus a cada
control de un formulario puede guiar al usuario mostrándole instrucciones breves o mensajes en la barra de estado.
También puede proporcionar avisos visuales activando, desactivando o mostrando otros controles que dependan del
control que tiene el enfoque.
Nota Un objeto puede recibir el enfoque sólo si sus propiedades Enabled y Visible están establecidas a True. Para
personalizar el interfaz de teclado en Visual Basic para mover el enfoque, establezca el orden de tabulación o
especifique teclas de acceso para controles de un formulario.

Ejemplo del evento GotFocus

Este ejemplo muestra un mensaje en la barra de estado cuando un botón de un grupo OptionButton obtiene el enfoque.
Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario que contenga dos controles
OptionButton y un control Label. Establezca la propiedad Name de ambos controles OptionButton a OptionGroup y,
después, presione F5 y haga clic en los controles OptionButton.

Private Sub Form_Load ()


Label1.AutoSize = True

Página 45 de 159
Curso Visual Basic 5.0

End Sub

Private Sub OptionGroup_GotFocus (Index As Integer)


Select Case Index
Case 0
Label1.Caption = "La opción 1 tiene el enfoque."
Case 1
Label1.Caption = "La opción 2 tiene el enfoque."
End Select
End Sub

Private Sub OptionGroup_LostFocus (Index As Integer)


Label1.Caption = ""
End Sub

13.4- KeyPress
Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Objeto Form Controles HScrollBar y VScrollBar,
Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Ocurre cuando el usuario presiona y suelta una tecla.


Sintaxis
Private Sub Form_KeyPress(keyascii As Integer)
Private Sub objeto_KeyPress([índice As Integer,]keyascii As Integer)

La sintaxis del evento KeyPress consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Un entero que identifica de manera única a un control si está en una matriz de controles.
keyascii Un entero que devuelve un código de tecla numérico ANSI estándar. keyascii se pasa por referencia;
al cambiarlo se envía un carácter diferente al objeto. Cambiar keyascii a 0 cancela la pulsación de
tecla, de forma que el objeto no recibe ningún carácter.

Comentarios

El objeto que tiene el enfoque recibe el evento. Un formulario puede recibir el evento sólo si no tiene controles visibles
y activados. Un evento KeyPress puede implicar a cualquier carácter imprimible del teclado, a la tecla CTRL combinada
con un carácter del alfabeto estándar o uno de los caracteres especiales, y la tecla ENTRAR o RETROCESO. Un
procedimiento de evento KeyPress es útil para interceptar pulsaciones de teclas realizadas en un control TextBox o
ComboBox. Esto le permite comprobar inmediatamente la validez de las pulsaciones o el formato de los caracteres a
medida que se escriben. Cambiar el valor del argumento keyascii cambia el carácter mostrado.
KeyPress interpreta las mayúsculas y minúsculas de cada carácter como códigos de tecla distintos y, por tanto, como
caracteres diferentes.
Nota El número ANSI para la combinación de teclado CTRL+@ es 0. Puesto que Visual Basic reconoce un valor
keyascii de 0 como una cadena de longitud cero (""), evite utilizar CTRL+@ en sus aplicaciones.

Ejemplo del evento KeyPress

Este ejemplo convierte a mayúsculas el texto escrito en un control TextBox. Para probar este ejemplo, pegue el código
en la sección Declaraciones de un formulario que contenga un control TextBox y, después, presione F5 y escriba algo en
el control TextBox.

Página 46 de 159
Curso Visual Basic 5.0

Private Sub Text1_KeyPress (KeyAscii As Integer)


Char = Chr(KeyAscii)
KeyAscii = Asc(UCase(Char))
End Sub

13.5- Load
Aplicable a:
Objeto Form.

Ocurre cuando se carga un formulario. Para un formulario de inicio, ocurre cuando una aplicación se inicia como
resultado de una instrucción Load o como resultado de una referencia a una propiedad o control de un formulario
descargado.
Sintaxis
Private Sub Form_Load( )
Private Sub MDIForm_Load( )

Comentarios

Normalmente utiliza un procedimiento de evento Load para incluir código de inicialización para un formulario; por
ejemplo, código que especifica los valores predeterminados de los controles, indica el contenido que se va a cargar en
controles ComboBox o ListBox e inicializa variables a nivel del formulario.
El evento Load ocurre tras el evento Initialize.
Nota Cuando cree procedimientos para eventos relacionados, como Activate, GotFocus, Paint y Resize, asegúrese de
que sus acciones no entran en conflicto y no producen eventos recursivos.

Ejemplo del evento Load

Este ejemplo carga elementos en un control ComboBox cuando se carga un formulario. Para probar este ejemplo, pegue
el código en la sección Declaraciones de un formulario que contenga un control ComboBox y después presione F5.

Private Sub Form_Load ()


Combo1.AddItem "Mozart" ' Agrega elementos a la lista.
Combo1.AddItem "Beethoven"
Combo1.AddItem "Rock 'n Roll"
Combo1.AddItem "Reggae"
Combo1.ListIndex = 2 ' Establece la selección predeterminada.
End Sub

13.6- LostFocus

Aplicable a
Control CheckBox, Control ComboBox, Control CommandButton, Objeto Form Controles HScrollBar y VScrollBar,
Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Ocurre cuando un objeto pierde el enfoque, ya sea por una acción del usuario, como tabular o hacer clic en otro objeto, o
bien mediante un cambio del enfoque en el código con el método SetFocus.
Sintaxis
Private Sub Form_LostFocus( )
Private Sub objeto_LostFocus([índice As Integer])

La sintaxis del evento LostFocus consta de las siguientes partes:

Página 47 de 159
Curso Visual Basic 5.0

Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Un entero que identifica de manera única a un control si está en una matriz de controles.

Comentarios

Un procedimiento de evento LostFocus resulta especialmente útil para comprobar y validar actualizaciones. Utilizar
LostFocus puede hacer que la validación tenga lugar conforme el usuario mueve el enfoque del control. Otro uso para
este tipo de procedimiento de evento es activar, desactivar, ocultar y mostrar otros objetos, como en un procedimiento de
evento GotFocus. También puede invertir o cambiar condiciones que estableció en el procedimiento de evento GotFocus
del objeto.

Ejemplo del evento LostFocus


Este ejemplo cambia el color de un control TextBox cuando recibe o pierde el enfoque (se selecciona con el mouse o la
tecla TAB) y muestra el texto apropiado en el control Label. Para probar este ejemplo, pegue el código en la sección
Declaraciones de un formulario que contenga dos controles TextBox y un control Label y, después, presione F5 y
mueva el enfoque entre Text1 y Text2.

Private Sub Text1_GotFocus ()


' Muestra el enfoque en rojo.
Text1.BackColor = RGB(255, 0, 0)
Label1.Caption = "Text1 tiene el enfoque."
End Sub

Private Sub Text1_LostFocus ()


' Muestra la pérdida del enfoque en azul.
Text1.BackColor = RGB(0, 0, 255)
Label1.Caption = "Text1 no tiene el enfoque."
End Sub

13.7- MouseMove
Aplicable a:
Control CheckBox, Control CommandButton, Control Data, Objeto Form, Control Frame, Control Image, Control
Label, Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Ocurre cuando el usuario mueve el mouse.

Sintaxis
Private Sub Form_MouseMove(botón As Integer, mayús As Integer, x As Single, y As Single)
Private Sub MDIForm_MouseMove(botón As Integer, mayús As Integer, x As Single, y As Single)
Private Sub objeto_MouseMove([índice As Integer,] botón As Integer, mayús As Integer, x As Single, y As Single)

La sintaxis del evento MouseMove consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Un entero que identifica de manera única a un control si está en una matriz de controles.
botón Un entero que corresponde al estado de los botones del mouse en el cual un bit se establece si el botón está
presionado. El argumento botón es un campo de bit con los bits correspondientes al botón primario (bit 0), al botón
secundario (bit 1) y al botón central (bit 2). Estos bits corresponden a los valores 1, 2 y 4, respectivamente. Indica el estado
completo de los botones del mouse; alguno, todos o ninguno de estos tres bits puede estar establecido, lo que indica que
algunos, todos o ninguno de los botones está presionado.

Página 48 de 159
Curso Visual Basic 5.0

mayús Un entero que corresponde al estado de las teclas MAYÚS, CTRL y ALT. Un bit está establecido si la tecla está
presionada. El argumento mayús es un campo de bits con los bits menos significativos correspondientes a la tecla MAYÚS
(bit 0), CTRL (bit 1) y ALT (bit 2 ). Estos bits corresponden a los valores 1, 2 y 4, respectivamente. El argumento mayús
indica el estado de estas teclas. Alguno, todos o ninguno de los bits puede estar establecido, lo que indica que alguna, todas
o ninguna de las teclas está presionada. Por ejemplo, si se presionaron las teclas CTRL y ALT, el valor de shift sería 6.
x, y Un número que especifica la ubicación actual del puntero del mouse. Los valores x e y siempre se expresan en
términos del sistema de coordenadas establecido por las propiedades ScaleHeight, ScaleWidth, ScaleLeft y ScaleTop del
objeto.

Comentarios

El evento MouseMove se genera continuamente a medida que el puntero del mouse se mueve por los objetos. A menos
que otro objeto haya capturado el mouse, un objeto reconoce un evento MouseMove siempre que la posición del mouse
esté dentro de sus bordes.

Ejemplo del evento MouseMove

Este ejemplo muestra una aplicación de dibujo simple. El procedimiento de evento MouseDown funciona con un
procedimiento MouseMove relacionado para activar el dibujo cuando está presionado cualquier botón del mouse. El
procedimiento de evento MouseUp desactiva el dibujo. Para probar este ejemplo, pegue el código en la sección
Declaraciones de un formulario, después presione F5, haga clic en el formulario y mueva el mouse mientras está
presionado el botón del mismo.

Dim PaintNow As Boolean ' Declara una variable.


Private Sub Form_MouseDown (Button As Integer, Shift As Integer, X As Single, Y As Single)
PaintNow = True ' Activa el dibujo.
End Sub

Private Sub Form_MouseUp (Button As Integer, X As Single, Y As Single)


PaintNow = False ' Desactiva el dibujo.
End Sub

Private Sub Form_MouseMove (Button As Integer, Shift As Integer, X As Single, Y As Single)


If PaintNow Then
PSet (X, Y) ' Dibuja un punto.
End If
End Sub

Private Sub Form_Load ()


DrawWidth = 10 ' Utiliza un pincel más ancho.
ForeColor = RGB(0, 0, 255) ' Establece el color de dibujo.
End Sub

13.8- Timer
Aplicable a:
Control Timer

Ocurre cuando ha transcurrido un intervalo preestablecido para un control Timer. La frecuencia del intervalo se
almacena en la propiedad Interval del control, que especifica el tiempo en milisegundos.

Sintaxis
Private Sub objeto_Timer([índice As Integer])

Página 49 de 159
Curso Visual Basic 5.0

La sintaxis del evento Timer consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Un entero que identifica de manera única a un control si está en una matriz de controles.

Comentarios

Utilice este procedimiento de evento para indicar a Visual Basic qué hacer cada vez que se agote el intervalo de tiempo
de un control Timer. Cuando esté trabajando con el evento Timer:
• La propiedad Interval especifica el intervalo entre los eventos Timer, en milisegundos.
• Siempre que la propiedad Enabled del control Timer esté establecida a True y la propiedad Interval sea mayor
que 0, el evento Timer espera durante el periodo especificado en la propiedad Interval.

Ejemplo del evento Timer

Este ejemplo muestra un reloj digital. Para probar este ejemplo, pegue el código en la sección Declaraciones de un
formulario que contenga un control Label y un control Timer y, después, presione F5.

Private Sub Form_Load ()


Timer1.Interval = 1000 ' Establece el intervalo de Timer.
End Sub

Private Sub Timer1_Timer ()


Label1.Caption = Time ' Actualiza la presentación de la hora.
End Sub

Este ejemplo mueve un control PictureBox por un formulario. Para probar este ejemplo, pegue el código en la sección
Declaraciones de un formulario que contenga un control Timer y un control PictureBox y, después, presione F5. Si
desea obtener un efecto visual mejor puede asignar un mapa de bits al control PictureBox mediante la propiedad
Picture.

Dim DeltaX, DeltaY As Integer ' Declara variables.


Private Sub Timer1_Timer ()
Picture1.Move Picture1.Left + DeltaX, Picture1.Top + DeltaY
If Picture1.Left < ScaleLeft Then DeltaX = 100
If Picture1.Left + Picture1.Width > ScaleWidth + ScaleLeft Then
DeltaX = -100
End If
If Picture1.Top < ScaleTop Then DeltaY = 100
If Picture1.Top + Picture1.Height > ScaleHeight + ScaleTop Then
DeltaY = -100
End If
End Sub

Private Sub Form_Load ()


Timer1.Interval = 1000 ' Establece el intervalo.
DeltaX = 100 ' Inicializa variables.
DeltaY = 100
End Sub

Página 50 de 159
Curso Visual Basic 5.0

13.9- Unload
Aplicable a:
Objeto Form.

Ocurre cuando un formulario está a punto de quitarse de la pantalla. Cuando ese formulario se vuelve a cargar, el
contenido de todos sus controles se reinicializa. Este evento se desencadena porque un usuario cierra el formulario
mediante el comando Cerrar del menú Control o una instrucción Unload.

Sintaxis
Private Sub objeto_Unload(cancelar As Integer)

La sintaxis del evento Unload consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
cancelar Un entero que determina si el formulario se quita de la pantalla. Si cancelar es 0, el formulario se quita.
Establecer cancelar a cualquier valor distinto de cero impide que el formulario se quite.

Comentarios

Establecer cancelar a un valor distinto de cero impide que el formulario se quite, pero no detiene los demás eventos,
como la salida del entorno operativo Microsoft Windows. Utilice el evento QueryUnload para detener la salida de
Windows.
Utilice un procedimiento de evento Unload para comprobar si el formulario se debe descargar o para especificar
acciones que desea que tengan lugar cuando se descargue el formulario. También puede incluir cualquier código de
validación a nivel del formulario que pueda necesitar para cerrar el formulario o guardar los datos en un archivo.
El evento QueryUnload ocurre antes que el evento Unload. El evento Unload ocurre antes que el evento Terminate.
El evento Unload puede estar causado por la utilización de la instrucción Unload o porque el usuario elija el comando
Cerrar del menú Control del formulario, salga de la aplicación con el botón Finalizar tarea de la Lista de tareas, o
salga del entorno operativo Microsoft Windows mientras la aplicación se está ejecutando.

Ejemplo del evento Unload

Este ejemplo muestra un procedimiento simple para cerrar un formulario mientras se avisa al usuario con varios cuadros
de mensajes. En una aplicación real, puede agregar llamadas a procedimientos Sub de propósito general que emulen el
proceso de los comandos Salir, Guardar y Guardar como del menú Archivo de Visual Basic. Para probar este
ejemplo, pegue el código en la sección Declaraciones de un formulario y, después, presione F5. Una vez que se muestre
el formulario, presione ALT+F4 para cerrar el formulario.

Private Sub Form_Unload (Cancel As Integer)


Dim Msg, Response ' Declara variables.
Msg = "¿Desea guardar los datos antes de cerrar?"
Response = MsgBox(Msg, vbQuestion + vbYesNoCancel, "Diálogo Cerrar")
Select Case Response
Case vbCancel ' No se permite cerrar.
Cancel = -1
Msg = "Se ha cancelado el comando."
Case vbYes
' Introduzca código para guardar los datos aquí.
Msg = "Datos guardados."'
Case vbNo
Msg = "Datos no guardados."
End Select
MsgBox Msg, vbOKOnly, "Confirmación" ' Mostrar mensaje.
End Sub

Página 51 de 159
Curso Visual Basic 5.0

13.10- QueryUnload
Aplicable a:
Objeto Form y Colección Forms, Objeto MDIForm

Ocurre antes de que se cierre un formulario o una aplicación.

Sintaxis
Private Sub Form_QueryUnload(cancelar As Integer, modo_descarga As Integer)
Private Sub MDIForm_QueryUnload(cancelar As Integer, modo_descarga As Integer)

La sintaxis del evento QueryUnload consta de las siguientes partes:


Parte Descripción
cancelar Un entero. Establecer este argumento a cualquier valor distinto de 0 detiene el evento QueryUnload en
todos los formularios cargados y detiene el cierre del formulario y de la aplicación.
modo_descarga Un valor o una constante que indica la causa del evento QueryUnload, tal y como se describe en Valores
que se pueden obtener.

Valores que se pueden obtener


El argumento modo_descarga devuelve los siguientes valores:
Constante Valor Descripción
vbFormControlMenu 0 El usuario eligió el comando Cerrar del menú Control del formulario.
vbFormCode 1 Se invocó la instrucción Unload desde el código.
VbAppWindows 2 La sesión actual del entorno operativo Microsoft Windows está inalizando.
vbAppTaskManager 3 El Administrador de tareas de Microsoft Windows está cerrando la
aplicación.
vbFormMDIForm 4 Un formulario MDI secundario se está cerrando porque el formulario MDI
también se está cerrando.

Comentarios

Normalmente este evento se utiliza para asegurarse de que no hay tareas sin finalizar en los formularios incluidos en una
aplicación antes de que esa aplicación se cierre. Por ejemplo, si un usuario no ha guardado todavía algunos datos nuevos
de cualquier formulario, su aplicación puede pedir al usuario que los guarde.
Cuando una aplicación se cierra, puede utilizar los procedimientos de evento QueryUnload o Unload para establecer la
propiedad Cancel a True, deteniendo el proceso de cierre. Sin embargo, el evento QueryUnload ocurre en todos los
formularios antes de que se descargue ninguno de ellos y el evento Unload ocurre conforme se descarga cada
formulario.

Ejemplo del evento QueryUnload

En este ejemplo, al cerrar un formulario se consulta al operador si realmente quiere salir o no. También se chequea si
está saliendo del formulario o de toda la aplicación.

' Pegar en la sección Declaraciones de Form1.


Private Sub Form_QueryUnload (Cancel As Integer, UnloadMode As Integer)
Dim Msg ' Declara la variable.
If UnloadMode > 0 Then
' Si sale de la aplicación.
Msg = "¿Realmente desea salir de la aplicación?"
Else

Página 52 de 159
Curso Visual Basic 5.0

' Si sólo se cierra el formulario.


Msg = "¿Realmente desea cerrar el formulario?"
End If
' Si el usuario hace clic en el botón No, se detiene QueryUnload.
If MsgBox(Msg, vbQuestion + vbYesNo, Me.Caption) = vbNo Then Cancel = True
End Sub

13.11- Validate
Aplicable a:
Control Data

Se produce antes de que otro registro se convierta en el registro actual, antes del método Update (excepto cuando se
guardan los datos con el método UpdateRecord) y antes de una operación Delete, Unload o Close.
Sintaxis
Private Sub objeto_Validate ([índice As Integer,] acción As Integer, guardar As Integer)

La sintaxis del evento Validate consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a
índice Identifica el control si se encuentra en una matriz de controles
acción Un entero que indica la operación que provoca el evento, como se describe en Valores
guardar Una expresión booleana que especifica si los datos enlazados han cambiado, como se describe en Valores

Valores
Los valores de acción son:
Constante Valor Descripción
vbDataActionCancel 0 Cancela la operación al salir de Sub
vbDataActionMoveFirst 1 Método MoveFirst
vbDataActionMovePrevious 2 Método MovePrevious
vbDataActionMoveNext 3 Método MoveNext
vbDataActionMoveLast 4 Método MoveLast
vbDataActionAddNew 5 Método AddNew
vbDataActionUpdate 6 Operación Update (no UpdateRecord)
vbDataActionDelete 7 Método Delete
vbDataActionFind 8 Método Find
vbDataActionBookmark 9 Se ha establecido la propiedad Bookmark
vbDataActionClose 10 El método Close
vbDataActionUnload 11 Se está descargando el formulario

Los valores de guardar son:


Valor Descripción
True Los datos enlazados han cambiado
False Los datos enlazados no han cambiado

Comentarios

El argumento guardar indica inicialmente si los datos enlazados han cambiado. Este argumento puede ser False si los
datos del búfer de copia han cambiado. Si guardar es True cuando este evento termina, se invocan los métodos Edit y
UpdateRecord. El método UpdateRecord sólo guarda los datos de controles enlazados o del búfer de copia en los que
la propiedad DataChanged sea True.

Página 53 de 159
Curso Visual Basic 5.0

Este evento se produce incluso aunque no se hayan modificado los datos de los controles enlazados y aunque no existan
controles enlazados. Puede utilizar este evento para cambiar valores y actualizar datos. También puede decidir guardar
los datos o detener cualquier acción que esté provocando el evento y sustituirla por otra acción diferente.
Puede cambiar el argumento acción para cambiar una acción por otra. Puede cambiar los diversos métodos Move y el
método AddNew, que se pueden intercambiar libremente (cualquier Move en AddNew, cualquier Move en cualquier
otro Move o AddNew en cualquier Move). Cuando utilice AddNew, puede utilizar MoveNext y después ejecutar otro
AddNew para examinar la propiedad EditMode y determinar si hay una operación Edit o AddNew en curso. El intento
de sustituir AddNew o una acción Move en cualquier otra acción se pasa por alto o genera un error interceptable. Si se
establece acción a 0, se puede detener cualquier acción.
Dentro del código de este evento puede comprobar los datos de cada control enlazado en el que DataChanged sea
True. Después puede establecer DataChanged a False para evitar guardar dichos datos en la base de datos.
Durante este evento no puede utilizar ningún método (como MoveNext) en el objeto Recordset subyacente.

Ejemplo de la propiedad DataChanged y del evento Validate


Este ejemplo ilustra una validación de datos sencilla. En la tabla Authors de la base de datos Biblio.mdb hay dos
campos: Au_ID y Author. Como el valor de Au_ID se utiliza para identificar de forma única al autor, este valor no se
debe cambiar. El ejemplo no permite que se modifique el campo Au_ID, que está enlazado a Text1.

Private Sub Data1_Validate (Action As Integer, Save As Integer)


If Text1.DataChanged Then ' Comprueba si los datos han cambiado.
MsgBox "No puede cambiar el número de Id."
Text1.DataChanged = False ' No guarda los datos modificados.
End If
...
End Sub

14- Métodos más importantes de los controles estándares.

14.1- AddItem
Aplicable a:
ControlComboBox, ControlListBox

Agrega un elemento a un control ListBox o ComboBox.


Sintaxis
objeto.AddItem elemento, índice

La sintaxis del método AddItem consta de las siguientes partes:


Parte Descripción
objeto Requerido. Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.
Elemento Requerido. expresión de cadena que especifica el elemento que se va a agregar al objeto.
índice Opcional. Entero que especifica la posición dentro del objeto donde se insertan el elemento o la fila nuevos.
Para el primer elemento de un control ListBox o ComboBox, índice es 0.

Comentarios

Si se especifica un valor válido para índice, elemento se sitúa en dicha posición dentro del objeto. Si se omite índice,
elemento se agrega en la posición que le corresponda dentro del orden apropiado (si la propiedad Sorted es True) o al
final de la lista (si Sorted es False).
Los controles ListBox o ComboBox que están enlazados a un control Data no aceptan el método AddItem.

Página 54 de 159
Curso Visual Basic 5.0

Ejemplo del método AddItem


Este ejemplo utiliza el método AddItem para agregar 100 elementos a un cuadro de lista. Para probar este ejemplo,
pegue el código en la sección Declaraciones de un formulario con un control ListBox llamado List1, y después presione
F5 y haga clic en el formulario.
Private Sub Form_Click ()
Dim Entry, I, Msg ' Declara variables.
Msg = "Haga clic en Aceptar para agregar 100 elementos a su cuadro de lista."
MsgBox Msg ' Muestra el mensaje.
For I = 1 To 100 ' Cuenta de 1 a 100.
Entry = "Entrada " & I ' Crea la entrada.
List1.AddItem Entry ' Agrega la entrada.
Next I
Msg = "Haga clic en Aceptar para quitar una de cada dos entradas."
MsgBox Msg ' Muestra el mensaje.
For I = 1 To 50 ' Determina cómo quitar
List1.RemoveItem I ' cada elemento
Next I
Msg = "Haga clic en Aceptar para quitar todos los elementos del cuadro de lista."
MsgBox Msg ' Muestra el mensaje.
List1.Clear ' Limpia el cuadro de lista.
End Sub

14.2- AddNew (Objeto Recordset)


Aplicable a:
Objeto Recordset.

Crea un nuevo registro para un objeto Recordset de tipo Table o Dynaset.

Sintaxis
recordset.AddNew

El marcador de posición del recordset es una variable de objeto que representa un objeto Recordset que se puede
actualizar al que puede agregar un registro nuevo.

Comentarios

Utilice el método AddNew para crear y agregar un nuevo registro en el objeto Recordset llamado por el recordset. Este
método establece los campos a los valores predeterminados y si no se especifican valores predeterminados, establece los
campos a Null (los valores predeterminados especificados pare el Recordset tipo Table).
Después de modificar el nuevo registro, utilice el método Update para guardar los cambios y agregar el registro al
Recordset. No se producirán cambios en la base de datos hasta que no se utilice el método Update.
Precaución Si ejecuta un AddNew y a continuación realiza una operación que desplace otro registro sin usar Update,
los cambios se perderán sin previo aviso. Además, si cierra el Recordset o finaliza el procedimiento que declara el
Recordset o su objeto Database, el nuevo registro y los cambios realizados se descartarán sin previo aviso.
Si no se ha desplazado hasta el último registro de su Recordset, los registros agregados a las tablas subyacentes pueden
incluirse, si se colocan más allá del registro activo. Sin embargo, si agrega un registro a un Recordset, el registro será
visible en el Recordset y se incluirá en la tabla subyacente donde estará visible para todos los nuevos objetos
Recordset.
La posición del nuevo registro depende del tipo de Recordset:

Página 55 de 159
Curso Visual Basic 5.0

• En un objeto Recordset tipo Dynaset, los registros se insertan al final del conjunto del Recordset,
independientemente de las reglas de clasificación u orden que estuvieran en vigor cuando se abrió el Recordset.
• En un objeto Recordset tipo Table en el que su propiedad Index se haya establecido, los registros se insertan en el
lugar adecuado dentro del orden definido. Si no se ha establecido la propiedad Index, los nuevos registros se
insertarán al final del Recordset.

Ejemplo de método AddNew

En este ejemplo se agrega un regisro nuevo a la tabla Agenda de la base de datos Clientes, tomando los datos desde un
formulario que contiene 3 cajas de texto (txtCodigo, txtNombre y txtDireccion) y un botón para agregar los datos
(cmdAgregar)

Private Sub cmdAgregar_Click ()


Dim wsp as WorkSpace ‘Dimensiono las variables
Dim Base as Database
Dim Agenda as Recordset

Set wsp = DbEngine.Workspaces(0) ‘Seteo el espacio de trabajo


Set Base = wsp.OpenDatabase (“Clientes.mdb”) ‘Abro la base de Datos
Set Agenda = BasedeDatos.OpenRecordset(“SELECT * FROM Agenda”) ‘Abro el Recordset

Agenda.AddNew ‘Agrego un registro en blanco


Agenda!Codigo = txtCodigo.Text ‘Asigno los valores de las cajas de texto a los campos
Agenda!Direccion = txtDireccion.Text
Agenda.Nombre = txtNombre.Text
Agenda.Update

Agenda.Close ‘Cierro el Recordset


Base.Close ‘Cierro la base de Datos
Wsp.Close ‘Cierro el espacio de trabajo

End Sub

14.3- CancelUpdate (Objeto Recordset)


Aplicanble a:
Objeto Recordset.

Cancela todas las actualizaciones pendientes del objeto Recordset.

Sintaxis
recordset.CancelUpdate tipo

La sintaxis del método CancelUpdate consta de las siguientes partes.

Parte Descripción
recordset Una variable de objeto que representa el objeto Recordset en el que se cancelan las actualizaciones
pendientes.
Tipo Opcional. Una constante que indica el tipo de actualización, como se especifica en Valores (sólo espacios de
trabajo ODBCDirect).

Comentarios

Página 56 de 159
Curso Visual Basic 5.0

El método CancelUpdate cancela todas las actualizaciones pendientes a causa de una operación Edit o AddNew. Por
ejemplo, si un usuario llama al método Edit o AddNew sin haber llamado anteriormente al método Update,
CancelUpdate cancelará todos los cambios efectuados después de llamar a Edit o AddNew.

Ejemplo del método CancelUpdate

Al mismo ejemplo del Evento AddNew, le agregamos la opción de confirmar o volver para atrás la actualización al
operador, según la respuesta a una caja de mensajes.

Private Sub cmdAgregar_Click ()


Dim wsp as WorkSpace ‘Dimensiono las variables
Dim Base as Database
Dim Agenda as Recordset

Set wsp = DbEngine.Workspaces(0) ‘Seteo el espacio de trabajo


Set Base = wsp.OpenDatabase (“Clientes.mdb”) ‘Abro la base de Datos
Set Agenda = BasedeDatos.OpenRecordset(“SELECT * FROM Agenda”) ‘Abro el Recordset

Agenda.AddNew ‘Agrego un registro en blanco


Agenda!Codigo = txtCodigo.Text ‘Asigno los valores de las cajas de texto a los campos
Agenda!Direccion = txtDireccion.Text
Agenda.Nombre = txtNombre.Text

If MsgBox ("Agrega el nuevo registro”, vbYesNo) = vbYes then


Agenda.Update
Else
Agenda.CancelUpdate
End If

Agenda.Close ‘Cierro el Recordset


Base.Close ‘Cierro la base de Datos
Wsp.Close ‘Cierro el espacio de trabajo

End Sub

14.4- Clear (Clipboard, Combo Box, List Box)


Aplicable a:
Objeto Control ComboBox, Control ListBox-

Borra el contenido de los controles ListBox o ComboBox.


Sintaxis
objeto.Clear

El marcador de posición objeto representa una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.

Comentarios

Los controles ListBox o ComboBox que estén enlazados a un control Data no aceptan el método Clear.

Ejemplo del método Clear

Página 57 de 159
Curso Visual Basic 5.0

Este ejemplo utiliza el método Clear para borrar todos los elementos de un cuadro de lista. Para probar este ejemplo,
pegue el código en la sección Declaraciones de un formulario con un control ListBox llamado List1, y después presione
F5 y haga clic en el formulario.
Private Sub Form_Click ()
Dim Entry, I, Msg ' Declara variables.
Msg = "Haga clic en Aceptar para agregar 100 elementos a su cuadro de lista."
MsgBox Msg ' Muestra el mensaje.
For I = 1 To 100 ' Cuenta de 1 a 100.
Entry = "Entrada " & I ' Crea la entrada.
List1.AddItem Entry ' Agrega la entrada.
Next I
Msg = "Haga clic en Aceptar para quitar cualquier otra entrada."
MsgBox Msg ' Muestra el mensaje.
For I = 1 To 50 ' Determina cómo quitar
List1.RemoveItem I ' uno de cada dos
Next I ' elementos.
Msg = "Haga clic en Aceptar para quitar todos los elementos del cuadro de lista."
MsgBox Msg ' Muestra el mensaje.
List1.Clear ' Limpia el cuadro de lista.
End Sub

14.5- Close (Objetos Database, Recordset o Workspace)


Aplicable a:
Objeto Database, Objeto Recordset, Objeto Workspace.

Cierra un objeto DAO (Data Access Object).

Sintaxis
objeto.Close

El marcador de posición objeto es una variable de objeto que representa un objeto Database, Recordset o Workspace
abierto.

Comentarios

Si el objeto Database, Recordset o Workspace llamado por objeto está cerrado cuando utiliza Close se produce un
error en tiempo de ejecución.
Precaución Si sale de un procedimiento que declara objetos Database o Recordset y la base de datos esté cerrada, los
cambios no guardados se perderán, todas las transacciones pendientes se anularán y se anularán todas las modificaciones
pendientes de los datos.
Si intenta cerrar un objeto Connection o Database mientras hay algún objeto Recordset abierto, estos objetos
Recordset se cerrarán y las actualizaciones o modificaciones pendientes quedarán anuladas. Si intenta cerrar un objeto
Workspace mientras hay algún objeto Database abierto, los objetos Database se cerrarán, el cual cerrará sus objetos
Recordset.
La utilización del método Close en un objeto Recordset original o duplicado no afecta al otro objeto Recordset.
Una alternativa al método Close es establecer el valor de una variable de objeto a Nothing (Set dbsTemp = Nothing).

Ejemplo de método Close

Son válidos los ejemplos de los métodos AddNew y CancelUpdate. (donde se cierran objetos Workspace, Database y
Recordset),

Página 58 de 159
Curso Visual Basic 5.0

14.6- Cls
Aplicable a:
Objeto Form, Control PictureBox.

Borra los gráficos y el texto generados en tiempo de ejecución de los controles Form o PictureBox.

Sintaxis
objeto.Cls

El marcador de posición objeto representa una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a. Si
se omite objeto, se supone que el objeto es el control Form que tenga el enfoque.

Comentarios
Cls borra el texto y los gráficos generados en tiempo de ejecución por instrucciones gráficas y de impresión. Los mapas
de bits de fondo definidos mediante la propiedad Picture y los controles colocados en un Form en tiempo de diseño no
se ven afectados por Cls.
Después de llamar a Cls, las propiedades CurrentX y CurrentY del objeto se restablecen a 0.

Ejemplo del método Cls

Este ejemplo utiliza el método Cls para eliminar la información impresa de un formulario. Para probar este ejemplo,
pegue el código en la sección Declaraciones de un formulario, y después presione F5 y haga clic en el formulario.
Private Sub Form_Click ()
Dim Msg ' Declara variable.
ForeColor = QBColor(15) ' Establece el color de primer plano a blanco.
BackColor = QBColor(1) ' Establece el color de fondo a azul.
Msg = "Esta información se imprime en el fondo del formulario."
Print Msg ' Imprime el mensaje en el formulario.
Msg = "Haga clic en Aceptar para borrar la información y el patrón de fondo "
Msg = Msg & "mostrado en el formulario."
MsgBox Msg ' Muestra el mensaje.
Cls ' Borra el fondo del formulario.
End Sub

14.7- CompactDatabase (Objeto DBEngine)


Aplicable a:
Objeto DBEngine

Copia, compacta y ofrece la posibilidad de cambiar la versión, la secuencia de ordenación y la codificación. (sólo
espacio de trabajo Microsoft Jet).

Sintaxis
DBEngine.CompactDatabase antiguabasededatos, nuevabasededatos, escenario, opciones, contraseña

La sintaxis del método CompactDatabase tiene los siguientes argumentos:

Página 59 de 159
Curso Visual Basic 5.0

-Antiguabasededatos: Una String que identifica una base de datos existente y cerrada. Puede ser una ruta completa y un
nombre de archivo, como "C:\db1.mdb". Si el nombre de archivo tiene una extensión, deberá especificarla. Si su red lo
admite, también puede especificar una ruta de red, como "\\server1\share1\dir1\db1.mdb".
-nuevabasededatos: Un tipo de datos String que es la ruta completa de la base de datos compactada que va a crear.
También puede especificar una ruta de acceso de red al igual que con antiguabasededatos. No puede usar el argumento
nuevabasededatos para especificar el mismo archivo de base de datos que antiguabasededatos.
-Escenario: Opcional. Un tipo de datos Variant que es una expresión de cadena que se utiliza para especificar la secuencia
de ordenación para crear nuevabasededatos, como se especifica en Opciones. Si omite este argumento, el escenario de la
nuevabasededatos será el mismo que el de la antiguabasededatos.
También puede crear una contraseña para nuevabasededatos concatenando la cadena de la contraseña (que comienza con
";pwd=") con una constante del argumento escenario, como este:
dbLangSpanish & ";pwd=NuevaContraseña"
Si desea utilizar el mismo escenario como antiguabasededatos (el valor predeterminado), pero especificar una contraseña
nueva, simplemente escriba una contraseña en escenario:
";pwd=NuevaContraseña"
opciones Opcional. Un valor entero que indica una o más opciones, según se especifica en Opciones. Puede
combinar opciones sumando las correspondientes constantes.
-Contraseña: Opcional. Un tipo de datos Variant que es una expresión de cadena que contiene una contraseña, si la
base de datos está protegida con contraseña. La cadena ";pwd=" debe preceder a la propia contraseña. Si incluye una valor
de contraseña en escenario, este valor se ignora.

Puede utilizar una de las siguientes constantes en el argumento opciones para especificar si desea o no codificar la base
de datos mientras se compacta.
Constante Descripción
dbEncrypt Codifica la base de datos durante la compactación.
DbDecrypt Descodifica la base de datos durante la compactación.

Si omite una constante de codificación o si incluye a la vez dbDecrypt y dbEncrypt, nuevabasededatos tendrá la
misma codificación que antiguabasededatos.
Puede usar una de las siguientes constantes en el argumento opciones para especificar la versión del formato de los datos
para la base de datos compactada. Esta constante afecta sólo a la versión del formato de datos de nuevabasededatos y no
afecta a la versión de ninguno de los objetos definidos por Microsoft Access, como formularios e informes.
Constante Descripción
dbVersion10 Crea una base de datos que utiliza el motor de base de datos Microsoft Jet versión 1.0
durante la compactación.
DbVersion11 Crea una base de datos que utiliza el motor de base de datos Microsoft Jet versión 1.1
durante la compactación.
DbVersion20 Crea una base de datos que utiliza el motor de base de datos Microsoft Jet versión 2.0
durante la compactación.
DbVersion30 Crea una base de datos que utiliza el motor de base de datos Microsoft Jet versión 3.0 (compatible con la
versión 3.5) durante la compactación.

Sólo puede especificar una constante de versión. Si omite una constante de versión, nuevabasededatos tendrá la misma
versión que antiguabasededatos. Sólo puede compactar nuevabasededatos a una versión igual o posterior a la de
antiguabasededatos.

Comentarios

Al cambiar datos de una base de datos, el archivo de base de datos puede fragmentarse y utilizar más espacio en disco
del necesario. Regularmente, puede usar el método CompactDatabase en la base de datos para desfragmentar el archivo
de base de datos. La base de datos compactada suele ser más pequeña y ejecutarse con más rapidez. También puede
cambiar la secuencia de ordenación, la codificación o la versión del formato de datos, mientras copia y compacta la base
de datos.
Tiene que cerrar antiguabasededatos antes de compactarla. En un entorno multiusuario, los demás usuarios no pueden
tener abierta antiguabasededatos mientras usted la compacta. Si antiguabasededatos no está cerrada o no se encuentra
disponible para su uso exclusivo, se producirá un error.

Página 60 de 159
Curso Visual Basic 5.0

Puesto que CompactDatabase crea una copia de la base de datos, deberá disponer de espacio suficiente en disco para la
base de datos original y la duplicada. La operación de compactación fracasará si no hay suficiente espacio disponible en
disco. La base de datos duplicada nuevabasededatos no tiene por qué estar en el mismo disco que antiguabasededatos.
Después de compactar una base de datos, puede eliminar el archivo antiguabasededatos y cambiar el nombre del
archivo compactado nuevabasededatos por el nombre del archivo original.
El método CompactDatabase copia todos los datos y valores de permisos de seguridad de la base de datos especificada
en antiguabasededatos a la base de datos especificada en nuevabasededatos.
Si utiliza el método CompactDatabase para convertir una base de datos versión 1.x a una versión 2.5 o 3.x, solamente
las aplicaciones que utilizan las versiones de Microsoft Jet 2.5 o 3.x pueden abrir la base de datos convertida.
Precaución Debido a que el método CompactDatabase no convertirá objetos Microsoft Access, no es recomendable
utilizar CompactDatabase para convertir una base de datos que contenga dichos objetos. Para convertir una base de
datos que contenga objetos Microsoft Access, en el menú Herramientas, elija Utilidades de la base de datos y después
haga clic en Convertir base de datos.
Ejemplo de método CompactDatabase
Este ejemplo utiliza el método CompactDatabase compactar la base de Datos Clientes.mdb.
Sub CompactDatabaseX()
DBEngine.CompactDatabase "Clientes.mdb", “Compact.mdb"
End Sub

14.8- Delete (Objeto Recordset)


Aplicable a:
Objeto Recordset.

• Objetos Recordset: elimina el registro activo de un objeto Recordset de tipo Dynaset o Table. Para espacios de
trabajo ODBCDirect, el tipo de controlador determina si los objetos Recordset se pueden actualizar y, por tanto,
admiten el método Delete.

Sintaxis
recordset.Delete

La sintaxis del método Delete utiliza los siguientes argumentos.


Argumentos Descripción
recordset Una variable de objeto que identifica un objeto Recordset de tipo Dynaset o Table abierto, que contiene
el registro que desea eliminar.

Comentarios
Puede utilizar el método Delete para eliminar un registro activo de un objeto Recordset.
Recordsets
Un objeto Recordset debe contener un registro activo antes de que utilice el método Delete; en caso contrario se
produce un error en tiempo de ejecución.
En objetos Recordset, Delete elimina el registro activo y lo hace inaccesible. Aunque no pueda modificarlo o utilizarlo,
el registro eliminado permanecerá activo. Sin embargo, una vez que se desplace a otro registro no podrá volver a
convertir en activo el registro eliminado. Las referencias subsiguientes a un registro eliminado en un Recordset no son
válidas y producen un error.
Si la tabla base es la tabla principal en una relación de eliminación de cascada, al eliminar el registro activo también se
eliminarán uno o más registros de una tabla externa.
Nota Para agregar, modificar o eliminar un registro, debe tener un índice único en el registro en el origen de datos de
base. Si no es así, se producirá un error "Permiso denegado" en la llamada al método AddNew, Delete o Edit en un
espacio de trabajo Microsoft Jet.

Página 61 de 159
Curso Visual Basic 5.0

Ejemplo de método Delete


Se necesitan borrar todos los registros de la tabla Agenda (dentro de la base de datos Clientes) cuyos códigos de Clientes
sean menores a 10.

Private Sub cmdAgregar_Click ()


Dim wsp as WorkSpace ‘Dimensiono las variables
Dim Base as Database
Dim Agenda as Recordset

Set wsp = DbEngine.Workspaces(0) ‘Seteo el espacio de trabajo


Set Base = wsp.OpenDatabase (“Clientes.mdb”) ‘Abro la base de Datos
Set Agenda = BasedeDatos.OpenRecordset(“SELECT * FROM Agenda WHERE Agenda.Codigo < 10”) ‘Abro el
Recordset

If Not Agenda.EOF ‘si encontré algún registro


Agenda.MoveFirst ‘me muevo al primer registro
Do While Not Agenda.EOF ‘mientras no sea fin de archivo
Agenda.Delete ‘elimino el registro
Agenda.MoveNext ‘me desplazo al siguiente registro
Loop
End If

Agenda.Close ‘Cierro el Recordset


Base.Close ‘Cierro la base de Datos
Wsp.Close ‘Cierro el espacio de trabajo

End Sub

14.9- Edit (Objeto Recordset)


Aplicable a :
Objeto Recordset.

Copia el registro activo de un objeto Recordset al búfer de copia para su posterior edición.

Sintaxis
recordset.Edit

El recordset representa el nombre de un objeto Recordset abierto y que se puede actualizar que contiene el registro que
desea modificar.

Comentarios
Una vez que utiliza el método Edit, los cambios realizados en los campos del registro activo son copiados al búfer de
copia. Después de realizar los cambios deseados en el registro, utilice el método Update para guardar los cambios.
El registro activo permanece activo después de utilizar el método Edit.
Precaución Si modifica un registro y a continuación pasa a otro registro sin utilizar antes Update, los cambios se
perderán sin previo aviso. Además, si cierra recordset o finaliza el procedimiento que declara el Recordset o el objeto
Database o Connection, el registro modificado se descarta sin previo aviso.

Página 62 de 159
Curso Visual Basic 5.0

La utilización de Edit produce un error bajo las siguientes condiciones:


• No hay ningún registro activo.
• El objeto Database o Recordset se abrió de sólo lectura.
• No hay campos que se pueden actualizar en el registro.
• El objeto Database o Recordset se abrió para uso en modo exclusivo por otro usuario (espacio de trabajo Microsoft
Jet).

Nota Para agregar, modificar o eliminar un registro, debe tener un índice único en el registro en el origen de datos de
base. Si no es así, se producirá un error "Permiso denegado" en la llamada al método AddNew, Delete o Edit en un
espacio de trabajo Microsoft Jet, o se producirá un error "Argumento no válido" el la llamada al método Update en un
espacio de trabajo ODBCDirect.

Ejemplo de método Edit


Se necesita asignar la zona 1 a todos los registros de la tabla Agenda (dentro de la base de datos Clientes) cuyos códigos de
Clientes sean menores a 20.

Private Sub cmdAgregar_Click ()


Dim wsp as WorkSpace ‘Dimensiono las variables
Dim Base as Database
Dim Agenda as Recordset

Set wsp = DbEngine.Workspaces(0) ‘Seteo el espacio de trabajo


Set Base = wsp.OpenDatabase (“Clientes.mdb”) ‘Abro la base de Datos
Set Agenda = BasedeDatos.OpenRecordset(“SELECT * FROM Agenda WHERE Agenda.Codigo < 20”) ‘Abro el
Recordset

If Not Agenda.EOF ‘si encontré algún registro


Agenda.MoveFirst ‘me muevo al primer registro
Do While Not Agenda.EOF ‘mientras no sea fin de archivo
Agenda.Edit ‘Edito el registro
Agenda!Zona = 1
Agenda.Update
Agenda.MoveNext ‘me desplazo al siguiente registro
Loop
End If
Agenda.Close ‘Cierro el Recordset
Base.Close ‘Cierro la base de Datos
Wsp.Close ‘Cierro el espacio de trabajo

End Sub

14.10- Hide
Aplicable a:
Objeto Form.

Oculta un objeto Form pero no lo descarga.

Sintaxis
objeto.Hide

Página 63 de 159
Curso Visual Basic 5.0

El marcador de posición objeto representa una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a. Si
se omite objeto, se supone que objeto es el formulario que tenga el enfoque.

Comentarios
Cuando se oculta un formulario, se quita de la pantalla y su propiedad Visible queda establecida a False. Los controles
de un formulario oculto no son accesibles para el usuario, pero están disponibles para la aplicación de Visual Basic en
ejecución y para otros procesos que se estén comunicando con la aplicación mediante DDE, así como para los eventos
del control Timer.
Cuando se oculta un formulario, el usuario no puede interactuar con la aplicación hasta que el código del procedimiento
de evento que ha provocado la ocultación del formulario haya terminado de ejecutarse.
Si el formulario no está cargado cuando se llama al método Hide, el método Hide carga el formulario pero no lo
presenta.

Ejemplo del método Hide

Este ejemplo utiliza el método Hide para ocultar un formulario. Para probar este ejemplo, pegue el código en la sección
Declaraciones de un formulario, y después presione F5 y haga clic en el formulario.
Private Sub Form_Click ()
Dim Msg ' Declara variable.
Hide ' Oculta el formulario.
Msg = "Haga clic en Aceptar para que vuelva a aparecer el formulario."
MsgBox Msg ' Muestra el mensaje.
Show ' Muestra de nuevo el formulario.
End Sub

14.11-MoveFirst - MoveLast - MoveNext – MovePrevious (Objeto Recordset)

Aplicable a:
Objeto Recordset.

Mueven al registro primero, último, siguiente o anterior de un objeto Recordset y lo convierten en el registro activo.

Sintaxis
recordset.{MoveFirst | MoveLast [dbRunAsync] | MoveNext | MovePrevious}

El marcador de posición recordset es una variable de objeto que representa un objeto Recordset abierto.

Comentarios
Precaución Si modifica el registro activo, utilice el método Update para guardar los cambios antes de ir a otro registro.
Si va a otro registro sin actualizar, los cambios se perderán sin previo aviso.
Al abrir un Recordset, el primer registro está activo y la propiedad BOF es False. Si el Recordset no contiene registros
la propiedad BOF es True y no habrá ningún registro activo.
Si el primer o el último registro está activo cuando utiliza MoveFirst o MoveLast, el registro activo no cambia.
Si utiliza MovePrevious cuando el primer registro está activo, la propiedad BOF es True y no habrá ningún registro
activo. Si vuelve a utilizar MovePrevious se producirá un error y BOF será True.
Si utiliza MoveNext cuando el último registro está activo, la propiedad EOF es True y no habrá ningún registro activo.
Si vuelve a utilizar MoveNext se producirá un error y EOF será True.
Si recordset hace referencia a un objeto Recordset de tipo Table (sólo espacios de trabajo Microsoft Jet), el
movimiento seguirá el índice activo. Puede establecer el índice activo utilizando la propiedad Index. Si no establece el
índice activo, el orden de los registros devueltos no estará definido.

Página 64 de 159
Curso Visual Basic 5.0

Importante Puede utilizar el método MoveLast para llenar completamente un objeto Recordset de tipo Dynaset o
Snapshot para obtener el número de registros activos en el Recordset. Sin embargo, si utiliza MoveLast puede hacer
más lentas sus aplicaciones. Sólo debe utilizar MoveLast para obtener un total de registros si es absolutamente
necesario obtener un total exacto en un Recordset abierto recientemente.

No puede utilizar los métodos MoveFirst, MoveLast y MovePrevious en un Recordset de tipo Forward-only.
Para mover la posición del registro activo en un objeto Recordset un número específico de registros hacia adelante o
hacia atrás, utilice el método Move.

Ejemplo de métodos MoveFirst, MoveLast, MoveNext, MovePrevious

Para un ejemplo de uso de los métodos MoveFirst y MoveNext, mire el ejemplo del método Edit.
Se necesita asignar la zona 1 a todos los registros de la tabla Agenda (dentro de la base de datos Clientes) cuyos códigos de
Clientes sean menores a 20. Es necesario recorrer la tabla de atrás hacia adelante.

Private Sub cmdAgregar_Click ()


Dim wsp as WorkSpace ‘Dimensiono las variables
Dim Base as Database
Dim Agenda as Recordset

Set wsp = DbEngine.Workspaces(0) ‘Seteo el espacio de trabajo


Set Base = wsp.OpenDatabase (“Clientes.mdb”) ‘Abro la base de Datos
Set Agenda = BasedeDatos.OpenRecordset(“SELECT * FROM Agenda WHERE Agenda.Codigo < 20”) ‘Abro el
Recordset

If Not Agenda.EOF ‘si encontré algún registro


Agenda.MoveLast ‘me muevo al último registro
Do While Not Agenda.BOF ‘mientras no sea principio de archivo
Agenda.Edit ‘Edito el registro
Agenda!Zona = 1
Agenda.Update
Agenda.MovePrevious ‘me desplazo al registro anterior
Loop
End If
Agenda.Close ‘Cierro el Recordset
Base.Close ‘Cierro la base de Datos
Wsp.Close ‘Cierro el espacio de trabajo

End Sub

14.12- OpenDatabase (Objeto Workspace)


Aplicable a:
Objeto DBEngine, Objeto Workspace.

Abre una base de datos especificada en un objeto Workspace y devuelve una referencia al objeto Database que la
representa.

Sintaxis
Set basededatos = espaciodetrabajo.OpenDatabase (nombrebasededatos, opciones, sólolectura, conexión)

La sintaxis del método OpenDatabase consta de las siguientes partes.


Argumento Descripción
basededatos Una variable de objeto que representa el objeto Database que va a abrir.

Página 65 de 159
Curso Visual Basic 5.0

espaciodetrabajo Opcional. Una variable de objeto que representa el objeto Workspace existente que
contendrá la base de datos. Si no incluye un valor para espaciodetrabajo,
OpenDatabase utiliza el espacio de trabajo predeterminado.
Nombrebasededatos Un tipo de datos String que es el nombre de un archivo de base de datos Microsoft Jet
existente o el nombre del origen de datos (DSN) de un origen de datos ODBC
existente.
opciones Opcional. Un tipo de datos Variant que establece varias opciones para la base de
datos, como se especifica en Valores.
sólolectura Opcional. Un valor de tipo de datos Variant (subtipo Boolean) que es True si desea
abrir la base de datos con acceso de sólo lectura o False (predeterminado) si desea
abrir la base de datos con acceso de lectura/escritura.
conexión Opcional. Un tipo de datos Variant (subtipo String) que especifica información
variada sobre la conexión, incluyendo las contraseñas.

Valores
Para los espacios de trabajo Microsoft Jet, puede utilizar los siguientes valores para el argumento opciones:
Valor Descripción
True Abre la base de datos en modo exclusivo.
False (Predeterminado) Abre la base de datos en modo compartido.

Comentarios

Cuando abre una base de datos, automáticamente se agrega a la colección Databases.


Estas son algunas consideraciones que debe aplicar cuando utilice nombrebasededatos:
• Si hace referencia a una base de datos que ya está abierta para acceso en modo exclusivo por otro usuario, se
produce un error.
• Si no hace referencia a una base de datos existente, se produce un error.

El argumento conexión se expresa en dos partes: el tipo de base de datos, seguido por punto y coma (;) y los argumentos
opcionales. Primero debe proporcionar el tipo de base de datos, como "ODBC;" o "FoxPro 2.5;". A continuación, os
argumentos opcionales sin un orden concreto, separados por punto y coma. Uno de los parámetros puede ser la
contraseña (si hay alguna asignada). Por ejemplo:
"FoxPro 2.5; pwd=micontraseña"

Para cerrar una base de datos y, de este modo, quitar el objeto Database de la colección Databases, utilice el método
Close en el objeto .

Ejemplo método OpenDatabase

Es válido el mismo ejemplo utilizado para los métodos MoveFirst, MoveLast, MoveNext, MovePrevious.

14.13- OpenRecordset (Objeto Database)

Aplicable a:
Objeto Database.

Crea un nuevo objeto Recordset y lo añade a la colección Recordsets.

Sintaxis
Set variable = objeto.OpenRecordset (origen, tipo, opciones, bloquearmodificaciones)

La sintaxis del método OpenRecordset consta de las siguientes partes.


Argumento Descripción

Página 66 de 159
Curso Visual Basic 5.0

variable Una variable de objeto que representa el objeto Recordset que desea abrir.
Objeto Una variable de objeto que representa un objeto existente desde el que desea crear
el objeto Recordset nuevo.
Origen Un tipo de datos String que especifica el origen de los registros para el nuevo
Recordset. El origen puede ser un nombre de tabla, un nombre de consulta o una
instrucción SQL que devuelve registros.
Tipo Opcional. Una constante que indica el tipo de objeto Recordset a abrir, como se
especifica en Valores.
Opciones Opcional. Una combinación de constantes que especifican las características del
objeto Recordset nuevo, como se especifica en Valores.
Bloquearmodificaciones Opcional. Una constante que determina el bloqueo para el objeto Recordset,
como se especifica en Valores.

Valores
Puede utilizar una de las siguientes constantes para el argumento tipo.
Constante Descripción
dbOpenTable Abre un objeto Recordset de tipo Table (sólo espacios de trabajo Microsoft Jet).
dbOpenDynaset Abre un objeto Recordset de tipo Dynaset (actualizable).
DbOpenSnapshot Abre un objeto Recordset de tipo Snapshot (sólo lectura)
DbOpenForwardOnly Abre un objeto Recordset de tipo Forward-only.

Nota Si abre un objeto Recordset en un espacio de trabajo Microsoft Jet y no especifica un tipo, el método
OpenRecordset crea una objeto Recordset de tipo Table, si es posible. Si especifica una tabla vinculada o una consulta,
el método OpenRecordset crea un objeto Recordset.de tipo Dynaset.

Puede utilizar una combinación de las siguientes constantes para el argumento opciones:

-DbAppendOnly: Permite al usuario anexar registros nuevos al objeto Recordset, pero impide la modificación o
eliminación de registros existentes (sólo objetos Recordset de tipo Dynaset de Microsoft Jet).
-DbSeeChanges: Genera un error en tiempo de ejecución si otro usuario está cambiando los datos que usted está
modificando.(Sólo en objetos Recordset de tipo Snapshot de Microsoft Jet). Esto es útil en aplicaciones donde varios
usuarios tiene acceso de lectura/escritura simultáneo a los mismos datos.
-DbDenyWrite: Previene que otros usuarios puedan modificar o agregar registros (sólo objetos Recordset de Microsoft
Jet).
-DbDenyRead: Previene que otros usuarios puedan leer datos de una tabla (sólo objetos Recordset de tipo Table de
Microsoft Jet).
-DbForwardOnly: Crea un objeto Recordset de tipo Forward-only (sólo objetos Recordset de tipo Snapshot de
Microsoft Jet). Se proporciona sólo para compatibilidad con versiones anteriores y debe utilizar la constante
dbOpenForwardOnly en el argumento tipo en vez de utilizar esta opción.
-DbReadOnly : Previene que otros usuarios puedan hacer cambios el objeto Recordset (sólo Microsoft Jet). La constante
dbReadOnly en el argumento bloquearmodificaciones reemplaza esta opción, la cual se proporciona para compatibilidad
con versiones anteriores.
-dbInconsistent : Permite actualizaciones inconsistentes (sólo objetos Recordset de tipo Dynaset de Microsoft Jet).
-DbConsistent : Permite sólo actualizaciones consistentes (sólo objetos Recordset de tipo Dynaset de Microsoft Jet).

Nota Las constantes dbConsistent y dbInconsistent se excluyen mutuamente y el uso de ambos produce un error.
Proporcionar un argumento bloquearmodificaciones cuando el argumento opciones utiliza la constante dbReadOnly
también produce un error.

Puede utilizar las siguientes constantes para el argumento bloquearmodificaciones:.


-dbReadOnly: Previene que los usuarios hagan cambios al Recordset. Puede utilizar dbReadOnly en el argumento
opciones o en el argumento bloquearmodificaciones, pero nunca en ambos. Si lo utiliza en ambos argumentos, se produce
un error en tiempo de ejecución.
-DbPessimistic: Utiliza el bloqueo pesimista para determinar cómo se pueden hacer cambios al objeto Recordset en un
entorno multiusuario. La página que contiene el registro que está modificando está bloqueada mientras utiliza el método
Edit (predeterminado en espacios de trabajo Microsoft Jet).

Página 67 de 159
Curso Visual Basic 5.0

-DbOptimistic: Utiliza el bloqueo optimista para determinar cómo se pueden hacer cambios al objeto Recordset en un
entorno multiusuario. La página que contiene el registro que está modificando está bloqueada mientras se ejecuta el método
Update.

Comentarios

En un espacio de trabajo Microsoft Jet, si objeto hace referencia a un objeto QueryDef o Recordset de tipo Dynaset o
Snapshot o si origen hace referencia a una instrucción SQL o un TableDef que representa una tabla adjunta, no podrá
utilizar dbOpenTable para el argumento tipo y si lo hace, se producirá un error interceptable.
Si objeto hace referencia a un Recordset de tipo Dynaset o Snapshot, el Recordset nuevo es del mismo tipo objeto. Si
objeto hace referencia a un objeto Recordset de tipo Table, el tipo del objeto nuevo es un objeto Recordset de tipo
Dynaset. No puede abrir objetos Recordset nuevos desde objetos Recordset de tipo Forward-only.

Utilice la constante dbSeeChanges en espacio de trabajo Microsoft Jet si desea captar los cambios realizados mientras
dos o más usuarios están modificando o eliminando el mismo registro. Por ejemplo, si dos usuarios empiezan a
modificar el mismo registro, el primer usuario que ejecute el método Update consigue realizar la operación. Cuando el
segundo usuario ejecute el método Update ocurre un error de tiempo de ejecución. Del mismo modo, si el segundo
usuario intenta utilizar el método Delete para eliminar un registro y el primer usuario ha cambiado ya el mismo, se
produce un error de tiempo de ejecución.
En general, si al usuario se le presenta este error mientras está actualizando, su código debe actualizar el contenido de
los campos y leer los valores recientemente modificados. Si se produce el error durante el proceso de eliminación, el
código puede mostrar al usuario los nuevos datos del registro junto con un mensaje que indica que se han modificado
recientemente los datos. En este momento, el código puede solicitar una confirmación de que el usuario desea aún
eliminar el registro.
Al cerrar un Recordset utilizando el método Close, se eliminará automáticamente de la colección Recordsets.

Ejemplo del método OpenRecordset


Es válido el mismo ejemplo utilizado para los métodos MoveFirst, MoveLast, MoveNext, MovePrevious.

14.14- RemoveItem
Aplicable a:
Control ComboBox, Control ListBox.

Quita un elemento de un control ListBox o ComboBox. No acepta argumentos con nombre.

Sintaxis
objeto.RemoveItem índice

La sintaxis del método RemoveItem consta de las siguientes partes:


Parte Descripción
objeto Requerido. Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.
índice Requerido. Un entero que especifica la posición dentro del objeto del elemento o la fila que se va a
quitar. Para los primeros elementos de los controles ListBox o ComboBox, índice es 0.

Comentarios

Los controles ListBox o ComboBox que están enlazados a un control Data no aceptan el método RemoveItem.

Ejemplo del método RemoveItem

Página 68 de 159
Curso Visual Basic 5.0

Este ejemplo utiliza el método RemoveItem para quitar entradas de un cuadro de lista. Para probar este ejemplo, pegue
el código en la sección Declaraciones de un formulario que contenga un control ListBox llamado List1, y después
presione F5 y haga clic en el formulario.

Private Sub Form_Click ()


Dim Entry, I, Msg ' Declara variables.
Msg = "Haga clic en Aceptar para agregar 100 elementos al cuadro de lista."
MsgBox Msg ' Muestra el mensaje.
For I = 1 To 100 ' Cuenta de 1 a 100.
Entry = "Entrada " & I ' Crea la entrada.
List1.AddItem Entry ' Agrega la entrada.
Next I
Msg = "Haga clic en Aceptar para quitar una de cada dos entradas."
MsgBox Msg ' Muestra el mensaje.
For I = 1 To 50 ' Determina cómo quitar
List1.RemoveItem I ' uno de cada dos
Next I ' elementos.
Msg = "Haga clic en Aceptar para quitar todos los elementos del cuadro de lista."
MsgBox Msg ' Muestra el mensaje.
List1.Clear ' Borra el cuadro de lista.
End Sub

14.15- RepairDatabase (Objeto DBEngine)


Aplicable a:
Objeto DBEngine.

Intenta reparar una base de datos dañada que accede a base de datos Microsoft Jet.

Sintaxis

DBEngine.RepairDatabase nombrebasededatos

El argumento nombrebasededatos representa un tipo de datos String que es la ruta de acceso y el nombre de un archivo
de base de datos del motor Microsoft Jet existente. Si se omite la ruta, sólo se buscará en el directorio activo.

Comentarios

Debe cerrar la base de datos especificada por nombrebasededatos antes de repararla. En un entorno multiusuario, los
demás usuarios no podrán tener abierto nombrebasededatos mientras usted la repara. Si no está cerrado
nombrebasededatos o no está disponible para uso exclusivo, se producirá un error.
Este método intenta reparar una base de datos marcada como posiblemente dañada por una operación de escritura
incompleta. Esto puede ocurrir si una aplicación que utiliza el motor de base de datos Microsoft Jet termina
inesperadamente debido a un corte en el suministro eléctrico o un problema de hardware. La base de datos no se marcará
como posiblemente dañada si utiliza el método Close o si sale de la aplicación de una manera normal.
El método RepairDatabase también intenta validar todas las tablas del sistema y todos los índices. Se descartan los
datos que no se puedan reparar. Si no se puede reparar la base de datos, se produce un error interceptable.
Cuando intente abrir o compactar una base de datos dañada, normalmente se producirá un error interceptable. En
algunas situaciones, sin embargo, puede que no se detecte una base de datos dañada y no se produzca ningún error. Es
conveniente ofrecer a los usuarios un método de ejecutar el método RepairDatabase en su aplicación, si la base de
datos se comporta de manera impredecible.
Algunos tipos de bases de datos se pueden dañar si un usuario termina una aplicación sin cerrar los objetos Database o
Recordset y el motor de base de datos Microsoft Jet, Microsoft Windows no tienen la oportunidad de vaciar las

Página 69 de 159
Curso Visual Basic 5.0

memorias de caché de datos. Para evitar que se dañen las bases de datos, establezca procedimientos para cerrar las
aplicaciones y apagar los sistemas que aseguren que todas las páginas de la memoria caché están guardadas en la base de
datos. En algunos casos, puede que sean necesarias fuentes de alimentación ininterrumpida para evitar pérdidas de datos
por las fluctuaciones del suministro eléctrico.
Nota Después de reparar una base de datos, también es conveniente compactar la misma utilizando el método
CompactDatabase para defragmentar el archivo y recuperar espacio en disco.

Ejemplo del método RepairDatabase


Este ejemplo intenta reparar la base de datos llamada Neptuno.mdb.
Sub RepairDatabaseX()

Dim errBucle As Error


If MsgBox("¿Desea reparar la base de datos Neptuno?", vbYesNo) = vbYes Then
DBEngine.RepairDatabase "Neptuno.mdb"
MsgBox "¡Fin del procedimiento reparar!"
End If

End Sub

14.16- SetFocus
Aplicable a
Control CheckBox, Control ComboBox, Control CommandButton, Objeto Form Controles HScrollBar y VScrollBar,
Control ListBoxControl OptionButton, Control PictureBox, Control TextBox.

Mueve el enfoque al control o formulario especificado.

Sintaxis
objeto.SetFocus

El marcador de posición objeto representa una expresión de objeto que da como resultado un objeto de la lista
Aplicable a.

Comentarios

El objeto debe ser un objeto Form o un control que pueda recibir el enfoque. Después de invocar el método SetFocus,
cualquier entrada del usuario se dirige al formulario o al control especificado.
El enfoque sólo se puede mover a un formulario o un control visible. Como un formulario y los controles de un
formulario no son visibles hasta que el evento Load del formulario ha terminado, no puede usar en su propio evento
Load el método SetFocus para mover el enfoque al formulario que se está cargando a menos que use primero el método
Show para mostrar el formulario antes de que el procedimiento de evento Form_Load haya terminado.
Tampoco puede mover el enfoque a un formulario o un control si su propiedad Enabled es False. Si la propiedad
Enabled se ha establecido a False en tiempo de diseño, primero debe establecerla a True antes de poder recibir el
enfoque mediante el método SetFocus.

Ejemplo del método SetFocus


Al hacer click en un botón de comando, setea el foco a la caja de texto txtCodigo

Private Sub cmd1_Click()

Página 70 de 159
Curso Visual Basic 5.0

TxtCodigo.Setfocus
End Sub

14.17- Show
Aplicable a:
Objeto Form.

Sintaxis
objeto.Show estilo, formulario_propietario

La sintaxis del método Show consta de las siguientes partes:


Parte Descripción
objeto Opcional. Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable
a. Si se omite objeto, se supone que objeto es el formulario asociado con el
módulo de formulario activo.
estilo Opcional. Un entero que determina si el formulario es modal o no modal. Si estilo
es 0, el formulario es no modal; si estilo es 1, el formulario es modal.
formulario_propietario Opcional. Una expresión de cadena que especifica el componente que "posee" el
formulario que se muestra. Para los formularios estándar de Visual Basic, utilice la
palabra clave Me.

Comentarios

Si el formulario especificado no está cargado cuando se invoca el método Show, Visual Basic lo carga automáticamente.
Cuando Show presenta un formulario no modal, continúa con la ejecución del código que haya a continuación. Cuando
Show presenta un formulario modal, el código que hay a continuación no se ejecuta hasta que el formulario se oculta o
se descarga.
Cuando Show presenta un formulario modal, no hay entradas (de teclado o del mouse) excepto sobre los objetos del
formulario modal. El programa debe ocultar o descargar los formularios modales (normalmente como respuesta a alguna
acción del usuario) antes de que pueda producirse la entrada en otro formulario.
Aunque los demás formularios de la aplicación están deshabilitados cuando se presenta un formulario modal, los de las
demás aplicaciones no lo están.
El formulario inicial de una aplicación se muestra automáticamente después de invocar su evento Load.

Ejemplo del método Show

Este ejemplo utiliza el método Show para mostrar un formulario oculto. Para probar este ejemplo, pegue el código en la
sección Declaraciones de un formulario y después presione F5 y haga clic en el formulario.
Private Sub Form_Click ()
Dim Msg ' Declara variable.
Hide ' Oculta el formulario.
Msg = "Haga clic en Aceptar para que vuelva a aparecer el formulario."
MsgBox Msg ' Muestra el mensaje.
Show ' Muestra de nuevo el formulario.
End Sub

14.18- Update (Objeto recordset)


Aplicable a

Página 71 de 159
Curso Visual Basic 5.0

Objeto Recordset.

Guarda el contenido del búfer de copia en un objeto Recordset de tipo Dynaset o Table especificado.

Sintaxis
recordset.Update (tipo, obligar )

La sintaxis del método Update tiene las siguientes partes.


Parte Descripción
Recordset Una variable de objeto que representa un objeto Recordset abierto que se puede actualizar.
Tipo Opcional. Una constante que indica el tipo de actualización, como se especifica en Valores
(sólo espacios de trabajo ODBCDirect).
Obligar Opcional. Un valor de tipo Boolean que indica si se pueden o no obligar los cambios en la base
de datos, sin tener en cuenta si los datos base se han cambiado por otro usuario desde la
llamada al método AddNew, Delete o Edit. Si es True, los cambios se fuerzan y los cambios
hechos por otros usuarios se sobrescriben. Si es False (predeterminado), los cambios hechos
por otros usuarios mientras la actualización está pendiente provocarán que falle la
actualización para aquellos cambios conflictivos.

Comentarios
Utilice Update para guardar el registro activo y los cambios que haya efectuado en él.
Precaución Los cambios realizados en el registro activo se perderán si:
• Utiliza el método Edit o AddNew y a continuación, pasa a otro registro sin actualizarlo previamente mediante
Update.
• Utiliza Edit o AddNew y, a continuación, vuelve a usar Edit o AddNew sin utilizar previamente Update.
• Cierra el conjunto de registros a los que hace referencia recordset sin utilizar primero Update.
• Cancela la operación Edit utilizando el método CancelUpdate.

Para modificar un registro, utilice el método Edit para copiar el contenido del registro activo al búfer de copia. Si no
utiliza Edit en primer lugar, se producirá un error cuando utilice Update o intente cambiar el valor de un campo.
En un espacio de trabajo Microsoft Jet, cuando el objeto Recordset de la propiedad LockEdits establecida como True
(bloqueo pesimista) en un entorno multiusuario, el registro permanecerá bloqueado desde el momento en que se utiliza
Edit hasta que se ejecuta el método Update o se cancele la edición. Si la configuración de la propiedad LockEdits es
False (bloqueo optimista), el registro se bloquea y se compara con el registro previamente modificado justo antes de se
actualizado en la base de datos. Si ha cambiado el registro desde que utilizó el método Edit, la operación Update falla..
Para que la operación Update continúe con los cambios, utilice de nuevo el método Update. Para volver al registro, tal
como lo cambió el otro usuario, actualice el registro activo usando los métodos Move 0.
Nota Para agregar, modificar o eliminar un registro, debe haber un índice único en el registro del origen de datos base.
Se obtiene no lo hay, se producirá un error "Permiso denegado" en la llamada al método AddNew, Delete o Edit en un
espacio de trabajo Microsoft Jet, se producirá un error "Argumento no válido" en la llamada al método Update en un
espacio de trabajo ODBCDirect.

Ejemplo del método Update

Es válido el ejemplo del método AddNew.

15- Propiedades más importantes de los controles estándares.

Página 72 de 159
Curso Visual Basic 5.0

15.1- ActiveControl

Aplicable a:
Objeto Form.

Devuelve el control que tiene el enfoque. No está disponible en tiempo de diseño y es de sólo lectura en tiempo de
ejecución.

Sintaxis
objeto.ActiveControl

El marcador de posición objeto representa una expresión de objeto que da como resultado un objeto de la lista Aplicable
a.

Comentarios

Puede utilizar ActiveControl para tener acceso a las propiedades de un control o para invocar sus métodos. Por ejemplo,
Screen.ActiveControl.Tag = "0". Si todos los controles del formulario son invisibles o están desactivados, se producirá
un error en tiempo de ejecución.
Cada formulario puede tener un control activo (Form.ActiveControl), independientemente de que el formulario esté
activo o no. Puede escribir código que manipule el control activo de cada formulario de la aplicación, incluso cuando el
formulario no sea el activo.

Ejemplo de la propiedad ActiveControl

En este ejemplo se muestra el texto del control activo. Para probarlo, pegue el código en la sección Declaraciones de un
formulario que contenga controles TextBox, Label y CommandButton, y luego presione F5 y haga clic en el
formulario.
Private Sub Form_Click ()
If TypeOf Screen.ActiveControl Is TextBox Then
Label1.Caption = Screen.ActiveControl.Text
Else
Label1.Caption = "Botón: " + Screen.ActiveControl.Caption
End If
End Sub

15.2- BackColor, ForeColor


Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form, Control Frame,
Control Label, Control ListBox, Control OptionButton, Control PictureBox, Control Shape, Control TextBox.
• BackColor: devuelve o establece el color de fondo de un objeto.
• ForeColor: devuelve o establece el color de primer plano utilizado para mostrar texto y gráficos en un objeto.

Sintaxis
objeto.BackColor [= color]
objeto.ForeColor [= color]

La sintaxis de las propiedades BackColor y ForeColor consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
color Un valor o una constante que determina el color de fondo o de primer plano del objeto, según se indica en Valores.

Página 73 de 159
Curso Visual Basic 5.0

Valores
Visual Basic utiliza el esquema de colores rojo-verde-azul (RGB) del entorno operativo Microsoft Windows. Los
valores admitidos para color son:

Para todos los formularios y controles, los valores predeterminados en tiempo de diseño son:
• BackColor: el color predeterminado del sistema especificado por la constante vbWindowBackground.
• ForeColor: el color predeterminado del sistema especificado por la constante vbWindowText.

Comentarios

En los controles Label y Shape, la propiedad BackColor se pasa por alto cuando el valor de la propiedad BackStyle es
0 (transparente).
Si establece la propiedad BackColor de un objeto Form o de un control PictureBox, se borra todo el texto y todos los
gráficos, incluidos los gráficos persistentes. Al establecer la propiedad ForeColor, los gráficos o el resultado impreso no
se ven afectados. En el resto de los controles, el color de la pantalla cambia inmediatamente.
El intervalo válido para un color RGB normal va de 0 a 16.777.215 (&HFFFFFF). El byte más alto de los números de
este intervalo es 0, y los 3 más bajos, del menos significativo al más significativo, determinan la intensidad de rojo,
verde y azul, respectivamente. Cada uno de los componentes rojo, verde y azul se representa con un número entre 0 y
255 (&HFF). Si el byte más alto no es 0, Visual Basic utiliza los colores del sistema, definidos por el usuario en el Panel
de control o por las constantes que se encuentran en la biblioteca de objetos de Visual Basic (VB) en el Examinador de
objetos.
Para mostrar texto en el entorno operativo Windows, tanto el color del texto como el de fondo deben ser sólidos. Si no
aparece el color que ha seleccionado para el texto o para el fondo, puede que uno de ellos sea de medios tonos; es decir,
puede que esté formado por píxeles de hasta tres colores distintos. Si elige un color de medios tonos para el texto o el
fondo, se utilizará el color sólido más próximo.

Ejemplo de las propiedades BackColor y ForeColor

En este ejemplo se restablecen aleatoriamente los colores de primer plano y de fondo dos veces por segundo en un
formulario y en un control PictureBox. Para probar este ejemplo, pegue el código en la sección Declaraciones de un
formulario que contenga un control PictureBox y un control Timer control, y luego presione F5.

Private Sub Form_Load ()


Timer1.Interval = 500
End Sub

Private Sub Timer1_Timer ()


BackColor = QBColor(Rnd * 15)
ForeColor = QBColor(Rnd * 10)
Picture1.BackColor = QBColor(Rnd * 15)
Picture1.ForeColor = QBColor(Rnd * 10)
End Sub

15.3- BackStyle
Aplicable a
Control Label, Control Shape.

Devuelve o establece un valor que indica si un control Label o el fondo de un color Shape es transparente u opaco.

Sintaxis
objeto.BackStyle [= número]

La sintaxis de la propiedad BackStyle consta de las siguientes partes:

Página 74 de 159
Curso Visual Basic 5.0

Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
número Una expresión numérica que especifica la transparencia, según se indica en Valores.

Valores
Los valores admitidos para número son:
Valor Descripción
0 Transparente: el color de fondo y los gráficos son visibles a través del control.
1 (Predeterminado) Opaco: el control se llena con el valor de su propiedad BackColor, ocultando los colores o
gráficos que haya tras él.

Comentarios

Puede utilizar la propiedad BackStyle para crear controles transparentes cuando use un color de fondo en un objeto
Form o en un control PictureBox, o cuando desee colocar un control sobre un gráfico. Utilice un control opaco cuando
quiera que destaque.
La propiedad BackColor de un control se pasa por alto cuando BackStyle = 0.

15.4-BOF. EOF (Objeto Recordset)


Aplicable a
Objeto Recordset.

• BOF: indica si la posición del registro activo es anterior al primer registro de un objeto Recordset.
• EOF: indica si la posición del registro activo es posterior al último registro de un objeto Recordset.

Valores devueltos

Los valores que se obtienen para las propiedades BOF y EOF son un tipo de datos Boolean.
La propiedad BOF devuelve el valor True, si la posición del registro activo es anterior al primer registro y False si el
registro activo está en el registro activo o en el posterior.
La propiedad EOF devuelve el valor True, si la posición del registro activo es posterior al último registro y False si el
registro activo está en el último registro o antes de éste.

Comentarios

Puede utilizar las propiedades BOF y EOF para determinar si un objeto Recordset contiene registros o si se han
sobrepasado los límites de un objeto Recordset al ir pasando de un registro a otro.
La ubicación del puntero de l registro activo determina los valores devueltos de BOF y EOF.
Si BOF o EOF tienen el valor True, no existe registro activo.
Si abre un objeto Recordset que no contiene ningún registro, tanto BOF como EOF tendrán el valor True y el valor de
la propiedad RecordCount será 0. Cuando se abre un objeto Recordset que contiene al menos un registro, el primer
registro pasa a ser el registro activo y tanto BOF como EOF tendrán el valor False; que conservará hasta que se
sobrepase el principio o el final del objeto Recordset, mediante los métodos MovePrevious o MoveNext
respectivamente. Cuando se sobrepasan el principio o el final del conjunto de registros, no hay registro activo o no existe
ningún registro.
Si elimina el último registro que queda en el objeto Recordset, tanto BOF como EOF podrán seguir teniendo el valor
False hasta que intente volver a situar el registro activo.
Si utiliza el método MoveLast en un objeto Recordset que contiene registros, el último registro pasará a ser el registro
activo. Si a continuación utiliza el método MoveNext, el registro activo dejará de ser válido y EOF pasará a tener el
valor True. Por el contrario, si utiliza el método MoveFirst en un objeto Recordset que contiene registros, el primer
registro pasa a ser el registro activo. Si a continuación utiliza el método MovePrevious, el registro activo dejará de ser
válido y BOF asumirá el valor True.

Página 75 de 159
Curso Visual Basic 5.0

Normalmente, al trabajar con todos los registros de un objeto Recordset, el código irá pasando de un registro a otro
mediante MoveNext, hasta que la propiedad EOF presente el valor True.
Si utiliza MoveNext cuando EOF tiene el valor True o MovePrevious cuando BOF tiene el valor True, se producirá
un error.
Si se permite usar un método Move, ello no implica necesariamente que el método vaya a situar de forma correcta un
registro. Simplemente indica que se permite intentar utilizar el método de movimiento en cuestión, sin que se produzca
ningún error. El estado de los indicadores de BOF y EOF puede cambiar como resultado de intentar la operación Move.
El método OpenRecordset invoca internamente MoveFirst. Por tanto, un OpenRecordset en un conjunto de registros
vacío provoca que tanto BOF como EOF tengan el valor True. (Consulte la tabla que sigue para comprobar el
comportamiento de un método MoveFirst que ha fallado).
Todos los métodos Move que sitúan sin problemas un registro borran (con valor False) tanto BOF como EOF.
En un espacio de trabajo Microsoft Jet, si agrega un registro a un objeto Recordset vacío, BOF pasará a False, pero
EOF permanecerá en True, que indica que la posición actual es al final del objeto Recordset.
Ningún método Delete, incluso si se elimina el único registro que quede en un conjunto de registros, modificará el valor
de BOF ni el de EOF.

Ejemplo de las propiedades BOF y EOF

Como ejemplo de la propiedad EOF sirve el ejemplo de métodos MoveFirst, MoveLast, MoveNext, MovePrevious.
Como ejemplo de la propiedad BOF sirve el ejemplo del método Edit.

15.5-BOFAction, EOFAction
Aplicable a:
Control Data.

Devuelve o establece un valor que indica qué acción lleva a cabo el control Data cuando las propiedades BOF o EOF
son True.

Sintaxis
objeto.BOFAction [= entero]
objeto.EOFAction [= entero]

La sintaxis de las propiedades BOFAction y EOFAction consta de estas partes:


Parte Descripción
objeto Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a
entero Un valor de tipo Integer que especifica una acción, como se describe en Valores

Valores
Para la propiedad BOFAction, los valores de entero son los siguientes:
Configuración Valor Descripción
VbBOFActionMoveFirst 0 MoveFirst (Predeterminado): mantiene el primer registro como
registro actual.
vbBOFActionBOF 1 BOF: al desplazarse más allá del comienzo de un Recordset se
desencadena el evento Validate del control Data del primer
registro. En este punto se desactiva el botón Mover anterior del
control Data.

Para la propiedad EOFAction, los valores de entero son los siguientes:


Configuración Valor Descripción
vbEOFActionMoveLast 0 MoveLast (Predeterminado): mantiene el último registro como
registro actual.
vbEOFActionEOF 1 EOF: al desplazarse más allá del final de un Recordset se
desencadena el evento Validation del control Data del último

Página 76 de 159
Curso Visual Basic 5.0

registro. En este momento se desactiva el botón Mover siguiente


del control Data.
vbEOFActionAddNew 2 AddNew: al desplazarse más allá del último registro se
desencadena el evento Validation del control Data en el registro
actual, seguido de un AddNew automático.

Comentarios

Estas constantes se enumeran en la biblioteca de objetos de Visual Basic (VB) en el Examinador de objetos.
Si establece la propiedad EOFAction a vbEOFActionAddNew, cuando el usuario mueva el puntero del registro actual
a EOF usando el control Data, el registro actual se situará en un nuevo registro del búfer de copia. En este punto podrá
modificar el registro recién agregado. Si realiza cambios en el nuevo registro y el usuario mueve posteriormente el
puntero del registro actual usando el control Data, el registro se añadirá automáticamente al Recordset. Si no realiza
cambios en este nuevo registro y cambia de posición el registro actual a otro registro, el nuevo registro se descartará. Si
utiliza el control Data para situar otro registro mientras se encuentra sobre este nuevo registro, se creará otro registro
nuevo.
Cuando utiliza código para manipular objetos Recordset creados con el control Data, la propiedad EOFAction no surte
ningún efecto; sólo es efectiva cuando se manipula el control Data con el mouse.

Tipo de datos
Integer

15.6-BorderStyle
Aplicable a:
Objeto Form, Control Frame, Control Image, Control Label, Control Line, Control PictureBox, Control Shape, Control
TextBox.

Devuelve o establece un valor que indica cuál es el estilo de los bordes del control. La propiedad BorderStyle es de
lectura y escritura durante el diseño del control y de sólo lectura en tiempo de ejecución.

Sintaxis
objeto.BorderStyle [= enum]

La sintaxis de la propiedad BorderStyle consta de las partes siguientes:


Elemento Descripción
objeto Expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.
enum Valor enumerado que determina el estilo de los bordes del control, como se describe en Valores.

Valores
Los valores de enum son:
Valor Descripción
0-None Sin bordes. Éste es el valor predeterminado.
1-Fixed Single Se dibuja una única línea alrededor del control.

15.7-Caption
Aplicable a:
Control CheckBox, Control CommandButton, Control Data, Objeto Form, Control Frame, Control Label, Control Menu,
Control OptionButton.

Página 77 de 159
Curso Visual Basic 5.0

• Formulario: determina el texto que se muestra en la barra de título del objeto Form. Cuando el formulario está
minimizado, este texto se muestra debajo del icono del formulario.
• Control: determina el texto que se muestra en un control o junto a éste.
• Objeto MenuLine: determina el texto que se muestra para un control Menu o un objeto de la colección
MenuItems.

Sintaxis
objeto.Caption [= cadena]

La sintaxis de la propiedad Caption consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a. Si se omite objeto,
se supondrá que el formulario asociado al módulo de formulario activo es objeto.
cadena Una expresión de cadena que da como resultado el texto que se muestra como título.

Comentarios

Cuando crea un nuevo objeto, su título predeterminado es el valor predeterminado de la propiedad Name. Este título
predeterminado incluye el nombre de objeto y un entero, como Comando1 o Formulario1. Para obtener una etiqueta más
descriptiva, establezca la propiedad Caption.
Puede utilizar la propiedad Caption para asignar una tecla de acceso a un control. En el título, incluya un signo &
inmediatamente delante del carácter que desea designar como tecla de acceso. El carácter estará subrayado. Presione la
tecla ALT y el carácter subrayado para mover el enfoque a ese control. Si desea incluir un signo & en un título sin crear
una tecla de acceso, incluya dos signos (&&). En el título sólo aparecerá un símbolo y no habrá caracteres subrayados.
Para un control Label, el tamaño del título es ilimitado. Para los formularios y todos los demás controles que tienen
títulos, el límite es de 255 caracteres.
Para mostrar el título de un formulario, establezca la propiedad BorderStyle a Fixed Single (1 o vbFixedSingle),
Sizable (2 o vbSizable) o Fixed Dialog (3 o vbFixedDialog). Si el título es demasiado largo para la barra de título, se
recortará.
Sugerencia Para una etiqueta, establezca la propiedad AutoSize a True con el fin de ajustar automáticamente el
tamaño del control de modo que quepa el título.

Ejemplo de la propiedad Caption


Este ejemplo cambia la propiedad Caption de un control CommandButton cada vez que el usuario hace clic en el
botón. Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario que contenga un
CommandButton llamado Command1, y después presione F5 y haga clic en el botón.

Private Sub Command1_Click ()


' Comprueba el título y lo cambia.
If Command1.Caption = "Ha hecho clic" Then
Command1.Caption = "Aceptar"
Else
Command1.Caption = "Ha hecho clic"
End If
End Sub

15.8-DatabaseName
Aplicable a
Control Data.

Devuelve o establece el nombre y la ubicación del origen de datos de un control Data.

Página 78 de 159
Curso Visual Basic 5.0

Sintaxis
objeto.DatabaseName [ = nombre_ruta ]

La sintaxis de la propiedad DatabaseName consta de estas partes:


Parte Descripción
objeto Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.
nombre_ruta Una expresión de cadena que indica la ubicación de los archivos de base de datos.

Comentarios

Si el sistema de red lo admite, el argumento nombre_ruta puede ser un nombre completo de ruta de acceso de red como
\\Miserv\Micomp\Basedato.mdb.
El tipo de base de datos está indicado por el archivo o el directorio al que señala nombre_ruta, de la siguiente manera:

nombre_ruta Señala a... Tipo de base de datos


Archivo .mdb Base de datos de Microsoft Access
Directorio con archivos .dbf Base de datos de dBASE
Directorio con archivos .xls Base de datos de Microsoft Excel
Directorio con archivos .dbf Base de datos de FoxPro
Directorio con archivos .wk1, .wk3, .wk4 o .wks Base de datos de Lotus
Directorio con archivos .pdx Base de datos de Paradox

Si cambia la propiedad DatabaseName después de abrir el objeto Database del control, deberá utilizar el método
Refresh para abrir la nueva base de datos.
Nota Para obtener un mejor rendimiento al tener acceso a bases de datos externas, se recomienda adjuntar tablas de
bases de datos externas a una base de datos del motor Microsoft Jet (.mdb) y utilizar el nombre de esta base de datos en
la propiedad DatabaseName.

Tipo de datos

String
Ejemplo de la propiedad DatabaseName

Este ejemplo examina la propiedad Database de un control Data e imprime el nombre de cada Table en la ventana
Depuración.

Sub PrintTableNames ()
Dim Td As TableDef
' Define el archivo de la base de datos.
Data1.DatabaseName = "BIBLIO.MDB"
Data1.Refresh ' Abre la base de datos.
' Lee e imprime el nombre de cada tabla de la base de datos.
For Each Td in Data1.Database.TableDefs
Debug.Print Td.Name
Next
End Sub

15.9-DataChanged
Aplicable a:

Página 79 de 159
Curso Visual Basic 5.0

Control CheckBox, Control ComboBox, Control Image, Control Label, Control ListBox, Control PictureBox, Control
TextBox.

Devuelve o establece un valor que indica que algún proceso distinto de la recuperación de datos del registro actual ha
cambiado los datos del control enlazado. No está disponible en tiempo de diseño.

Sintaxis
objeto.DataChanged [= valor]

La sintaxis de la propiedad DataChanged consta de estas partes:


Parte Descripción
objeto Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.
valor Una expresión booleana que indica si los datos han cambiado, como se describe en Valores.

Valores
Los valores admitidos para valor son los siguientes:
Valor Descripción
True Los datos que hay actualmente en el control no son iguales que los del registro actual.
False (Predeterminado) Los datos que hay actualmente en el control (si los hay) son iguales que los del registro actual.

Comentarios

Cuando un control Data se mueve de un registro a otro, pasa datos desde los campos del registro actual a controles
enlazados al campo específico o todo el registro. Cuando se muestran datos en los controles enlazados, la propiedad
DataChanged se establece a False. Si el usuario o alguna otra operación cambia el valor del control enlazado, la
propiedad DataChanged se establece a True. Si pasa a otro registro la propiedad DataChanged no se ve afectada.
Cuando el control Data comienza a pasar a otro registro, se produce el evento Validate. Si DataChanged es True para
algún control enlazado, el control Data invoca automáticamente los métodos Edit y Update para enviar los cambios a la
base de datos.
Si no desea guardar en la base de datos los cambios de un control enlazado, puede establecer la propiedad
DataChanged a False en el evento Validate.
Inspeccione el valor de la propiedad DataChanged en el código para el evento Change de un control con el fin de evitar
eventos en cascada. Esto se aplica a controles enlazados y no enlazados.

Tipo de datos
Integer (Boolean)

15.10-DataField
Aplicable a:
Control CheckBox, Control ComboBox, Control Image, Control Label, Control ListBox, Control PictureBox, Control
TextBox.

Devuelve o establece un valor que enlaza un control a un campo del registro actual.

Sintaxis
objeto.DataField [= valor]

La sintaxis de la propiedad DataField consta de estas partes:


Parte Descripción
objeto Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.

Página 80 de 159
Curso Visual Basic 5.0

valor Una expresión de cadena que se evalúa como el nombre de uno de los campos del objeto Recordset especificado
por las propiedades RecordSource y DatabaseName de un control Data.

Comentarios

Los controles enlazados proporcionan acceso a datos específicos de la base de datos. Los controles enlazados que
administran un único campo suelen mostrar el valor un campo específico del registro actual. La propiedad DataSource
de un control enlazado especifica un control Data válido y la propiedad DataField especifica un nombre de campo
válido en el objeto Recordset creado por el control Data. Juntas, estas propiedades especifican qué datos aparecen en el
control enlazado.
Cuando utiliza un objeto QueryDef o una instrucción SQL que devuelve los resultados de una expresión, el motor de
base de datos Microsoft Jet genera automáticamente el nombre de campo . Por ejemplo, cuando codifica una función
agregada de SQL o una expresión en su consulta SQL, a menos que asigne un alias a los campos agregados mediante
una cláusula AS, los nombres de campo se generarán automáticamente. El nombre del campo de expresión suele ser
Expr1 seguido de un número de tres dígitos que comienza por 000. La primera expresión devuelta tendría el nombre
Expr1000.
Se recomienda codificar las consultas SQL para asignar alias a columnas de expresión como se muestra a continuación:

Data1.RecordSource = "Select AVG(Sales) " _


& " AS AverageSales From SalesTable"
Text1.DataField = "AverageSales"
Data1.Refresh

Nota Compruebe que el valor de la propiedad DataField es válido para cada control enlazado. Si cambia el valor de la
propiedad RecordSource de un control Data y a continuación utiliza Refresh, el objeto Recordset identificará el nuevo
objeto. Esto puede invalidar los valores de DataField de controles enlazados y generar un error interceptable.

Tipo de datos
String

15.11-DataSource
Aplicable a:
Control CheckBox, Control ComboBox, Control Image, Control Label, Control ListBox, Control PictureBox.

Establece un valor que especifica el control Data a través del cual el control actual se enlaza a una base de datos. No
está disponible en tiempo de ejecución.

Comentarios
Para enlazar un control a un campo de una base de datos en tiempo de ejecución, debe especificar un control Data en la
propiedad DataSource en tiempo de diseño desde la ventana Propiedades.
Para completar la conexión con un campo del objeto Recordset administrado por el control Data, también deberá
proporcionar el nombre de un objeto Field en la propiedad DataField. A diferencia de la propiedad DataField, el valor
de la propiedad DataSource no está disponible en tiempo de ejecución.

Tipo de datos
String

15.12-Enabled

Página 81 de 159
Curso Visual Basic 5.0

Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form, Control Frame,
Controles HScrollBar y VScrollBar, Control Image, Control Label, Control ListBox, Control Menu, Control
OptionButton, Control PictureBox, Control TextBox, Control Timer.

Devuelve o establece un valor que determina si un formulario o un control puede responder a eventos generados por el
usuario.

Sintaxis
objeto.Enabled [= booleano]

La sintaxis de la propiedad Enabled consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a. Si se omite
objeto, se supondrá que el formulario asociado al módulo del formulario activo es objeto.
Booleano Una expresión de tipo Boolean que especifica si objeto puede responder a eventos generados por
el usuario.

Valores
Los valores admitidos para booleano son:
Valor Descripción
True (Predeterminado) Permite que objeto responda a eventos.
False Impide que objeto responda a eventos.

Comentarios

La propiedad Enabled permite activar o desactivar formularios y controles en tiempo de ejecución. Por ejemplo, puede
desactivar objetos que no se aplican al estado actual de la aplicación. También puede desactivar un control empleado
fundamentalmente con fines de presentación, como un cuadro de texto que proporciona información de sólo lectura.
Si desactiva un control Timer estableciendo Enabled a False cancelará la cuenta atrás establecida por la propiedad
Interval del control.

Ejemplo de la propiedad Enabled


Este ejemplo habilita un control CommandButton siempre que un control TextBox contenga texto. Para probar este
ejemplo, pegue el código en la sección Declaraciones de un formulario con controles CommandButton y TextBox, y
después presione F5 y escriba algo en el cuadro de texto.

Private Sub Form_Load ()


Text1.Text = "" ' Borra el cuadro de texto.
Command1.Caption = "Guardar" ' Coloca el título del botón.
End Sub

Private Sub Text1_Change ()


If Text1.Text = "" Then ' Mira si el cuadro de texto está vacío.
Command1.Enabled = False ' Deshabilita el botón.
Else
Command1.Enabled = True ' Habilita el botón.
End If
End Sub

15.13-FontBold, FontItalic, FontStrikethru, FontUnderline.

Página 82 de 159
Curso Visual Basic 5.0

Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form, Control Frame, Control
Label, Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Devuelve o establece los estilos de fuente en los siguientes formatos: Negrita, Cursiva, Tachado y Subrayado.

Sintaxis
objeto.FontBold [= booleano]
objeto.FontItalic [= booleano]
objeto.FontStrikethru [= booleano]
objeto.FontUnderline [=booleano]

La sintaxis de las propiedades FontBold, FontItalic, FontStrikethru y FontUnderline consta de las siguientes partes:
Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
Booleano Una expresión booleana que especifica el estilo de fuente, según se indica en Valores.

Valores
Los valores admitidos para booleano son:
Valor Descripción
True (Predeterminado para FontBold). Habilita el formato en el estilo correspondiente.
False (Predeterminado para FontItalic, FontStrikethru y FontUnderline) Deshabilita el formato en el estilo
correspondiente.

Comentarios
Utilice estas propiedades de fuente para dar formato al texto, ya sea en tiempo de diseño mediante la ventana
Propiedades o en tiempo de ejecución a través de código. En el caso de los controles PictureBox y los objetos Form y
Printer, establecer estas propiedades no afecta a los gráficos ni al texto ya dibujados en el control u objeto. Para todos
los demás controles, las modificaciones en la fuente se hacen efectivas en la pantalla inmediatamente.
Nota Las fuentes disponibles en Visual Basic varían dependiendo de la configuración del sistema y de los dispositivos
de presentación e impresión. En las propiedades relacionadas con las fuentes sólo pueden establecerse valores para los
que existan fuentes en el sistema.
En general, deberá modificar la propiedad FontName antes de establecer los atributos de tamaño y estilo con las
propiedades FontSize, FontBold, FontItalic, FontStrikethru y FontUnderline. Sin embargo, cuando especifique un
tamaño inferior a 8 puntos para una fuente TrueType, debe establecer el tamaño en puntos con la propiedad FontSize,
después especificar la propiedad FontName y después establecer de nuevo el tamaño con FontSize. El entorno
operativo Microsoft Windows utiliza una fuente distinta para las fuentes TrueType con un tamaño inferior a 8 puntos.
Ejemplo de las propiedades FontBold, FontItalic, FontStrikethru y FontUnderline
En este ejemplo se escribe texto en un formulario con una de entre dos combinaciones de estilos con cada clic del mouse
(ratón). Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario, presione F5 y haga clic
en el formulario.

Private Sub Form_Click ()


FontStrikethru = Not FontStrikethru ' Alternar el tachado.
FontItalic = Not FontItalic ' Alternar el estilo de la fuente.
Print "¡Ahora es el momento!" ' Imprimir texto.
End Sub

15.14-FontName
Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form, Control Frame, Control
Label, Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Página 83 de 159
Curso Visual Basic 5.0

Devuelve o establece la fuente utilizada para mostrar texto en un control o en una operación de dibujo o impresión en
tiempo de ejecución.

Sintaxis
objeto.FontName [= fuente]

La sintaxis de la propiedad FontName consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
fuente Una expresión de cadena que especifica el nombre de la fuente que se va a utilizar.

Comentarios

El valor predeterminado de esta propiedad lo determina el sistema. Las fuentes disponibles en Visual Basic varían
dependiendo de la configuración del sistema y de los dispositivos de presentación e impresión. En las propiedades
relacionadas con fuentes sólo pueden establecerse valores para los que exista una fuente.
En general, deberá modificar FontName antes de establecer los atributos de tamaño y estilo con las propiedades
FontSize, FontBold, FontItalic, FontStrikethru y FontUnderline.

Ejemplo de la propiedad FontName

En este ejemplo se escribe el nombre de cada fuente usando como fuente ella misma. Para probar este ejemplo, pegue el
código en la sección Declaraciones de un formulario. Presione F5 para ejecutar el programa y luego haga clic en el
formulario. Cada vez que haga clic en el formulario aparecerá el nombre de la fuente.
Private Sub Form_Click ()
Static I ' Declarar variables.
Dim OldFont
OldFont = FontName ' Conservar la fuente original.
FontName = Screen.Fonts(I) ' Cambiar a una nueva fuente.
Print Screen.Fonts(I) ' Imprimir el nombre de la fuente.
I = I + 1 ' Incrementar el contador.
If I = FontCount Then I = 0 ' Comenzar.
FontName = OldFont ' Restaurar la fuente original.
End Sub

15.15-FontSize
Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form, Control Frame, Control
Label, Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Devuelve o establece el tamaño de la fuente que se va a utilizar para el texto mostrado en un control o en una operación
de dibujo.

Sintaxis
objeto.FontSize [= puntos]

La sintaxis de la propiedad FontSize consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
puntos Una expresión numérica que especifica el tamaño de fuente que se va a utilizar, en puntos.

Página 84 de 159
Curso Visual Basic 5.0

Comentarios
Utilice esta propiedad para dar al texto el tamaño que desee. El valor predeterminado está determinado por el sistema.
Para cambiar este valor, especifique el nuevo tamaño de la fuente en puntos.
El valor máximo de FontSize es 2160 puntos.
Nota Las fuentes disponibles en Visual Basic varían dependiendo de la configuración del sistema y de los dispositivos
de presentación e impresión. En las propiedades relacionadas con las fuentes sólo pueden establecerse valores para los
que exista una fuente.
En general, deberá modificar FontName antes de establecer los atributos de tamaño y estilo con las propiedades
FontSize, FontBold, FontItalic, FontStrikethru y FontUnderline. Sin embargo, cuando especifique un tamaño
inferior a 8 puntos para una fuente TrueType, primero deberá establecer el tamaño en puntos con la propiedad FontSize,
después especificar la propiedad FontName y por último establecer de nuevo el tamaño con FontSize. El entorno
operativo Microsoft Windows utiliza una fuente distinta para las fuentes TrueType con un tamaño inferior a 8 puntos.

Ejemplo de la propiedad FontSize

En este ejemplo se escribe texto en un formulario con uno de entre dos tamaños en puntos con cada clic del mouse. Para
probar este ejemplo, pegue el código en la sección Declaraciones de un formulario. Presione F5 para ejecutar el
programa y luego haga clic en el formulario.
Private Sub Form_Click ()
FontSize = 24 ' Establecer FontSize.
Print "Éste es un tipo de 24 puntos." ' Imprimir con el tipo grande.
FontSize = 8 ' Establecer FontSize.
Print "Éste es un tipo de 8 puntos." 'Imprimir con el tipo pequeño.
End Sub

15.16-Heigth, Width
Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form, Control Frame,
Controles HScrollBar y VScrollBar, Control Image, Control Label, Control ListBox, Control OptionButton, Control
PictureBox, Control Shape, Control TextBox.

Sintaxis
objeto.Height [= número]
objeto.Width [= número]

La sintaxis de las propiedades Height y Width consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
número Una expresión numérica que especifica las dimensiones del objeto, según se indica en Valores.

Valores
Las medidas se calculan de la siguiente forma:
• Form: alto y ancho externos del formulario, incluyendo los bordes y la barra de título.
• Control: se mide desde el centro del borde del control, de forma que los controles con anchos de borde distintos se
alineen correctamente. Estas propiedades utilizan las unidades de escala del contenedor de un control.

Comentarios

Para los objetos Form estas propiedades se miden siempre en twips. Para los formularios y controles, los valores de
estas propiedades cambian cuando el usuario o el código modifican el tamaño del objeto. Los límites máximos de estas
propiedades para todos los objetos dependen del sistema.

Página 85 de 159
Curso Visual Basic 5.0

Utilice las propiedades Height, Width, Left y Top para realizar operaciones o cálculos que impliquen el área total de un
objeto, como puede ser mover el objeto o cambiar su tamaño. Utilice las propiedades ScaleLeft, ScaleTop, ScaleHeight
y ScaleWidth para realizar operaciones o cálculos que impliquen solamente el área interna de un objeto, como dibujar o
mover objetos dentro de otro objeto.

Ejemplo de las propiedades Height y Width

En este ejemplo se establece como tamaño de un formulario el 75 por ciento del tamaño de la pantalla y se centra el
formulario al cargarlo. Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario. Presione
F5 y haga clic en el formulario.

Private Sub Form_Click ()


Width = Screen.Width * .75 ' Establecer el ancho del formulario.
Height = Screen.Height * .75 ' Establecer el alto del formulario.
Left = (Screen.Width - Width) / 2 ' Centrar el formulario horizontalmente.
Top = (Screen.Height - Height) / 2 ' Centrar el formulario verticalmente.
End Sub

15.17-Icon
Aplicable a:
Objeto Form.

Devuelve el icono que aparece al minimizar un formulario en tiempo de ejecución.

Sintaxis
objeto.Icon

El marcador de posición objeto representa una expresión de objeto que da como resultado un objeto de la lista Aplicable
a.

Comentarios

Utilice esta propiedad para especificar un icono para cualquier formulario que el usuario pueda minimizar en tiempo de
ejecución.
Por ejemplo, puede asignar a un formulario un icono único que indique su función. Especifique el icono cargándolo
mediante la ventana Propiedades en tiempo de diseño. El archivo que cargue debe tener la extensión .ico y el formato
correspondiente. Si no especifica ningún icono, se utilizará el icono predeterminado para los formularios en Visual
Basic.
Puede utilizar como origen de iconos la biblioteca de iconos de Visual Basic (ubicada en el subdirectorio Icons). Cuando
crea un archivo ejecutable, puede asignar un icono a la aplicación mediante la propiedad Icon de cualquier formulario de
la misma.
Nota Puede ver un icono de formulario en la esquina superior izquierda del formulario en Windows 95, o cuando se
minimiza el formulario en Windows 95 y en Windows NT. Si el formulario está minimizado, el valor de la propiedad
BorderStyle debe ser 1 (Fixed Single, Simple fijo) o 2 (Sizable, Tamaño ajustable), y el de la propiedad MinButton
debe ser True para que el icono sea visible.
En tiempo de ejecución puede asignar el valor de la propiedad Icon de un objeto a la propiedad DragIcon o Icon de otro
objeto distinto. También puede asignar un icono obtenido con la función LoadPicture. Si utiliza la función
LoadPicture sin argumentos, se asigna un icono vacío (nulo) al formulario, lo que permite dibujar sobre el icono en
tiempo de ejecución.

Página 86 de 159
Curso Visual Basic 5.0

15.18-Index (Matriz de Controles)


Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data Control Frame, Controles HScrollBar y
VScrollBar, Control Image, Control Label, Control Line, Control ListBox, Control Menu, Control OptionButton,
Control PictureBox, Control Shape, Control TextBox, Control Timer.

Devuelve o establece el número que identifica un control de forma exclusiva en una matriz de controles. Sólo está
disponible si el control forma parte de una matriz de controles.

Sintaxis
objeto[(número)].Index

La sintaxis de la propiedad Index consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
número Una expresión numérica que da como resultado un entero que identifica un control individual en una matriz de
controles.

Valores
Los valores admitidos para número son:
Valor Descripción
Ningún valor (Predeterminado) No forma parte de una matriz de controles.
0 a 32.767 Parte de una matriz. Especifica un entero mayor o igual que 0 que identifica un control en una matriz de
controles. Todos los controles de una matriz de controles tienen la misma propiedad Name. Visual Basic asigna
automáticamente el siguiente entero disponible de la matriz de controles.

Comentarios

Puesto que los elementos de matrices de controles comparten el mismo valor de la propiedad Name, deberá utilizar la
propiedad Index en código para especificar un determinado control de la matriz. Index debe aparecer como un entero (o
una expresión numérica que da como resultado un entero) entre paréntesis al lado del nombre de la matriz de controles;
por ejemplo, MisBotones(3). También puede utilizar el valor de la propiedad Tag para distinguir un control de otro en
una matriz de controles.
Cuando un control de la matriz reconoce que se ha producido un evento, Visual Basic llama al procedimiento de evento
de la matriz de controles y pasa el valor de Index correspondiente como argumento adicional.
Aunque Visual Basic asigna de forma predeterminada el siguiente entero disponible como valor de Index para un nuevo
control de una matriz de controles, puede anular este valor asignado y omitir enteros. También puede establecer Index a
un entero distinto de 0 para el primer control de la matriz. Si hace referencia a un valor Index en el código que no
identifica uno de los controles de una matriz de controles, se producirá un error en tiempo de ejecución de Visual
Basic.
Nota Para quitar un control de una matriz de controles, cambie el valor de la propiedad Name del control y elimine el
valor de su propiedad Index.

Ejemplo de la propiedad Index


Este ejemplo comienza con dos controles OptionButton y agrega un nuevo OptionButton al formulario cada vez que
hace clic en un control CommandButton.

Private Sub Command1_Click ()


Static MaxIdx ' Índice mayor de la matriz.
If MaxIdx = 0 Then MaxIdx = 1 ' MaxIdx preestablecido.
MaxIdx = MaxIdx + 1 ' Incrementa el índice.
If MaxIdx > 7 Then Exit Sub ' Coloca ocho botones en el formulario.

Página 87 de 159
Curso Visual Basic 5.0

Load OptButton(MaxIdx) ' Crea nuevos elementos en la matriz.


' Establece la ubicación del nuevo botón de opciones bajo un botón previo.
OptButton(MaxIdx).Top = OptButton(MaxIdx - 1).Top + 360
OptButton(MaxIdx).Visible = True' Hace visible el nuevo botón.
End Sub

15.19-ListCount
Aplicable a:
Control ComboBox, Control ListBox

Devuelve el número de elementos de la parte de lista de un control.

Sintaxis
objeto.ListCount

El marcador de posición objeto representa una expresión de objeto que da como resultado un objeto de la lista Aplicable
a.

Comentarios
ListCount proporciona información específica de cada control:
• Controles ComboBox y ListBox: el número de elementos de la lista.

Si no hay seleccionado ningún elemento, el valor de la propiedad ListIndex es –1. El primer elemento de la lista
corresponde a ListIndex = 0 y ListCount es siempre una unidad mayor que el valor máximo de ListIndex.

Ejemplo de la propiedad ListCount

En este ejemplo se carga la lista de fuentes de impresora en un control ComboBox, se muestra el primer elemento de la
lista y se escribe el número total de fuentes. Cada vez que se hace clic en el botón de comando, todos los elementos de la
lista cambian a mayúsculas o a minúsculas. Para probar este ejemplo, pegue el código en la sección Declaraciones de un
formulario que contenga un control ComboBox (Style = 2) y un control CommandButton, presione F5 y haga clic en
el control CommandButton.

Private Sub Form_Load ()


Dim I ' Declarar la variable.
AutoRedraw = True ' Establecer AutoRedraw.
For I = 0 To Printer.FontCount - 1 ' Poner los nombre de las fuentes en una lista.
Combo1.AddItem Printer.Fonts(I)
Next I
Combo1.ListIndex = 0 ' Establecer el texto del primer elemento.
' Imprimir la información de ListCount en el formulario.
Print "Número de fuentes de impresora: "; Combo1.ListCount
End Sub
Private Sub Command1_Click ()
Static UpperCase
Dim I ' Declarar variable.
For I = 0 To Combo1.ListCount - 1 ' Bucle por la lista.
If UpperCase Then
Combo1.List(I) = UCase(Combo1.List(I))
Else
Combo1.List(I) = LCase(Combo1.List(I))
End If
Next I

Página 88 de 159
Curso Visual Basic 5.0

UpperCase = Not UpperCase ' Cambiar mayúsculas y minúsculas.


End Sub

15.20-ListIndex
Aplicable a:
Control ComboBox, Control ListBox

Devuelve o establece el índice del elemento seleccionado actualmente en el control. No está disponible en tiempo de
diseño.

Sintaxis
objeto.ListIndex [= índice]

La sintaxis de la propiedad ListIndex consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Una expresión numérica que especifica el índice del elemento actual, según se indica en Valores.

Valores
Los valores admitidos para índice son:
Valor Descripción
–1 (Predeterminado para los controles ComboBox) Indica que actualmente no hay ningún elemento
seleccionado. Para un control ComboBox indica que el usuario ha escrito texto nuevo en la parte de
cuadro de texto.
n (Predeterminado para los controles ListBox) Número que indica el índice del elemento seleccionado
actualmente.

Comentarios
La expresión List(List1.ListIndex) devuelve la cadena correspondiente al elemento seleccionado actualmente.
El primer elemento de la lista corresponde a ListIndex = 0 y ListCount es siembre una unidad mayor que el valor
máximo de ListIndex.

Ejemplo de la propiedad ListIndex

En este ejemplo se muestran los nombres de tres jugadores en un control ListBox y el sueldo del jugador seleccionado
en un control Label. Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario que
contenga un control ComboBox y un control Label, presione F5 y elija un nombre en el control ComboBox.

Dim Player(0 To 2) ' Dimensionar dos matrices.


Dim Salary(0 To 2)
Private Sub Form_Load ()
Dim I ' Declarar variable.
AutoSize = True
Player(0) = "Daniel Rendich" ' Introducir los datos en las matrices.
Player(1) = "Federico Couto"
Player(2) = "Ernesto Méndez"
Salary(0) = "234.500$"
Salary(1) = "158.900$"
Salary(2) = "1.030.500$"
For I = 0 To 2 ' Agregar los nombres a la lista.
Combo1.AddItem Player(I)

Página 89 de 159
Curso Visual Basic 5.0

Next I
Combo1.ListIndex = 0 ' Mostrar el primer elemento de la lista.
End Sub

Private Sub Combo1_Click ()


' Mostrar el salario correspondiente al nombre.
Label1.Caption = Salary(Combo1.ListIndex)
End Sub

15.21-Locked
Aplicable a:
Control TextBox

Devuelve o establece un valor que indica si un control se puede modificar.

Sintaxis
objeto.Locked [ = booleano]

La sintaxis de la propiedad Locked consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
Booleano Una expresión booleana que especifica si el control se puede modificar, como se describe en
Valores.

Valores
Los valores admitidos para booleano son:
Valor Descripción
True Control TextBox: el texto del control se puede desplazar y resaltar, pero no se puede modificar. El
programa puede cambiar el texto si cambia la propiedad Text.
False Control TextBox: puede modificar el texto del control.

15.22-MousePointer
Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form Control Frame,
Controles HScrollBar y VScrollBar, Control Image, Control Label, Control ListBox, Control OptionButton, Control
PictureBox, Control TextBox.

Devuelve o establece un valor que indica el tipo de puntero de mouse que aparece cuando se sitúa el mouse sobre un
área determinada de un objeto en tiempo de ejecución.

Sintaxis
objeto.MousePointer [= valor]

La sintaxis de la propiedad MousePointer consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
valor Un número entero que especifica el tipo de puntero de mouse que aparece, según se describe en
Valores.

Página 90 de 159
Curso Visual Basic 5.0

Valores
Los valores admitidos para valor son:
Constante Valor Descripción
vbDefault 0 (Predeterminado) Forma determinada por el objeto.
VbArrow 1 Flecha.
VbCrosshair 2 Cruz (puntero en forma de cruz).
VbIbeam 3 Forma de I.
VbIconPointer 4 Icono (pequeño cuadrado dentro de otro cuadrado).
VbSizePointer 5 Tamaño (flecha de cuatro puntas: norte, sur, este y oeste).
VbSizeNESW 6 Tamaño NE SO (flecha doble que apunta al nordeste y al sudoeste).
VbSizeNS 7 Tamaño N S (flecha doble que apunta al norte y al sur).
VbSizeNWSE 8 Tamaño NO SE (flecha doble que apunta al noroeste y al sudeste).
VbSizeWE 9 Tamaño O E (flecha doble que apunta al oeste y al este).
VbUpArrow 10 Flecha hacia arriba.
VbHourglass 11 Reloj de arena (espera).
VbNoDrop 12 No colocar.
VbArrowHourglass 13 Flecha y reloj de arena.
VbArrowQuestion 14 Flecha y signo de interrogación.
vbSizeAll 15 Ajustar todo.
vbCustom 99 Icono personalizado especificado en la propiedad MouseIcon.

Comentarios
Puede utilizar esta propiedad cuando desee indicar los cambios en la funcionalidad al desplazar el puntero del mouse por
los controles de un formulario o cuadro de diálogo. La opción de reloj de arena (11) es útil para indicar que el usuario
debe esperar a que termine un proceso u operación.

Ejemplo de la propiedad MousePointer

En este ejemplo se cambia el puntero del mouse por un reloj de arena mientras se dibujan círculos en la pantalla y al
final del procedimiento el puntero adopta la forma que tenía originalmente. Para probar este ejemplo, pegue el código en
la sección Declaraciones de un formulario. Presione F5 para ejecutar el programa y luego haga clic en el formulario.

Private Sub Form_Click ()


Dim I ' Declara una variable.
' Cambia el puntero del mouse por un reloj de arena.
Screen.MousePointer = vbHourglass
' Establece un color aleatorio y dibuja círculos en el formulario.
For I = 0 To ScaleWidth Step 50
ForeColor = RGB(Rnd * 255, Rnd * 255, Rnd * 255)
Circle (I, ScaleHeight * Rnd), 400
Next
' Vuelve al puntero normal.
Screen.MousePointer = vbDefault
End Sub

15.23-Multiline
Aplicable a:
Control TextBox.

Devuelve o establece un valor que indica si un control TextBox acepta y muestra múltiples líneas de texto. Es de sólo
lectura en tiempo de ejecución.

Página 91 de 159
Curso Visual Basic 5.0

Sintaxis
objeto.MultiLine

El marcador de posición objeto representa una expresión de objeto que da como resultado un objeto de la lista
Aplicable a.

Valores
Los valores admitidos para la propiedad MultiLine son:
Valor Descripción
True Permite múltiples líneas de texto.
False (Predeterminado) Pasa por alto los retornos de carro y restringe los datos a una única línea.

Comentarios
Los controles TextBox de múltiples líneas ajustan el texto a la línea siguiente cuando el usuario se extiende más allá del
cuadro de texto.
También puede agregar barras de desplazamiento a los controles TextBox más grandes, utilizando para ello la propiedad
ScrollBars. Si no se especifica un control de barra de desplazamiento horizontal, el texto de los controles TextBox de
múltiples líneas se ajustará automáticamente a la línea siguiente.
Nota En los formularios sin ningún botón predeterminado, al presionar ENTRAR en un control TextBox de múltiples
líneas, el enfoque pasa a la línea siguiente. Si existe un botón predeterminado, deberá presionar CTRL+ENTRAR para pasar
a la línea siguiente.

15.24-Name
Aplicable a:
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form, Control Frame,
Controles HScrollBar y VScrollBar, Control Image, Control Label, Control Line, Control Menu, Control OptionButton,
Control PictureBox, Control Shape, Control TextBox, Control Timer.

Devuelve el nombre utilizado en el código para identificar un formulario, un control o un objeto de acceso a datos. Es de
sólo lectura en tiempo de ejecución.

Sintaxis
objeto.Name

El marcador de posición objeto representa una expresión de objeto que da como resultado un objeto de la lista
Aplicable a. Si se omite objeto, se supondrá que el formulario asociado al módulo del formulario activo es objeto.

Comentarios

El nombre predeterminado para objetos nuevos es el tipo de objeto y un entero único. Por ejemplo, el primer objeto
Form nuevo será Form1 y el tercer control TextBox que cree en un formulario será Text3.
La propiedad Name de un objeto debe comenzar por una letra y puede tener un máximo de 40 caracteres. Puede incluir
números y caracteres de subrayado (_), pero no signos de puntuación ni espacios en blanco. Aunque el valor de la
propiedad Name puede ser una palabra clave, un nombre de propiedad o el nombre de otro objeto, esto puede crear
conflictos en el código.
Puede crear un conjunto de controles del mismo tipo si establece la propiedad Name al mismo valor. Por ejemplo,
cuando establece el nombre de todos los botones de opción en un grupo como MiOpc, Visual Basic asigna valores
únicos a la propiedad Index de cada control con el fin de distinguir unos de otros en la matriz. Dos controles de distinto
tipo no pueden tener el mismo nombre.

Página 92 de 159
Curso Visual Basic 5.0

Nota Aunque Visual Basic usa a menudo el valor de la propiedad Name como valor predeterminado de las
propiedades Caption y Text, el cambio de una de estas propiedades no afecta a las otras.

15.25-NewIndex
Aplicable a:
Control ComboBox, Control ListBox.

Devuelve el índice del último elemento agregado a un control ComboBox o ListBox. Es de sólo lectura en tiempo de
ejecución.

Sintaxis
objeto.NewIndex

El marcador de posición objeto representa una expresión de objeto que da como resultado un objeto de la lista
Aplicable a.

Comentarios
Puede utilizar esta propiedad con listas ordenadas cuando necesite una lista de valores asociados a cada elemento de la
matriz de la propiedad ItemData. Al agregar un elemento a una lista ordenada, Visual Basic lo inserta en orden
alfabético. Esta propiedad indica la posición en la que se ha insertado el elemento, de forma que pueda insertar el valor
correspondiente en la propiedad ItemData con el mismo índice.
La propiedad NewIndex devuelve -1 cuando no hay ningún elemento en la lista o cuando se ha eliminado un elemento
después de agregar el último elemento.

15.26-ItemData
Aplicable a:
Control ComboBox, Control ListBox.

Devuelve o establece un número específico para cada elemento de un control ComboBox o ListBox.

Sintaxis
objeto.ItemData(índex) [= número]

La sintaxis de la propiedad ItemData consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice El número de un elemento concreto del objeto.
número El número que se asocia con el elemento especificado.

Comentarios

La propiedad ItemData es una matriz de valores enteros largos cuyo número de elementos es el valor de la propiedad
List de un control. Puede utilizar los números asociados con cada elemento para identificar los elementos. Por ejemplo,
puede usar un número de identificación de empleado para identificar cada nombre de empleado de un control ListBox.
Cuando llena el ListBox, también se llenan los elementos correspondientes de la matriz ItemData con los números de
empleado.
La propiedad ItemData se usa a menudo como índice de una matriz de estructuras de datos asociadas con los elementos
de un control ListBox.

Página 93 de 159
Curso Visual Basic 5.0

Nota Cuando inserta un elemento en una lista con el método AddItem, el elemento también se inserta
automáticamente en la matriz ItemData. Sin embargo, el valor no se reinicia a cero; conserva el valor que había en esa
posición antes agregar el elemento a la lista. Cuando use la propiedad ItemData, asegúrese de establecer su valor al
agregar nuevos elementos a la lista.

Ejemplo de la propiedad ItemData


Este ejemplo llena un control ListBox con nombres de empleados y llena la matriz de propiedades ItemData con
números de empleados usando la propiedad NewIndex para mantener los números sincronizados con la lista ordenada.
Un control Label presenta el nombre y el número de un elemento cuando el usuario hace una selección en la lista. Para
probar este ejemplo, pegue el código en la sección Declaraciones de un formulario que contenga un control ListBox y
un control Label. Establezca la propiedad Sorted del ListBox a True, y después presione F5 y haga clic en el control
ListBox.

Private Sub Form_Load ()


' Llena List1 y la matriz ItemData con los
' elementos correspondientes ordenados.
List1.AddItem "Judy Phelps"
List1.ItemData(List1.NewIndex) = 42310
List1.AddItem "Chien Lieu"
List1.ItemData(List1.NewIndex) = 52855
List1.AddItem "Mauro Sorrento"
List1.ItemData(List1.NewIndex) = 64932
List1.AddItem "Cynthia Bennet"
List1.ItemData(List1.NewIndex) = 39227
End Sub

Private Sub List1_Click ()


' Agrega el número y el nombre del empleado.
Msg = List1.ItemData(List1.ListIndex) & " "
Msg = Msg & List1.List(List1.ListIndex)
Label1.Caption = Msg
End Sub

15.27-PassWordChar
Aplicable a:
Control TextBox.

Devuelve o establece un valor que indica si en un control TextBox aparecen los caracteres que escribe el usuario o un
carácter marcador de posición. Devuelve o establece el carácter utilizado como marcador de posición.

Sintaxis
objeto.PasswordChar [= valor]

La sintaxis de la propiedad PasswordChar consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
valor Una expresión de cadena que especifica el carácter marcador de posición.

Comentarios

Página 94 de 159
Curso Visual Basic 5.0

Utilice esta propiedad para crear un campo de contraseña en un cuadro de diálogo. Aunque puede utilizarse cualquier
carácter como marcador de posición, la mayoría de las aplicaciones para Windows usan el asterisco (*) (Chr(42)).
Esta propiedad no afecta a la propiedad Text, que contiene exactamente lo que haya escrito el usuario o lo que se haya
establecido con el código. Para mostrar el texto real, establezca PasswordChar a una cadena de longitud cero (""), que
es la opción predeterminada.
Puede asignar cualquier cadena a esta propiedad, pero sólo será significativo el primer carácter, pasándose por alto todos
los demás.
Nota Si la propiedad MultiLine está establecida a True, la propiedad PasswordChar no tendrá efecto.

Ejemplo de la propiedad PasswordChar


En este ejemplo se ilustra cómo la propiedad PasswordChar afecta a la forma en que un control TextBox muestra el
texto. Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario que contenga un control
TextBox, presione F5 y haga clic en el formulario. Cada vez que haga clic en el formulario, el texto alternará entre el
carácter asterisco (*) de contraseña y texto normal.

Private Sub Form_Click ()


If Text1.PasswordChar = "" Then
Text1.PasswordChar = "*"
Else
Text1.PasswordChar = ""
End If
End Sub

15.28-Picture
Aplicable a:
Control CheckBox, Control CommandButton, Objeto Form, Control Image, Control OptionButton, Control PictureBox.

Devuelve o establece un gráfico que se mostrará en un control.

Sintaxis
objeto.Picture [= imagen]

La sintaxis de la propiedad Picture consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
imagen Una expresión de cadena que especifica un archivo que contiene un gráfico, según se indica en Valores.

Valores
Los valores admitidos para imagen son:
Valor Descripción
(Ninguno) (Predeterminado) Ninguna imagen.
(Mapa de bits, icono, metarchivo, GIF, JPEG)) Especifica un gráfico que puede cargar mediante la ventana
Propiedades en tiempo de diseño. En tiempo de ejecución
también puede establecer esta propiedad, utilizando la
función LoadPicture con un mapa de bits, un icono o un
metarchivo.

Comentarios

Página 95 de 159
Curso Visual Basic 5.0

En tiempo de diseño, puede transferir un gráfico con el Portapapeles mediante los comandos Copiar, Cortar y Pegar
del menú Edición.
Al establecer la propiedad Picture en tiempo de diseño, el gráfico se guarda y se carga con el formulario. Si crea un
archivo ejecutable, la imagen estará contenida en él. Los gráficos cargados en tiempo de ejecución no se guardan con la
aplicación.
Nota En tiempo de ejecución puede establecer la propiedad Picture al valor de la propiedad Icon, Image o Picture de
cualquier otro objeto y también se le puede asignar un gráfico devuelto por la función LoadPicture.

Ejemplo de la propiedad Picture

En este ejemplo se cargan iconos de la biblioteca de iconos de Visual Basic en dos controles PictureBox. Al hacer clic
en el formulario, el tercer control PictureBox se utiliza para intercambiar los otros dos. Puede utilizar dos iconos
cualesquiera. Pegue el código en la sección Declaraciones de un formulario que contenga tres controles PictureBox
(para Picture3, establezca Visible = False). Presione F5 para ejecutar el programa y luego haga clic en el formulario.

Private Sub Form_Load ()


' Cargar los iconos.
Picture1.Picture = LoadPicture("ICONOS\EQUIPO\PAPEL02A.ICO")
Picture2.Picture = LoadPicture("ICONOS\EQUIPO\PAPEL02B.ICO")
End Sub

Private Sub Form_Click ()


' Cambiar los iconos.
Picture3.Picture = Picture1.Picture
Picture1.Picture = Picture2.Picture
Picture2.Picture = Picture3.Picture
' Borrar la tercera imagen (no es necesario si no está visible).
Picture3.Picture = LoadPicture()
End Sub

15.29-Recordset
Aplicable a:
Control Data.

Devuelve o establece un objeto Recordset definido por las propiedades de un control Data o por un objeto Recordset
existente.

Sintaxis
Set objeto.Recordset [= valor ]

La sintaxis de la propiedad Recordset consta de estas partes:


Parte Descripción
objeto Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.
valor Una variable de objeto que contiene un objeto Recordset.

Comentarios

El control Data se inicializa automáticamente cuando se inicia la aplicación antes del procedimiento inicial Form_Load.
Si son válidas las propiedades Connect, DatabaseName, Options, RecordSource, Exclusive, ReadOnly y
RecordsetType, o si establece estas propiedades del control Data en tiempo de ejecución y utiliza el método Refresh,
el motor de base de datos Microsoft Jet intentará crear un nuevo objeto Recordset basado en esas propiedades. Es
posible tener acceso a este Recordset a través de la propiedad Recordset de un control Data. Sin embargo, si una o más

Página 96 de 159
Curso Visual Basic 5.0

de estas propiedades se establecen de forma incorrecta en tiempo de diseño, puede ocurrir un error no interceptable
cuando Visual Basic intente usar las propiedades para abrir la base de datos determinada y crear el objeto Recordset.
También puede solicitar el tipo de Recordset que se va a crear si establece la propiedad RecordsetType del control
Data Si no solicita un tipo específico, se creará un Recordset de tipo dynaset. Si utiliza la propiedad RecordsetType
podrá solicitar la creación de un Recordset de tipo table, snapshot o dynaset. Sin embargo, si el motor Jet no puede
crear el tipo solicitado, se producirá un error interceptable.
En la mayoría de los casos, el tipo predeterminado y la configuración del objeto Recordset que se ha creado es poco
eficiente. Es decir, puede que no necesite un cursor actualizable, con desplazamiento completo y basado en claves para
tener acceso a los datos. Por ejemplo, puede ser más rápido crear un Recordset de tipo snapshot de sólo lectura que el
Recordset predeterminado. Asegúrese de que elige el tipo más eficiente estableciendo las propiedades Exclusive,
Options y ReadOnly según su situación.
Es posible que no se pueda actualizar un Recordset aunque solicite un Recordset de tipo dynaset o table. Si no se puede
actualizar la base de datos, la tabla o el campo subyacente, es posible que el Recordset completo o partes de él sean de
sólo lectura. Examine la propiedad Updatable de los objetos Database y Recordset o la propiedad DataUpdatable del
objeto Field para determinar si el código puede modificar los registros. Incluso si la propiedad DataUpdatable devuelve
True, hay situaciones en las que los campos de datos subyacentes pueden no ser actualizables; por ejemplo, puede que
no tenga permisos suficientes para realizar cambios. Puede haber también otros factores que impidan la actualización de
campos.
El número de registros devueltos por el Recordset puede determinarse desplazándose al último registro del Recordset y
examinando la propiedad RecordCount del objeto Recordset. Antes de desplazarse al último registro, el valor devuelto
por la propiedad RecordCount sólo indica el número de filas procesadas por el motor Jet. El ejemplo siguiente muestra
cómo combinar la propiedad RecordCount de un Recordset con la propiedad Recordset para mostrar el número de
registros del conjunto de registros de un control Data:
Data1.Recordset.MoveLast
MsgBox "Registros: " & Data1.Recordset.RecordCount

Edición profesional y Edición empresarial


Si crea un objeto Recordset mediante código u otro control Data, puede establecer la propiedad Recordset del control
Data a este nuevo Recordset. Cualquier Recordset existente en el control Data y el objeto Database asociado con él se
liberarán cuando se asigne un nuevo Recordset a la propiedad Recordset.
Asegúrese de que las propiedades DataField de los controles enlazados conectados al control Data se establecen de
forma que coincidan con los nombres de campo del nuevo objeto Recordset.
Por ejemplo, para crear un Recordset en código y pasarlo a un control Data existente:

Dim Db As Database, Rs As Recordset ' Definidas como variables públicas.


Sub ApplyRecordset()
Set Db = Workspaces(0).OpenDatabase("BIBLIO.MDB")
Set Rs = Db.OpenRecordset("AUTHORS") ' De forma predeterminada el objeto Table.
Set Data1.Recordset = Rs ' Asigna el Recordset.
Data1.Recordset.Index = "PrimaryKey"
Debug.Print Rs.Type ' Muestra el tipo creado.
End Sub

Nota El control Data no es compatible con objetos Recordset de tipo forward-only (desplazamiento sólo hacia
adelante). Si intenta asignar al control Data un objeto Recordset de tipo forward-only, ocurre un error interceptable.
Importante Siempre puede hacer referencia a las propiedades del Recordset del control Data mediante la propiedad
Recordset. Si hace referencia directamente al Recordset, podrá determinar el Index que va a utilizar con objetos Table,
la colección Parameters de un objeto QueryDef o el tipo de Recordset.
Tipo de datos
Recordset

15.30-RecordsetType
Aplicable a:

Página 97 de 159
Curso Visual Basic 5.0

Control Data.

Devuelve o establece un valor que indica el tipo de objeto Recordset que desea que cree el control Data.

Sintaxis
objeto.RecordsetType [= valor ]

La sintaxis de la propiedad RecordsetType consta de estas partes:


Parte Descripción
objeto Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a
valor Una constante o un valor que indica el tipo de Recordset, como se describe en Valores

Valores
Los valores admitidos para valor son los siguientes:
Configuración Valor Descripción
VbRSTypeTable 0 Un Recordset de tipo table
vbRSTypeDynaset 1 (Predeterminado) Un Recordset de tipo dynaset
vbRSTypeSnapshot 2 Un Recordset de tipo snapshot

Comentarios

Si el motor de base de datos Microsoft Jet no puede crear el tipo de Recordset que ha solicitado, se produce un error
interceptable.
Si no especifica un RecordsetType antes de que el control Data cree el Recordset, se creará si es posible un Recordset
de tipo dynaset.
En la mayoría de los casos, el tipo predeterminado y la configuración del objeto Recordset que se ha creado es poco
eficiente. Es decir, puede que no necesite un cursor actualizable, con desplazamiento completo y basado en claves para
tener acceso a los datos. Por ejemplo, un Recordset de tipo snapshot con desplazamiento sólo hacia adelante de sólo
lectura puede ser más rápido de crear que el cursor predeterminado. Asegúrese de que elige el tipo más eficiente
estableciendo las propiedades RecordsetType, Exclusive, Options y ReadOnly según su situación.

Tipo de datos
Integer

Ejemplo de la propiedad RecordsetType

Este ejemplo utiliza el control Data para crear un objeto Recordset y examina la propiedad RecordsetType del control
Data para determinar el tipo de conjunto de registros creado.

Sub DisplayRecordsetType()
' Indica el tipo de Recordset deseado.
Data1.RecordsetType = vbRSTypeDynaset
Data1.DatabaseName = "BIBLIO.MDB"
Data1.RecordSource = "Authors"
Data1.Refresh

Select Case Data1.RecordsetType


Case vbRSTypeTable
Debug.print "Creado Recordset de tipo Table."
Case vbRSTypeDynaset
Debug.print "Creado Recordset de tipo Dynaset."
Case vbRSTypeSnapshot
Debug.print "Creado Recordset de tipo Snapshot."
End Select
End Sub

Página 98 de 159
Curso Visual Basic 5.0

15.31-RecordSource
Aplicable a:
Control Data.

Devuelve o establece la tabla, la instrucción SQL o el objeto QueryDef subyacente para un control Data.

Sintaxis
Objeto.RecordSource [= valor]

La sintaxis de la propiedad RecordSource consta de estas partes:


Parte Descripción
objeto Una expresión de objeto cuyo resultado es un objeto de la lista Aplicable a.
valor Una expresión de cadena que especifica un nombre, como se describe en Valores.

Valores
Los valores admitidos para valor son los siguientes:
Valor Descripción
Un nombre de tabla El nombre de una de las tablas definidas en la colección TableDefs del objeto
Database.
Una consulta SQL Una cadena SQL válida que utiliza una sintaxis apropiada para el origen de datos.
Un QueryDef El nombre de uno de los objetos QueryDef de la colección QueryDefs del objeto
Database, al tener acceso a una base de datos de Jet.

Comentarios

La propiedad RecordSource especifica el origen de los registros accesibles a través de controles enlazados del
formulario.
Si establece la propiedad RecordSource al nombre de una tabla existente en la base de datos, todos los campos de esa
tabla serán visibles en los controles enlazados adjuntos al control Data. Para conjuntos de registros de tipo table
(RecordsetType = vbRSTypeTable), el orden de los registros recuperados lo establece el objeto Index que se
selecciona mediante la propiedad Index del Recordset. Para objetos Recordset de tipo dynaset y snapshot, puede
ordenar los registros usando una instrucción SQL con una cláusula Order By en la propiedad RecordSource del control
Data. De lo contrario, los datos se devuelven sin ningún orden en particular.
Si establece la propiedad RecordSource al nombre de un objeto QueryDef existente en la base de datos, todos los
campos devueltos por QueryDef serán visibles para los controles enlazados adjuntos al control Data. El orden de los
registros recuperados lo establece la consulta del objeto QueryDef. Por ejemplo, QueryDef puede incluir una cláusula
ORDER BY para cambiar el orden de los registros que devuelve el objeto Recordset creado por el control Data o una
cláusula WHERE para filtrar los registros. Si el objeto QueryDef no especifica ningún orden, los datos se devolverán
sin ningún orden concreto.
Nota En tiempo de diseño, los objetos QueryDef mostrados en la ventana Propiedades para la propiedad
RecordSource se filtran para mostrar únicamente los objetos QueryDef que se pueden utilizar con el control Data. No
se muestran los objetos QueryDef que tengan parámetros.
Si establece la propiedad RecordSource a una instrucción SQL que devuelve registros, todos los campos devueltos por
la consulta SQL serán visibles para los controles enlazados adjuntos al control Data. Esta instrucción puede incluir una
cláusula ORDER BY para cambiar el orden de los registros devueltos por el objeto Recordset creado por el control
Data o una cláusula WHERE para filtrar los registros.
Nota Cada vez que el objeto QueryDef o la instrucción SQL devuelve un valor de una expresión, el motor de base de
datos Microsoft Jet crea automáticamente el nombre de campo de la expresión. El nombre suele ser Expr1 seguido de un
número de tres dígitos que comienza por 000. Por ejemplo, la primera expresión se llamaría Expr1000.

Página 99 de 159
Curso Visual Basic 5.0

En la mayoría de los casos, es posible que quiera asignar un alias a expresiones de modo que conozca el nombre de la
columna a la que va a enlazar el control enlazado. Para obtener más información al respecto, vea la cláusula AS de la
instrucción SQL SELECT.
Después de cambiar el valor de la propiedad RecordSource en tiempo de ejecución, deberá utilizar el método Refresh
para activar el cambio y volver a generar el Recordset.
En tiempo de ejecución, si el Recordset especifica un nombre de un tipo Table no válido, un nombre de QueryDef o
contiene sintaxis de SQL no válida, se generará un error interceptable. Si el error ocurre durante el procedimiento inicial
Form_Load, el error no será interceptable.
Nota Asegúrese de que cada control enlazado tiene un valor válido para su propiedad DataField. Si cambia el valor de
la propiedad RecordSource de un control Data y a continuación utiliza Refresh, el Recordset identificará al nuevo
objeto. Esto puede invalidar los valores de la propiedad DataField de controles enlazados y producir un error
interceptable.

Tipo de datos

String

15.32-Shape
Aplicable a
Control Shape

Devuelve o establece un valor que indica la apariencia de un control Shape.

Sintaxis
objeto.Shape [= valor]

La sintaxis de la propiedad Shape consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
valor Un número entero que especifica la apariencia del control, según se describe en Valores.

Valores
Los valores admitidos para valor son:
Constante Valor Descripción
vbShapeRectangle 0 (Predeterminado) Rectángulo
vbShapeSquare 1 Cuadrado
vbShapeOval 2 Elipse
vbShapeCircle 3 Círculo
VbShapeRoundedRectangle 4 Rectángulo redondeado
VbShapeRoundedSquare 5 Cuadrado redondeado

Ejemplo de la propiedad Shape

En este ejemplo se ilustran las seis posibles formas del control Shape. Para probarlo, pegue el código en la sección
Declaraciones de un formulario que contenga un control OptionButton y un control Shape. En el OptionButton,
establezca a 0 la propiedad Index para crear una matriz de controles de un elemento y presione F5. Haga clic en cada
control OptionButton para ver una forma distinta.

Private Sub Form_Load ()


Dim I ' Declara una variable.
Option1(0).Caption = "Forma nº 0"
For I = 1 To 5 ' Crea cinco instancias de Option1.

Página 100 de 159


Curso Visual Basic 5.0

Load Option1(I)
' Establece la ubicación del nuevo botón de opción.
Option1(I).Top = Option1(I - 1).Top + Option1(0).Height + 40
' Establece el título del botón de opción.
Option1(I).Caption = "Forma nº " & I
' Muestra el nuevo botón de opción.
Option1(I).Visible = True
Next I
End Sub

Private Sub Option1_Click (Index As Integer)


Shape1.Shape = Index
End Sub

15.33-SQL (Objeto QueryDef)


Aplicable a
Objeto QueryDef

Establece o devuelve la instrucción SQL que define la consulta ejecutada por un objeto QueryDef.
Valores devueltos y establecidos
El valor que se puede establecer u obtener es un tipo de datos String que contiene una instrucción SQL.

Comentarios
La propiedad SQL contiene la instrucción SQL que determina cómo se seleccionan, agrupan y ordenan los registros
cuando se ejecuta la consulta. Puede utilizar la consulta para seleccionar registros a incluir en un objeto Recordset de
tipo Dynaset o Snapshot. También puede definir consultas para modificar datos sin devolver registros.
La sintaxis SQL utilizada en una consulta debe ser acorde con el dialecto SQL del motor de consulta, que está
determinado por el tipo de espacio de trabajo. En un espacio de trabajo Microsoft Jet, utilice el lenguaje SQL de
Microsoft Jet.

Ejemplo de la propiedad SQL

Este ejemplo demuestra la propiedad SQL estableciendo y modificando la propiedad SQL de un QueryDef temporal y
comparando los resultados. Se necesita la función SalidaSQL para ejecutar este procedimiento.

Sub SQLX()

Dim dbsNeptuno As Database


Dim qdfTemp As QueryDef
Dim rstEmpleados As Recordset

Set dbsNeptuno = OpenDatabase("Neptuno.mdb")


Set qdfTemp = dbsNeptuno.CreateQueryDef("")

' Abre un Recordset utilizando un objeto QueryDef


' temporal e imprime un informe.
SalidaSQL "SELECT * FROM Empleados " & _
"WHERE País = 'España' " & _
"ORDER BY Apellidos", qdfTemp

' Abre un Recordset utilizando un objeto QueryDef

Página 101 de 159


Curso Visual Basic 5.0

' temporal e imprime un informe.


SalidaSQL "SELECT * FROM Empleados " & _
"WHERE País = 'México' " & _
"ORDER BY Apellidos", qdfTemp

dbsNeptuno.Close

End Sub

Function SalidaSQL(strSQL As String, qdfTemp As QueryDef)

Dim rstEmpleados As Recordset

' Establece la propiedad SQL del objeto QueryDef


' temporal y abre un Recordset.
qdfTemp.SQL = strSQL
Set rstEmpleados = qdfTemp.OpenRecordset

' Enumera el Recordset.


Do While Not rstEmpleados.EOF
Debug.Print " " & rstEmpleados!Nombre & " " &rstEmpleados!Apellidos & ", " & !País
.MoveNext
Loop
RstEmpleados.Close
End Function

15.34-Stretch
Aplicable a
Control Image

Devuelve o establece un valor que indica si un gráfico cambia su tamaño para ajustarse al de un control Image.

Sintaxis
objeto.Stretch [= booleano]

La sintaxis de la propiedad Stretch consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
Booleano Una expresión de tipo Boolean que especifica si el gráfico cambia su tamaño, como se describe en Valores.

Valores
Los valores admitidos para booleano son:
Valor Descripción
True El gráfico cambia de tamaño para ajustarse al del control.
False (Predeterminado) El control cambia de tamaño para ajustarse al del gráfico.

Comentarios
Si Stretch tiene el valor True, al cambiar el tamaño del control también se cambiará el del gráfico que contenga.

Ejemplo de la propiedad Stretch

Página 102 de 159


Curso Visual Basic 5.0

En este ejemplo se carga un icono de flecha de un directorio de iconos en un control Image. La flecha se arrastra por el
formulario cuando la propiedad Stretch tiene el valor True y salta por el formulario cuando la propiedad Stretch tiene
el valor False. Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario que contenga un
control Image, un control CheckBox y un control Timer, presione F5 y haga clic en el formulario. Asegúrese de
comprobar la ruta de acceso al directorio de iconos y cámbiela si es necesario. Para ver los distintos efectos de la
propiedad Stretch, haga clic en el control CheckBox y luego en el formulario.

Dim ImgW ' Declara una variable.


Private Sub Form_Load ()
' Carga un icono en el control Image.
Image1.Picture = LoadPicture("ICONS\ARROWS\ARW02RT.ICO")
Image1.Left = 0 ' Mueve la imagen al borde izquierdo.
ImgW = Image1.Width ' Guarda el ancho de la imagen.
Timer1.Interval = 300
Timer1.Enabled = False ' Deshabilita el cronómetro.
Check1.Caption = "Propiedad Stretch"
End Sub

Private Sub Form_Click ()


Timer1.Enabled = True ' Habilita el cronómetro.
End Sub

Private Sub Timer1_Timer ()


Static MoveIcon As Integer ' Indicador para desplazar el icono.
If Not MoveIcon Then
Image1.Move Image1.Left + ImgW, Image1.Top, ImgW * 2
Else
' Mueve la imagen y la devuelve a su ancho original.
Image1.Move Image1.Left + ImgW, Image1.Top, ImgW
End If
' Si la imagen está fuera del borde del formulario, empezar otra vez.
If Image1.Left > ScaleWidth Then
Image1.Left = 0
Timer1.Enabled = False
End If
MoveIcon = Not MoveIcon ' Restablece el indicador.
End Sub

Private Sub Check1_Click ()


Image1.Stretch = Check1.Value
End Sub

15.35-Style
Aplicable a
Control CheckBox, Control ComboBox, Control CommandButton, Control ListBox, Control OptionButton

Devuelve o establece un valor que indica el tipo de muestra y el comportamiento del control. Es de sólo lectura en
tiempo de ejecución.

Sintaxis
objeto.Style

Página 103 de 159


Curso Visual Basic 5.0

El marcador de posición objeto representa una expresión de objeto que da como resultado un objeto de la lista
Aplicable a.

Valores
Los valores de la propiedad Style para los controles Checkbox, CommandButton, y OptionButton son:
Constante Valor Descripción
vbButtonStandard 0 (Predeterminado) Estándar. El control aparece como en las versiones
anteriores de Visual Basic. Es decir, un control Checkbox aparece como
una casilla de verificación con una etiqueta a su lado, un control
OptionButton aparece como un botón de opción con una etiqueta a su
lado y un CommandButton como un CommandButton estándar sin un
gráfico asociado.
vbButtonGraphical 1 Gráfico. El control se muestra con un estilo gráfico. Es decir, un control
Checkbox se muestra como un botón de tipo CommandButton que se
puede soltar o presionar, un OptionButton aparece como un botón tipo
CommandButton que permanece suelto o presionado hasta que se
seleccione otro OptionButton de su grupo de opciones y un
CommandButton se muestra como un CommandButton estándar que
también puede mostrar un gráfico asociado.

Los valores de la propiedad Style para el control ComboBox son los siguientes:
Constante Valor Descripción
vbComboDropDown 0 (Predeterminado) Cuadro combinado desplegable. Incluye una
lista desplegable y un cuadro de texto. El usuario puede
seleccionar datos en la lista o escribir en el cuadro de texto.
VbComboSimple 1 Cuadro combinado simple. Incluye un cuadro de texto y una lista,
que no se despliega. El usuario puede seleccionar datos en la lista
o escribir en el cuadro de texto. El tamaño de un cuadro
combinado simple incluye las partes de edición y de lista. De
forma predeterminada, el tamaño de un cuadro combinado simple
no muestra ningún elemento de la lista. Incremente la propiedad
Height para mostrar más elementos de la lista.
vbComboDrop-DownList 2 Lista desplegable. Este estilo sólo permite la selección desde la
lista desplegable.

Los valores de la propiedad Style para el control ListBox son los siguientes:
Constante Valor Descripción
vbListBoxStandard 0 (Predeterminado) Estándar. El control ListBox se muestra como en las
versiones anteriores de Visual Basic. Es decir, como una lista de
elementos de texto.
vbListBoxCheckbox 1 Casilla de verificación. El control ListBox se muestra sin una marca de
verificación junto a cada elemento de texto. Es posible seleccionar
múltiples elementos del ListBox si activa la casilla de verificación que
hay junto a ellos.
Comentarios
Para decidir el valor que debe elegir para el control ComboBox, siga estas directrices:
• Utilice el valor 0 (cuadro combinado desplegable) ó 1 (cuadro combinado simple) para proporcionar al usuario una
lista de opciones. Los dos tipos permiten al usuario especificar una opción en el cuadro de texto. El valor 0 ahorra
espacio en el formulario, ya que la parte de lista se cierra cuando el usuario selecciona un elemento.
• Utilice el valor 2 (lista desplegable) para mostrar una lista fija de opciones entre las cuales el usuario pueda elegir
una. La parte de lista se cierra cuando el usuario selecciona un elemento.

Página 104 de 159


Curso Visual Basic 5.0

15.36-TabIndex
Aplicable a
Control CheckBox, Control ComboBox, Control CommandButton, Control Frame, Controles HScrollBar y VScrollBar,
Control Label, Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Devuelve o establece el orden de tabulación de la mayoría de los objetos dentro de su formulario.

Sintaxis
objeto.TabIndex [= índice]

La sintaxis de la propiedad TabIndex consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
índice Un número entero entre 0 y (n–1), donde n es el número de controles del formulario que tienen la propiedad
TabIndex. Al asignar a TabIndex un valor inferior a 0 se produce un error.

Comentarios

De forma predeterminada, Visual Basic asigna un orden de tabulación a los controles cuando se van agregando a un
formulario, con la excepción de los controles Menu, Timer, Data, Image, Line y Shape, que no se incluyen en el orden
de tabulación. En tiempo de ejecución, los controles invisibles o deshabilitados y los controles que no pueden recibir el
enfoque (controles Frame y Label) permanecen en el orden de tabulación pero se pasan por alto al tabular.
Cada control nuevo se sitúa el último en el orden de tabulación. Si modifica el valor de la propiedad TabIndex de un
control para cambiar el orden predeterminado, Visual Basic renumerará automáticamente la propiedad TabIndex de los
controles restantes para reflejar las inserciones y eliminaciones. Puede efectuar los cambios en tiempo de diseño
mediante la ventana propiedades o en tiempo de ejecución a través de código.
Nota El orden de tabulación de un control no afecta a su tecla de acceso asociada. Si presiona la tecla de acceso de un
control Frame o Label, el enfoque pasará al siguiente control del orden de tabulación que pueda recibir el enfoque.

Ejemplo de la propiedad TabIndex


En este ejemplo se invierte el orden de tabulación de un grupo de botones modificando la propiedad TabIndex de una
matriz de botones de comando. Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario
que contenga cuatro controles CommandButton. Establezca CommandX en la propiedad Name de cada botón para
crear la matriz de controles, y luego presione F5 y haga clic en el formulario para invertir su orden de tabulación.

Private Sub Form_Click ()


Dim I, X ' Declarar variables.
' Invertir el orden de tabulación estableciendo el valor inicial de X.
If CommandX(0).TabIndex = 0 Then X = 4 Else X = 1
For I = 0 To 3
CommandX(I).Caption = X ' Establecer el título.
CommandX(I).TabIndex = X - 1 ' Establecer el orden de tabulación.
If CommandX(0).TabIndex = 3 Then
X=X-1 ' Disminuir X.
Else
X=X+1 ' Incrementar X.
End If
Next I
End Sub

Página 105 de 159


Curso Visual Basic 5.0

15.37-TabStop
Aplicable a
Control CheckBox, Control ComboBox, Control CommandButton, Controles HScrollBar y VScrollBar, Control
ListBox, Control OptionButton, Control PictureBox, Control TextBox,

Devuelve o establece un valor que indica si el usuario puede utilizar la tecla TAB para llevar el enfoque a un objeto.

Sintaxis
objeto.TabStop [= booleano]

La sintaxis de la propiedad TabStop consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
Booleano Una expresión de tipo Boolean que especifica si el objeto es un tabulador, como se describe en Valores.

Valores
Los valores admitidos para booleano son:
Valor Descripción
True (Predeterminado) Designa el objeto como un tabulador.
False Hace que se salte el objeto en la tabulación, aunque el objeto mantiene su lugar en el orden de tabulación real,
determinado en la propiedad TabIndex.

Comentarios

Esta propiedad permite agregar o quitar un control del orden de tabulación de un formulario. Por ejemplo, si utiliza un
control PictureBox para dibujar un gráfico, establezca a False su propiedad TabStop para que el usuario no pueda
situarse en el control PictureBox.

15.38-Tag
Aplicable a
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form Control Frame,
Controles HScrollBar y VScrollBar, Control Image, Control Label, Control Line, Control ListBox, Control Menu,
Control OptionButton, Control PictureBox, Control Shape, Control TextBox, Control Timer.

Devuelve o establece una expresión que almacena cualquier dato adicional que necesite el programa. Al contrario de lo
que sucede con otras propiedades, Visual Basic no utiliza el valor de Tag. Puede utilizar esta propiedad para identificar
objetos.

Sintaxis
objeto.Tag [= expresión]

La sintaxis de la propiedad Tag consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
Expresión Una expresión de cadena que identifica el objeto. El valor predeterminado es una cadena de longitud cero ("").

Comentarios

Puede utilizar esta propiedad para asignar una cadena de identificación a un objeto sin afectar al resto de sus propiedades
ni causar efectos secundarios.

Página 106 de 159


Curso Visual Basic 5.0

Ejemplo de la propiedad Tag

En este ejemplo se muestra un icono único para cada control que se arrastra. Para probar este ejemplo, pegue el código
en la sección Declaraciones de un formulario que contenga tres controles PictureBox. Establezca a 1 la propiedad
DragMode de Picture1 y Picture2, y luego presione F5. Utilice el mouse para arrastrar Picture1 o Picture2 sobre
Picture3.

Private Sub Form_Load ()


Picture1.Tag = "ICONOS\FLECHAS\PUNTO03.ICO"
Picture2.Tag = "ICONOS\FLECHAS\PUNTO04.ICO"
End Sub

Private Sub Picture3_DragOver (Source As Control, X As Single, Y As Single, State As Integer)


If State = vbEnter Then
' Seleccionar en base a la propiedad Name de cada PictureBox.
Select Case Source.Name
Case "Picture1"
' Cargar el icono para Picture1.
Source.DragIcon = LoadPicture(Picture1.Tag)
Case "Picture2"
' Cargar el icono para Picture2.
Source.DragIcon = LoadPicture(Picture2.Tag)
End Select
ElseIf State = vbLeave Then
' Cuando el origen no está sobre Picture3, descargar el icono.
Source.DragIcon = LoadPicture()
End If
End Sub

15.39-Text
Aplicable a
Control ComboBox, Control ListBox, Control TextBox

• Control ComboBox (propiedad Style con el valor 0 [cuadro combinado desplegable] o 1 [cuadro combinado
simple]) y control TextBox: devuelve o establece el texto contenido en el área de edición.
• Control ComboBox (propiedad Style con el valor 2 [cuadro combinado desplegable]) y control ListBox: devuelve
el elemento seleccionado en el cuadro de lista; el valor de retorno es siempre equivalente al que devuelve la
expresión List(ListIndex). Es de sólo lectura en tiempo de diseño y es de sólo lectura en tiempo de ejecución.

Sintaxis
objeto.Text [= cadena]

La sintaxis de la propiedad Text consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
cadena Una expresión de cadena que especifica el texto.

Comentarios
Solamente en tiempo de diseño, los valores predeterminados de la propiedad Text son:
• Controles ComboBox y TextBox: la propiedad Name del control.
• Control ListBox: una cadena de longitud cero ("").

Página 107 de 159


Curso Visual Basic 5.0

En el caso de un control ComboBox con el valor 0 (cuadro combinado desplegable) o 1 (cuadro combinado simple) en
la propiedad Style, o para un control TextBox, esta propiedad es útil para leer la cadena real contenida en el área de
edición del control. Para un control ComboBox o ListBox con el valor 2 (lista desplegable) en la propiedad Style, puede
utilizar la propiedad Text para determinar el elemento seleccionado actualmente.
El valor de Text para un control TextBox está limitado a 2048 caracteres, a no ser que el valor de la propiedad
MultiLine sea True, en cuyo caso el límite es aproximadamente 32 KB.

Ejemplo de la Propiedad Texto

En este ejemplo se ilustra el uso de la propiedad Text. Para probar este ejemplo, pegue el código en la sección
Declaraciones de un formulario que contenga tres controles TextBox y un control CommandButton, presione F5 y
escriba texto en Text1.
Private Sub Text1_Change ()
Text2.Text = LCase(Text1.Text) ' Mostrar texto en minúsculas.
Text3.Text = UCase(Text1.Text) ' Mostrar texto en mayúsculas.
End Sub

Private Sub Command1_Click () ' Eliminar el texto.


Text1.Text = ""
End Sub

15.40-ToolTipText
Aplicable a
Objeto Button, Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Control Frame,
Control Image, Control Label, Control ListBox, Control OptionButton, Control PictureBox, Control TextBox.

Devuelve o establece Información sobre herramientas.

Sintaxis
objeto.ToolTipText [= cadena]

La sintaxis de la propiedad ToolTipText consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
cadena Una cadena asociada con un objeto de la lista Aplicable a que aparece durante un segundo aproximadamente en un
pequeño rectángulo debajo del objeto cuando el cursor del usuario pasa por encima del objeto en tiempo de ejecución.

Comentarios

Si usa únicamente una imagen para identificar un objeto, puede usar esta propiedad para explicar con pocas palabras
cada uno de esos objetos.
En tiempo de diseño puede establecer la cadena de la propiedad ToolTipText en el cuadro de diálogo de propiedades
del control.

15.41-Value
Aplicable a
Control CheckBox, Control CommandButton, Controles HScrollBar y VScrollBar, Control OptionButton

• Controles CheckBox y OptionButton: devuelve o establece el estado del control.


• Control CommandButton: devuelve o establece un valor que indica si se ha elegido el botón. No está disponible en
tiempo de diseño.

Página 108 de 159


Curso Visual Basic 5.0

• Controles HScrollBar y VScrollBar (barras de desplazamiento horizontal y vertical): devuelve o establece la


posición actual de la barra de desplazamiento, cuyo valor de retorno se encuentra siempre entre los valores de las
propiedades Max y Min, inclusive.

Sintaxis
objeto.Value [= valor]

La sintaxis de la propiedad Value consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
valor Un valor que especifica el estado, contenido o posición de un control, según se indica en Valores.

Valores
Los valores admitidos para valor son:
• Control CheckBox: 0 es desactivado (predeterminado), 1 es activado y 2 es atenuado.
• Control CommandButton: True indica que se ha elegido el botón y False (predeterminado) indica que no se ha
elegido. Al establecer a True la propiedad Value se invoca el evento Click del botón.
• Controles HScrollBar y VScrollBar: establece valores entre –32.768 y 32.767 para situar el cuadro de
desplazamiento.
• Control OptionButton: True indica que el botón está seleccionado y False (predeterminado) que no lo está.

Ejemplo de la propiedad Value

En este ejemplo se muestra el valor numérico de un control HScrollBar (barra de desplazamiento horizontal) en un
control TextBox. Para probar este ejemplo, pegue el código en la sección Declaraciones de un formulario que contenga
un control TextBox y un control HScrollBar. Presione F5 para ejecutar el programa y haga clic en la barra de
desplazamiento.

Private Sub Form_Load ()


HScroll1.Min = 0 ' Inicializar la barra de desplazamiento.
HScroll1.Max = 1000
HScroll1.LargeChange = 100
HScroll1.SmallChange = 1
End Sub

Private Sub HScroll1_Change ()


Text1.Text = Format (HScroll1.Value)
End Sub

15.42-Visible
Aplicable a
Control CheckBox, Control ComboBox, Control CommandButton, Control Data, Objeto Form Control Frame,
Controles HScrollBar y VScrollBar, Control Image, Control Label, Control Line, Control ListBox, Control
Menu, Control OptionButton, Control PictureBox, Control Shape, Control TextBox

Devuelve o establece un valor que indica si un objeto es visible o está oculto.

Sintaxis
objeto.Visible [= booleano]

La sintaxis de la propiedad Visible consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.

Página 109 de 159


Curso Visual Basic 5.0

Booleano Una expresión booleana que especifica si el objeto es visible o si está oculto.

Valores
Los valores admitidos para booleano son:
Valor Descripción
True (Predeterminado) El objeto es visible.
False El objeto está oculto.

Comentarios

Para ocultar un objeto al inicio, establezca la propiedad Visible a False en tiempo de diseño. Si establece esta propiedad
en el código puede ocultar y volver a mostrar posteriormente un control en tiempo de ejecución como respuesta a un
evento determinado.
Nota El uso del método Show o Hide en un formulario equivale a establecer True o False, respectivamente, en su
propiedad Visible a través del código.

Ejemplo de la propiedad Visible

En este ejemplo se crea una animación mediante dos controles PictureBox. Para probar este ejemplo, pegue el código
en la sección Declaraciones de un formulario que contenga dos controles PictureBox de tamaño de icono. Establezca a
FileCab la propiedad Name de los dos controles PictureBox para crear una matriz, presione F5 y haga clic en la imagen
para ver la animación.

Private Sub Form_Load ()


Dim I ' Declara la variable.
FileCab(0).BorderStyle = 0 ' Establecer BorderStyle.
FileCab(1).BorderStyle = 0
' Cargar los iconos en los cuadros de imagen.
FileCab(1).Picture = LoadPicture("ICONOS\OFFICE\ARCH03B.ICO")
FileCab(0).Picture = LoadPicture("ICONOS\OFFICE\ARCH03A.ICO")
For I = 0 To 1
FileCab(I).Move 400, 400 ' Colocar los gráficos en el mismo punto.
Next I
FileCab(1).Visible = False ' Establecer a invisible.
FileCab(0).Visible = True ' Establecer a visible.
End Sub

Private Sub FileCab_Click (Index As Integer)


Dim I ' Declarar variable.
For I = 0 To 1
' Cambiar la visibilidad para los dos gráficos.
FileCab(I).Visible = Not FileCab(I).Visible
Next I
End Sub

15.43-WindowState
Aplicable a
Objeto Form.

Devuelve o establece un valor que indica el estado visual de una ventana de formulario en tiempo de ejecución.

Sintaxis

Página 110 de 159


Curso Visual Basic 5.0

objeto.WindowState [= valor]

La sintaxis de la propiedad WindowState consta de las siguientes partes:


Parte Descripción
objeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.
valor Un número entero que especifica el estado del objeto, como se describe en Valores.

Valores
Los valores admitidos para valor son:
Constante Valor Descripción
vbNormal 0 (Predeterminado) Normal
VbMinimized 1 Minimizada (minimizada a un icono)
VbMaximized 2 Maximizada (ampliado al tamaño máximo)

Comentarios

Antes de mostrar un formulario, la propiedad WindowState tiene siempre el valor Normal (0), cualquiera que sea su
estado inicial. Esto se refleja en los valores de las propiedades Height, Left, ScaleHeight, ScaleWidth, Top y Width.
Si un formulario se oculta después de mostrarse, estas propiedades reflejarán el estado anterior hasta que se muestre de
nuevo el formulario, independientemente de los cambios que se hagan mientras tanto en la propiedad WindowState.

Ejemplo de la propiedad WindowState

En este ejemplo se oculta un cuadro de diálogo (Form2) cuando el formulario primario (Form1) se minimiza y se vuelve
a mostrar cuando el formulario primario vuelve al estado original o se maximiza. Para probar este ejemplo, pegue el
código en la sección Declaraciones de Form1 en una aplicación que contenga dos formularios. Presione F5 para iniciar
el ejemplo. Desplace Form1 de forma que pueda ver los dos formularios, minimice o maximice el formulario y observe
el comportamiento de Form2.

Private Sub Form_Load ()


Form2.Show ' Muestra Form2.
End Sub

Private Sub Form_Resize ()


' Si el primario está minimizado...
If Form1.WindowState = vbMinimized Then
' ... oculta Form2.
Form2.Visible = False
' Si el primario no está minimizado...
Else
' ... restaura Form2.
Form2.Visible = True
End If
End Sub

16- Operadores.

16.1-Operadores Aritméticos.
Operadores utilizados para ejecutar cálculos matemáticos.

Página 111 de 159


Curso Visual Basic 5.0

Operador ^: Se utiliza para elevar un número a la potencia del exponente.


resultado = número^exponente

Operador *: Se utiliza para multiplicar dos números.


resultado = número1*número2

Operador /: Se utiliza para dividir dos números y obtener un resultado de signo flotante.
resultado = número1/número2

Operador \: Se utiliza para dividir dos números y obtener un resultado entero.


resultado = número1\número2

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


resultado = número1 Mod número2

Operador +: Se utiliza para sumar dos números.


resultado = expresión1+expresión2

Operador -:Se utiliza para hallar la diferencia entre dos números o para indicar el valor negativo de una expresión
numérica.
resultado = número1-número2

16.2-Operadores de Comparación.
Operadores utilizados para efectuar comparaciones.

Se utilizan para comparar expresiones.


Sintaxis
resultado = expresión1 operadorcomparación expresión2
resultado = cadena Like patrón

Los operadores de comparación constan de las siguientes partes:


Parte Descripción
resultado Obligatorio; cualquier variable numérica.
expresión Obligatorio; cualquier expresión.
operadorcomparación Obligatorio; cualquier operador de comparación.
cadena Obligatorio; cualquier expresión de cadena.
patrón Obligatorio; cualquier expresión de cadena o intervalo de caracteres.

Operador Like:
Se utiliza para comparar dos cadenas de caracteres.
Sintaxis
resultado = cadena Like patrón

La sintaxis del operador Like consta de las siguientes partes:


Parte Descripción
Resultado Obligatorio; cualquier variable numérica.
cadena Obligatorio; cualquier expresión de cadena.
patrón Obligatorio; cualquier expresión de cadena que satisface las convenciones de coincidencia de patrones
descritas en Comentarios.

Comentarios

Página 112 de 159


Curso Visual Basic 5.0

Si cadena coincide con patrón, el resultado es True; si no coincide, el resultado es False. Si cadena o patrón es Null, el
resultado es también Null.
La función integrada de búsqueda de coincidencia de patrones ofrece una herramienta versátil para efectuar
comparaciones de cadenas. Las características de esta función permiten el empleo de caracteres comodín, listas de
caracteres o intervalos de caracteres en cualquier combinación para hallar coincidencias en cadenas. En la siguiente tabla
se indican los caracteres que se pueden poner en patrón y con qué coinciden los mismos:
? Un carácter cualquiera.
* Cero o más caracteres.
# Un dígito cualquiera (0–9).

16.3-Operadores de Concatenación.
Operadores utilizados para combinar cadenas de caracteres.
Operador &: Se utiliza para forzar la concatenación de las cadenas de dos expresiones.
resultado = expresión1 & expresión2

16.4-Operadores Lógicos.

Operadores usados para realizar operaciones lógicas.

Operador And:
Se utiliza para efectuar una conjunción lógica de dos expresiones.
resultado = expresión1 And expresión2

La sintaxis del operador And consta de las siguientes partes:


Parte Descripción
resultado Obligatorio; cualquier variable numérica.
expresión1 Obligatorio; cualquier expresión.
expresión2 Obligatorio; cualquier expresión.

Si y sólo si ambas expresiones se evalúan como True, el resultado es True. Si cualquiera de las expresiones es False, el
resultado es False. La siguiente tabla ilustra cómo se determina el resultado:

Operador Not: Se utiliza para ejecutar una negación lógica sobre una expresión.
resultado = Not expresión

Operador Or: Se utiliza para ejecutar una disyunción lógica sobre dos expresiones.
resultado = expresión1 Or expresión2

17- Funciones más importantes de Visual Basic.

17.1-Asc.
Devuelve un tipo Integer que representa el código de carácter correspondiente a la primera letra de una cadena.
Sintaxis
Asc(cadena)

El argumento obligatorio cadena es una expresión de cadena válida. Si cadena no contiene caracteres, se produce un
error en tiempo de ejecución.

Página 113 de 159


Curso Visual Basic 5.0

Ejemplo de la función Asc

En este ejemplo se utiliza la función Asc para devolver el código de carácter correspondiente a la primera letra de una
cadena de caracteres.

Dim MiNúmero
MiNúmero = Asc("A") ' Devuelve 65.
MiNúmero = Asc("a") ' Devuelve 97.
MiNúmero = Asc("Apple") ' Devuelve 65.

17.2-Date
Devuelve un tipo Variant (Date) que contiene la fecha actual del sistema.
Sintaxis
Date
Comentarios
Utilice la instrucción Date para establecer la fecha del sistema.

17.3-DateDiff
Devuelve un valor de tipo Variant (Long) que especifica el número de intervalos de tiempo entre dos fechas
determinadas.
Sintaxis
DateDiff(interval, date1, date2[, firstdayofweek[, firstweekofyear]])

La sintaxis de la función DateDiff consta de los siguientes argumentos con nombre:


Parte Descripción
interval Requerido. Expresión de tipo cadena con el intervalo de tiempo utilizado para calcular la
diferencia entre date1 y date2.
date1, date2 Se requiere; Variant (Date). Las dos fechas que se van a utilizar en el cálculo.
firstdayofweek Opcional. Constante que especifica el primer día de la semana. Si no se especifica, se asume
que es el domingo.
firstweekofyear Opcional. Constante, que especifica la primera semana del año. Si no se especifica, se
asume que es aquélla en la que se encuentre el 1 de enero.

Valores
El argumento interval toma los valores siguientes:
Intervalo Descripción
yyyy Año
q Trimestre
m Mes
y Día del año
d Día
w Día de la semana
ww Semana
h Hora
n Minuto
s Segundo

El argumento firstdayofweek toma los siguientes valores:


Constante Valor Descripción

Página 114 de 159


Curso Visual Basic 5.0

vbUseSystem 0 Utilice la configuración de la API de NLS.


vbSunday 1 Domingo (predeterminado)
vbMonday 2 Lunes
vbTuesday 3 Martes
vbWednesday 4 Miércoles
vbThursday 5 Jueves
vbFriday 6 Viernes
vbSaturday 7 Sábado

El argumento firstweekofyear toma los valores siguientes:


Constante Valor Descripción
vbUseSystem 0 Utilice la configuración de la API de NLS.
VbFirstJan1 1 Empieza con la semana en la que se encuentra el 1 de enero
(predeterminado).
VbFirstFourDays 2 Empieza con la primera semana que tenga al menos cuatro días en el
nuevo año.
VbFirstFullWeek 3 Empieza con la primera semana que esté completamente incluída en el
nuevo año.
Comentarios
Puede utilizar la función DateDiff para determinar el número de intervalos especificados que existen entre dos fechas.
Por ejemplo, con DateDiff podría calcular el número de días entre dos fechas o el número de semanas entre hoy y el
final del año.
Si desea saber el número de días entre date1 y date2, puede utilizar Día del año ("y") o Día ("d"). Cuando interval es
Día de la semana ("w"), DateDiff devuelve el número de semanas entre las dos fechas. Si date1 es lunes, DateDiff
contará el número de lunes hasta date2. En la cuenta incluirá date2, pero no date1. Si interval es Semana ("ww"), la
función DateDiff devolverá el número de semanas entre las dos fechas. En este caso contará el número de domingos
entre date1 y date2. DateDiff contará date2 si es domingo, pero no date1, aunque sea domingo.
Si date1 se refiere a un momento posterior en el tiempo a date2, la función DateDiff devolverá un número negativo.
El argumento firstdayofweek afecta a los cálculos que utilizan "w" y "ww" como símbolos de intervalo.
Si fecha1 o fecha2 es un literal de fecha, el año, si se especifica, pasará a ser una parte permanente de la fecha. Sin
embargo, si fecha1 o fecha2 está comprendida entre comillas dobles ("") y se omite el año, se insertará el año en curso
en el código cada vez que se evalúe la expresión fecha1 o fecha2. Así es posible escribir código que se pueda usar en
años distintos.
Cuando compara el 31 de diciembre con el 1 de enero del año siguiente, DateDiff para un año ("yyyy") devolverá 1
aunque sólo haya pasado un día.

17.4-DoEvents
Cede el control de la ejecución al sistema operativo, para que éste pueda procesar otros eventos.
Sintaxis
DoEvents( )
Comentarios
La función DoEvents devuelve un tipo Integer que representa el número de formularios abiertos por una versión
independiente de Visual Basic, como la de Visual Basic edición estándar. DoEvents devuelve 0 en el resto de las
aplicaciones.
La función DoEvents pasa el control al sistema operativo. El control no se devuelve hasta que el sistema operativo haya
terminado de procesar los eventos en cola y se hayan enviado todas las teclas de la cola SendKeys.
DoEvents es más útil para tareas sencillas como permitir que un usuario cancele un proceso después de que ha
comenzado, por ejemplo una búsqueda de un archivo.
Precaución Cuando dé preferencia al procesador temporalmente dentro de un procedimiento de evento, asegúrese de que
el procedimiento no se ejecute de nuevo desde una parte diferente del código antes de que devuelva la primera llamada.
Esto podría causar resultados impredecibles. Además, no utilice la función DoEvents si existe la posibilidad de que otras
aplicaciones interactúen con el procedimiento, de manera imprevista, durante el tiempo en que éste ha cedido el control.

Página 115 de 159


Curso Visual Basic 5.0

Ejemplo de la función DoEvents

En este ejemplo se utiliza la instrucción DoEvents para ceder el control de la ejecución al sistema operativo una vez
cada 1000 iteraciones del bucle. DoEvents devuelve el número de formularios de Visual Basic abiertos, sólo cuando la
aplicación principal es Visual Basic.
' Crea una variable para mantener el número de
' formularios de Visual Basic cargados y visibles

Dim I, OpenForms
For I = 1 To 150000 ' Inicia el bucle.
If I Mod 1000 = 0 Then ' Si el bucle se ejecuta 1000 veces.
OpenForms = DoEvents ' Cede el control al sistema operativo.
End If
Next I ' Incrementa el contador del bucle.

17.5-Format

Devuelve un tipo Variant (String) que contiene una expresión formateada de acuerdo a las instrucciones contenidas en
una expresión de formato.
Sintaxis
Format(expresión[, formato[, primerdíadesemana[, primerdíadeaño]]])

La sintaxis de la función Format consta de las siguientes partes:


Parte Descripción
expresión Obligatorio. Cualquier expresión válida.
formato Opcional. Una expresión de formato definida por el usuario o con nombre válida.
primerdíadesemana Opcional. Una constante que especifica el primer día de la semana.
primerdíadeñao Opcional. Una constante que especifica la primera semana del año.

Valores
El argumento primerdíadesemana tiene estos valores:
Constante Valor Descripción
vbUseSystem 0 Utiliza el valor de API NLS.
VbSunday 1 Domingo (predeterminado)
vbMonday 2 Lunes
vbTuesday 3 Martes
vbWednesday 4 Miércoles
vbThursday 5 Jueves
vbFriday 6 Viernes
vbSaturday 7 Sábado

El argumento primerdíadeaño tiene estos valores:


Constante Valor Descripción
vbUseSystem 0 Utiliza el valor de API NLS.
vbFirstJan1 1 Comienza con la semana donde está el 1 de enero (predeterminado).
vbFirstFourDays 2 Comienza con la primera semana del año que tenga cuatro días como
mínimo.
vbFirstFullWeek 3 Comienza con la primera semana completa del año.

Comentarios
Para dar formato a:

Números: Utilice formatos numéricos con nombre predefinidos o cree formatos numéricos definidos por el usuario.

Página 116 de 159


Curso Visual Basic 5.0

Fechas y horas: Utilice formatos de fecha/hora con nombre predefinidos o cree formatos de fecha/hora definidos por el
usuario.
Números seriales de fecha y hora: Utilice formatos de fecha y hora o formatos numéricos.
Cadenas : Cree sus propios formatos de cadena definidos por el usuario.

Ejemplo de la función Format


En este ejemplo se muestran varios usos de la función Format para dar formato a valores utilizando formatos definidos
por el usuario y formatos con nombre. La verdadera salida formateada presentada por el sistema para el separador de
fecha (/), de hora (:) y el literal AM/ PM depende de las configuraciones en ese momento. Cuando las horas y las fechas
se vuelven a listar en el entorno de desarrollo, se utilizan los formatos abreviados de hora y de fecha de la configuración
regional del código. Cuando son presentados por el código en ejecución, se utilizan los formatos abreviados de fecha y
hora de la configuración regional del sistema, los cuales pueden diferir de la configuración regional del código. En este
ejemplo se asume que es Inglés/Estados Unidos.
MiHora y MiFecha se presentan en el entorno de desarrollo utilizando configuraciones actuales de fecha corta y hora
corta.

Dim MiHora, MiFecha, MiCadena


MiHora = #17:04:23#
MiFecha = #27 enero 1993#

' Devuelve la hora actual del sistema en el formato largo de hora definido por el sistema.
MiCadena = Format(Time, "Long Time")

' Devuelve la fecha actual del sistema en el formato largo de fecha definido por el sistema.
MiCadena = Format(Date, "Long Date")

MiCadena = Format(MiHora, "h:m:s") ' Devuelve "17:4:23".


MiCadena = Format(MiHora, "hh:mm:ss AMPM") ' Devuelve "05:04:23 PM".
MiCadena = Format(MiFecha, "dddd, d mmm aaaa")' Devuelve "Miércoles,
' 27 de Ene de 1993".
' Si no se suministra el formato, devuelve una cadena.
MiCadena = Format(23) ' Devuelve "23".

' Formatos definidos por el usuario.


MiCadena = Format(5459.4, "##,##0.00") ' Devuelve "5.459,40".
MiCadena = Format(334.9, "###0.00") ' Devuelve "334,90".
MiCadena = Format(5, "0.00%") ' Devuelve "500,00%".
MiCadena = Format("HOLA", "<") ' Devuelve "hola".
MiCadena = Format("Esto es", ">") ' Devuelve "ESTO ES".

17.6-Iif
Devuelve uno de entre dos valores, dependiendo de la evaluación de una expresión.
Sintaxis
IIf(expr, truepart, falsepart)

La sintaxis de la función IIf cuenta con los siguientes argumentos con nombre:
Parte Descripción
expr Requerido. Expresión que se desea evaluar.
Truepart Requerido. Valor o expresión devuelta si expr es True.
falsepart Requerido. Valor o expresión devuelta si expr es False.

Comentarios

Página 117 de 159


Curso Visual Basic 5.0

IIf siempre evalúa truepart y falsepart, aunque sólo vaya a devolver una de ellas. Por esta razón, deberá vigilar que no
se produzcan efectos no deseados. Por ejemplo, si al evaluar falsepart se produce un error de división por cero, se
generará un error aunque expr sea True.

Ejemplo de la función IIf


Este ejemplo utiliza la función IIf para calcular el parámetro Prueba del procedimiento Comprobar y devuelve la palabra
"Grande" si la cantidad es mayor que 1000; de lo contrario, devuelve la palabra "Pequeño".

Function Comprobar (Prueba As Integer)


Comprobar = IIf(Prueba > 1000, "Grande", "Pequeño")
End Function

17.7-InputBox
Muestra un mensaje en un cuadro de diálogo, espera que el usuario escriba un texto o haga clic en un botón y devuelve
un tipo String con el contenido del cuadro de texto.
Sintaxis
InputBox(prompt[, title][, default][, xpos][, ypos][, helpfile, context])

La sintaxis de la función InputBox consta de estos argumentos con nombre:


-Prompt: Requerido. Expresión de cadena que se muestra como mensaje en el cuadro de diálogo. La longitud máxima de
prompt es de aproximadamente 1024 caracteres, según el ancho de los caracteres utilizados. Si prompt consta de más de
una línea, puede separarlos utilizando un carácter de retorno de carro (Chr(13)), un carácter de avance de línea (Chr(10)) o
una combinación de los caracteres de retorno de carro-avance de línea (Chr(13) y Chr(10)) entre cada línea y la siguiente.
-title: Opcional. Expresión de cadena que se muestra en la barra de título del cuadro de diálogo. Si omite title, en la barra de
título se coloca el nombre de la aplicación.
-default: Opcional. Expresión de cadena que se muestra en el cuadro de texto como respuesta predeterminada cuando no
se suministra una cadena. Si omite default, se muestra el cuadro de texto vacío.
-xpos: Opcional. Expresión numérica que especifica, en twips, la distancia en sentido horizontal entre el borde izquierdo
del cuadro de diálogo y el borde izquierdo de la pantalla. Si se omite xpos, el cuadro de diálogo se centra horizontalmente.
-ypos: Opcional. Expresión numérica que especifica, en twips, la distancia en sentido vertical entre el borde superior del
cuadro de diálogo y el borde superior de la pantalla. Si se omite ypos, el cuadro de diálogo se coloca a aproximadamente un
tercio de la altura de la pantalla, desde el borde superior de la misma.
-helpfile: Opcional. Expresión de cadena que identifica el archivo de Ayuda que se utilizará para proporcionar ayuda
interactiva para el cuadro de diálogo. Si se especifica helpfile, también deberá especificarse context.
-Context: Opcional. Expresión numérica que es el número de contexto de Ayuda asignado por el autor al tema de Ayuda
correspondiente. Si se especifica context, también deberá especificarse helpfile.

Comentarios
Cuando se especifica tanto helpfile como context, el usuario puede presionar F1 para ver el tema de Ayuda
correspondiente a context. Si el usuario hace clic en Aceptar o presiona ENTRAR, la función InputBox devuelve lo que
haya en el cuadro de texto. Si el usuario hace clic en Cancelar, la función devuelve una cadena de caracteres de longitud
cero ("").
Nota Si desea especificar más que el primer argumento con nombre, debe utilizar InputBox en una expresión. Si desea
omitir algunos argumentos de posición, debe incluir el delimitador de coma correspondiente.

Ejemplo de la función InputBox


En este ejemplo se muestran distintas maneras de utilizar la función InputBox para indicar al usuario que debe
introducir un valor. Si se omiten las posiciones x e y, el diálogo se centra automáticamente según los ejes respectivos. La
variable MyValue contiene el valor introducido por el usuario, si éste elige Aceptar o presiona ENTRAR. Si el usuario
elige Cancelar, se devuelve una cadena de caracteres de longitud cero.

Dim Mensaje, Título, ValorPred, MiValor


Mensaje = " Introduzca un número del 1 a 3" ' Establece el mensaje.

Página 118 de 159


Curso Visual Basic 5.0

Título = "Demostración de InputBox" ' Establece el título.


ValorPred = "1" ' Establece el valor predeterminado.
' Muestra el mensaje, el título, y el valor predeterminado.
MiValor = InputBox(Mensaje, Título, ValorPred)

' Muestra el mensaje, el título y el valor predeterminado.


MiValor = InputBox(Mensaje, Título, , , , "DEMO.HLP", 10)

' Se muestra el diálogo en la posición 100, 100.


MiValor = InputBox(Mensaje, Título, ValorPred, 100, 100)

17.8-Int, Fix
Devuelve un valor del mismo tipo que el que se pasó como parámetro y que contiene la parte entera de un número.
Sintaxis
Int(número)
Fix(número)

El argumento número es un tipo Double o cualquier expresión numérica válida. Si número contiene Null, la función
devolverá Null.

Comentarios
Las funciones Int y Fix eliminan la fracción de un número y devuelven el valor entero resultante.
La diferencia entre Int y Fix es que si el número es negativo, Int devuelve el primer entero negativo menor o igual a
número, mientras que Fix devuelve el primer entero negativo mayor o igual a número. Por ejemplo, Int convierte -8.4
en -9 y Fix convierte -8.4 a -8.
La función Fix(número) es equivalente a:
Sgn(número) * Int(Abs(número))

17.9-IsDate
Devuelve un valor de tipo Boolean que indica si una expresión se puede convertir en una fecha.
Sintaxis
IsDate(expresión)

El argumento expresión requerido, es un tipo de datos Variant que contiene una expresión de fecha o una expresión de
cadena reconocible como una fecha o una hora.

Comentarios
La función IsDate devuelve True si la expresión es una fecha o se puede convertir en una fecha válida; en caso
contrario, devuelve False. En Microsoft Windows, el intervalo de fechas válidas va desde el 1 de enero de 100 D.C.
hasta el 31 de diciembre de 9999 D.C; los intervalos varían de un sistema operativo a otro.

Ejemplo de la función IsDate


En este ejemplo se utiliza la función IsDate para determinar si una expresión puede convertirse en fecha.

Dim MiFecha, TuFecha, SinFecha, MiPrueba


MiFecha = "12 febrero 1969": TuFecha = #2/12/69#: SinFecha = "Hola"
MiPrueba = IsDate(MiFecha) ' Devuelve True.
MiPrueba = IsDate(TuFecha) ' Devuelve True.
MiPrueba = IsDate(SinFecha) ' Devuelve False.

Página 119 de 159


Curso Visual Basic 5.0

17.10-IsNull

Devuelve un valor de tipo Boolean que indica si una expresión contiene datos no válidos (Null).

Sintaxis
IsNull(expresión)

El argumento expresión requerido, es un tipo de datos Variant que contiene una expresión numérica o una expresión de
cadena.

Comentarios
La función IsNull devuelve True si expresión es Null; en cualquier otro caso, IsNull devuelve False. Si expresión está
formada por más de una variable, la presencia de Null en cualquier variable hace que se devuelva True para toda la
expresión.
El valor Null indica que Variant contiene datos no válidos. La función Null no es la misma que la función Empty, la
cual indica que una variable todavía no ha sido inicializada. Tampoco es lo mismo que una cadena de longitud cero (""),
que a veces se suele llamar cadena nula.
Importante Utilice la función IsNull para determinar si una expresión contiene un valor Null. Las expresiones que
espera evaluar como True en ciertas circunstancias, tales como If Var = Null AND If Var <> Null, son siempre False.
Esto se debe a que cualquier expresión que contiene un Null es por si misma de valor Null y por consiguiente False.

Ejemplo de la función IsNull


En este ejemplo se utiliza la función IsNull para determinar si una variable contiene Null.

Dim MiVar, MiPrueba


MiPrueba = IsNull(MiVar) ' Devuelve False.

MiVar = ""
MiPrueba = IsNull(MiVar) ' Devuelve False.

MiVar = Null
MiPrueba = IsNull(MiVar) ' Devuelve True.

17.11-Left

Devuelve un tipo Variant (String) que contiene un número especificado de caracteres del lado izquierdo de una cadena.

Sintaxis
Left(string, length)

La sintaxis de la función Left tiene estos argumentos con nombre:


Parte Descripción
string Obligatorio. Expresión de cadena de la cual se devuelven los caracteres que están más a la izquierda.
Si string contiene Null, se devuelve Null.
length Se requiere, un tipo Variant (Long). Expresión numérica que indica cuántos caracteres se van a
devolver. Si es 0, devuelve una cadena de longitud cero (""). Si es mayor o igual al número de
caracteres en string, se devuelve la cadena entera.

Comentarios

Página 120 de 159


Curso Visual Basic 5.0

Para determinar el número de caracteres en string, utilice la función Len.

Ejemplo de la función Left


En este ejemplo se utiliza la función Left para devolver un número especificado de caracteres del lado izquierdo de una
cadena.

Dim UnaCadena, MiCadena


UnaCadena = "Hola Mundo" ' Define la cadena.
MiCadena = Left(UnaCadena, 1) ' Devuelve "H".
MiCadena = Left(UnaCadena, 6) ' Devuelve "Hola M".
MiCadena = Left(UnaCadena, 10) ' Devuelve "Hola Mundo".

17.12-Len
Devuelve un tipo Long que contiene el número de caracteres en una cadena o el número de bytes necesarios para
almacenar una variable.

Sintaxis
Len(cadena | nombrevar)

La sintaxis de la función Len consta de las siguientes partes:


Parte Descripción
cadena Cualquier expresión de cadena válida. Si cadena contiene Null, se devuelve Null.
Nombrevar Cualquier nombre de variable válido. Si nombrevar contiene Null, se devuelve Null. Si
nombrevar es un tipo Variant, Len actúa igual que con un tipo String y siempre devuelve
el número de caracteres que contiene.

Comentarios
Se deben especificar uno (y sólo uno) de los dos argumentos posibles.

Ejemplo de la función Len


En este ejemplo se utiliza la función Len para devolver el número de caracteres en una cadena o el número de bytes
requeridos para almacenar una variable.

Dim MiEntero As Integer, MyCur As Currency


Dim MiCadena, MiLong
MiCadena = "Hola a todos" ' Inicializa la cadenas.
MiLong = Len(MiEntero) ' Devuelve 2.
MiLong = Len(MiCadena) ' Devuelve 11.
MiLong = Len(MyCur) ' Devuelve 8.

17.13-LoadPicture
Carga un gráfico en un control PictureBox o un control Image.

Sintaxis
LoadPicture([expresión_cadena])

El marcador de posición expresión_cadena es el nombre del archivo gráfico que se quiere cargar.

Página 121 de 159


Curso Visual Basic 5.0

Comentarios
Los formatos gráficos reconocidos por Visual Basic incluyen archivos de mapas de bits (.BMP), archivos de iconos
(.ICO), archivos de longitud codificada (.RLE), metarchivos (.WMF), metarchivos mejorados (.EMF), archivos GIF y
archivos JPEG (.JPG).
Es posible limpiar los gráficos de formularios, cuadros de imagen y controles de imagen si asigna LoadPicture sin
argumentos.
Para cargar gráficos para presentarlos en un control PictureBox, en un control Image o como fondo de un formulario, el
valor devuelto por LoadPicture debe asignarse a la propiedad Picture del objeto en el que se quiere presentar la
imagen. Por ejemplo:
Image1.Picture = LoadPicture("FIESTA.BMP")

Para asignar un icono a un formulario, establezca el valor devuelto por la función LoadPicture a la propiedad Icon del
objeto Form:
Set Form1.Icon = LoadPicture("MIICONO.ICO")

Ejemplo de la función LoadPicture


Este ejemplo usa la función LoadPicture para cargar una imagen en la propiedad Picture de un formulario y para borrar
la imagen del objeto Form. Para probar este ejemplo, pegue el código en la sección Declaraciones de un objeto Form y
después ejecute el ejemplo y haga clic en el objeto Form.

Private Sub Form_Click ()


Dim Msg as String ' Declara variables.
On Error Resume Next ' Establece el tratamiento de errores.
Height = 3990
Width = 4890 ' Define el alto y el ancho.
Set Picture = LoadPicture("PAPEL.BMP")
' Carga un mapa de bits.
If Err Then
Msg = "Imposible encontrar el archivo .BMP."
MsgBox Msg ' Presenta el mensaje de error.
Exit Sub ' Sale si hay error.
End If
Msg = "Elija "Aceptar" para borrar el mapa de bits del formulario."
MsgBox Msg
Set Picture = LoadPicture() ' Limpia el formulario.
End Sub

17.14-Ltrim, Rtrim y Trim

Devuelve un tipo Variant (String) que contiene una copia de una cadena determinada sin espacios a la izquierda
(LTrim), sin espacios a la derecha (RTrim) o sin espacios ni a la derecha ni a la izquierda (Trim).

Sintaxis
LTrim(cadena)
RTrim(cadena)
Trim(cadena)

El argumento cadena obligatorio es cualquier expresión de cadena válida. Si cadena contiene Null, se devuelve Null.

Ejemplo de las funciones LTrim, RTrim y Trim


En este ejemplo se utilizan las funciones LTrim and RTrim para eliminar espacios a la derecha y a la izquierda de una
variable de cadena de caracteres. El uso de la función Trim logra el mismo resultado.

Página 122 de 159


Curso Visual Basic 5.0

Dim MiCadena, CadenaCorte


MiCadena = " <-Cortar-> " ' Inicializa la cadena.
CadenaCorte = LTrim(MiCadena) ' CadenaCorte = "<-Cortar-> ".
CadenaCorte = RTrim(MiCadena) ' CadenaCorte = " <-Cortar->".
CadenaCorte = LTrim(RTrim(MiCadena)) ' CadenaCorte = "<-Cortar->".
' El uso de la función Trim por sí sola logra el mismo resultado.
CadenaCorte = Trim(MiCadena) ' CadenaCorte = "<-Cortar->".

17.15-Mid
Devuelve un tipo Variant (String) que contiene un número especificado de caracteres de una cadena.

Sintaxis
Mid(string, start[, length])

La sintaxis de la función Mid tiene estos argumentos con nombre:


Parte Descripción
string Obligatorio. Expresión de cadena de la cual se devuelven los caracteres. Si string contiene Null, se
devuelve Null.
start Obligatorio; un tipo Long. Posición de carácter en string en la cual comienza la parte que se quiere
tomar. Si start es mayor que el número de caracteres en la string, Mid devuelve una cadena de
longitud cero ("").
length Opcional, un tipo Variant (Long). Número de caracteres que se van a devolver. Si se omite o en el
texto hay menos de length caracteres (incluyendo el carácter de start), se devuelven todos los
caracteres desde la posición de start hasta el final de la cadena.

Comentarios
Para determinar el número de caracteres en string, utilice la función Len.

Ejemplo de la función Mid


En este ejemplo se utiliza la función Mid para devolver un número especificado de caracteres de una cadena.

Dim MiCadena, PrimeraPalabra, UltimaPalabra, PalabraMedia


MiCadena = "Demostración función Mid" ' Crea la cadena de texto.
PrimeraPalabra = Mid(MiCadena, 1, 12) ' Devuelve "Demostración".
UltimaPalabra = Mid(MiCadena, 21, 3) ' Devuelve "Mid".
PalabraMedia = Mid(MiCadena, 14) ' Devuelve "función Mid".

17.16-MsgBox
Muestra un mensaje en un cuadro de diálogo, espera a que el usuario haga clic en un botón y devuelve un tipo Integer
correspondiente al botón elegido por el usuario.

Sintaxis
MsgBox(prompt[, buttons][, title][, helpfile, context])

La sintaxis de la función MsgBox consta de estos argumentos con nombre:


Parte
-prompt: Requerido. Expresión de cadena que representa el prompt en el cuadro de diálogo. La longitud máxima de prompt
es de aproximadamente 1024 caracteres, según el ancho de los caracteres utilizados. Si prompt consta de más de una línea,

Página 123 de 159


Curso Visual Basic 5.0

puede separarlos utilizando un carácter de retorno de carro (Chr(13)) o un carácter de avance de línea (Chr(10)), o una
combinación de caracteres de retorno de carro-avance de línea (Chr(13) y Chr(10)) entre cada línea y la siguiente.
-buttons: Opcional. Expresión numérica que corresponde a la suma de los valores que especifican el número y el tipo de
los botones que se pretenden mostrar, el estilo de icono que se va a utilizar, la identidad del botón predeterminado y la
modalidad del cuadro de mensajes. Si se omite este argumento, el valor predeterminado para buttons es 0.
-title: Opcional. Expresión de cadena que se muestra en la barra de título del cuadro de diálogo. Si se omite title, en la barra
de título se coloca el nombre de la aplicación.
-helpfile: Opcional. Expresión de cadena que identifica el archivo de Ayuda que se utiliza para proporcionar ayuda
interactiva en el cuadro de diálogo. Si se especifica helpfile, también se debe especificar context.
-context: Opcional. Expresión numérica que es igual al número de contexto de Ayuda asignado por el autor al tema de
Ayuda correspondiente. Si se especifica context, también se debe especificar helpfile.

Valores
El argumento buttons tiene estos valores:
Constante Valor Descripción
vbOKOnly 0 Muestra solamente el botón Aceptar.
VbOKCancel 1 Muestra los botones Aceptar y Cancelar.
VbAbortRetryIgnore 2 Muestra los botones Anular, Reintentar e Ignorar.
VbYesNoCancel 3 Muestra los botones Sí, No y Cancelar.
VbYesNo 4 Muestra los botones Sí y No.
VbRetryCancel 5 Muestra los botones Reintentar y Cancelar.
VbCritical 16 Muestra el icono de mensaje crítico.
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.
VbDefaultButton1 0 El primer botón es el predeterminado.
VbDefaultButton2 256 El segundo botón es el predeterminado.
VbDefaultButton3 512 El tercer botón es el predeterminado.
VbDefaultButton4 768 El cuarto botón es el predeterminado.
VbApplicationModal 0 Aplicación modal; el usuario debe responder al cuadro de mensajes antes
de poder seguir trabajando en la aplicación actual.
VbSystemModal 4096 Sistema modal; se suspenden todas las aplicaciones hasta que el usuario
responda al cuadro de mensajes.

El primer grupo de valores (0 a 5) describe el número y el tipo de los botones mostrados en el cuadro de diálogo; el
segundo grupo (16, 32, 48, 64) describe el estilo del icono, el tercer grupo (0, 256, 512) determina el botón
predeterminado y el cuarto grupo (0, 4096) determina la modalidad del cuadro de mensajes. Cuando se suman números
para obtener el valor final del argumento buttons, se utiliza solamente un número de cada grupo.
Nota Estas constantes las especifica Visual Basic for Applications. Por tanto, el nombre de las mismas puede utilizarse
en cualquier lugar del código en vez de sus valores reales.

Valores devueltos
Constante Valor Descripción
vbOK 1 Aceptar
vbCancel 2 Cancelar
vbAbort 3 Anular
vbRetry 4 Reintentar
vbIgnore 5 Ignorar
vbYes 6 Sí
vbNo 7 No

Comentarios
Cuando se proporcionan tanto helpfile como context, el usuario puede presionar F1 para ver el tema de Ayuda
correspondiente al context.

Página 124 de 159


Curso Visual Basic 5.0

Si el cuadro de diálogo cuenta con un botón Cancelar, presionar la tecla ESC tendrá el mismo efecto que hacer clic en
este botón. Si el cuadro de diálogo contiene un botón Ayuda, se suministra ayuda interactiva para ese cuadro de diálogo.
Sin embargo, no se devuelve valor alguno hasta que se hace clic en uno de estos botones.
Nota Si desea especificar más que el primer argumento con nombre, debe utilizar MsgBox en una expresión. Si desea
omitir algún argumento de posición, debe incluir el delimitador de coma correspondiente.

Ejemplo de la función MsgBox


En este ejemplo se utiliza la función MsgBox para mostrar un mensaje de error crítico en un cuadro de diálogo con
botones Sí y No. El botón No se considera la respuesta predeterminada. El valor devuelto por la función MsgBox
depende del botón elegido por el usuario. En este ejemplo, se supone que DEMO.HLP es un archivo de Ayuda que
contiene un tema con un número de contexto igual a 1000.

Dim Mensaje, Estilo, Título, Ayuda, Ctxt, Respuesta, MiCadena


Mensaje = "¿Desea continuar?" ' Define el mensaje.
Estilo = vbYesNo + vbCritical + vbDefaultButton2 ' Define los botones.
Título = "Demostración de MsgBox" ' Define el título.
Ayuda = "DEMO.HLP" ' Define el archivo de ayuda.
Ctxt = 1000 ' Define el tema
Respuesta = MsgBox(Mensaje, Estilo, Título, Ayuda, Ctxt)
If Respuesta = vbYes Then ' El usuario eligió el botón Sí.
MiCadena = "Sí" ' Ejecuta una acción.
Else ' El usuario eligió el botón No.
MiCadena = "No" ' Ejecuta una acción.
End If

17.17-Right
Devuelve un tipo Variant (String) que contiene un número especificado de caracteres del lado derecho de una cadena.

Sintaxis
Right(string, lenght)

La sintaxis de la función Right tiene estos argumentos con nombre:


Parte Descripción
String Obligatorio. Expresión de cadena desde la cual se devuelven los caracteres que están más a la
derecha. Si string contiene Null, se devuelve Null.
lenght Se requiere, un tipo Variant (Long). Expresión numérica que indica cuántos caracteres se van a
devolver. Si es 0, se devuelve una cadena de longitud cero (""). Si es mayor o igual al número de
caracteres en string, se devuelve la cadena completa.

Comentarios
Para determinar el número de caracteres en string, utilice la función Len.

Ejemplo de la función Right


En este ejemplo se utiliza la función Right para devolver un número especificado de caracteres de la parte derecha de la
cadena.

Dim UnaCadena, MiCadena


UnaCadena = "Hola Mundo" ' Define una cadena.
MiCadena = Right(UnaCadena, 1) ' Devuelve "o".
MiCadena = Right(UnaCadena, 6) ' Devuelve "Mundo".
MiCadena = Right(UnaCadena, 20) ' ' Devuelve "Hola Mundo".

Página 125 de 159


Curso Visual Basic 5.0

17.18-Str
Devuelve en un tipo Variant (String) la representación de cadena de un número.

Sintaxis
Str(número)

El argumento número necesario es un tipo Long que contiene una expresión numérica válida.

Comentarios
Cuando los números se convierten a cadenas, siempre se reserva un espacio a la izquierda para el signo del número. Si
número es positivo, la cadena devuelta contiene un espacio a la izquierda y el signo más se da por supuesto.
Utilice la función Format para convertir valores numéricos en valores con formato de fecha, hora, moneda o en otros
formatos definidos por el usuario. A diferencia de Str, la función Format no incluye un espacio a la izquierda para el
signo del número.
Nota La función Str sólo reconoce el punto (.) como separador decimal válido.

Ejemplo de la función Str


En este ejemplo se utiliza Str para devolver una representación de cadena de un número. Cuando un número se
convierte en una cadena siempre se reserva un espacio a la izquierda para el signo.

Dim MiCadena
MiCadena = Str(459) ' Devuelve " 459".
MiCadena = Str(-459.65) ' Devuelve "-459,65".
MiCadena = Str(459.001) ' Devuelve " 459,001".

17.19-Ucase

Devuelve un tipo Variant (String) que contiene una cadena especificada que se ha convertido a mayúsculas.

Sintaxis
UCase(cadena)

El argumento cadena necesario es cualquier expresión de cadena válida. Si string contiene Null, se devuelve Null.

Comentarios
Sólo se convierten a mayúsculas las letras minúsculas. Las letras mayúsculas o los caracteres que no son letras no sufren
cambios.

Ejemplo de la función UCase


En este ejemplo se utiliza la función UCase para devolver la versión en mayúsculas de una cadena.

Dim LowerCase, UpperCase


LowerCase = "Hola Mundo 1234" ' Cadena a convertir.
UpperCase = UCase(LowerCase) ' Devuelve "HOLA MUNDO 1234".

17.20-Val
Devuelve los números contenidos en una cadena como un valor numérico del tipo adecuado.

Página 126 de 159


Curso Visual Basic 5.0

Sintaxis
Val(cadena)

El argumento obligatorio cadena es cualquier expresión de cadena válida.

Comentarios
La función Val deja de leer la cadena en el primer carácter que no puede reconocer como parte de un número. Los
símbolos y caracteres que se consideran a menudo parte de valores numéricos, como signos de moneda y comas, no se
reconocen. Sin embargo, la función reconoce los prefijos de base &O (para octal) y &H (para hexadecimal). Los
espacios en blanco, los tabuladores y los avances de línea se eliminan del argumento.
Lo siguiente devuelve el valor 1615198:

Val(" 1615 198 Calle N.E.")

En el código que se muestra a continuación, Val devuelve el valor decimal -1 correspondiente al valor hexadecimal
entre paréntesis:
Val("&HFFFF")

Nota La función Val sólo reconoce el punto (.) como separador decimal válido.

Ejemplo de la función Val


En este ejemplo se utiliza la función Val para devolver los números contenidos en una cadena.

Dim MiValor
MiValor = Val("2457") ' Devuelve 2457.
MiValor = Val(" 2 45 7") ' Devuelve 2457.
MiValor = Val("24 y 57") ' Devuelve 24.

18- Instrucciones más usadas en Visual Basic.


2.10.1-FileCopy.
Copia un archivo.

Sintaxis
FileCopy origen, destino

La sintaxis de la instrucción FileCopy consta de los siguientes argumentos con nombre:


Parte Descripción
origen Requerido. Expresión de cadena que especifica el nombre de un archivo que se va a copiar. El origen puede
incluir el directorio o carpeta y la unidad de disco.
Destino Requerido. Expresión de cadena que especifica el nombre del archivo de destino. Puede incluir el directorio o
carpeta y la unidad de disco.

Comentarios
Si intenta utilizar la instrucción FileCopy en un archivo abierto actualmente, se producirá un error.
Ejemplo de la instrucción FileCopy
En este ejemplo se utiliza la instrucción FileCopy para copiar un archivo en otro. Se supone que ARCHORIG es un
archivo que contiene información.

Dim ArchOrigen, ArchDestino


ArchOrigen = "ARCHORIG" ' Se define el nombre del archivo de origen.
ArchDestino = "ARCHDEST" ' Se define el nombre del archivo de origen.

Página 127 de 159


Curso Visual Basic 5.0

File Copy ArchOrigen, ArchDestino ' Se copia el archivo de origen en el archivo de destino.

2.10.2-Kill
Elimina archivos del disco.

Sintaxis
Kill nombre_ruta

El argumento requerido nombre_ruta es una expresión de cadena que especifica uno o más nombres de archivos que se
van a eliminar. Puede incluir el directorio o carpeta y la unidad de disco.

Comentarios
La función Kill permite el uso de los caracteres comodín '*' (múltiples caracteres) y '?' (un solo carácter) para especificar
varios archivos.
Se producirá un error si intenta usar la instrucción Kill para eliminar un archivo abierto.
Nota Para eliminar directorios, utilice la instrucción RmDir.

Ejemplo de la instrucción Kill


En este ejemplo se utiliza la instrucción Kill para borrar un archivo de un disco.

' Se supone que PRUEBA es un archivo que contiene información.


Kill "PRUEBA" ' Se elimina el archivo.

' En Microsoft Windows:


' Se eliminan todos los archivos *.TXT del directorio actual.
Kill "*.TXT"

2.10.3-MkDir

Crea un directorio o carpeta.

Sintaxis
MkDir ruta

El argumento requerido ruta es una expresión de cadena que identifica el directorio o carpeta que se va a crear. Puede
incluir la unidad de disco. Si no se especifica la unidad de disco, la instrucción MkDir crea el directorio o carpeta en la
unidad de disco actual.

Ejemplo de la instrucción MkDir


En este ejemplo se utiliza la instrucción MkDir para crear un directorio o una carpeta. Si no se especifica la unidad de
disco, el directorio o carpeta se crea en la unidad actual.

MkDir "MIDIR" ' Se crea el directorio o la carpeta.

2.10.4-On Error.

Activa una rutina de control de errores y especifica la ubicación de la misma en un procedimiento; también puede
utilizarse para desactivar una rutina de control de errores.

Sintaxis
On Error GoTo línea
On Error Resume Next

Página 128 de 159


Curso Visual Basic 5.0

On Error GoTo 0

La sintaxis de la instrucción On Error puede tener cualquiera de los formatos siguientes:


Instrucción:
-On Error GoTo línea: Activa la rutina de control de errores que comienza en la línea especificada en el argumento
necesario línea. El argumento línea es cualquier etiqueta de línea o número de línea. Si se produce un error en tiempo de
ejecución, el control pasa a línea, activando el controlador de errores. La línea especificada en el argumento línea debe
encontrarse en el mismo procedimiento que la instrucción On Error; o de lo contrario, se producirá un error en tiempo de
compilación.
-On Error Resume Next: Especifica que, en caso de que se produzca un error en tiempo de ejecución, el control pase a la
instrucción que sigue inmediatamente a aquélla en la que se ha producido el error, donde continúa la ejecución.
-On Error GoTo 0: Desactiva cualquier controlador de errores del procedimiento actual.

Comentarios
Si no utiliza una instrucción On Error, cualquier error en tiempo de ejecución que se produzca será fatal; es decir,
aparecerá un mensaje de error y la ejecución se detendrá.
Nota Una rutina de control de errores no es un procedimiento Sub ni Function,. Es una sección de código marcada con
una etiqueta o un número de línea.

Las rutinas de control de errores se basan en el valor de la propiedad Number del objeto Err para determinar la causa
del error. Una rutina de control de errores debe comprobar y guardar los valores de las propiedades del objeto Err antes
de que pueda producirse otro error o antes de que se llame a un procedimiento que pueda causarlo. Los valores de las
propiedades del objeto Err reflejan solamente el error más reciente. El mensaje de error asociado a Err.Number se
encuentra en Err.Description.
On Error Resume Next hace que la ejecución continúe en la instrucción que sigue inmediatamente a la que causó el
error en tiempo de ejecución, o en la que sigue inmediatamente a la última llamada desde el procedimiento que contiene
la instrucción On Error Resume Next. Esta instrucción permite continuar la ejecución a pesar de que se haya producido
un error en tiempo de ejecución.. Puede colocar la rutina de control de errores donde se produciría el error, en vez de
transferir el control a otra posición dentro del procedimiento. La instrucción On Error Resume Next pasa a estar
inactiva cuando se llama a otro procedimiento, por tanto usted debe ejecutar una instrucción On Error Resume Next en
cada rutina que llamada si desea un control de errores integrado dentro de la propia rutina.
On Error GoTo 0 desactiva el control de errores en el procedimiento actual. No especifica la línea 0 como el inicio del
código de control de errores, ni siquiera cuando el procedimiento contiene una línea con el número 0. Sin una
instrucción On Error GoTo 0, el control de errores se desactiva automáticamente al salir del procedimiento.
Para evitar que el código de control de errores se ejecute cuando no se ha producido ningún error, coloque una
instrucción Exit Sub o Exit Function inmediatamente antes de la rutina de control de errores, como en el ejemplo
siguiente:

Sub InicializarMatriz(Var1, Var2, Var3, Var4)


On Error GoTo ControlErrores
...
Exit Sub
ControlErrores:
...
Resume Next
End Sub

Aquí, el código de control de errores viene a continuación de la instrucción Exit Sub y precede a End Sub para
separarlo del flujo normal del procedimiento. El código de control de errores puede situarse en cualquier lugar del
procedimiento.

Ejemplo de la instrucción On Error


Este ejemplo utiliza primero la instrucción On Error GoTo para especificar la ubicación de una rutina de control de
errores dentro de un procedimiento. En el ejemplo, un intento de eliminar un archivo abierto genera el error número 55.
El error se controla en la rutina de manejo de errores y a continuación se devuelve el control a la instrucción que

Página 129 de 159


Curso Visual Basic 5.0

provocó el error. La instrucción On Error GoTo 0 desactiva la detección de errores. A continuación se utiliza la
instrucción On Error Resume Next para retardar la detección de errores de forma que se pueda conocer con total
seguridad el contexto para el error generado por la instrucción posterior. Observe que Err.Clear se utiliza para borrar
las propiedades del objeto Err después de tratar el error.

Sub DemoInstrucOnError()
On Error GoTo ControlError ' Activa la rutina de control de errores.
Open "PRUEBA" For Output As #1 ' Abre archivo para salida.
Kill "PRUEBA" ' Intenta eliminar el archivo
' abierto.
On Error Goto 0 ' Desactiva la detección de errores.
On Error Resume Next ' Retarda detección de errores.
RefObjeto = GetObject("MiWord.Basic") ' Intenta
' iniciar un objeto que no existe, después
' comprueba errores de Automatización.
If Err.Number = 440 Or Err.Number = 432 Then
' Indica al usuario lo que ha ocurrido. Luego borra el objeto Err.
Msg = "¡Se produjo un error al intentar abrir el objeto Automatización!"
MsgBox Msg, , "Prueba de error retardada"
Err.Clear ' Borra campos del objeto Err
End If
Exit Sub ' Salir para evitar el controlador.
ControlError: ' Rutina de control de errores.
Select Case Err.Number ' Evalúa el número de error.
Case 55 ' Error "Archivo ya está abierto".
Close #1' Cierra el archivo abierto.
Case Else
' Puede incluir aquí otras situaciones...
End Select
Resume ' Continuar ejecución en la línea que
' causó el error.
End Sub

2.10.5-Option Explicit

Se usa en el nivel de módulo para forzar declaraciones explícitas de todas las variables en ese módulo.

Sintaxis
Option Explicit

Comentarios
Si se usa, la instrucción Option Explicit debe aparecer en un módulo antes de cualquier procedimiento.
Cuando Option Explicit aparece en un módulo, debe declarar explícitamente todas las variables mediante las
instrucciones Dim, Private, Public, ReDim o Static. Si intenta usar un nombre de variable no declarado, ocurrirá un
error en tiempo de compilación.
Nota Utilice Option Explicit para evitar escribir incorrectamente el nombre de una variable existente o para evitar
confusiones en el código, donde el alcance de la variable no está claro.

Ejemplo de la instrucción Option Explicit


En este ejemplo se utiliza la instrucción Option Explicit para forzar la declaración explícita de todas las variables. Si se
intenta utilizar una variable no declarada se obtiene un error en el tiempo de compilación. La instrucción Option
Explicit sólo se utiliza en el nivel de módulo.

Option Explicit ' Fuerza la declaración explícita de variables.


Dim MiVar ' Declara la variable.
MiEnt = 10 ' La variable no declarada genera un error.

Página 130 de 159


Curso Visual Basic 5.0

MiVar = 10 ' La variable declarada no generará error.

2.10.6-SendKeys
Envía una o más pulsaciones de teclas a la ventana activa, como si se hubieran presionado desde el teclado.

Sintaxis
SendKeys string[, wait]

La sintaxis de la instrucción SendKeys consta de estos argumentos con nombre:


Parte Descripción
string Requerido. Expresión de cadena que especifica las pulsaciones de teclas que se van a enviar.
wait Opcional. Valor Boolean que indica el modo de espera. Si este valor es False (predeterminado), se devuelve el
control al procedimiento inmediatamente después de enviar las pulsaciones. Si es True, se procesan las pulsaciones antes
de devolver el control al procedimiento.

Comentarios
Cada tecla está representada por uno o más caracteres. Para especificar un único carácter del teclado, se utiliza el
carácter propiamente dicho. Por ejemplo, para representar la letra A, utilice "A" como string. Si se desea representar
más de un carácter, agregue cada carácter adicional al que lo precede. Para representar las letras A, B y C, utilice "ABC"
para string.
El signo más (+), el símbolo de intercalación (^), el símbolo de porcentaje (%), la tilde (~) y los paréntesis ( ) tienen
significados especiales para SendKeys. Para especificar uno de estos caracteres, debe incluirlo entre llaves. Por ejemplo,
para especificar el signo más, utilice {+}.
Para especificar caracteres que no se muestran al presionar una tecla (como por ejemplo ENTRAR o TAB) y teclas que
representan acciones, en lugar de caracteres, se utilizan los siguientes códigos:
Tecla:
RETROCESO: {BACKSPACE}, {BS}o {BKSP}
INTER: {BREAK}
BLOQ MAYÚS: {CAPSLOCK}
SUPR: {DELETE} o {DEL}
FLECHA ABAJO: {DOWN}
FIN: {END}
ENTRAR: {ENTER}o ~
ESC: {ESC}
AYUDA: {HELP}
INICIO: {HOME}
INSERT : {INSERT} o {INS}
FLECHA IZQUIERDA: {LEFT}
BLOQ NÚM: {NUMLOCK}
RE PÁG: {PGDN}
AV PÁG: {PGUP}
IMPR PANT: {PRTSC}
FLECHA DERECHA: {RIGHT}
BLOQ DESPL: {SCROLLLOCK}
TAB: {TAB}
FLECHA ARRIBA: {UP}
F1: {F1}
F2: {F2}
F3: {F3}
F4: {F4}
F5: {F5}
F6: {F6}
F7: {F7}
F8: {F8}
F9: {F9}

Página 131 de 159


Curso Visual Basic 5.0

F10: {F10}
F11: {F11}
F12: {F12}
F13: {F13}
F14: {F14}
F15: {F15}
F16: {F16}

Para especificar teclas con cualquier combinación de las teclas MAYÚS, CTRL y ALT, introduzca delante del código de
la tecla uno o más de los siguientes códigos:
Tecla
MAYÚS: +
CTRL (CONTROL): ^
ALT: %

Para especificar que se debe mantener presionada una combinación cualquiera de las teclas MAYÚS, CTRL y ALT
mientras se presionan otras teclas, ponga entre paréntesis el código relativo a esas teclas. Por ejemplo, para especificar
que se debe mantener presionada MAYÚS mientras se presionan las teclas E y C, utilice "+(EC)". Para especificar que
se debe mantener presionada MAYÚS mientras se presiona la tecla E y que luego se debe presionar C, sin presionar
MAYÚS, utilice "+EC".
Para especificar pulsaciones repetidas de teclas, utilice el formato {tecla número}. Debe dejar un espacio en blanco entre
tecla y número. Por ejemplo, {LEFT 42} significa que se debe presionar la tecla FLECHA IZQUIERDA 42 veces; {h
10} significa que se debe presionar la tecla h 10 veces.
Nota No puede utilizar SendKeys para enviar pulsaciones de teclas a aplicaciones que no estén diseñadas para
funcionar con Microsoft Windows. SendKeys puede enviar también la pulsación de la tecla IMPR PANT (PRTSC) a
cualquier aplicación.

Ejemplo de la instrucción SendKeys


En este ejemplo se utiliza la función Shell para ejecutar la aplicación Calculadora incluida en Microsoft Windows; luego
se utiliza la instrucción SendKeys para enviar pulsaciones de teclas para sumar algunos números y finalmente se
termina la aplicación Calculadora. La instrucción SendKeys no está disponible en Macintosh. (Para ver el ejemplo,
péguelo en un procedimiento y a continuación, ejecute el procedimiento. Puesto que AppActivate cambia el enfoque a la
aplicación Calculadora, no puede avanzar paso a paso por el código).

Dim ReturnValue, I
ReturnValue = Shell("Calc.exe", 1) ' Ejecuta la Calculadora.
AppActivate ReturnValue ' Activa la Calculadora.
For I = 1 To 100 ' Establece un bucle contador.
SendKeys I & "{+}", True ' Envía pulsaciones a la Calculadora
Next I ' para sumar cada valor de I.
SendKeys "=", True ' Obtiene el total general.
SendKeys "%{F4}", True ' Envía ALT+F4 para cerrar la Calculadora.

2.10.7-Unload
Descarga de memoria un formulario..

Sintaxis
Unload objeto

El marcador de posición objeto es el nombre de un objeto Form.

Comentarios
La descarga de un formulario puede ser necesaria o conveniente en aquellos casos en los que la memoria utilizada sea
necesaria para alguna otra tarea o cuando sea necesario restablecer las propiedades a sus valores originales.

Página 132 de 159


Curso Visual Basic 5.0

Antes de descargar un formulario se produce el evento Query_Unload, seguido del procedimiento de evento
Form_Unload. Si establece el argumento cancelar a True en alguno de estos eventos no se descargará el formulario.
Nota Cuando se descarga un formulario, sólo se descarga el componente mostrado. El código asociado al módulo del
formulario permanece en memoria.

Ejemplo de la instrucción Unload


Este ejemplo usa la instrucción Unload para descargar un objeto Form. Para probar este ejemplo, pegue el código en la
sección Declaraciones de un objeto Form y después ejecute el ejemplo y haga clic en el objeto Form.

Private Sub Form_Click ()


Dim Answer, Msg ' Declara la variable.
Unload Form1 ' Descarga el formulario.
Msg = "Form1 se ha descargado. Elija "Sí" para cargarlo y "
Msg = Msg & "presentarlo. Elija "No" para cargar el "
Msg = Msg & "formulario y dejarlo invisible."
Answer = MsgBox(Msg, vbYesNo) ' Obtiene la respuesta del usuario.
If Answer = vbYes Then ' Evalúa la respuesta.
Show ' Si es Sí, muestra el formulario.
Else
Load Form1 ' Si es No, sólo lo carga.
Msg = "Form1 se ha cargado. Elija "Aceptar" para mostrarlo."
MsgBox Msg ' Presenta el mensaje.
Show ' Muestra el formulario.
End If
End Sub

2.11-Trabajando con menúes.


2.11.1-Creación de menúes con el editor de menúes.
Puede utilizar el Editor de menús para crear nuevos menús y barras de menús, agregar nuevos comandos a menús
existentes, reemplazar comandos de menú existentes por sus propios comandos, y cambiar y eliminar menús y barras de
menús existentes.
Para presentar el Editor de menús
• En el menú Herramientas, elija Editor de menús.– O bien –
• Haga clic en el botón Editor de menús de la barra de herramientas.
.

Aparecerá el Editor de menús.

Mientras que casi todas las propiedades del control de menús pueden establecerse mediante el Editor de menús, todas las
propiedades de los menús están disponibles en la ventana Propiedades. Las dos propiedades más importantes de los
controles de menús son:

• Name: es el nombre que se utiliza para hacer referencia al control de menús en el código.
• Caption: es el texto que aparece en el control.

Otras propiedades del Editor de menús, como Index, Checked y NegotiatePosition, se describen más adelante en este
tema.

2.11.2-Uso del cuadro de lista del editor de menúes.


El cuadro de lista del control de menús (la parte inferior del Editor de menús) enumera todos los controles de menús del
formulario actual. Cuando escribe un elemento de menú en el cuadro de texto Caption, dicho elemento también aparece
en el cuadro de lista del control de menús. Si selecciona un control de menús existente del cuadro de lista, podrá
modificar las propiedades de dicho control.

Página 133 de 159


Curso Visual Basic 5.0

Por ejemplo, la figura del editor de menúes muestra los controles de menús del menú Archivo de una aplicación típica.
La posición del control de menús en el cuadro de lista del control de menús determina si el control es un título de menú,
un elemento de menú, un título de submenú o un elemento de submenú:
• Un control de menús que aparezca alineado a la izquierda en el cuadro de lista se presenta en la barra de menús
como un título de menú.
• Un control de menús que esté sangrado una vez en el cuadro de lista se presenta en el menú cuando el usuario hace
clic en el título de menú precedente.
• Un control de menús sangrado seguido de controles de menús con un nivel mayor de sangría se convierte en un
título de submenú. Los controles de menús sangrados bajo el título del submenú se convierten en elementos del
submenú.
• Un control de menús con un guión (-) como propiedad Caption aparece como una barra separadora. Una barra
separadora divide los elementos del menú en grupos lógicos.

Nota Un control de menús no puede ser una barra separadora si es un título de menú, tiene elementos submenú, está
activado o desactivado, o tiene una tecla de método abreviado.

Para crear controles de menús en el Editor de menús


1.Seleccione el formulario.
2.En el menú Herramientas, elija Editor de menús.
– o bien –
Haga clic en el botón Editor de menús de la barra de herramientas.
3.En el cuadro de texto Caption, escriba el texto del título del primer menú que quiera que aparezca en la barra de
menús. Coloque también un signo & delante de la letra que desee que sea la tecla de acceso a dicho elemento de menú.
Esta letra aparecerá subrayada automáticamente en el menú.
El texto del título del menú se presenta en el cuadro de lista del control de menús.
4.En el cuadro de texto Name, escriba el nombre que desee utilizar para hacer referencia al control de menús desde el
código. Vea "Recomendaciones de títulos y nombres de menús", más adelante en este mismo tema.
5.Haga clic en los botones de flecha a la izquierda o a la derecha para modificar el nivel de sangría del control.
6.Establezca otras propiedades del control, si lo desea. Puede hacerlo con el Editor de menús o, posteriormente, en la
ventana Propiedades.
7.Elija Siguiente para crear otro control de menús.
– o bien –
Haga clic en Insertar para agregar un control de menús entre controles existentes.
También puede hacer clic en los botones de flecha arriba y flecha abajo para mover el control entre los controles de
menús existentes.
8.Elija Aceptar para cerrar el Editor de menús cuando haya creado todos los controles de menús del formulario.
En el formulario se mostrarán los títulos de los menús creados. En tiempo de diseño, haga clic en el título de un menú
para desplegar sus correspondientes elementos de menú.

2.11.3-Separación de elementos de menúes.


Una barra separadora se presenta como una línea horizontal entre los elementos de un menú. En un menú con muchos
elementos, puede utilizar una barra separadora para dividir los elementos en grupos lógicos. Por ejemplo, el menú
Ayuda de Visual Basic usa barras separadoras para dividir sus elementos de menú en tres grupos, como se muestra en la
figura.
Figura: Barras separadoras

Página 134 de 159


Curso Visual Basic 5.0

Para crear una barra separadora con el Editor de menús


1.Si va a agregar una barra separadora a un menú existente, elija Insertar para insertar un control de menús entre los
elementos de menú que desee separar.
2.Si es necesario, haga clic en el botón de flecha a la derecha para sangrar el nuevo elemento de menú al mismo nivel
que los elementos de menú que vaya a separar.
3.Escriba un guión (-) en el cuadro de texto Caption.
4.Establezca la propiedad Name.
5.Elija Aceptar para cerrar el Editor de menús.

Nota Aunque las barras separadoras se crean como controles de menús, no responden al evento Click y los usuarios no
pueden seleccionarlas.

2.11.4-Asignación de teclas de acceso y de método abreviado.


Puede mejorar el acceso por teclado a los comandos de los menús si define teclas de acceso y de método abreviado.

Teclas de acceso
Las teclas de acceso permiten al usuario abrir un menú presionando la tecla ALT y escribiendo una letra designada. Una
vez abierto el menú, el usuario puede elegir un control si presiona la letra (tecla de acceso) asignada al mismo. Por
ejemplo, ALT+E podría abrir el menú Edición y P podría seleccionar el elemento de menú Pegar. La asignación de la
tecla de acceso aparece como una letra subrayada en el título del control de menús, como se muestra en la figura.
Figura: Teclas de acceso.

Para asignar una tecla de acceso a un control de menús con el Editor de menús
1.Seleccione el elemento de menú al que desee asignar una tecla de acceso.
2.En el cuadro Título, escriba un signo & inmediatamente delante de la letra que elija como tecla de acceso.

Por ejemplo, si abre el menú Edición mostrado en la figura anterior, los siguientes valores de la propiedad Caption se
corresponden con las siguientes teclas de acceso.

Página 135 de 159


Curso Visual Basic 5.0

Nota No use teclas de acceso duplicadas en los menús. Si usa la misma tecla de acceso para más de un elemento del
menú, dicha tecla no funcionará. Por ejemplo, si C es la tecla de acceso para Cortar y Copiar, cuando seleccione el
menú Edición y presione C, se seleccionará el comando Copiar, pero la aplicación no ejecutará el comando hasta que
presione ENTRAR. El comando Cortar no se seleccionará.

Teclas de método abreviado


Las teclas de método abreviado ejecutan un elemento de menú inmediatamente cuando se presionan. A los elementos de
menú que se utilizan con más frecuencia se les puede asignar una tecla de método abreviado, que proporciona un
método de acceso por teclado de sólo un paso, en lugar del método de tres pasos de presionar ALT, un carácter de
acceso al título del menú y después un carácter de acceso al elemento del menú. Las asignaciones de métodos
abreviados incluyen combinaciones de teclas de función y de control, como CTRL+F1 o CTRL+A. Aparecen en el
menú a la derecha del elemento de menú correspondiente, como se muestra en la figura.
Figura: Teclas de método abreviado

Para asignar una tecla de método abreviado a un elemento de menú


1.Abra el Editor de menús.
2.Seleccione el elemento de menú.
3.Seleccione una combinación de teclas de función o de otra tecla en el cuadro combinado Shortcut.
Para quitar una asignación de tecla de método abreviado, elija "(Ninguno)" en la parte superior de la lista.

Nota Las teclas de método abreviado aparecen automáticamente en el menú; por tanto, no tiene que escribir
CTRL+tecla en el cuadro de texto Caption del Editor de menús.

2.11.5-Creación de Submenúes.
Cada menú que cree puede incluir hasta cinco niveles de submenús. Un submenú sale de otro menú para presentar sus
propios elementos de menú. Puede utilizar un submenú cuando:
• La barra de menús esté llena.
• Un control de menús concreto se utilice con poca frecuencia.
• Quiera hacer énfasis en la relación de un control de menús con otro.

Página 136 de 159


Curso Visual Basic 5.0

Sin embargo, si hay sitio en la barra de menús, es mejor crear un título de menú adicional en lugar de un submenú. De
esta manera, todos los controles son visibles para el usuario cuando el menú se despliega. También es una buena práctica
de programación restringir el uso de los submenús de forma que los usuarios no se pierdan intentando explorar la
interfaz de menús de la aplicación. (La mayoría de las aplicaciones utilizan sólo un nivel de submenús.)
En el Editor de menús, cualquier control de menús sangrado bajo un control de menús que no sea un título de menú es
un control de submenús. En general, los controles de submenús pueden incluir elementos de submenú, barras
separadoras y títulos de submenú.

Para crear un submenú


1.Cree el elemento de menú que vaya a ser el título del submenú.
2.Cree los elementos que vayan a aparecer en el nuevo submenú y sángrelos haciendo clic en el botón de flecha a la
derecha.
Cada nivel de sangría está precedido por cuatro puntos (.…) en el Editor de menús. Para quitar un nivel de sangría, haga
clic en botón de flecha a la izquierda.

Nota Si está pensando en la posibilidad de utilizar más de un nivel de submenús, piense en utilizar un cuadro de
diálogo en su lugar. Los cuadros de diálogo permiten que los usuarios especifiquen varias opciones en un único lugar.
Para obtener información acerca del uso de cuadros de diálogo, vea "Cuadros de diálogo", más adelante en este mismo
tema.

2.11.6-Escritura de código para controles de menúes.


Cuando el usuario elige un control de menús, se produce un evento Click. Es necesario escribir un procedimiento de
evento Click para cada control de menús. Todos los controles de menús, excepto las barras separadoras (y los controles
de menús desactivados o invisibles), reconocen el evento Click.
El código que escribe en un procedimiento de evento de menú no es diferente del que escribiría en los procedimientos de
evento de cualquier otro control. Por ejemplo, el código de un evento Click para el elemento Cerrar del menú Archivo
podría parecerse a lo siguiente:

Sub mnuFileClose_Click ()
Unload Me
End Sub

Visual Basic presenta automáticamente un menú cuando se elige el título del menú; por tanto, no es necesario que
escriba código para el procedimiento de evento Click de un título de menú a menos que quiera realizar alguna otra
acción, como desactivar ciertos elementos del menú cuando éste sea visible.
Nota En tiempo de diseño, los menús que cree se presentarán en el formulario al cerrar el Editor de menús. Al elegir un
elemento de un menú dentro del formulario se presenta el procedimiento de evento Click de dicho control de menús.

2.12-Depuración y control de errores.


2.12.1-Planteamientos de depuración.
Las técnicas de depuración que se presentan en este tema usan las herramientas de análisis proporcionadas por Visual
Basic. Visual Basic no puede diagnosticar ni solucionar los errores por usted, pero proporciona las herramientas para
ayudarle a analizar cómo fluye la ejecución de una parte del procedimiento a otra y cómo cambian los valores de las
propiedades y las variables a medida que se ejecutan las instrucciones. Las herramientas de depuración le dejan
examinar dentro de la aplicación para ayudarle a determinar lo que pasa y por qué.
La depuración en Visual Basic incluye puntos de interrupción, expresiones de interrupción, expresiones de inspección,
paso a paso a través de una instrucción o procedimiento cada vez y presentación de los valores de las variables y las
propiedades. Visual Basic también incluye características especiales de depuración, como la posibilidad de modificar y
continuar, establecimiento de la próxima instrucción para ejecutar y prueba de procedimientos mientras la aplicación
está en modo de interrupción.

Página 137 de 159


Curso Visual Basic 5.0

2.12.2- Tipos de errores.


Para entender de qué manera puede ser útil la depuración, considere los tres tipos de errores que se puede encontrar.
• Errores de compilación
• Errores en tiempo de ejecución
• Errores lógicos

2.12.3-Errores de Compilación.
Los errores de compilación se producen por un código creado incorrectamente. Si escribe incorrectamente una palabra
clave, omite algún signo de puntuación necesario o usa una instrucción Next sin la instrucción For correspondiente en
tiempo de diseño, Visual Basic detectará estos errores cuando compile la aplicación.
Los errores de compilación incluyen errores en la sintaxis. Por ejemplo, podría tener una instrucción como sigue:
Left

Left es una palabra válida en el lenguaje de Visual Basic, pero sin un objeto, no cumple con los requisitos sintácticos
para esa palabra (objeto.Left). Si ha seleccionado la opción Comprobación automática de sintaxis en la ficha Editor
del cuadro de dialogo Opciones, Visual Basic presentará un mensaje de error tan pronto como introduzca un error
sintáctico en la ventana Código.

Para establecer la opción Comprobación automática de sintaxis


1.En el menú Herramientas, seleccione Opciones y haga clic en la ficha Editor del cuadro de diálogo Opciones.
2.Seleccione Comprobación automática de sintaxis.

2.12.4-Errores en tiempo de ejecución


Los errores en tiempo de ejecución se producen mientras la aplicación está en ejecución (y Visual Basic los detecta)
cuando una instrucción intenta una operación que es imposible de realizar. Un ejemplo de esto es una división por cero.
Suponga que tiene esta instrucción:
Velocidad = Kilómetros / Horas

Si la variable Horas contiene cero, la división no es una operación válida, incluso aunque la instrucción sea
sintácticamente correcta. La aplicación se debe ejecutar antes de que se pueda detectar este error.

2.12.5-Errores lógicos.
Los errores lógicos se producen cuando una aplicación no actúa de la forma que se pretendía. Una aplicación puede
tener código sintácticamente válido, ejecutarse sin llevar a cabo ninguna operación que no sea válida y, aún así, producir
resultados incorrectos. Sólo si prueba la aplicación y analiza los resultados puede comprobar que la aplicación está
actuando correctamente.

2.12.6-Como ayudan las herramientas de depuración.


Las herramientas de depuración están diseñadas para ayudarle con:
• Los errores lógicos y los que se producen en tiempo de ejecución.
• La observación del comportamiento del código que no tiene errores.

Por ejemplo, un resultado incorrecto puede producirse al final de una larga serie de cálculos. En la depuración, la tarea
es determinar dónde ha fallado algo y qué es lo que ha fallado. Quizá se le ha olvidado inicializar una variable, ha
elegido el operador equivocado o ha utilizado una fórmula incorrecta.
No hay trucos mágicos para depurar y no hay una secuencia fija de pasos que funcione todas las veces. Básicamente, la
depuración le ayuda a entender qué es lo que está sucediendo mientras se ejecuta su aplicación. Las herramientas de
depuración le ofrecen una instantánea del estado actual de su aplicación, incluyendo lo siguiente:

Página 138 de 159


Curso Visual Basic 5.0

• La apariencia de la interfaz de usuario (UI).


• Los valores de las variables, expresiones y propiedades.
• Las llamadas a los procedimientos activos.

Cuanto mejor entienda cómo funciona su aplicación, más rápido podrá encontrar los errores.

2.12.7-La barra de herramientas de depuración.


Entre sus muchas herramientas de depuración, Visual Basic proporciona varios botones en la barra de herramientas
opcional Depuración que son muy útiles. La figura muestra estas herramientas. Para presentar la barra de herramientas
Depuración, haga clic con el botón secundario del mouse (ratón) en la barra de herramientas de Visual Basic y
seleccione la opción Depuración.
Figura: La barra de herramientas Depuración

La siguiente tabla describe brevemente el objetivo de cada herramienta. Los temas de este tema tratan las situaciones en
las que cada una de estas herramientas le pueden ayudar a depurar o analizar una aplicación con más eficacia.

Herramienta de depuración Objetivo


Punto de interrupción Define una línea en la ventana Código donde Visual Basic suspende la
ejecución de una aplicación.
Paso a paso por instrucciones Ejecuta la siguiente línea ejecutable de código de la aplicación y recorre
paso a paso las instrucciones de procedimientos.
Paso a paso por procedimientos Ejecuta la siguiente línea ejecutable de código de la aplicación sin recorrer
paso a paso las instrucciones de procedimientos.
Paso a paso para salir Ejecuta el resto del procedimiento actual y se interrumpe en la siguiente
línea del procedimiento de llamada.
Ventana Locales Presenta el valor actual de las variables locales.
Ventana Inmediato Le permite ejecutar código o valores de consulta mientras la aplicación
está en modo de interrupción.
Ventana Inspección Presenta los valores de las expresiones seleccionadas.
Inspección rápida Presenta el valor actual de una expresión mientras la aplicación está en
modo de interrupción.
Pila de llamadas Mientras está en modo de interrupción, presenta un cuadro de diálogo que
muestra todos los procedimientos a los que se ha llamado, pero que
todavía no se han ejecutado completamente.

2.13-Creación de un programa de instalación.

Página 139 de 159


Curso Visual Basic 5.0

2.13.1-Uso del Asistente para instalar de Visual Basic.


El Asistente para instalar de Visual Basic facilita la creación de un programa de instalación para una aplicación. Al igual
que otros asistentes, el Asistente para instalar le pide información para poder crear lo que quiera.
En la mayoría de los casos, el Asistente para instalar es todo lo que necesitará para crear un programa de instalación.
Para iniciar el Asistente para instalar
1-Si el proyecto para el que quiere crear un programa de instalación está abierto, guárdelo y cierre Visual Basic.
2-Seleccione el icono Asistente para instalar del menú Inicio de Visual Basic 5.0, en Windows 95 o en Windows NT
4.0, o del Grupo de programas de Visual Basic 5.0, en el Administrador de programas de Windows NT 3.51.

Cada pantalla del Asistente para instalar le pedirá información acerca del proyecto y le permitirá elegir qué opciones
quiere incorporar al programa de instalación, cómo se va a distribuir, si quiere que el Asistente para instalar compile la
aplicación, etc.
En cada una de estas pantallas se explica además su uso, cuándo cierta información es opcional y qué información debe
introducir antes de que el proceso pueda continuar (antes de que pueda pasar a la próxima pantalla). A medida que
avanza en cada pantalla, si necesita más información, presione F1 o haga clic en el botón Ayuda.

2.13.2-Opciones de Distribución.

Puede distribuir la aplicación en disquetes, en CD o en una red. Si va a utilizar disquetes, puede elegir el método
Disquete o el método Directorios de discos del Asistente para instalar. Si piensa distribuir la aplicación en un CD o en
una red, puede elegir el método Directorio único o el método Directorios de disco.

Figura: Elección de las opciones de distribución con el Asistente para instalar

Si piensa distribuir la aplicación en disquetes, puede utilizar la opción Unidad de discos para generar discos flexibles en
el equipo o puede crear imágenes de disquetes para emplearlas con un servicio de duplicado de discos mediante la
opción Directorios de discos.
Si piensa distribuir la aplicación en una red o en CD, también tiene dos opciones. Puede utilizar la opción Directorio
único o la opción Directorios de discos. Ambos métodos copian los archivos de instalación en un directorio temporal

Página 140 de 159


Curso Visual Basic 5.0

del equipo o de un servidor de red. A continuación puede ubicar los archivos de instalación en el servidor de red
adecuado o transferirlos a un CD.

Unidad de discos
Para crear disquetes para el programa de instalación de la aplicación cuando no necesite imágenes de disco, seleccione la
opción Unidad de discos de la pantalla Método de distribución del Asistente para instalar. Esta pantalla está disponible
cuando ejecuta el Asistente para instalar y selecciona la opción

Crear un programa de instalación.


El Asistente para instalar le preguntará el tipo de disquete (1,44, 1,2, 720 ó 360) y la unidad de disco del equipo. Al
igual que en la mayoría de las funciones del Asistente para instalar, se le pedirá que confirme los archivos y
dependencias del proyecto. Una vez confirmados, el Asistente para instalar determinará la disposición de los disquetes,
comprimirá los archivos apropiados y los copiará a la unidad de disco, pidiéndole que inserte y quite disquetes cuando
sea necesario.
También puede utilizar la opción Directorios de discos para crear imágenes de disco del programa de instalación. El
Asistente para instalar realiza esencialmente las mismas acciones que para la opción Unidad de discos, excepto que las
imágenes se copian a directorios separados de un directorio temporal del equipo o de un servidor de red en lugar de
copiarse a la unidad de disquetes. A continuación puede copiarlos manualmente a discos, ubicar los archivos en un
servidor de red y permitir que los usuarios los copien a disquetes (si está trabajando en un entorno de red) o
proporcionales un servicio de duplicado de disquetes.

Directorio único
Puede crear una instalación de directorio único si selecciona la opción Directorio único. Debe utilizar esta opción o la
opción Directorios de discos cuando desee distribuir la aplicación en una red o en CD. Esta técnica simplemente copia
todos los archivos de instalación a un único directorio.
Cuando seleccione esta opción, el Asistente para instalar le pedirá que confirme los archivos y dependencias del
proyecto y, a continuación, comprimirá y copiará los archivos apropiados a un directorio temporal del equipo o del
servidor de red. De forma predeterminada, los archivos se copian a C:\Windows\Temp\SwSetup.
Después, puede copiar los archivos al servidor de red o transferirlos a un CD.

Directorios de discos
La opción Directorios de discos copia los archivos a una estructura de directorios que se asemeja a los discos de
distribución: Disk1, Disk2, Disk3, etc.
Al igual que con la opción Directorio único, cuando seleccione esta opción el Asistente para instalar le pedirá que
confirme los archivos y las dependencias del proyecto, y después comprimirá y copiará los archivos apropiados a un
directorio temporal del equipo o del servidor de red. De forma predeterminada, los archivos se copian a
C:\Windows\Temp\SwSetup.
Puede copiar estos directorios (Disk1, Disk2, etc.) a un servidor de red o transferirlos a un CD para su distribución. El
usuario puede instalar la aplicación simplemente si abre la carpeta Disk1 y hace doble clic en el programa de instalación.

2.13.3-Instalación de Componentes de acceso a datos.


Si la aplicación utiliza Objetos de acceso a datos (DAO), el Asistente para instalar le pedirá que elija los componentes
ISAM apropiados y de espacio de trabajo.
Puede elegir uno o más formatos de base de datos ISAM. Al menos debe seleccionar un espacio de trabajo; el Asistente
para instalar no le permitirá desactivar las dos opciones de espacio de trabajo: debe seleccionar una o ambas.
Si la aplicación requiere controladores ODBC, debe instalarlos por separado. Para obtener más información, consulte
más adelante.
Figura: Opciones de acceso a datos

Página 141 de 159


Curso Visual Basic 5.0

Creación de un disco de instalación para aplicaciones ODBC


Para la Edición profesional y la Edición empresarial, si crea una aplicación con ODBC y desea distribuirla, debe crear
un disco de instalación de ODBC. Antes de instalar la aplicación de Visual Basic en la máquina del usuario (mediante
un programa de instalación que haya escrito), debe instalar ODBC.
Nota Si la aplicación utiliza Objetos de datos remotos (RDO), debe dar instrucciones al usuario para que instale los
controladores ODBC antes de instalar la aplicación. Si no se instalan primero los controladores ODBC, los componentes
RDO no se registrarán.

Para crear un disco de instalación de ODBC


1-Copie todos los archivos del subdirectorio \Odbc del directorio principal de Visual Basic a un disco o a un directorio
de red.
2-Antes de instalar la aplicación en la máquina del usuario, ejecute el programa Setup.exe del disco de instalación de
ODBC o del directorio de red. Utilice la función Shell para ejecutar el archivo Setup.exe de ODBC desde el programa
de instalación o asigne al disco de instalación de ODBC un título como "Programa de instalación de ODBC: ejecute
Setup.exe antes de instalar la aplicación".

Después de ubicar los archivos ODBC en un disco, compruebe el disco de instalación de ODBC en una máquina que no
tenga archivos ODBC.
Nota Para instalar ODBC en la máquina de un usuario, debe utilizar el programa de instalación proporcionado en el
subdirectorio \Odbc del directorio principal de Visual Basic. Algunos de los archivos ODBC están comprimidos y el
programa de instalación debe descomprimirlos para instalarlos correctamente.

3) Acceso a Bases de Datos con Visual Basic y Lenguage SQL.


3.1-Fundamentos del lenguage SQL.
3.1.1- Qué es SQL?
SQL es un lenguaje de programación de bases de datos 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 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.

Página 142 de 159


Curso Visual Basic 5.0

El SQL moderno ha evolucionado hasta ser un estándar utilizado ampliamente en bases de datos relacionales y se define
por 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 Jet. Estas diferencias se contemplan más adelante en este
tema, pero la estructura y el funcionamiento generales del lenguaje son muy coherentes entre los distintos fabricantes. Si
ha utilizado alguna implementación de SQL, no tendrá dificultad en realizar la transición a la versión de Microsoft Jet.

SQL frente a desplazamiento


Como se describió antes en este manual, el motor de base de datos Microsoft Jet proporciona dos métodos para la
mayoría de las tareas con bases de datos:
• Un modelo de desplazamiento basado en el movimiento por los registros de las bases de datos.
• Un modelo relacional basado en el lenguaje de consulta estructurado (SQL).

Los programadores que estén familiarizados con sistemas de bases de datos orientados a archivos, como dBASE,
FoxPro y Paradox, se sentirán más cómodos con los modelos de desplazamiento. No obstante, en la mayoría de los
casos, el método equivalente de SQL es más eficiente y debe usarse cuando sea importante el rendimiento. Además,
SQL tiene la ventaja de ser una interfaz de bases de datos estándar, por lo que conocer los comandos de SQL permite
tener acceso y manipular una gran variedad de productos de bases de datos procedentes de distintos fabricantes.
En la práctica, a menudo se encontrará utilizando los dos modelos simultáneamente. Por ejemplo, podría utilizar la
instrucción SQL SELECT para crear un pequeño Recordset de elementos seleccionados de una tabla grande y a
continuación emplear los métodos de desplazamiento Move para avanzar por el Recordset y examinar determinados
registros de uno en uno.
Nota Los términos relacionales fila y columna equivalen a los conocidos términos de bases de datos registro y campo.
Puesto que SQL es un lenguaje de base de datos relacional puro, los términos fila y columna se utilizan con más
frecuencia para describir el funcionamiento de los comandos SQL. Para evitar confusiones, ambos conjuntos de
términos se usan indistintamente en este tema. Recuerde simplemente que una fila es un registro y una columna un
campo.

3.1.2-Componentes de SQL.
El lenguaje SQL está compuesto por comandos, cláusulas, operadores y funciones agregadas. Estos elementos se
combinan en las instrucciones empleadas para crear, actualizar y manipular bases de datos.

3.1.2.1-Comandos de SQL

Comando Descripción
SELECT Utilizado para consultar registros de la base de datos que satisfagan un criterio determinado.
INSERT Utilizado para cargar lotes de datos en la base de datos en una única operación.
UPDATE Utilizado para modificar los valores de determinados campos y registros.
DELETE Utilizado para quitar registros de una tabla de base de datos.

3.1.2.2-Cláusulas de SQL

Las cláusulas son condiciones de modificación utilizadas para definir los datos que desea seleccionar o manipular. La
siguiente tabla muestra las cláusulas que puede utilizar.
Cláusula Descripción
FROM Utilizada para especificar la tabla de la cual se van a seleccionar los registros.
WHERE Utilizada para especificar las condiciones que deben cumplir los registros que se van a
seleccionar.
GROUP BY Utilizada para separar los registros seleccionados en grupos específicos.
HAVING Utilizada para expresar la condición que debe satisfacer cada grupo.
ORDER BY Utilizada para ordenar los registros seleccionados de acuerdo con un orden especificado.

3.1.2.3-Operadores de SQL

Existen dos tipos de operadores en SQL: operadores lógicos y operadores de comparación.

Página 143 de 159


Curso Visual Basic 5.0

Operadores lógicos
Los operadores lógicos se usan para conectar expresiones, normalmente dentro de una cláusula WHERE. Por ejemplo:
SELECT * from Mitabla WHERE condición1 AND condición2

Aquí el operador AND conecta las expresiones condición1 y condición2 para especificar que se deben cumplir las dos
condiciones para satisfacer el criterio de selección. Los operadores lógicos son:
• AND
• OR
• NOT

Operadores de comparación
Los operadores de comparación se usan para comparar valores relativos de dos expresiones con el fin de determinar la
acción que debe ejecutarse. Por ejemplo:
SELECT * from Editores WHERE Id_de_editor = 5

Aquí el operador ‘=’ especifica que sólo se seleccionarán los registros que tengan un campo Id_de_editor con un valor
de 5.
Los operadores de comparación se enumeran en la siguiente tabla.
Operador Significado/Uso
< Menor que
<= Menor o igual que
> Mayor que
>= Mayor o igual que
= Igual que
<> Distinto de
BETWEEN Utilizado para especificar un intervalo de valores
LIKE Utilizado en la comparación de modelos
IN Utilizado para especificar registros de una base de datos

3.1.2.4-Funciones agregadas de SQL.

Las funciones agregadas se usan dentro de una cláusula SELECT en grupos de registros para devolver un único valor
que se aplica a un grupo de registros. Por ejemplo, la función agregada AVG devuelve el promedio de todos los valores
de un determinado campo de un objeto Recordset. La siguiente tabla enumera las funciones agregadas.
Función agregada Descripción
AVG Utilizada para calcular el promedio de los valores de un determinado campo.
COUNT Utilizada para devolver el número de registros de la selección.
SUM Utilizada para devolver la suma de todos los valores de un determinado campo.
MAX Utilizada para devolver el valor más alto de un campo especificado.
MIN Utilizada para devolver el valor más bajo de un campo especificado.

3.1.3-Comandos más importantes de SQL

3.1.3.1-Select

Pide al motor de base de datos Microsoft Jet que devuelva información de la base de datos como un conjunto de
registros.
Sintaxis
SELECT [predicado] { * | tabla.* | [tabla.]campo1 [AS alias1] [, [tabla.]campo2 [AS alias2] [, ...]]}
FROM expresióntabla [, ...] [IN basededatosexterna]
[WHERE... ]
[GROUP BY... ]
[HAVING... ]

Página 144 de 159


Curso Visual Basic 5.0

[ORDER BY... ]

La sintaxis de la instrucción SELECT consta de las siguientes partes:


Parte Descripción
predicado Uno de los siguientes predicados: ALL, DISTINCT, DISTINCTROW o TOP. Puede
utilizar el predicado para limitar el número de registros devueltos. Si no especifica
ninguno, el valor predeterminado es ALL.
* Especifica que se seleccionan todos los campos de la tabla o tablas especificadas.
tabla El nombre de la tabla que contiene los campos de la que se van a seleccionar los
registros.
campo1, campo2 Los nombres de los campos que contienen los datos que desea recuperar. Si incluye
más de un campo, éstos se recuperan en el orden enumerado.
alias1, alias2 Los nombres que se van a utilizar como encabezados de columnas en vez de los
nombres de columnas originales en tabla.
expresióntabla El nombre de la tabla o las tablas que contienen los datos que desea recuperar.
Basededatosexterna El nombre de la base de datos que contiene las tablas en expresióntabla si no están en la
base de datos activa.
Comentarios
Para realizar esta operación, el motor de base de datos Microsoft Jet busca la tabla o las tablas especificadas, extrae las
columnas elegidas, selecciona las filas que cumplen los criterios y ordena o agrupa las filas resultantes en el orden
especificado.
Las instrucciones SELECT no modifican los datos de la base de datos.
La instrucción SELECT suele ser la primera palabra en una instrucción SQL.
La sintaxis mínima para una instrucción SELECT es:
SELECT campos FROM tabla

Puede utilizar un asterisco (*) para seleccionar todos los campos de una tabla. El ejemplo siguiente selecciona todos los
campos de la tabla Empleados:
SELECT * FROM Empleados;

Si se incluye un nombre de campo en más de una tabla en la instrucción FROM, escriba delante el nombre de la tabla y
el operador . (punto). En el siguiente ejemplo, el campo Departamento está en la tabla Empleados y en la tabla
Supervisores. La instrucción SQL selecciona los departamentos de la tabla Empleados y los nombres de supervisores de
la tabla Supervisores:
SELECT Empleados.Departamento, Supervisores.NombreSupervisor
FROM Empleados INNER JOIN Supervisores
WHERE Empleados.Departamento = Supervisores.Departamento;

Cuando se crea un objeto Recordset, el motor de base de datos Microsoft Jet utiliza el nombre de campo de la tabla
como el nombre de objeto Field en el objeto Recordset. Si desea un nombre de campo diferente o un nombre que no
participe en la expresión utilizada para generar el campo, utilice la palabra reservada AS. El siguiente ejemplo utiliza
el título Nacimiento para dar nombre al objeto Field devuelto en el objeto Recordset resultante:
SELECT FechaNacimiento
AS Nacimiento FROM Empleados;

Siempre que utilice funciones de dominio agregado o consultas que devuelvan nombres de objetos Field ambiguos o
duplicados, debe utilizar la cláusula AS para proporcionar un nombre alternativo para el objeto Field. El siguiente
ejemplo utiliza el título CuentaEncabezado para dar nombre al objeto Field devuelto del objeto Recordset resultante:
SELECT COUNT(IdEmpleado)
AS CuentaEncabezado FROM Empleados;

Puede utilizar otras cláusulas en una instrucción SELECT para limitar y organizar aún más los datos devueltos. Para
obtener más información al respecto, vea el tema de Ayuda relativo a las cláusulas que esté utilizando.

3.1.3.2-Delete

Página 145 de 159


Curso Visual Basic 5.0

Crea una consulta de eliminación que elimina registros de una o más tablas enumeradas en la cláusula FROM y que
cumplen la cláusula WHERE.
Sintaxis
DELETE [tabla.*]
FROM tabla
WHERE criterio

La instrucción DELETE consta de las siguientes partes:


Parte Descripción
tabla El nombre opcional de la tabla cuyos registros se van a eliminar.
tabla El nombre de la tabla cuyos registros se van a eliminar.
criterio Una expresión que determina qué registros se van a eliminar.
Comentarios
La instrucción DELETE es especialmente útil cuando desea eliminar muchos registros.
Cuando utiliza DELETE sólo se elimina el dato; la estructura de la tabla y todas sus propiedades, como los atributos y
los índices de los campos, permanecen intactos.
Puede utilizar DELETE para quitar registros de las tablas que están en una relación uno a varios con otras tablas. Las
operaciones de eliminación en cascada hacen que los registros de las tablas que están en el lado varios de la relación se
eliminen cuando el registro correspondiente del lado uno de la relación se elimina en la consulta. Por ejemplo, en la
relación entre las tablas Clientes y Pedidos, la tabla Clientes está en el lado uno y la tabla Pedidos está en el lado varios
de la relación. La eliminación de un registro de la tabla Clientes provoca que los registros correspondientes de la tabla
Pedidos se eliminen si se especifica la opción de eliminación en cascada.
Una consulta de eliminación suprime registros completos, y no sólo los datos de los campos específicos. Si desea
eliminar valores de un campo específico, cree una consulta de actualización que cambie los valores a Null.
Importante
• Después de quitar registros utilizando una consulta de eliminación, no puede deshacer la operación. Si desea saber
qué registros se eliminaron, primero examine el resultado con una consulta de selección que utilice el mismo
criterio y después ejecute la consulta de eliminación.
• Mantenga siempre copias de seguridad de sus datos. Si elimina los registros por equivocación, podrá recuperarlos
de sus copias de seguridad.

3.1.3.3-Insert

Agrega uno o varios registros a una tabla. Esto se conoce como una consulta de datos añadidos.
Sintaxis
Consulta de datos añadidos para múltiples registros:
INSERT INTO destino [IN basededatosexterna] [(campo1[, campo2[, ...]])]
SELECT [origen.]campo1[, campo2[, ...]
FROM expresióntabla

Consulta de datos añadidos para un registro:


INSERT INTO destino [(campo1[, campo2[, ...]])]
VALUES (valor1[, valor2[, ...])

La instrucción INSERT INTO consta de las siguientes partes:


-destino: El nombre de la tabla o consulta donde se van a añadir registros.
-Basededatosexterna: La ruta de una base de datos externa. Si desea una descripción de la ruta de acceso, vea la cláusula
IN.
-origen: El nombre de la tabla o consulta de donde se van a copiar registros.
-Campo1, campo2: Los nombres de los campos donde se van a añadir los datos, si está a continuación del argumento
destino, o los nombres de los campos de donde se obtienen los datos, si está a continuación de un argumento origen.

Página 146 de 159


Curso Visual Basic 5.0

-Expresióntabla: El nombre de la tabla o las tablas de donde se van a insertar los registros. Este argumento puede ser un
nombre de tabla sencillo o uno compuesto resultante de una operación INNER JOIN, LEFT JOIN o RIGHT JOIN, o
una consulta guardada.
-Valor1, valor2: Los valores que se van a insertar en los campos específicos del nuevo registro. Cada valor se inserta en el
campo que corresponde a la posición del valor en la lista: valor1 se inserta en campo1 del nuevo registro, valor2 dentro de
campo2, y así sucesivamente. Debe separar los valores con una coma y escribir los campos de texto entre comillas ('
').

Comentarios
Puede utilizar la instrucción INSERT INTO para agregar un único registro a una tabla utilizando la sintaxis de consulta
de datos añadidos para un único registro como se muestra anteriormente. En este caso, su código especifica el nombre y
valor de cada campo del registro. Debe especificar cada uno de los campos del registro a los que se va a asignar un valor
y dicho valor para ese campo. Cuando no especifique cada campo, se inserta el valor predeterminado o Null en las
columnas no especificadas. Los registros se agregan al final de la tabla.
También puede utilizar la instrucción INSERT INTO para añadir un conjunto de registros de otra tabla o consulta
utilizando la cláusula SELECT ... FROM tal y como se muestra anteriormente en la sintaxis de consulta de datos
añadidos para múltiples registros. En este caso, la cláusula SELECT especifica los campos a añadir a la tabla destino
especificada.
La tabla origen o destino puede especificar una tabla o una consulta. Si especifica una consulta, el motor de base de
datos Microsoft Jet añade registros a cualquiera y a todas las tablas especificadas en la consulta.
La instrucción INSERT INTO es opcional pero cuando se incluye, debe preceder a la instrucción SELECT.
Si su tabla de destino contiene una clave principal, asegúrese de que añade un valor único y distinto de Null al campo
o campos de la clave principal; si no, el motor de base de datos Microsoft Jet no añadirá los registros.
Si añade registros a una tabla con un campo de tipo AutoNumber y desea volver a numerar los registros añadidos, no
incluya el campo AutoNumérico en su consulta. Incluya el campo Autonumérico en la consulta si desea conservar los
valores originales del campo.
Utilice la cláusula IN para añadir registros a una tabla de otra base de datos.
Para ver qué registros se van a añadir antes de ejecutar la consulta de datos añadidos, ejecute primero una consulta de
selección que utilice el mismo criterio de selección para ver los resultados.
Una consulta de datos añadidos copia los registros de una o más tablas a otra. Las tablas que contienen los registros que
añade no se ven afectadas por la consulta de datos añadidos.
En lugar de añadir registros existentes de otra tabla, puede especificar el valor de cada campo en un registro nuevo
utilizando la cláusula VALUES. Si omite la lista de campos, la cláusula VALUES debe incluir un valor para cada campo
de la tabla o; de lo contrario; la instrucción INSERT fallará. Utilice una instrucción INSERT INTO adicional con una
cláusula VALUES para cada registro adicional que desee crear.

3.1.3.4-Update

Crea una consulta de actualización que cambia los valores de los campos en una tabla específica según un criterio
específico.
Sintaxis
UPDATE tabla
SET nuevovalor
WHERE criterio;

La instrucción UPDATE consta de las siguientes partes:


Parte Descripción
tabla El nombre de la tabla cuyos datos desea modificar.
Nuevovalor Una expresión que determina el valor que se va insertar en un campo concreto de los registros
actualizados.
Criterio Una expresión que determina qué registros se actualizarán. Sólo se actualizan los registros que
satisfacen la expresión.

Comentarios
La instrucción UPDATE es especialmente útil desea cambiar muchos registros o cuando los registros que desea cambiar
están en múltiples tablas.

Página 147 de 159


Curso Visual Basic 5.0

Puede cambiar varios campos al mismo tiempo. El ejemplo siguiente aumenta los valores de Importe Pedido en un 10
por ciento y los valores de Cargo en un 3 por ciento para las compañías de envío de México:
UPDATE Pedidos
SET ImportePedido = ImportePedido * 1.1,
Cargo = Cargo * 1.03
WHERE PaísDestinatario = 'México';

Importante
• La instrucción UPDATE no genera un conjunto de resultado. Además, después de actualizar registros utilizando
una consulta de actualización, no puede deshacer la operación. Si desea saber qué registros se actualizaron, examine
primero el resultado de una consulta de selección que utilice el mismo criterio y después ejecute la consulta de
actualización.
• Mantenga siempre copias de seguridad de sus datos. Si actualiza registros equivocados, puede recuperarlos desde
sus copias de seguridad.

3.1.4-Cláusulas más importantes de SQL

3.1.4.1-From

Especifica las tablas o consultas que contienen la lista de campos enumerados en la instrucción SELECT.
Sintaxis
SELECT listacampos
FROM expresióntabla [IN basededatosexterna]

Una instrucción SELECT que contiene una cláusula FROM consta de las siguientes partes:
Parte Descripción
listacampos El nombre del campo o de los campos que se van a recuperar junto con cualquier alias
de nombre de campo, funciones de dominio agregado de SQL, predicados de
selección (ALL, DISTINCT, DISTINCTROW o TOP) u otras opciones de la
instrucción SELECT.
Expresióntabla Una expresión que identifica a una o más tablas de las que se van a recuperar datos. La
expresión puede ser un nombre de tabla único, un nombre de consulta guardada o una
composición resultante de una cláusula INNER JOIN, LEFT JOIN o RIGHT JOIN.
Basededatosexterna La ruta completa de una base de datos externa que contiene todas las tablas en
expresióntabla.

Comentarios
La cláusula FROM es obligatoria y sigue a cualquier instrucción SELECT.
El orden de los nombres de las tablas en expresióntabla no es importante.
Para mejorar el rendimiento y facilitar el uso, se recomienda que utilice una tabla vinculada en lugar de una cláusula IN
para recuperar datos de una base de datos externa.
El siguiente ejemplo muestra cómo puede recuperar datos de la tabla Empleados:
SELECT Apellidos, Nombre
FROM Empleados;

3.1.4.2-Where

Especifica qué registros de las tablas enumeradas en la cláusula FROM se ven afectados por la instrucción SELECT,
UPDATE o DELETE.
Sintaxis
SELECT listacampos
FROM expresióntabla
WHERE criterio

Un instrucción SELECT que contiene una cláusula WHERE consta de las siguientes partes:

Página 148 de 159


Curso Visual Basic 5.0

Parte Descripción
listacampos El nombre del campo o de los campos que se van a recuperar con cualquier alias de nombre
de campo, predicado de selección (ALL, DISTINCT, DISTINCTROW o TOP) u otras
opciones de la instrucción SELECT.
Expresióntabla El nombre de la tabla o de las tablas de las que se van a recuperar los datos.
Criterio Una expresión que deben cumplir los registros para que se incluyan en el resultado de la
consulta.
Comentarios
El motor de base de datos Microsoft Jet selecciona los registros que cumplen las condiciones enumeradas en la
cláusula WHERE. Si no especifica una cláusula WHERE, la consulta devuelve todas las filas de la tabla.
La cláusula WHERE es opcional, pero cuando se incluye, sigue a la cláusula FROM. Por ejemplo, puede seleccionar
todos los empleados del departamento de ventas (WHERE Dept = 'Ventas') o todos los clientes que tengan entre 18 y 30
años (WHERE Edad Between 18 And 30).
Si no utiliza una cláusula JOIN para realizar operaciones de combinación SQL en múltiples tablas, el objeto Recordset
resultante no podrá actualizar.
La cláusula WHERE es similar a la cláusula HAVING. La cláusula WHERE determina qué registros se seleccionan. De
forma parecida, una vez que los registros se agrupan con la cláusula GROUP BY, la cláusula HAVING determina qué
registros se van a mostrar.
Utilice la cláusula WHERE para eliminar registros que no desea que se agrupen mediante una cláusula GROUP BY.
Utilice varias expresiones para determinar qué registros devuelve la instrucción SQL. Por ejemplo, la siguiente
instrucción SQL selecciona todos los empleados cuyos salarios son superiores a $21,000:
SELECT Apellidos, Salario
FROM Empleados
WHERE Salario > 21000;

Una cláusula WHERE puede contener hasta 40 expresiones vinculadas por operadores lógicos, como And y Or.
Cuando introduce un nombre de campo que contiene un espacio en blanco o un signo de puntuación, escriba el nombre
entre corchetes ([ ]). Por ejemplo, una tabla de información de clientes podría incluir información acerca de unos clientes
concretos:
SELECT [Restaurante favorito del cliente]

Cuando especifica el argumento criterio, los literales de fecha deben estar en el formato de EE.UU., incluso si no está
utilizando la versión norteamericana del motor de base de datos Microsoft Jet. Por ejemplo, el 10 de mayo de 1996, se
escribe 10/5/96 en España y Latinoamérica, y 5/10/96 en Estados Unidos de América. Asegúrese de escribir los literales
de fecha entre signos # como se muestra en los siguientes ejemplos.
Para encontrar registros con fecha 10 de mayo de 1996 en una base de datos española o latinoamericana, debe utilizar la
siguiente instrucción SQL:
SELECT *
FROM Pedido
WHERE Fecha de envío = #5/10/96#;

También puede utilizar la función DateValue, que reconoce las configuraciones internacionales establecidas por
Microsoft Windows. Por ejemplo, utilice este código para Estados Unidos de América:
SELECT *
FROM Pedidos
WHERE Fecha de envío = DateValue('5/10/96');

Y utilice este código para España y Latinoamérica:


SELECT *
FROM Pedidos
WHERE Fecha de envío = DateValue('10/5/96');

3.1.4.3-Order By

Página 149 de 159


Curso Visual Basic 5.0

Ordena los registros resultantes de una consulta por un campo o unos campos especificados en sentido ascendente o
descendente.
Sintaxis
SELECT listacampos
FROM tabla
WHERE criterioselección
[ORDER BY campo1 [ASC | DESC ][, campo2 [ASC | DESC ]][, ...]]]

Una instrucción SELECT que contenga una cláusula ORDER BY consta de las siguientes partes:
Apartado Descripción
listacampos El nombre del campo o de los campos que se van a recuperar junto con cualquier alias de
nombre de campo, funciones de dominio agregado de SQL , predicado de selección
(ALL, DISTINCT, DISTINCTROW o TOP) u otras opciones de la instrucción
SELECT.
tabla El nombre de la tabla o tablas de las que se van a recuperar los datos. Para obtener más
información al respecto, vea la cláusula FROM.
criterioselección Criterio de selección. Si la instrucción incluye una cláusula WHERE, el motor de base de
datos Microsoft Jet ordena los valores después de aplicar las condiciones de la cláusula
WHERE a los registros.
Campo1, campo2 Los nombres de los campos por los que se va a ordenar.
Comentarios
La cláusula ORDER BY es opcional. Sin embargo, si desea que su datos se muestren ordenados, debe utilizar la cláusula
ORDER BY.
El orden predeterminado es ascendente (A a Z, 0 a 9). Los dos ejemplos siguientes ordenan los nombres de los
empleados por su apellido:
SELECT Apellidos, Nombre
FROM Empleados
ORDER BY Apellidos;

SELECT Apellidos, Nombre


FROM Empleados
ORDER BY Apellidos ASC;

Para ordenar en sentido descendente (de Z a A,y de 9 a 0), agregue la palabra reservada DESC al final de cada campo
por el que desee ordenar en sentido descendente. El siguiente ejemplo selecciona los sueldos y los ordena en sentido
descendente:
SELECT Apellidos, Salario
FROM Empleados
ORDER BY Salario DESC, Apellidos;

Si especifica un campo que contiene datos de tipo Memo u Objeto OLE en la cláusula ORDER BY, se produce un
error. El motor de base de datos Microsoft Jet no ordena campos de estos tipos.
La cláusula ORDER BY suele ser el último elemento de una instrucción SQL.
Puede incluir campos adicionales en la cláusula ORDER BY. Los registros se ordenan primero por el primer campo
enumerado después de la cláusula ORDER BY. Los registros que tengan valores iguales en ese campo se ordenan
entonces por el valor del segundo campo, y así sucesivamente.

3.1.5-Operaciones más importantes de SQL

3.1.5.1-Inner Join

Combina registros de dos tablas siempre que existan valores coincidentes en un campo común.
Sintaxis
FROM tabla1 INNER JOIN tabla2 ON tabla1.campo1 operadorcomp tabla2.campo2

Página 150 de 159


Curso Visual Basic 5.0

La operación INNER JOIN consta de las siguientes partes:


Parte Descripción
tabla1, tabla2 Los nombres de las tablas cuyos registros se van a combinar.
Campo1, campo2 Los nombres de los campos que se van a combinar. Si no son numéricos, los campos
deben ser del mismo tipo de datos y contener la misma clase de datos, pero no tienen
porqué tener el mismo nombre.
Operadorcomp Cualquier operador de comparación relacional: "=," "<," ">," "<=," ">=," o "<>."
Comentarios
Puede utilizar una operación INNER JOIN en cualquier cláusula FROM. Esta es el tipo de combinación más común.
Las combinaciones internas combinan los registros de dos tablas siempre que tengan valores coincidentes en un campo
común a ambas tablas.
Puede utilizar INNER JOIN con las tablas Departamentos y Empleados para seleccionar todos los empleados de cada
departamento. En cambio, para seleccionar todos los departamentos (aunque alguno no tenga empleados asignados) o
todos los empleados (aunque alguno no esté asignado a ningún departamento), puede utilizar una operación LEFT
JOIN o RIGHT JOIN para crear una combinación externa.
Si intenta combinar campos que contienen datos de tipo Memo se produce un error.
Puede combinar dos campos numéricos cualesquiera de tipos similares. Por ejemplo, puede combinar campos
AutoNumber y Long puesto que son tipos similares. Sin embargo, no puede combinar campos de tipo Single y Double.
El siguiente ejemplo muestra cómo podría combinar las tablas Categorías y Productos por el campo IdCategoría:
SELECT NombreCategoría, NombreProducto
FROM Categorías INNER JOIN Productos
ON Categorías.IdCategoría = Productos.IdCategoría;

En el ejemplo anterior, IdCategoría es el campo combinado, pero no se incluye en la salida de la consulta porque no está
incluido en la instrucción SELECT. Para incluir el campo combinado, incluya el nombre de campo en la instrucción
SELECT; en este caso, Categorías. IdCategoría.
También puede vincular varias cláusulas ON en una instrucción JOIN, utilizando la sintaxis siguiente:
SELECT campos
FROM tabla1 INNER JOIN tabla2
ON tabla1.campo1 operadorcomp tabla2.campo1 AND
ON tabla1.campo2 operadorcomp tabla2.campo2) OR
ON tabla1.campo3 operadorcomp tabla2.campo3)];

También puede anidar instrucciones JOIN utilizando la sintaxis siguiente:


SELECT campos
FROM tabla1 INNER JOIN
(tabla2 INNER JOIN [( ]tabla3
[INNER JOIN [( ]tablax [INNER JOIN ...)]
ON tabla3.campo3 operadorcomp tablax.campox)]
ON tabla2.campo2 operadorcomp tabla3.campo3)
ON tabla1.campo1 operadorcomp tabla2.campo2;

Una operación LEFT JOIN o RIGHT JOIN se puede anidar dentro de una operación INNER JOIN, pero una operación
INNER JOIN no se puede anidar dentro de LEFT JOIN o RIGHT JOIN.

3.1.5.2-Left Join, Right Join

Combinan registros de la tabla de origen cuando se utiliza en cualquier cláusula FROM.


Sintaxis
FROM tabla1 [ LEFT | RIGHT ] JOIN tabla2
ON tabla1.campo1 operadorcomp tabla2.campo2

Las operaciones LEFT JOIN y RIGHT JOIN consta de las siguientes partes:
Parte Descripción
tabla1, tabla2 El nombre de las tablas cuyos registros se van a combinar.

Página 151 de 159


Curso Visual Basic 5.0

Campo1, campo2 Nombres de los campos que se combinan. Los campos deben ser del mismo tipo de datos
y contener la misma clase de dato, pero no necesitan tener el mismo nombre.
operadorcomp Cualquier operador de comparación relacional: "=," "<," ">," "<=," ">=," or "<>."
Comentarios
Utilice una operación LEFT JOIN para crear una combinación externa por la izquierda. Las combinaciones externas
por la izquierda pueden incluir todos los registros de la primera (parte izquierda) de dos tablas, aunque no haya valores
coincidentes para los registros de la segunda tabla (parte derecha).
Utilice una operación RIGHT JOIN para crear una combinación externa por la derecha. Las combinaciones externas
por la izquierda pueden incluir todos los registros de la segunda (parte derecha) de dos tablas, aunque no haya valores
coincidentes para los registros de la primera tabla (parte izquierda).
Por ejemplo, podría utilizar LEFT JOIN con las tablas Departamentos (parte izquierda) y Empleados (parte derecha)
para seleccionar todos los departamentos, incluyendo aquellos que no tengan empleados asignados a ellos. Para
seleccionar todos los empleados, incluyendo aquellos que no estén asignados a ningún departamento, podría utilizar
RIGHT JOIN.
El siguiente ejemplo muestra cómo podría combinar las tablas Categorías y Productos mediante el campo IdCategoría.
La consulta produce una lista de todas las categorías, incluyendo aquellas que no contienen productos:
SELECT NombreCategoría,
NombreProducto
FROM Categorías LEFT JOIN Productos
ON Categorías.IdCategoría = Productos.IdCategoría;

En este ejemplo, el campo combinado es IdCategoría pero no se incluye en el resultado de la consulta porque no está
incluido en la instrucción SELECT. Para incluir el campo combinado, introduzca el nombre del campo en la instrucción
SELECT; en este caso, Categorías.IdCategoría.
Notas
• Para crear una consulta que incluya sólo los registros en los cuales los datos de los campos combinados son los
mismos, utilice una operación INNER JOIN.
• Una operación LEFT JOIN o RIGHT JOIN se puede anidar en una INNER JOIN, pero una INNER JOIN no se
puede anidar en una LEFT JOIN o RIGHT JOIN. Vea la explicación del anidamiento en el tema dedicado a INNER
JOIN para ver cómo se anidan combinaciones dentro de otras combinaciones.
• Puede vincular múltiples cláusulas ON. Vea la explicación de la vinculación de cláusulas en el tema dedicado a
INNER JOIN para ver cómo se hace.
• Si intenta combinar campos que contienen datos tipo Memo, se produce un error.

3.1.6-Operadores más importantes en SQL

3.1.6.1-Like

Compara una expresión de cadena con un modelo en una expresión SQL.


Sintaxis
expresión Like "modelo"

La sintaxis del operador Like consta de las siguientes partes:


Parte Descripción
Expresión Expresión SQL utilizada en una cláusula WHERE.
modelo Cadena o literal de cadena de caracteres con la que se compara expresión.

Comentarios
Puede utilizar el operador Like para encontrar valores en un campo que coincidan con el modelo que se especificó. Para
modelo, puede especificar el valor completo (por ejemplo , Like "García") o puede utilizar caracteres comodín para
encontrar un intervalo de valores (por ejemplo, Like "Ga*").
En una expresión, puede utilizar el operador Like para comparar un valor de campo con una expresión de cadena. Por
ejemplo, si introduce Like "C*" en una consulta SQL, la consulta devuelve todos los valores de campo que empiecen
con la letra C.

Página 152 de 159


Curso Visual Basic 5.0

El siguiente ejemplo devuelve los datos que empiezan con la letra P seguida de cualquier letra entre A y F, y tres
números:
Like "P[A-F]###"

La tabla siguiente muestra cómo puede utilizar el operador Like para probar expresiones de diferentes método modelos.

3.2-Objetos de Acceso a Bases de Datos.


3.2.1-DBEngine.
El objeto DBEngine es el objeto de nivel más alto en el modelo de objeto DAO.

Comentarios
El objeto DBEngine contiene y controla todos los otros objetos en la jerarquía de los objetos del DAO. No puede crear
objetos DBEngine adicionales y el objeto DBEngine no es un elemento de ninguna colección.
Con cualquier tipo de base de datos o conexión, puede:
• Utilizar la propiedad Version para obtener el número de versión del DAO.
• Utilizar la propiedad DefaultType para establecer el tipo predeterminado de conexión de base de datos que
utilizarán a continuación los objetos Workspace creados.
• Utilizar las propiedades DefaultPassword y DefaultUser para establecer la identificación de usuario y contraseña
para el objeto Workspace predeterminado.
• Utilizar el método CreateWorkspace para crear un objeto Workspace nuevo. Puede utilizar argumentos
opcionales para sobrescribir los valores de las propiedades DefaultType, DefaultPassword y DefaultUser.
• Utilizar el método OpenDatabase para abrir una base de datos en el Workspace predeterminado y utilizar los
métodos BeginTrans, Commit y Rollback para controlar transacciones en el Workspace predeterminado.
• Utilizar la colección Workspaces para hacer referencia a objetos Workspace específicos.
• Utilizar la colección Errors para examinar detalles sobre los errores de acceso a datos.

Otras propiedades y métodos sólo están disponibles cuando utiliza DAO con el motor de base de datos Microsoft Jet.
Puede utilizarlos para controlar el motor de base de datos Microsoft Jet, manipular sus propiedades y ejecutar tareas en
objetos temporales que no son elementos de colecciones. Por ejemplo, puede:
• Utilizar el método CreateDatabase para crear un nuevo objeto Microsoft Jet Database.

Página 153 de 159


Curso Visual Basic 5.0

• Utilizar el método Idle para activar el motor de base de datos Microsoft Jet y completar las tareas pendientes.
• Utilice los métodos CompactDatabase y RepairDatabase para mantener los archivos de base de datos.
• Utilizar las propiedades IniPath y SystemDB para especificar la ubicación de la información de Registro de
Windows de Microsoft Jet y el archivo de información de grupo de trabajo Microsoft Jet, respectivamente. El
método SetOption le permite sobrescribir los valores del Registro de Windows para el motor de base de datos
Microsoft Jet.

Después de cambiar los valores de la propiedad DefaultType y IniPath, sólo los objetos Workspace subsiguientes
reflejarán estos cambios.
Para hacer referencia a una colección que pertenezca al objeto DBEngine, a un método o a una propiedad que se aplique
a este objeto, utilice la siguiente sintaxis:
[DBEngine.][colección | método | propiedad]

Métodos
Métodos BeginTrans, CommitTrans, Rollback Método OpenConnection
Método CompactDatabase Método OpenDatabase
Método CreateDatabase Método RegisterDatabase
Método CreateWorkspace Método RepairDatabase
Método Idle Método SetOption

Propiedades
Propiedad DefaultType Propiedad LoginTimeout
Propiedad DefaultUser, DefaultPassword Propiedad SystemDB
Propiedad IniPath Propiedad Version

3.2.2-Workspace
Un objeto Workspace define una sesión para un usuario. Contiene las bases de datos abiertas y proporciona
mecanismos para realizar transacciones y, en espacios de trabajo Microsoft Jet admite asegurar grupos de trabajo.

También controles si utiliza el motor de base de datos Microsoft Jet o ODBCDirect para tener acceso a datos externos.

Comentarios
Utilice el objeto Workspace para administrar la sesión actual o para iniciar una sesión adicional. En una sesión, puede
abrir múltiples bases de datos o conexiones y administrar transacciones. Por ejemplo, puede:
• Utilizar las propiedades Name, UserName y Type para establecer una sesión con nombre. La sesión crea un
alcance en el que puede abrir múltiples bases de datos y dirigir una instancia de transacciones anidadas.
• Utilice el método Close para terminar una sesión.
• Utilizar el método OpenDatabase para abrir una o más bases de datos existentes en ese Workspace.

Página 154 de 159


Curso Visual Basic 5.0

• Utilizar los métodos BeginTrans, CommitTrans y Rollback para administrar el proceso de transacciones anidadas
en un Workspace y utilizar varios objetos Workspace para realizar varias transacciones simultáneas y
superpuestas.

Además, utilizar una base de datos Microsoft Jet, puede establecer seguridad basada en nombres de usuario y
contraseñas:
• Utilice las colecciones Groups y Users para establecer permisos de acceso a nivel de grupo y usuario a objetos en
el objeto Workspace.
• Utilice la propiedad IsolateODBCTrans para aislar múltiples transacciones que involucren a la misma base de
datos ODBC conectada a Microsoft Jet.

Cuando hace la primera referencia o utiliza un objeto Workspace, automáticamente crea el espacio de trabajo
predeterminado, DBEngine.Workspaces(0). Los valores de las propiedades Name y UserName del espacio de trabajo
predeterminado son "#Default Workspace#" y "Admin," respectivamente. Si está establecida la seguridad, el valor de la
propiedad UserName es el nombre del usuario que inició la sesión.
Cuando utilice transacciones, afecta a todas las bases de datos del objeto Workspace especificado - incluso si están
abiertos múltiples objetos Database en el objeto Workspace. Por ejemplo, utilice un método BeginTrans, actualice
varios registros en una base de datos y después elimine registros en otra base de datos. Si después utiliza el método
Rollback, las operaciones de actualización y eliminación se cancelan y se deshacen los cambios. Puede crear objetos
Workspace adicionales para administrar transacciones independientemente a través de los objetos Database.
Puede crear objetos Workspace con el método CreateWorkspace. Después de crear un nuevo objeto Workspace, debe
agregarlo a la colección Workspaces si necesita hacer referencia a él desde la colección Workspaces.
Puede utilizar un objeto Workspace creado nuevamente sin agregarlo a la colección Workspaces. Sin embargo, debe
hacer referencia a él mediante la variable de objeto que tiene asignada.
Para hacer referencia a un objeto Workspace en una colección por su número de orden o por el valor de la propiedad
Name, utilice cualquiera de los formatos de sintaxis siguientes:
DBEngine.Workspaces(0)
DBEngine.Workspaces("nombre")
DBEngine.Workspaces![nombre]

Métodos
Métodos BeginTrans, CommitTrans, Rollback Método CreateUser
Método Close Método OpenConnection
Método CreateDatabase Método OpenDatabase
Método CreateGroup

Propiedades
Propiedad DefaultCursorDriver Propiedad Name
Propiedad IsolateODBCTrans Propiedad Type
Propiedad LoginTimeout Propiedad UserName

3.2.3-Database.
Un objeto Database representa una base de datos abierta.

Página 155 de 159


Curso Visual Basic 5.0

Comentarios
Para manipular una base de datos abierta se utiliza un objeto Database y sus métodos y propiedades. En cualquier tipo
de bases de datos, puede:
• Utilizar el método Execute para ejecutar una consulta de acción.
• Utilizar la propiedad RecordsAffected para determinar cuántos registros se cambiaron en una consulta de acción.
• Utilizar el método OpenRecordset para ejecutar una consulta de selección y crear un objeto Recordset.
• Utilizar la propiedad Version para determinar qué versión de un motor de base de datos creó la base de datos.

Con una base de datos Microsoft Jet (archivo .mdb), también puede utilizar otros métodos, propiedades y colecciones
para manipular un objeto Database, y para crear, modificar u obtener información acerca de sus tablas, consultas y
relaciones. Por ejemplo, puede:
• Utilizar los métodos CreateTableDef y CreateRelation para crear respectivamente tablas y relaciones.
• Utilizar el método CreateProperty para definir nuevas propiedades Database.
• Utilizar el método CreateQueryDef para crear una definición de consulta permanente o temporal.
• Utilizar los métodos MakeReplica, Synchronize y PopulatePartial para crear y sincronizar réplicas parciales o
completas de la base de datos.
• Establecer la propiedad CollatingOrder para establecer el orden alfabético para campos de tipo carácter en
diferentes idiomas.

Utilice el método CreateDatabase para crear un objeto Database permanente que se anexa automáticamente a la
colección Databases y de ese modo guardarlo en disco.
No necesita especificar el objeto DBEngine cuando utiliza el método OpenDatabase.
Abrir una base de datos con tablas vinculadas no establece automáticamente vínculos a los archivos externos
especificados o a los origen de datos ODBC conectados a Microsoft Jet. Debe hacer referencia a los objetos
TableDef o Field de la tabla o abrir un objeto Recordset. Si no puede establecer vínculos a estas tablas, se produce un
error interceptable. También puede necesitar permiso para tener acceso a la base de datos u otro usuario podría tener
abierta la base de datos de modo exclusivo. En estos casos se producen errores interceptable.
También puede utilizar el método OpenDatabase para abrir una base de datos externa (como FoxPro, dBASE y
Paradox) directamente en vez de abrir una base de datos Microsoft Jet que tiene vínculos con las tablas.
Nota No se recomienda abrir un objeto Database directamente en un origen de datos ODBC conectado a Microsoft Jet,
como Microsoft SQL Server, porque el rendimiento de la consulta es mucho más lento que cuando se utilizan tablas
vinculadas. Sin embargo, el rendimiento no es un problema al abrir un objeto Database directamente en un archivo de
base de datos ISAM externo, como FoxPro o Paradox.

Cuando un procedimiento que declara un objeto Database termina su ejecución, estos objetos Database locales se
cierran junto con cualquier objeto Recordset abierto. Todas las actualizaciones pendientes se pierden y las transacciones
pendientes se reanudan, pero no se produce ningún error. Se pueden terminar explícitamente las transacciones
pendientes o editar y cerrar objetos Recordset y Database, antes de abandonar los procedimientos que declaran
localmente esas variables del objeto.
Cuando utiliza uno de los métodos de transacción (BeginTrans, CommitTrans o Rollback) en el objeto Workspace,
estas transacciones se aplican a todas las bases de datos abiertas en el Workspace desde el que se abrió el objeto

Página 156 de 159


Curso Visual Basic 5.0

Database. Si desea utilizar transacciones independientes, primero debe abrir un objeto Workspace adicional y después
abrir otro objeto Database en ese objeto Workspace.
Nota Puede abrir el mismo origen de datos o base de datos más de una vez, creando nombres duplicados en la
colección Databases. Debe asignar objetos Database a variables de objeto y hacer referencia a ellas con un nombre de
variable.

Métodos
Método Close Método MakeReplica
Método CreateProperty Método NewPassword
Método CreateQueryDef Método OpenRecordset
Método CreateRelation Método PopulatePartial
Método CreateTableDef Método Synchronize
Método Execute

Propiedades
Propiedad CollatingOrder Propiedad ReplicaID
Propiedad Connect Propiedad Transactions
Propiedad Connection Propiedad Updatable
Propiedad Name Propiedad V1xNullBehavior
Propiedad QueryTimeout Propiedad Version
Propiedad RecordsAffected
Propiedad Replicable

3.2.4-Recordset.

Un objeto Recordset representa los registros de una tabla base o los registros que se generan al ejecutar una consulta.
Comentarios
Utilice los objetos Recordset para manipular datos en una base de datos a nivel de registro. Cuando utiliza objetos de
acceso de datos, interactúa con los datos prácticamente utilizando objetos Recordset. Todos los objetos Recordset se
construyen utilizando registros (filas) y campos (columnas). Existen tres tipos de objetos Recordset:
• Recordset de tipo Table - una representación en código de una tabla base que puede utilizarse para añadir, cambiar
o eliminar registros desde una única tabla de base de datos (sólo espacios de trabajo Microsoft Jet).
• Recordset de tipo Dynaset - el resultado de una consulta cuyos registros pueden actualizarse. Un objeto Recordset
de tipo Dynaset es un conjunto dinámico de registros que puede utilizarse para añadir, cambiar o eliminar registros
desde una tabla o tablas subyacentes de una base de datos. Un objeto Recordset de tipo Dynaset puede contener
campos de una o más tablas de una base de datos.
• Recordset de tipo Snapshot - una copia estática de un conjunto de registros que puede utilizar para encontrar datos
o generar informes. Un objeto Recordset de tipo Snapshot puede contener campos de una o más tablas de una base
de datos pero no se puede actualizar.
• Recordset de tipo Forward-only - idéntico a un tipo Snapshot excepto que no se proporciona ningún cursor. Sólo
puede avanzar en los registros. Esto mejora el rendimiento en situaciones donde sólo necesita hacer una pasada
sencilla en el conjunto de resultado.
• Recordset de tipo Dynamic - un conjunto de resultado de una consulta de una o más tablas base en las que puede
agregar, cambiar o eliminar registros de una consulta que devuelve filas. Además, también aparecen en el objeto
Recordset los registros que agregan, eliminan o modifican otros usuarios en la tablas base.

Página 157 de 159


Curso Visual Basic 5.0

Puede elegir el tipo de objeto Recordset que quiere crear usando el argumento tipo del método OpenRecordset.
En un espacio de trabajo Microsoft Jet, si no especifica un tipo, DAO intenta crear el tipo de objeto Recordset con la
mayor funcionalidad disponible, comenzando con tabla. Si no está disponible este tipo, DAO intenta un Dynaset,
después un Snapshot y por último un objeto Recordset de tipo Forward-only.
Cuando se crea un objeto Recordset utilizando un objeto TableDef no adjunto, se crean objetos Recordset de tipo
Table. Sólo pueden crearse Recordset de tipo Dynaset o Snapshot con tablas adjuntas o tablas de bases de datos
externas ODBC.
Cuando abre el objeto se agrega automáticamente un nuevo objeto Recordset a la colección Recordsets y se elimina
automáticamente cuando lo cierra.
Nota Si utiliza variables para representar un objeto Recordset y el objeto Database que contiene el conjunto de
registros, compruebe que las variables tengan el mismo alcance o duración. Por ejemplo, si establece una variable global
que representa un objeto Recordset, debe asegurarse de que la variable que represente la base de datos que contiene el
conjunto de registros también sea global o se encuentra en un procedimiento Sub o Function con la palabra clave
Static.

Su aplicación puede crear tantas variables objeto Recordset como se necesiten. Un objeto Recordset puede hacer
referencia a una o más tablas o consultas y los campos sin conflictos.
Los Recordset de tipo Dynaset y Snapshot se almacenan en la memoria local. Si no hay suficiente espacio en la
memoria local para almacenar los datos, el motor de base de datos Microsoft Jet guarda los datos adicionales en el disco
TEMP. Si este espacio está agotado, se producirá un error.
La colección predeterminada de un objeto Recordset es la colección Fields y la propiedad predeterminada de un objeto
Field es la propiedad Value. El código puede simplificarse utilizando estos valores predeterminados.
Cuando se crea un objeto Recordset, el registro activo se coloca como primer registro si existen varios registros. Si no
hay registros, el valor de la propiedad RecordCount será 0 y los valores de la propiedad BOF y EOF serán True.
Puede utilizar los métodos MoveNext, MovePrevious, MoveFirst y MoveLast para volver a establecer el registro
activo. Los objetos Recordset de tipo Forward-only sólo admiten el método MoveNext. Cuando se utilizan los métodos
Move para moverse entre los registros (o "andar" a través del objeto Recordset), puede utilizar las propiedades BOF y
EOF para comprobar el inicio o el fin del objeto Recordset.
Con los objetos Recordset de tipo Dynaset y Snapshot en un espacio de trabajo Microsoft Jet, también puede utilizar los
métodos Find, como FindFirst, para localizar un registro específico basado en un criterio. Si no se encuentra el registro,
la propiedad NoMatch se establece a True. Para objetos Recordset de tipo Table, puede buscar registros utilizando el
método Seek.
La propiedad Type indica el tipo de objeto Recordset creado y la propiedad Updatable indica si puede cambiar los
registros del objeto.
La información acerca de la estructura de la tabla base, como los nombres y los tipos de datos de cada objeto Field y
cualquier objeto Index, se almacena en un objeto TableDef.
Para hacer referencia a un objeto Recordset en una colección por su número de orden o por el valor de la propiedad
Name, utilice cualquiera de los formatos de sintaxis siguientes:
Recordsets(0)
Recordsets("nombre")
Recordsets![nombre]

Métodos
Método AddNew Métodos FindFirst, FindLast, FindNext, FindPrevious
Método Cancel Método GetRows
Método CancelUpdate Método Move
Método Clone Métodos MoveFirst, MoveLast, MoveNext, MovePrevious
Método Close Método NextRecordset
Método CopyQueryDef Método OpenRecordset
Método Delete Método Requery
Método Edit Método Seek
Método FillCache Método Update

Propiedades
Propiedad AbsolutePosition Propiedad LockEdits

Página 158 de 159


Curso Visual Basic 5.0

Propiedad BatchCollisionCount Propiedad Name


Propiedad BatchCollisions Propiedad NoMatch
Propiedad BatchSize Propiedad PercentPosition
Propiedades BOF, EOF Propiedad RecordCount
Propiedad Bookmark Propiedad RecordStatus
Propiedad Bookmarkable Propiedad Restartable
Propiedad CacheSize Propiedad Sort
Propiedad CacheStart Propiedad StillExecuting
Propiedad Connection Propiedad Transactions
Propiedades DateCreated, LastUpdated Propiedad Type
Propiedad EditMode Propiedad Updatable
Propiedad Filter Propiedad UpdateOptions
Propiedad Index Propiedad ValidationRule
Propiedad LastModified Propiedad ValidationText

Página 159 de 159