Aprenda Visual Basic Practicando ( PDFDrive )

Prévia do material em texto

APRENDA VISUAL BASIC 
PRACTICANDO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
APRENDA VISUAL BASIC 
PRACTICANDO 
José Felipe Ramírez Ramírez 
Master en Informática Administrativa, 
Catedrático de la Facultad de Contaduría Pública y Administración, 
Universidad Autónoma de Nuevo León, México 
Revisión técnica: 
Lic. José Luis Ramos 
Coordinador de la Carrera de Informática Administrativa, Facultad de Contaduría 
Pública y Administración, Universidad Autónoma de Nuevo León, México 
 
Pearson 
Educación 
MÉXICO • ARGENTINA • BRASIL • COLOMBIA • COSTA RICA • CHILE 
ESPAÑA • GUATEMALA • PERÚ • PUERTO RICO • VENEZUELA 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/ Datos de catalogación bibliográfica 
RAMÍREZ RAMÍREZ, JOSÉ 
FELIPE Aprenda Visual Basic 
practicando 
PEARSON EDUCACIÓN. México, 2001 
ISBN: 970-26-0285-8 
Área: Universitarios 
Formato: 18.5x23.5cm Páginas: 848 
Editor: José Luis Vázquez Chavarría 
e-mail: luis.vazquez@pearsoned.com 
Editor de desarrollo: Amonio Nuñez Ramos 
Supervisor de producción: José D. Hernández 
Garduño 
Diseño de portada: Iliana H. González Villafán 
PRIMERA EDICIÓN. 2001 
D-R, © 2001 por Pearson Educación de 
México, S.A. de C.V. Calle 4 No, 25-
2do. Piso 
 Fracc. Industrial Alce Blanco 53370 Naucalpan de 
Juárez, Edo. de México E-mail: 
editorial.universidades@pearsoned.com 
Cámara Nacional de la Industria Editorial Mexicana. Registro No. 1031 
 
Reservados todos los derechos. Ni la totalidad ni parte de esta publicación pueden 
reproducirse, registrarse o transmitirse, por un sistema de recuperación de 
información, en ninguna forma ni por ningún medio, sea electrónico, mecánico. 
fotoquímico, magnético o electro óptico, por fotocopia, grabación o cualquier otro. 
sin permiso previo por escrito del editor. 
El préstamo, alquiler o cualquier otra forma de cesión de uso de este ejemplar 
requerirá también la autorización del editor o de sus representantes. 
ISBN: 970-26-0285-8 
Impreso en México- Primea in México 
1234567890-03 02 01 
Pearson 
 Educación 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A Adriana, mi esposa, 
 porque ama mis propiedades, 
 hace mejores todos mis eventos 
y motiva todos mis métodos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CONTENIDO 
____________________________________________________________________ 
 
Contenido ..........................................................................................................................................vi 
índice de prácticas .............................................................................................................................xv 
Lo inesperado ....................................................................................................................................xx 
Prólogo ..............................................................................................................................................xxii 
Forma y contenido del libro .............................................................................................................xxiii 
Agradecimientos...............................................................................................................................xxvii 
 
Parte 1: Entorno Integrado de Desarrollo 
Capítulo 1: Visual Basic como plataforma de desarrollo ................................................. 3 
Objeto de la programación ...................................................................................................................... 4 
Visual Basic: más que un lenguaje de programación ............................................................................. 5 
Entorno Integrado de Desarrollo ............................................................................................................ 6 
Ediciones de Visual Basic ........................................................................................................................ 8 
Elementos del IDE .................................................................................................................................. 9 
La barra de menús ................................................................................................................................... 12 
La barra de herramientas ......................................................................................................................... 12 
Formulario (Form) .................................................................................................................................. 13 
Modos de trabajo con formularios: SD1 y MDI ..................................................................................... 13 
Tecnología orientada a objetos y Visual Basic ....................................................................................... 16 
Controles ................................................................................................................................................. 18 
Clase ........................................................................................................................................................ 18 
Objetos .................................................................................................................................................... 18 
Cuadro de herramientas .......................................................................................................................... 19 
Propiedades ............................................................................................................................................. 23 
Métodos .................................................................................................................................................. 24 
Ejemplificación de objeto - propiedad - método .................................................................................... 24 
Explorador de proyectos ......................................................................................................................... 25 
Tiempos de desarrollo de Visual Basic ................................................................................................... 27 
Ventana Propiedades ............................................................................................................................... 28 
Ventana Posición del formulario ............................................................................................................. 31 
Pasos para crear una aplicación en Visual Basic ..................................................................................... 32 
Resumen................................................................................................................................................... 33 
Algunas respuestas a los ejercicios ........................................................................................................ 34 
 
 Capitulo 2: Creación de la interfaz de usuario ............................................................... 35 
El punto de partida: ¿Qué desea hacer? .................................................................................................. 36 
 Paso 1: Crear la interfaz de usuario .................................................................................................... 37 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Contenido vii 
 
 Inserción de objetos............................................................................................................................... 37 
 Propiedades de posición y dimensión .................................................................................................. 41 
 Organización de los objetos en el formulario ...................................................................................... 48 
 Cómo establecer las aplicaciones para diferentesresoluciones de monitores ..................................... 52 
Resumen ....................................................................................................................................................... 55 
 Algunas respuestas a los ejercicios ..................................................................................................... 56 
 
Capítulo 3: Cómo establecer las propiedades de los objetos .............................................. 57 
 Consideraciones de diseño en Visual Basic .......................................................................................... 58 
Paso 2: Establecer las propiedades de los objetos ....................................................................................... 59 
 Validar que ya se tienen lodos los objetos que se requieren en el formulario..................................... 59 
 Cómo asignar el nombre adecuado a cada uno de los objetos .......................................................... 62 
 Cómo establecer las propiedades de apariencia y comportamiento .................................................. 67 
 Tablas de objetos y propiedades ........................................................................................................ 73 
Resumen ..................................................................................................................................................... 74 
Capítulo 4: Escritura del código de los eventos ................................................................... 75 
Paso 3: Escribir el código de los eventos .................................................................................................... 76 
El editor de código de Visual Basic ............................................................................................................ 76 
 Elementos de la ventana Código .......................................................................................................... 79 
 Caracteres especiales ............................................................................................................................ 81 
 Asistencia en la edición de código ....................................................................................................... 84 
 El evento predeterminado de los objetos............................................................................................... .84 
 Convenciones para la codificación ....................................................................................................... .94 
 Especificaciones de codificación ........................................................................................................... 96 
 ¿Qué hacer con los procedimientos de evento sin código? .................................................................... .97 
Resumen ...................................................................................................................................................... 98 
 Algunas respuestas a los ejercicios ..................................................................................................... 98 
Capítulo 5: Cómo guardar y ejecutar aplicaciones ............................................................. 101 
¿Cómo se almacena su trabajo en Visual Basic? ......................................................................................... 102 
Cómo guardar aplicaciones .......................................................................................................................... 103 
 Recomendaciones para nombrar archivos en Visual Basic .................................................................... 107 
Cómo ejecutar su aplicación ......................................................................................................................... 108 
Depuración y control del programa............................................................................................................... 114 
 Indicadores de margen ............................................................................................................................. 115 
 La ventana Código al depurar una aplicación ..........................................................................................117 
 Ejecución paso a paso .............................................................................................................................. 118 
 Puntos de interrupción ............................................................................................................................. 119 
Cómo generar un archivo ejecutable (EXE) ................................................................................................. 120 
Forma esquemática de presentación de aplicaciones ................................................................................... 123 
Resumen ...................................................................................................................................................... 127 
 Algunas respuestas a los ejercicios .......................................................................................................... 128 
 
 
Parte 2: Elementos de programación 
Capítulo 6: Variables y tipos de datos ...................................................................................................... 131 
 MsgBox .................................................................................................................................................. 132 
 Constantes de Visual Basic .................................................................................................................... 135 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
viii Contenido 
InputBox .................................................................................................................................................... 139 
Declaración de variables ................................................................................................................................ 142 
Tipos de datos ................................................................................................................................................ 143 
DIM: declaración de variables de memoria ................................................................................................... 145 
Alcance .......................................................................................................................................................... 147 
Nombre .......................................................................................................................................................... 148 
Constantes ...................................................................................................................................................... 150 
Matrices .......................................................................................................................................................... 150 
Funciones de límite de posiciones .................................................................................................................. 153 
Option Explicit ......................................................................................................................................... 155 
Conversión de datos ........................................................................................................................................ 158 
La función Format ........................................................................................................................................ 161 
Resumen ......................................................................................................................................................... 166 
 Algunas respuestas a los ejercicios....................................................................................................... 166 
 
Capítulo 7: Operadores y estructuras de control ...................................................................... 169 
Operadores aritméticos .................................................................................................................................... 170 
Operadores comparativos ................................................................................................................................ 172 
 Código ASCII ......................................................................................................................................... 173 
Operadores lógicos .......................................................................................................................................... 174 
Prioridad entre operadores ............................................................................................................................... 177 
Instrucción If (condicional) ........................................................................................................................... 178 
Select Case ................................................................................................................................................ 184 
For Next ....................................................................................................................................................... 186 
Do Loop .......................................................................................................................................................... 189 
Resumen .......................................................................................................................................................... 191 
 Algunas respuestas a los ejercicios ...................................................................................................... 191 
 
Capítulo 8: Funciones de manipulación de datos ......................................................................193 
Qué son las funciones .......................................................................................................................................194 
Funciones de fecha y hora ................................................................................................................................ 195 
Funciones de manipulación de cadenas (string) ......................................................................................... 202 
Funciones numéricas ........................................................................................................................................ 210 
Funciones de decisión ...................................................................................................................................... 213 
Funciones de uso específico ............................................................................................................................. 216 
 Funciones financieras ................................................................................................................................ 216 
 Funciones trigonométricas ........................................................................................................................ 217 
Resumen ........................................................................................................................................................... 218 
 
Capítulo 9: Procedimientos y funciones definidas por el usuario .......................................... 219 
Procedimientos ................................................................................................................................................. 220 
 Ejecución de procedimientos ............................................................................................................... 221 
 Cómo agregar procedimientos en Visual Basic ................................................................................... 222 
 Procedimientos que no utilizan argumentos y no devuelven valores ................................................. 224 
 Procedimientos que no utilizan argumentos y sí devuelven valores .................................................. 225 
 Procedimientos que utilizan argumentos ........................................................................................... 227 
 Especificación de argumentos opcionales ......................................................................................... 229 
 Valores predeterminados para argumentos opcionales ...................................................................... 232 
 Funciones con número incierto de argumentos ................................................................................ 233 
Resumen ......................................................................................................................................................... 237 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Contenido jx 
Parte 3: Controles gráficos y programación orientada a eventos 
Capítulo 10: Controles básicos para la introducción de datos ................................................................ 241 
Controles básicos para el acceso de datos ..................................................................................................... 242 
 Label....................................................................................................................................................... 242 
 TextBox.................................................................................................................................................. 243 
 CommandButton...................................................................................................................... 244 
Enfoque ......................................................................................................................................................... 249 
 La tecla presionada: evento KeyPress .................................................................................................. 259 
Resumen ........................................................................................................................................................ 262 
Capítulo 11: Programación orientada a eventos ........................................................................................ 263 
Eventos y su clasificación ............................................................................................................................... 264 
 Argumentos implícitos ............................................................................................................................. 266 
Resumen de las categorías de eventos, consideradas de uso general .............................................................. 266 
 TipoClic .................................................................................................................................................. 267 
 Tipo Cambios ......................................................................................................................................... 268 
 Tipo Enfoque .......................................................................................................................................... 270 
 Tipo Ratón .............................................................................................................................................. 284 
Prioridad de los eventos .................................................................................................................................. 294 
Resumen ..........................................................................................................................................................303 
Capítulo 12: Controles contenedores y controles de selección .................................................................. 305 
Objetos contenedores ...................................................................................................................................... 306 
Frame ............................................................................................................................................................. 306 
CheckBox ...................................................................................................................................................... 312 
Matriz de controles .......................................................................................................................................... 316 
Colores en Visual Basic utilizando RGB y QBColor .................................................................................... 323 
 RGB ........................................................................................................................................................... 323 
QBColor ............................................................................................................................................... 324 
OptionButton ............................................................................................................................................ 325 
HscrollBary y ScrollBar ..................................................................................................................... 330 
Resumen ........................................................................................................................................................... 337 
Capítulo 13: Controles de listas desplegables .............................................................................................. 339 
Concepto de colección ..................................................................................................................................... 340 
Listas desplegables: ListBox y ComboBox ................................................................................................ 342 
Cómo agregar y eliminar opciones de las listas desplegables ......................................................................... 343 
 Método Additem ..................................................................................................................................... 343 
 Propiedad ListCount ............................................................................................................................ 344 
 Propiedad List ........................................................................................................................................ 345 
 Propiedades Selected y Listindex ................................................................................................. 346 
 Método Removeltem .............................................................................................................................. 347 
 Método Clear .......................................................................................................................................... 348 
Resumen ........................................................................................................................................................... 368 
Capítulo 14: Editor de menús y manejo del Portapapeles ......................................................................... 371 
El Editor de menús .......................................................................................................................................... 372 
 Cómo invocar el Editor de menús .......................................................................................................... 373 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
x Contenido 
Manejo del Portapapeles ............................................................................................................................... 385 
 Len: longitud del texto .......................................................................................................................... 386 
 Propiedades del objeto fuente: SelStart, SelLength y SelText .............................................. 386 
 Métodos del objeto Clipboard: Clear, SetText y GetText .......................................................... 387 
Resumen ........................................................................................................................................................ 393 
Capítulo 15: Manejo de imágenes .............................................................................................................. 395 
Controles básicos para mostrar imágenes ....................................................................................................... 396 
Image .............................................................................................................................................................. 396 
 LoadPicture ......................................................................................................................................... 396 
PictureBox ................................................................................................................................................. 400 
Adición de componentes al proyecto .............................................................................................................. 405 
Almacenamiento de imágenes ......................................................................................................................... 409 
ImageList ( Microsoft Windows Common Controls 6.0) ...................................................................... 410 
Resumen .......................................................................................................................................................... 419 
 Algunas respuestas a los ejercicios ............................................................................................................. 419 
Capítulo 16; Arrastrar y colocar ................................................................................................................. 421 
Arrastrar y colocar .......................................................................................................................................... 422 
Estados de transición y punteros predefinidos ................................................................................................ 432 
Punteros predefinidos del entorno de Windows ..................................................................................... 433 
Manejo en modo manual de arrastrar y colocar .............................................................................................. 435 
Resumen .......................................................................................................................................................... 441 
Capítulo 17: Control del tiempo .................................................................................................................. 443 
Control básico para controlar el tiempo .......................................................................................................... 444 
 Timer ...................................................................................................................................................... 444 
Resumen .......................................................................................................................................................... 449 
Capítulo 18: Manejo del sistema de archivos ............................................................................................. 451 
El sistema de archivos .....................................................................................................................................452 
Controles básicos para el manejo del sistema de archivos .............................................................................. 452 
DriveListBox ............................................................................................................................................ 452 
DirListBox ................................................................................................................................................. 453 
FileListBox .............................................................................................................................................. 453 
Manejo del objeto FileSystem ................................................................................................................... 461 
 Manipulación de subdirectorios ................................................................................................................... 461 
 Manipulación de archivos ............................................................................................................................ 468 
Resumen ........................................................................................................................................................... 474 
Capítulo 19: Cuadros de diálogo comunes ...................................................................................................477 
Cuadros de diálogo comunes ............................................................................................................................478 
 CommonDialog ( Microsoft Common Dialog Control 6.0) ..................................................................... 478 
 Indicadores ................................................................................................................................................... 480 
 Manejo de errores ......................................................................................................................................... 481 
 Cuadro de diálogo Color ............................................................................................................................. 482 
 Cuadro de diálogo Fuente ............................................................................................................................ 485 
 Cuadro de diálogo Imprimir ........................................................................................................................ 491 
 Cuadro de diálogo Abrir/Guardar como ...................................................................................................... 497 
Resumen .......................................................................................................................................................... 504 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Contenido xi 
Capítulo 20: Cómo trabajar en una interfaz de múltiples documentos ............................................... 505 
 Fundamentos del entorno MDI .................................................................................................................. 506 
 Limitaciones que implica el uso de un formulario MDI ....................................................................... 508 
Cómo preparar su aplicación para compilación y distribución ................................................................... 511 
Resumen ...................................................................................................................................................... 512 
Capítulo 21: Controles ActiveX para mejorar la interfaz ..................................................................... 513 
Controles comunes de Windows ................................................................................................................. 514 
 ProgressBar ( Microsoft Windows Common Controls 6.0) ....................................................... 514 
 TreeView ( Microsoft Windows Common Controls 6.0) ............................................................. 518 
 Cómo agregar opciones a un sistema TreeView ............................................................................... 519 
 StatusBar ( Microsoft Windows Common Controls 6.0) ............................................................ 526 
 Cómo agregar opciones a un objeto basado en StatusBar .............................................................. 526 
 ToolBar ( Microsoft Windows Common Controls 6.0) ................................................................. 529 
 Cómo agregar opciones a un objeto basado en StatusBar .............................................................. 530 
Resumen ...................................................................................................................................................... 537 
 
 
Parte 4: Archivos y bases de datos 
Capítulo 22: Bases de datos y DAO ......................................................................................................... 541 
Conceptos de bases de datos ....................................................................................................................... 542 
 Base de datos, tabla, registro y campo ................................................................................................... 542 
 Clave primaria ........................................................................................................................................ 543 
 Clave externa y relaciones ...................................................................................................................... 544 
 Integridad referencial .............................................................................................................................. 545 
 Índices ..................................................................................................................................................... 545 
El motor de base de datos Microsoft Jet ...................................................................................................... 550 
 La interfaz de usuario y el código de aplicaciones ................................................................................ 550 
 El motor de base de datos ....................................................................................................................... 551 
 El almacén de datos ................................................................................................................................ 551 
DAO ............................................................................................................................................................. 551 
 Clases, objetos y colecciones ................................................................................................................. 554 
 Divisiones de la programación de bases de datos .................................................................................. 555 
 Lenguaje de Definición de Datos ........................................................................................................... 555 
 Lenguaje de Manipulación de Datos ...................................................................................................... 556 
Resumen ...................................................................................................................................................... 556 
 Algunas respuestas a los ejercicios ........................................................................................................ 556 
Capítulo 23: Lenguaje de Definición de Datos y DAO ........................................................................... 559 
Lenguaje de Definición de Datos ................................................................................................................. 560 
 Tipos de objetos en DAO ........................................................................................................................561 
 Sintaxis para el uso de colecciones ........................................................................................................ 562 
 Variables objeto ...................................................................................................................................... 563 
 Espacio de trabajo e integración de la base de datos .............................................................................. 570 
 Métodos Create ................................................................................................................................... 570 
 Bloque With... End With ................................................................................................................ 573 
 Elementos requeridos para agregar objetos ............................................................................................ 576 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
xii Contenido 
Cómo trabajar con las colecciones de DAO ................................................................................................... 587 
Resumen .......................................................................................................................................................... 594 
 Algunas respuestas a los ejercicios ........................................................................................................ 595 
Capítulo 24: Lenguaje de Manipulación de Datos y DAO ........................................................................ 597 
Lenguaje de Manipulación de Datos .............................................................................................................. 598 
 Validaciones a nivel tabla ....................................................................................................................... 599 
 Validaciones a nivel base de datos .......................................................................................................... 599 
Operaciones básicas de manipulación de bases de datos ............................................................................... 600 
Tareas de apertura de base de datos ................................................................................................................ 601 
 OpenDatabase ....................................................................................................................... 601 
 OpenRecordset ..................................................................................................................... 602 
 Tipos de Recordset ............................................................................................................... 603 
 Close ...................................................................................................................................... 605 
Tareas de escritura de datos (partel) ................................................................................................................ 605 
 AddNew y actualización al almacén de datos .......................................................................................... 606 
Tareas de búsqueda de datos (parte 1) ............................................................................................................. 609 
 Seek ........................................................................................................................................................ 609 
 Propiedad Index ..................................................................................................................................... 609 
 Propiedad NoMatch ................................................................................................................................ 610 
Tareas de escritura de datos (parte 2) .............................................................................................................. 610 
 Edit ........................................................................................................................................................ 611 
 Update .................................................................................................................................................... 611 
 Delete .................................................................................................................................................... 612 
Técnica RAR ................................................................................................................................................... 613 
Tareas de movimiento entre datos ................................................................................................................... 622 
Tareas de búsqueda de datos (parte 2) ............................................................................................................. 627 
 Condición ................................................................................................................................................... 628 
 Métodos Find ........................................................................................................................................... 629 
Resumen ........................................................................................................................................................... 636 
Capítulo 25: Controles Data y FlexGrid ................................................................................................ 639 
Control Data .................................................................................................................................................... 640 
 Objetos vinculados a campos de base de datos ........................................................................................ 641 
FlexGrid ...................................................................................................................................................... 646 
Consideraciones de incompatibilidad entre Access 97 y Access 2000 ........................................................... 649 
Resumen .......................................................................................................................................................... 655 
Capítulo 26: Bases de datos multiusuario usando DAO ........................................................................... 657 
La necesidad de capacidades multiusuario ..................................................................................................... 658 
 Cómo abrir la base de datos en modo compartido ................................................................................... 658 
 Cómo abrir los Recordsets en modo compartido .............................................................................. 659 
 Problemas al escribir y concepto de bloqueo ........................................................................................... 660 
Bloqueo pesimista y optimista ....................................................................................................................... 662 
 Bloqueo pesimista .................................................................................................................................... 662 
 Bloqueo optimista .................................................................................................................................... 663 
 Aclaración del "bloqueo de registros" ..................................................................................................... 664 
Manejo de errores para el modo multiusuario ................................................................................................ 665 
 On Error ............................................................................................................................... 665 
 Etiquetas .................................................................................................................................665 
 GoTo ........................................................................................................................................ 665 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Contenido xiii 
 Resume ............................................................................................................................................... 666 
Err y Error ....................................................................................................................................... 666 
Exit Sub ............................................................................................................................................. 666 
Resumen ....................................................................................................................................... 672 
 
Capítulo 27: Archivos planos para transferencia de datos ...................................................... 675 
Los archivos planos siguen vigentes ............................................................................................................... 676 
Creación y lectura de archivos planos ............................................................................................................. 677 
 Open ........................................................................................................................................................ 678 
 FreeFile ............................................................................................................................................... 678 
 Tipos de datos definidos por el usuario .................................................................................................... 679 
 Cómo escribir en un archivo ..................................................................................................................... 679 
 Input ...................................................................................................................................................... 684 
Resumen .......................................................................................................................................................... 688 
 
Capítulo 28: Manejo de bases de datos corporativas usando ADO ........................................ 689 
Bases de datos más allá de la computadora personal ...................................................................................... 690 
 Objeto de Datos ActiveX .......................................................................................................................... 690 
 Pubs: La base de datos de ejemplo ............................................................................................................ 692 
 Ejecución front - end a través de ADO ..................................................................................................... 693 
 Conexión a una base de datos corporativa mediante ADO ...................................................................... 694 
 Peticiones al servidor de bases de datos utilizando ADO ........................................................................ 701 
DataGr-id ( Microsoft DataGrid Control OLEDB) ................................................................................... 704 
SQL............................................................................................................................................................... 709 
DML usando ADO ........................................................................................................................................ 720 
ADO a través de ODBC ................................................................................................................................ 732 
 Conexión a través de DSN almacenado en el Registro ........................................................................... 733 
 Conexión a través de DSN almacenado en archivo DSN ....................................................................... 733 
MDAC y problemas comunes en el enlace ................................................................................................... 735 
Resumen ........................................................................................................................................................ 736 
 
Capítulo 29: Data Environment ................................................................................................. 737 
Organización de enlaces a datos utilizando el Data Environment ................................................................ 738 
 Estructura jerárquica del Data Environment .......................................................................................... 739 
Resumen ....................................................................................................................................................... 749 
Capítulo 30: Data Report ........................................................................................................... 751 
Informes a través del Data Report ................................................................................................................ 752 
 Cómo agregar un Data Report a un proyecto .......................................................................................... 752 
 Objetos del Data Report .......................................................................................................................... 753 
 Secciones del Data Report ....................................................................................................................... 753 
 Controles del Data Report ...................................................................................................................... 754 
Desarrollo de un informe .............................................................................................................................. 755 
 ¿Qué queremos? La imagen visual del informe ...................................................................................... 755 
 Cómo agregar campos del Data Environment al Data Report ................................................................ 760 
 Cómo agregar objetos al Data Report ..................................................................................................... 762 
Informes con grupos de datos ........................................................................................................................ 769 
 Data Environment para informes con grupos .......................................................................................... 771 
 Cómo se organizan las secciones ............................................................................................................. 776 
 Campos calculados y objetos rptFunction ........................................................................................ 783 
Resumen ......................................................................................................................................................... 787 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
xiv Contenido 
 
Parte 5: Apéndices 
Apéndice I: Convenciones ......................................................................................................................... 791 
Prefijos para los controles ............................................................................................................................ 791 
 Prefijos sugeridos para DAO .................................................................................................................. 794 
 Prefijos sugeridos para menús ................................................................................................................ 795 
 Selección de prefijos para otros controles ..............................................................................................795 
Convenciones de nombres de constantes y variables ................................................................................... 795 
 Prefijos de alcance de variables .............................................................................................................. 796 
 Constantes ............................................................................................................................................... 797 
 Variables .................................................................................................................................................. 797 
 Tipos de datos de variables ..................................................................................................................... 798 
 Nombres descriptivos de variables y procedimientos ............................................................................ 798 
 Tipos definidos por el usuario ................................................................................................................ 799 
Convenciones de codificación estructurada ................................................................................................. 799 
 Convenciones de comentarios al código ................................................................................................ 799 
 Cómo formatear el código ...................................................................................................................... 801 
 Agrupación de constantes ....................................................................................................................... 801 
 Operadores & y + .................................................................................................................................... 802 
 Creación de cadenas para MsgBox, InputBox y consultas SQL ........................................................ 802 
Apéndice II: Service Pack 5.0 de Visual Studio 6.0 ................................................................................... 803 
Necesidad del Service Pack ............................................................................................................................ 803 
 Consideraciones de instalación ................................................................................................................. 805 
Actualizaciones de productos relativos a Visual Basic ................................................................................... 807 
 Microsoft® Agent 2.0 ............................................................................................................................... 807 
 Visual Studio Installer ............................................................................................................................... 807 
Problemas con los controles, resueltos con SP5 .............................................................................................. 807 
Artículos de Microsoft Knowledge Base sobre los errores solucionados ........................................................ 812 
 
Índice ................................................................................................................................................................813 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ÍNDICE DE PRÁCTICAS 
_________________________________________________________________________ 
 
 
Parte 1: Entorno Integrado de Desarrollo 
Capitulo 1: Visual Basic como plataforma de desarrollo 
 01.01 Cómo iniciar sesión en Visual Basic...................................................................................... 6 
01.02 Cómo cerrar una sesión en Visual Basic................................................................................ 8 
01.03 Cómo activar los elementos del IDE ................................................................................... 11 
01.04 Cómo establecer el entorno de desarrollo a SDI ................................................................. 14 
01.05 Ubicación de los controles ................................................................................................... 22 
01.06 Cómo ocultar y mostrar formularios..................................................................................... 26 
01.07 Uso de la ventana Propiedades ............................................................................................. 30 
Capitulo 2: Creación de la interfaz de usuario 
02.01 Cómo insertar un objeto en la interfaz.................................................................................. 38 
02.02 Cómo cambiar la posición o las dimensiones de un objeto................................................... 43 
02.03 Cómo seleccionar un formulario... ....................................................................................... 45 
02.04 Corno cambiar el tamaño de un formulario. ......................................................................... 45 
02.05 Cómo guardar su trabajo....................................................................................................... 46 
02.06 Cómo agregar objetos en modo de trazo .............................................................................. 47 
02.07 Selección de objeto activo. en forma individual o en modo de grupo ................................. 49 
02.08 Cómo determinar la posición de un formulario en la pantalla ............................................. 51 
02.09 Cómo establecer las Guías de resolución ............................................................................. 53 
02.10 Cómo utilizar las herramientas del menú Formato para organizar objetos...................................... 54 
Capítulo 3: Cómo establecer las propiedades de los objetos 
03.01 Cómo validar la cantidad y el tipo de objetos requeridos en una aplicación......................... 60 
03.02 Cómo modificar la propiedad Ñame de los objetos............................................................... 66 
03.03 Cómo modificar las propiedades de apariencia y comportamiento....................................... 68 
 Capítulo 4: Escritura del código de los eventos 
04.01 Cómo abrir la ventana Código............................................................................................... 81 
04.02 Cómo manejar los componentes de la ventana Código ........................................................ 82 
04.03 Manejo de colores y autoformato al editar código................................................................. 85 
04.04 Compilación y detección de errores en modo de edición...................................................... 86 
04.05 Sugerencia de propiedades y métodos en modo de edición................................................... 87 
04.06 Uso de los cuadros Objeto y Evento para la selección y codificación de un procedimiento 
de evento determinado .......................................................................................................... 90 
04.07 Uso del carácter de .subrayado y la ayuda contextual en modo de edición........................... 92 
Capítulo 5: Cómo guardar y ejecutar aplicaciones 
05.01 Archivos de trabajo en Visual Basic ................................................................................. 104 
05.02 Cómo abrir un proyecto previamente guardado................................................................. 107 
05.03 Cómo ejecutar e interrumpir su programa.......................................................................... 110 
05.04 Cómo seleccionar el proyecto inicial.............. ................................................................... 111 
 
 
 
 
 
xv 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
xvi índice de prácticas 
05.05 Cómo seleccionar el objeto de inicio en un proyecto..........................................................................11305.06 Despliegue de errores en tiempo de ejecución ................................................................................... 116 
05.07 Cómo corregir código en modo de interrupción................................................................................. 118 
05.08 Cómo ejecutar un programa línea por línea................................................. ...................................... 119 
05.09 Cómo agregar y eliminar un punto de interrupción............................................................................ 120 
05.10 Cómo compilar un proyecto para generar un ejecutable en Visual Basic.......................................... 121 
 
Parte 2: Elementos de programación 
 Capítulo 6: Variables y tipos de datos 
06.01 MsgBox: creación de cuadros de información y confirmación de manera rápida..............................133 
06.02 Uso de constantes de Visual Basic...................................................................................................... 138 
06.03 InputBox: acceso rápido de datos ...................................................................................................140 
06.04 Determinación del nombre. tipo de datos y alcance indicado para las variables de memoria.............148 
06.05 Uso de matrices y determinación de límites mínimos y máximos del intervalo de subíndices...........154 
06.06 Declaración automática de variables en Visual Basic..........................................................................155 
06.07 Uso de Option Explicit (requerir la declaración de variables de manera explícita)...................156 
06.08 Cómo establecer Option Explicit de manera automática para todos los formularios nuevos....157 
06.09 Uso de funciones de conversión........................................................................ ................................. 160 
06.10 Uso de la función Format ................................................................................................................ 163 
06.11 Uso de la función Format. en formatos definidos por el usuario..................................................... 165 
 Capítulo 7: Operadores y estructuras de control 
07.01 Uso de los operadores aritméticos .......................................................................................................171 
07.02 Cómo se resuelven las condiciones que incluyen operadores de comparación....................................174 
07.03 Cómo especificar la preferencia al resolver condiciones. mediante el uso de paréntesis ....................177 
07.04 Uso de For Next ................................................................................................................ ...............187 
07.05 Uso de Exit For ................................................................................................................................188 
07.06 Uso de Do Loop .................................................................... .............................................................190 
 Capítulo 8: Funciones de manipulación de datos 
08.01 Uso de funciones de fecha y hora...................................................... .................................................201 
08.02 Uso de funciones de manipulación de cadenas................................................................................... 209 
08.03 Uso de funciones numéricas y de decisión.......................................................................................... 214 
 Capítulo 9: Procedimientos y funciones definidas por el usuario 
09.01 Creación de un procedimiento ............................................................................................................ 224 
09.02 Creación de un procedimiento que no utilice argumentos y devuelva valores................................... 226 
09.03 Creación de un procedimiento que utilice argumentos y devuelva valores........................................ 228 
09.04 Creación de un procedimiento que utilice argumentos opcionales y devuelva valores ..................... 231 
09.05 Creación de un procedimiento que utilice argumentos opcionales con valor predeterminado 
 y devuelva valores................................................................................................................ 233 
09.06 Creación de un procedimiento que utilice un número de argumentos incierto.................................. 236 
 
 
Parte 3: Controles gráficos y programación orientada a eventos 
 Capítulo 10: Controles básicos para la introducción de datos 
10.01 Uso de objetos basados en los controles Label. TextBox y CommandButton......................... 245 
 
 
 
 
 
 
 
 
 
 
 
 
Índice de prácticas xvii 
10.02 Uso de botones predefinidos de aceptación y cancelación y cuadros de texto multilíneas, 
de capacidad limitada.......................................................................................................................................... 251 
10.03 Uso de caracteres para escritura oculta y validación inmediata de caracteres, asegurando 
la captura de caracteres en mayúscula. Habilitar e inhabilitar botones............................................................... 256 
Capítulo 11: Programación orientada a eventos 
11.01 Demostración de algunos de los eventos de tipo Clic, Cambios y Enfoque.............................................. 271 
11.02 Demostración de algunos de los eventos de tipo Teclado ......................................................................... 279 
11.03 Demostración de algunos de los eventos de tipo Ratón ............................................................................ 285 
11.04 Cómo darle riqueza visual a un programa, mediante el evento MouseMove........................................... 287 
11.05 Elaboración de un programa que le permita visualizar la prioridad en la ejecución 
 de los eventos................................................................................................................................................. 295 
11.06 Demostración de la precedencia del evento MouseMove sobre el evento Click.................................. 301 
Capítulo 12: Controles contenedores y controles de selección 
12.01 Cómo utilizar un objeto contenedor para darle funcionalidad a una aplicación ................................... 307 
12.02 Uso de un control CheckBox para seleccionar varias características de manera simultánea ............. 312 
12.03 Uso de una matriz de controles y su uso a través de For Next y For Each .................................... 319 
12.04 Uso de funciones RGB y QBGolor para la manipulación de colores................................................... 325 
12.05 Uso de objetos tipo OptionButton y Shape, y de una matriz de controles ................................... 326 
12.06 Uso de barras de desplazamiento y números aleatorios ........................................................................ 332 
Capítulo 13: Controles de listas desplegables 
13.01 Utilización de un objeto ListBox, agregándole y eliminándole elementos 
de forma dinámica............................................................................................................................................. 349 
13.02 Uso de objetos ListBox de selección múltiple, que pasan elementos de una lista a otra.................... 354 
13.03 Uso de un objeto ListBox con estilo CheckBox................................................................................ 358 
13.04 Uso de los objetos ComboBox y ListBox para crear un explorador de fuentes.................................. 361 
13.05 Uso de un objeto ComboBox sensible a la escritura............................................................................... 365 
Capítulo 14: Editor de menús y manejo del Portapapeles 
14.01 Cómo se agrega un objeto de tipo menú.................................................................................................. 375 
14.02 Cómointroducir código a una opción de menú y utilizar un menú......................................................... 380 
14.03 Activación dinámica de opciones............................................................................................................. 381 
14.04 Modificación del tipo de letra utilizando el menú.................................................................................... 383 
14.05 Opciones de menú mutuamente excluyentes............................................................................................ 384 
14.06 Cómo se maneja el Portapapeles en Visual Basic..................................................................................... 387 
Capítulo 15: Manejo de imágenes 
15.01 Uso de objetos basados en el control Image y carga de imágenes con LoadPicture....................... 398 
15.02 Uso de objetos basados en el control PictureBox y modificación dinámica de imágenes ................ 401 
15.03 Cómo agregar componentes a un proyecto de Visual Basic .................................................................... 406 
15.04 Almacenamiento de imágenes en un objeto ImageList ...................................................................... 410 
15.05 Uso de una colección de imágenes ImageList .................................................................................... 416 
Capítulo 16: Arrastrar y colocar 
16.01 Programa que comprueba las operaciones de arrastrar y colocar.............................................................. 423 
16.02 Programa que comprueba las operaciones de arrastrar y colocar cuando el objeto de destino 
 no es de tipo Form......................................................................................................................................... 426 
 
 
 
 
 
 
 
 
 
 
 
 
xviii índice de prácticas 
16.03 Programa que comprueba las operaciones de arrastrar y colocar, y que utiliza un objeto 
 de destino que no es de tipo Form ......................................................................................................... 428 
16.04 Programa que comprueba los estados de las operaciones de arrastrar y colocar, así como 
 los punteros predefinidos del entorno de Windows ............................................................................... 434 
16.05 Programa que comprueba las operaciones de arrastrar y colocar utilizando el modo manual ........... 436 
Capítulo 17: Control del tiempo 
17.01 Uso del control Timer como valor absoluto. Un reloj.......................................................................444 
17.02 Uso del control Timer como valor relativo. Cuenta regresiva en captura.........................................446 
Capítulo 18: Manejo del sistema de archivos 
18.01 Uso de los controles básicos para el manejo del sistema de archivos................................................. 454 
18.02 Uso del objeto FileSystem para manipulación de directorios....................................................... 463 
18.03 Uso del objeto FileSystem para manipulación de archivos........................................................... 469 
Capítulo 19: Cuadros de diálogo comunes 
19.01 Cómo agregar el control CommonDialog al Cuadro de herramientas............................................. 479 
19.02 Uso del control CommonDialog para manipular el color en el formato estándar 
de Windows................................................................................................................................................... 482 
19.03 Uso del control CommonDialog para manipular las fuentes (tipos de letra) en el formato 
estándar de Windows.................................................................................................................................... 488 
19.04 Uso del control CommonDialog para manipular las especificaciones de impresora 
en el formato estándar de Windows.............................................................................................................. 493 
19.05 Uso del control CommonDialog para manejar el cuadro de diálogo Abrir/ Guardar como, 
en el formato estándar de Windows ............................................................................................................. 501 
Capítulo 20: Cómo trabajar en una interfaz de múltiples documentos 
20.01 Cómo agregar un formulario maestro para trabajo en MDI y los formularios hijos.......................... 506 
20.02 Cómo trabajar con varios formularios ............................................................................................... 509 
Capítulo 21: Controles ActiveX para mejorar la interfaz 
21.01 Uso de objetos basados en el control ProgressBar ..................................................................... 515 
21.02 Uso de TreeView ............................................................................................................................ 521 
21.03 Uso de StatusBar y ToolBar ..................................................................................................... 532 
 
Parte 4: Archivos y bases de datos 
Capítulo 22: Bases de datos y DAO 
22.01 Análisis de un modelo relacional de bases de datos. 
22.02 Identificación de elementos del modelo de datos ...... 
Capítulo 23: Lenguaje de Definición de Datos y DAO 
23.01 Habilitación de DAO.......................................................................................................................... 564 
23.02 DDL utilizando DAO: declaración de variables objeto...................................................................... 565 
23.03 DDL utilizando DAO: creación del almacén de base de datos........................................................... 574 
23.04 DDL utilizando DAO: creación de estructura de tablas y sus campos................................................ 579 
23.05 DDL utilizando DAO: creación de índices .........................................................................................582 
 
 
 
 
 
 
 
 
 
 
 
 
Índice de prácticas xix 
23.06 DDL utilizando DAO: creación de relaciones.................................................................................. 584 
23.07 Ingeniería inversa utilizando DAO: determinación del modelo de datos a partir 
 de un almacén de datos .......................................................................................................................... 589 
Capítulo 24: Lenguaje de Manipulación de Datos y DAO 
24.01 DML utilizando DAO: actualización de una tabla mediante la técnica RAR..................................... 614 
24.02 DML utilizando DAO: métodos de movimiento entre registros......................................................... 623 
24.03 DML utilizando DAO: búsqueda basada en criterios ......................................................................... 630 
Capítulo 25: Controles Data y FlexGrid 
25.01 Uso del control Data para agregar, eliminar, modificar y consultar registros................................... 642 
25.02 Uso del control Data para alimentar un FlexGrid ........................................................................647 
25.03 SQLViewer: intérprete de SQL para DAO, usando los controles Data y FlexGrid..................... 650 
Capítulo 26: Bases de datos multiusuario usando DAO 
26.01 Rutina de manejo de errores ............................................................................................................... 666 
26.02 Uso del DAO para aplicaciones multiusuario..................................................................................... 669 
Capítulo 27: Archivos planos para transferencia de datos 
27.01 Creación y escritura en archivos planos.............................................................................................. 680 
27.02 Proceso para bajar datos de una base de datos a archivos planos ...................................................... 682 
27.03 Cómo cargar datos a una base de datos desdeun archivo.................................................................. 685 
Capítulo 28: Manejo de bases de datos corporativas usando ADO 
28.01 Conexión a bases de datos corporativas usando ADO........................................................................ 697 
28.02 Visualización de bases de datos corporativas utilizando el control DataGrid y ADO....................705 
28.03 Consultas SQL a bases de datos corporativas usando ADO............................................................... 713 
28.04 DML utilizando ADO: actualización de una tabla mediante la técnica RAR..................................... 722 
Capítulo 29: Data Environment 
29.01 Uso del Data Environment para manejar bases de datos corporativas ............................................... 742 
Capítulo 30: Data Report 
30.01 Cómo definir un Data Environment para utilizarlo con el Data Report.............................................. 757 
30.02 Cómo complementar con objetos rptTextBox la sección Detalle de un Data Report................... 761 
30.03 Cómo complementar el Data Report con objetos rptLabel y rptLine. Asignación 
 de valores a objetos rptLabel ............................................................................................ 763 
30.04 Cómo complementar el Data Report con objetos rptShape y rptimage................................... 767 
30.05 Cómo definir un Data Environment para utilizarlo con el Data Report basado 
 en grupos de información........................................................................................................................ 772 
30.06 Cómo definir un Data Report basado en grupos de información........................................................ 778 
30.07 Cómo integrar a un informe datos consolidados, de la base de datos y de campos calculados...........785 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
LO INESPERADO 
_________________________________________________________________________ 
Errores en tiempo de diseño 
Apertura no solicitada de la ventana Código.................................................................................................... 43 
Changed database context to "Database" ...................................................................................................... 735 
¿Desea crear una matriz de controles?............................................................................................................... 65 
Especificación de alcance de procedimiento no requerida................................................................................ 93 
Formato regional de Windows afecta el valor devuelto de la función Format............................................... 165 
Las secciones del informe no coinciden con el origen de datos ..................................................................... 786 
No aparece la ventana Nuevo proyecto............................................................................................................... 7 
No hay ninguna fuente .................................................................................................................................... 488 
No se encontró campo <campo>.................................................................................................................... 786 
No se encuentra Data Environment en el menú Proyecto ............................................................................... 743 
No se puede colocar el control <control> en esta sección.............................................................................. 786 
No se recuperan datos,..................................................................................................................................... 748 
 
Errores de compilación (orden alfabético) 
Bloque if sin end if .......................................................................................................................................... 180 
Do sin Loop ..................................................................................................................................................... 190 
El Character de declaración de tipo no coincide con el tipo de datos declarado.......................................... 147 
El Character no es válido ............................................................................................................................... 147 
El número de dimensiones es incorrecto ......................................................................................................... 153 
End if sin bloque if .......................................................................................................................................... 180 
End Select sin Select Case .............................................................................................................................. 185 
For sin Next ..................................................................................................................................................... 188 
Loop sin Do ..................................................................................................................................................... 191 
Next sin For ..................................................................................................................................................... 189 
No coinciden los tipos ..................................................................................................................................... 397 
No se encontró el método o el dato miembro .................................................................................................. 248 
No se encontró método o elemento de datos ................................................................................................... 114 
No se ha definido el tipo definido por el usuario ........................................................................................... 570 
No se ha encontrado el archivo ....................................................................................................................... 397 
No se puede asignar a una matriz .................................................................................................................. 153 
Origen de datos no válido............................................................................................................................... 786 
Procedimiento Sub o Function no definido ..................................................................................................... 115 
Referencia de variable de control Next no válida ........................................................................................... 189 
Se esperaba ")", "(" ......................................................................................................................................... 228 
Se esperaba el fin de la instrucción.................................................................................................................. 146 
Se esperaba fin de la función ........................................................................................................................... 228 
Select Case sin End Select .............................................................................................................................. 185 
Uso no válido de una propiedad ..................................................................................................................... .248 
XX 
 
 
 
 
 
 
 
 
 
 
Lo inesperado xxi 
Errores en tiempo de ejecución (orden consecutivo) 
Algunos campos no regresan valores al ejecutar el informe........................................................................... 766 
El tamaño del informe excede el tamaño de la página.................................................................................... 766 
Error desconocido ADO.................................................................................................................................734 
No se encuentra el nombre del origen de datos (Administrador ODBC)....................................................... 734 
Error 5: Llamada a procedimientos o argumentos no válidos ........................................................................ 368 
Error 6: Desbordamiento................................................................................................................................. 146 
Error 9: El subíndice está fuera del intervalo....................,............................................................................ 153 
Error 13: No coinciden los tipos ...................................................................................................................... 228 
Error 48: Error al cargar la biblioteca "archivo.ocx".................................................................................... 735 
Error 53: No se ha encontrado el archivo....................................................................................................... 397 
Error 68: El dispositivo no está disponible ..................................................................................................... 463 
Error 75: Error de acceso a ruta o archivo ..................................................................................................... 463 
Error 76: No se ha encontrado la ruta de archivo........................................................................................... 462 
Error 91: Variable de tipo objeto o la variable de bloque With no está definida............................................ 730 
Error 380: El valor de la propiedad no es válido ........................................................................................... 515 
Error 424: Se requiere un objeto ............................................................................................................. 115, 247 
Error 481: La imagen no es válida.................................................................................................................. 397 
Error 3020: Update o CancelUpdate sinAddNew o Edit ................................................................................ 612 
Error 3044: {Rutaj No es una ruta válida ...................................................................................................... 575 
Error 3078: El motor de base de datos Jet no encuentra la tabla o query ..................................................... 603 
Error 3204: Base de datos ya existe................................................................................................................. 575 
Error 3264: No hay campos definidos - No se puede agregar el objeto TableDefo índex ............................. 576 
Error 3265: Elemento no encontrado en esta colección ................................................................................ 608 
Error 3368: Relaciones deben ser por el mismo número de campos del mismo tipo de datos ....................... 587 
Error 3420: Objeto inválido o no permanece definido ................................................................................... 578 
Error 3421: Error de conversión de tipo de datos .......................................................................................... 620 
Error 35600 El índice está fuera de los límites .............................................................................................. 415 
Error 35601 No se encontró el elemento ........................................................................................................ 415 
Error-2147217843: Conexión inválida............................................................................................................ 707 
Error -2147217843: Login failed.................................................................................................................... 707 
Error -2147217843: Attempt to locate entry in sysdatabase.......................................,................................... 708 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
PRÓLOGO 
_________________________________________________________________________ 
Aprenda Visual Basic practicando es un libro de propuesta. 
Nace de una realidad evidente: la gente compra los libros de programación para aprender. En muchos casos 
adquiere el conocimiento como resultado de la lectura y, sin embargo, está inconforme con el resultado y con sus 
propias potencialidades. La consecuencia obligada, si su afán de aprender persiste o si las necesidades de trabajo 
así lo demandan, es que termina tomando un curso. 
Tal pareciera entonces que los cursos son más completos, más efectivos, lo que nos lleva a planteamos la pregunta 
cuya respuesta mueve este libro: ¿qué tienen los cursos que no tengan los libros? La respuesta es simple: los 
cursos tienen más acción, como dirían algunos; hay interacción, aciertos y errores, el hacer del participante es 
diferente al hacer que corresponde al lector de un libro. 
Conocer la teoría es importante, pero no suficiente; todo lo plasmado en un libro funciona bien, pero en la realidad 
las cosas no siempre suceden de manera tan favorable en el trabajo diario. En la realidad aparecen situaciones 
inexploradas por los libros, en donde más que conocer la teoría, se requiere haberla comprendido mediante la 
vivencia práctica, para poder así ejercer el pensamiento lateral que nos lleve a resolver problemas ante los cuales 
nunca nos habíamos enfrentado. 
Éste es un libro práctico y creemos firmemente que la práctica hace al maestro. Cada capítulo tiene su objetivo 
particular, no sólo explica algo, sino sirve para algo. Es un libro en el que se vale escribir, de hecho se 
recomienda; está lleno de conceptos, cuestionarios, ejemplos, ejemplos y ejemplos. Es como leer un libro que 
además le brinda los elementos para que trabaje como lo haría en un curso. Reúne lo mejor de los dos mundos. 
Es excelente para el lector autodidacta, ya que le permite asimilar la información y practicar lo aprendido, así 
como dar seguimiento a sus propios avances en el aprendizaje. Para los maestros e instructores de Visual Basic, es 
un apoyo valioso como material de texto. Para el programador que ya ha tenido contacto con Visual Basic, es una 
caja de trucos que le puede facilitar la tarea de desarrollar aplicaciones avanzadas o pulir las que haya 
desarrollado. En términos generales, es útil para aquellos que no se dejan llevar por la engañosa creencia de que 
programar se aprende leyendo; programar se aprende programando y punto. 
Sólo esperamos una cosa: que practique, comprenda y aprenda Visual Basic. 
José Felipe Ramírez Ramírez 
Catedrático de la Universidad 
Autónoma de Nuevo León 
xxii 
 
 
 
 
 
 
 
 
 
 
FORMA Y CONTENIDO DEl LIBRO 
_________________________________________________________________________ 
 
 
La organización de este libro 
Este libro está dividido en cinco partes: 
• Entorno Integrado de Desarrollo. Trata de manera detallada los elementos y herramientas que 
Visual Basic proporciona para soportar el desarrollo de aplicaciones para Windows 95, 98, 2000 y 
NT. En esta parte se revisa el ciclo de desarrollo de aplicaciones de Visual Basic, desde el inicio 
de un proyecto hasta su compilación a ejecutable (EXE) para su distribución. Es fundamental que 
asimile y domine todo lo expuesto en esta parte, incluso si ya maneja Visual Basic, a efecto de 
unificar los conceptos que maneja el libro. 
• Elementos de programación. Trata de manera detallada los elementos de programación en Visual 
Basic, como el manejo de variables, procedimientos, funciones implícitas del lenguaje, tipos de 
datos, estructuras de control, etcétera. Si verdaderamente quiere ser un experto en Visual Basic, es 
necesario que deje lo sencillo, el lado "Visual", para profundizar en primera instancia en su lado 
"Basic". 
• Controles gráficos y programación orientada a eventos. Trata de manera detallada los controles 
básicos de Visual Basic. Al terminaresta parte, estará listo para diseñar cualquier interfaz de 
usuario que se proponga desarrollar. También se revisa el manejo de algunos controles ActiveX 
que proporcionarán un aspecto profesional a sus aplicaciones. 
• Archivos y bases de datos. Trata de manera específica la forma de utilizar bases de datos con 
Visual Basic, introduciéndolo a técnicas avanzadas para el registro, recuperación y eliminación de 
información, representación de modelos de datos en Visual Basic y el manejo de instrucciones 
SQL, utilizando para ello las versiones más recientes de las colecciones de objetos para manejo de 
datos: 
Objetos de Acceso a Datos de Microsoft, Objetos de Datos ActiveX de Microsoft y enlaces mediante 
ODBC. Esta parte también trata la manipulación de archivos de texto utilizando Visual Basic, así 
como el manejo del diseñador Data Report, que le permitirá crear informes para su salida en 
pantalla o papel. 
• Apéndices. Aquí se detallará información del producto y las costumbres asociadas a su uso. Los 
apéndices constituyen una referencia que no debe dejar de consultar para obtener buenos productos 
de su trabajo. Se tratarán en este caso las 
xxiii 
 
 
 
 
 
 
 
 
 
 
 
 
 
xxiv Forma y contenido del libro 
convenciones de la programación en Visual Basic, así como las mejoras relacionadas con el Service 
Pack 5.0 de Visual Studio. 
Cada parte se divide a su vez en capítulos; cada uno de los cuales tiene una organización consistente 
que facilita la presentación del material. 
• Cada capítulo tiene el tamaño adecuado para manejar un tema de manera completa, sin ser muy 
extenso; la idea es que no interrumpa un tema sin agotarlo. 
• Cada capítulo inicia con una sección de Objetivos, la cual describe de manera rápida lo que se 
pretende aprender en dicho capítulo. 
• Al final de cada capítulo se encontrará una sección de Resumen, en la cual se enumerarán los 
puntos más importantes, principalmente los que serán indispensables para capítulos posteriores. En 
el resumen también podrá encontrar respuestas relativas a algunas prácticas del capítulo. 
 
Notas 
Las notas que aparecen en el contenido de este libro pueden ser de los siguientes tipos: 
• Las referencias marcadas como Nota contienen información suplementaria, que no repercute en la 
realización de una tarea, pero que sin duda enriquecerá su acervo de conocimientos relativos a 
Visual Basic. 
• Las notas marcadas como Lo inesperado contienen explicaciones de aquello que le puede suceder 
y que no esperaba que ocurriera; comportamientos extraños, errores, situaciones imprevistas de 
toda índole. Por lo general, seguirán de prácticas que con toda intención generan el error, a efecto 
de que usted lo pueda analizar y prevenir. Este tipo de notas será vital para usted, ya que los 
errores más comunes y la forma de solucionarlos se detallarán en el momento oportuno. 
 
Prácticas 
• Las prácticas que se encuentren en este libro (que son muchas) estarán presentadas como listas 
numeradas (1, 2, 3, y así sucesivamente). Una viñeta triangular (>>) indica el inicio de una 
práctica. Las prácticas estarán numeradas por Capítulo.Práctica; las prácticas serán su guía para 
saber cómo hacer algo. 
• En el desarrollo de las prácticas será muy frecuente el uso de los menús de Visual Basic; algunos 
de ellos tienen diferentes niveles de profundidad, es decir, de un 
 
 
 
 
 
 
 
 
 
 
 
 
Forma y contenido del libro xxv 
menú surge otro menú, y así sucesivamente. Para manejar esa situación, será lo mismo decir 
"Seleccione en la barra de menús la opción Herramientas, después seleccione Opciones y después, en 
el cuadro de diálogo que aparece, seleccione la ficha Avanzadas", que "Seleccione el menú 
Herramientas — Opciones — Avanzadas". 
 
Lo simplificamos porque en la práctica es así de fácil: mediante tres clics usted ya habrá hecho todo el 
proceso de selección de una opción, en menos de tres segundos. La idea es que el libro no haga que lo 
sencillo parezca complejo. 
 
Notaciones y uso de tipos de letra 
• Se utilizarán itálicas cuando surjan conceptos y términos nuevos, incluyendo elementos propios del 
lenguaje que sean referidos por primera vez. También aplicará para las variables y argumentos, 
cuando aparezcan como parte de una sintaxis. Aplicarán cuando se haga referencia a otros textos, 
cuando se haga referencia a bibliotecas del lenguaje y cuando se describan mensajes de error en las 
secciones de Lo inesperado. 
•Se utilizará MCPdigital (u OCR A Extended) para las propiedades de los objetos (estén o no 
asociadas a los objetos), las referencias a funciones, palabras reservadas y el código de Visual Basic. 
•En la sintaxis, los corchetes "[ ]" encierran aquellos elementos opcionales. Las llaves "( }", por su 
parte, contendrán opciones mutuamente excluyentes. 
•Se utilizarán negritas en los nombres de directorios o archivos. Se utilizarán de igual manera para 
referir nombres de procedimientos creados por el usuario, así como para los datos de entrada que el 
usuario tiene que escribir, incluyendo pulsaciones de teclas. Se utilizarán para identificar las 
herramientas y componentes del Entorno Integrado de Desarrollo, en sus partes no utilizables 
como opción. 
•Se utilizarán negritas itálicas para los elementos de la interfaz que pueden ser utilizados como 
opción, las opciones de menú y otras opciones de interfaz, como botones de comando u otros que 
desencadenen alguna acción determinada, formen parte del Entorno Integrado de Desarrollo, o de 
la interfaz creada por los usuarios. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
xxvi Forma y contenido del libro 
 
Convenciones del teclado 
• El signo de suma (+) entre dos teclas indica que éstas deberán ser presionadas de manera 
simultánea; por ejemplo, "Alt+A". 
Archivos de apoyo 
En el sitio Web http://www.enlace.net/ramirez2 se ha colocado un archivo llamado 
AVBP.ZIP, que contiene los archivos comprimidos que son necesarios para la realización de las 
prácticas del libro. Al ejecutar el programa, se generará un directorio llamado \avbp, que a su 
vez tendrá varios directorios, como sigue: 
 
\avbp 
\cap01 
 \cap02 
\cap03 
.. 
• En \avbp\capn se colocarán los archivos necesarios para que pueda realizar de manera completa 
y correcta las prácticas. La ncorresponde al número de capítulo en donde son requeridos los 
archivos. 
• En \avbp\capn se deberán guardar las aplicaciones que vaya generando, a efecto de que tenga 
debidamente organizado su avance. La n corresponde al número de capítulo en el que son 
generadas las aplicaciones. 
Aunque no todos los capítulos requieren archivos o generan aplicaciones, se incluirán de tal forma 
que se tenga un estándar de uso. No se incluyen los ejercicios ya resueltos; la idea es que usted 
programe, ¿o no? 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
AGRADECIMIENTOS 
Aprenda Visual Basic practicando no es el esfuerzo de una sola persona, y mucho menos la visión unipersonal de 
un profesional en informática con ánimo de sentarse a escribir; más bien es una especie de consolidación 
colectiva, la contribución de muchas cabezas y muchas manos, con el objeto de producir un libro idóneo para 
capacitar a estudiantes de informática en la programación, utilizando para ello Visual Basic. 
Quiero agradecer a todos los que de una forma u otra contribuyeron con el desarrollo de este libro. Los miembros 
de la generación LI@ 1996-2000, de la Facultad de Contaduría y Administración, habitan de manera cómoda y 
curiosa en cada uno de los ejercicios contenidos en el texto: para ustedes mi amistad, mi respeto y mi apoyo 
constante. 
Especialmente agradezco a dos personas: a Dalila Garza Villarreal, quien de manera exhaustiva y dedicada corrió 
a cargo de los trabajos de edición del texto, le agradezco su paciencia y precisión en la revisión de los 
documentos; sin su atinado apoyo, este libro sería una retórica técnica y extraña. A Juan Francisco Guevara 
Álvarez, por otro lado, leagradezco haber probado y criticado todos y cada uno de los ejercicios y su explicación, 
haber aportado ideas ("por qué no le agrega esto Lic...") y por transmitirme la sensación de que la docencia sólo 
tiene esperanza si el alumno llega a superar al maestro. En palabras de Don Alfonso Reyes, son unos héroes en 
mangas de camisa. No temen al trabajo arduo y llegarán lejos. 
Agradezco a todos mis compañeros, que como yo, tienen muy presente que los egresados de la UANL deben ir 
abriendo surco, y que de hecho lo hacen con gusto: José Luis Ramos, Juvencio Jaramillo, Magdiel Martínez, José 
Méndez, Ismael Rodríguez Elizalde, Enrique Hernández Hernández, y a todos los compañeros de la División de 
Postgrado de la FACPyA; agradezco también a mis amigos de la Universidad del Norte, Instituto Tecnológico de 
Monterrey, ITESM, y demás; son tantos que no puedo precisarlos. 
Agradezco a mis amigos Javier Chalup Ayala, José Rogelio Martínez Delgadillo, Abraham Alvarez Escobedo, y 
tantos otros que comprendieron que mi preferente atención hacia el monitor de la computadora era un trance 
pasajero: si me dieran a escoger entre el libro y ustedes, ¡adiós libro! 
Agradezco a los alumnos y ex alumnos que con su retroalimentación ayudaron a obtener un mejor texto: 
Guadalupe Rangel Vázquez, Elsa Marcela Lugo, Anna Elizabeth Franco, Mónica Castañeda Guerra y, 
especialmente, a Mario Alberto Tamez García, quien probó todo el código del libro. 
Como siempre, dejo al último lo más importante: agradezco a mi esposa, a quien dedico este libro, por su 
paciencia y apoyo; a mi padre y a mi madre, porque les debo ser el profesional que soy: sólo cuando uno crece 
comienza a entender y a agradecer. A mis hermanos, todo mi amor y todo lo bueno. 
xxvii 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Parte 1 
Entorno integrado de 
Desarrollo 
 
En esta primera parte conocerá a Visual Basic como herramienta de 
desarrollo de aplicaciones para el entorno de Windows. Así como el 
artesano que termina primero su trabajo es aquel que sabe con 
exactitud de qué herramientas dispone y dónde se encuentran éstas, de 
la misma forma el desarrollador de aplicaciones conoce la enorme 
variedad de utilerías y características que Visual Basic pone a su 
disposición. 
 
Esta primera parte tiene como objetivo que usted sepa qué partes 
componen Visual Basic, cómo se utilizan esas partes, dónde las 
encuentra y cómo puede administrarlas. 
 
También se revisa el ciclo de desarrollo de aplicaciones en Visual 
Basic, que es el típico para la programación orientada a eventos. Se 
propondrá una forma de trabajo sistemática y metódica, que pueda 
repetir una y otra vez; recuerde: lo importante no es lo que hace, sino 
el método que utiliza. Si bajo un método obtiene e| éxito, repitiendo el 
método repetirá el éxito. 
 
Capítulos: 
1,2,3,4,5 
Número de prácticas: 37 
1 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2 
 
 
 
Capítulo 
1 
 
Visual Basic 
como plataforma 
de desarrollo 
 
Objetivos 
Aprender el objeto principal de la programación. Conocer la parte 
gráfica de Visual Basic, a través de su Entorno Integrado de Desarrollo 
(IDE), y la parte procedural, a través del manejo del lenguaje orientado 
a eventos, 
Al finalizar este capítulo deberá: 
• Saber cuál es el objeto de la programación 
• Entender la tecnología orientada a eventos 
• Conocer el Entorno Integrado de Desarrollo 
• Saber cómo está compuesto el IDE y para qué sirven cada una de sus 
partes 
• Dominar los conceptos básicos del desarrollo de aplicaciones en 
Visual Basic 
• Conocer los siete pasos para crear una aplicación en Visual Basic 
 
 
 
3 
 
 
4 Parte 1; Entorno Integrado de Desarrollo 
 
Objeto de la programación 
Usted quiere aprender a programar en Visual Basic. Si no lo ha hecho antes en ningún 
lenguaje y quiere empegar de lleno con la programación, déjeme decirle que estará 
empezando a la mitad en el proceso de desarrollo de aplicaciones: una medianía que si 
no percibe, puede costarle mucho trabajo entender, 
No siempre aprender a programar lo conducirá a solucionar sus problemas de infor-
mación. Simplemente automatizará tareas, y éstas pueden constituir en sí mismas una 
solución o un problema. 
En conclusión, queremos decirle que la programación no es una actividad aislada que 
produzca resultados por sí misma: la programación es una de las muchas tareas que se 
tienen que hacer al desarrollar una aplicación. 
El modelo clásico del Ciclo de Desarrollo de Aplicaciones tiene las siguientes fases: 
 
• Análisis. Se observa detenidamente un problema o situación con el fin de deter-
minar qué aplicación se requiere desarrollar. Se delimitan los problemas o se 
identifican áreas de oportunidad sobre las que hay que trabajar. 
• Diseño, Se define de manera sistemática y estructurada la forma en que se va a 
llevar a cabo el desarrollo. En el diseño se definen las vistas de la aplicación, así 
como su comportamiento y sus restricciones. 
• Programación. Se diseña y codifica la aplicación de tal forma que haga, sin 
errores, lo que está definido en la fase de diseño. 
• Pruebas. Se ejecuta la aplicación en todas sus variantes, a efecto de determinar si 
cumple con lo estipulado en el diseño, y se comprueba que la misma satisfaga los 
requerimientos determinados en la fase de análisis. En caso de que se detecten 
errores o funcionamientos equivocados, es necesario volver sobre las fases 
anteriores, a fin de aislar el problema y corregirlo. 
 
Como puede darse cuenta, la programación es una fase muy avanzada en e] proceso 
de desarrollo; si no sabe qué necesita hacer, mucho menos sabrá cómo hacerlo. Por 
otro lado. si ya sabe qué es lo que necesita hacer, debe asegurarse de que la transición 
del "qué" al "cómo" se haga sin errores. La mayoría de los errores de sistemas son 
debido a que lo especificado en e] análisis y el producto final no representan lo 
mismo. El argumento de los usuarios: "eso no es lo que yo quería", es generalmente 
válido. 
Concluimos que el objeto de la programación es generar código sin errores que 
cumpla con lo definido en el diseño y que satisfaga los requerimientos del análisis. 
En este libro seremos bastante claros con respecto a lo que queremos que el programa 
haga, a cómo lo haga, y además nos aseguraremos de que no tenga errores. Aún más 
importante, queremos que usted aprenda a resolver situaciones que generan error, 
 
 
 
 
Capitulo 1: Visual Basic como plataforma de desarrollo 5 
ya que una vez que concluya el ejercicio de este libro nadie le dirá cómo resolver los 
errores que le aparezcan; serán suyos, como suya será la solución a ellos. 
Nuestros grandes consejos: 
• No comience a programar sino hasta saber qué desea que su programa realice. 
Olvide la creencia de que en un momento de inexplicable lucidez programadora, las 
ideas con respecto a la solución de un problema aparecerán en el proceso de 
codificación. 
• Aprenda a desarrollar siempre de manera organizada y sistemática. Adquirirá 
destreza, experiencia y una facilidad casi automática para resolver errores. 
• Hágalo bien desde el principio. Cree programas bien desarrollados, aunque se tarde 
más; dice un dicho de mi tierra que "el flojo y el atenido trabajan dos veces". 
Piense en el tiempo de desarrollo como la suma del tiempo de desarrollo más el 
tiempo de mantenimiento; en ocasiones los trabajos de mantenimiento son 
demasiado onerosos, y en otros casos, hasta imposibles. 
• Consistencia cognoscitiva en comparación con ignorancia veloz. Con respecto al 
aprendizaje del contenido de este libro, no olvide la parábola de la tortuga y la 
liebre: no siempre el que corre más rápido llega primero a la meta. Comprenda los 
temas hasta que sea capaz de explicarlos sin ayuda del libro, y tema por tema, 
conviértase en un experto. Antes de mover los dedos, hay que mover las neuronas. 
 
Visual Basic más que un lenguaje de programación 
Algunos ubican a VisualBasic como un lenguaje de programación de propósito ge-
neral, otros le atribuyen el carácter de Desarrollo Rápido de Aplicaciones (RAD), e 
incluso hay quienes dicen que es un 4GL. Lo más cercano a la verdad, dentro de las 
definiciones que citamos, es que Visual Basic es un lenguaje de programación de 
propósito general, pero esa apreciación es muy limitada para describir lo que en 
realidad es Visual Basic- El lenguaje es sólo una parte de lo que el producto ofrece; en 
términos generales, Visual Basic es una plataforma de desarrollo de aplicaciones. 
Visual Basic proporciona elementos gráficos de diseño de aplicaciones, compilador, 
editor de programas con capacidad de depuración al instante y asistencia basada en 
colores, ayuda contextual, poderosos asistentes (wizards) que automatizan tareas de 
uso común, tan disímbolas en su objeto como en su complejidad, por citar sólo algu-
nas características. No por nada Visual Basic es la plataforma de desarrollo de apli-
caciones para Windows 95, Windows 98, Windows 2000 y Windows NT, líder en el 
mercado. 
 
 
 
 
 
 
 
 
 
6 Parte 1; Entorno Integrado de Desarrollo 
 Visual Basic lleva en su nombre los dos elementos generales que lo conforman. 
 
• Su parte "Visual" indica que es una interfaz gráfica de usuario (GUI), que en lugar de 
requerir el uso de comandos escritos para realizar tareas, sólo requiere el uso de 
herramientas gráficas, de tal forma que desarrollar se asemeja mucho a estar "dibujando" 
el trabajo. Esta parte está compuesta por el IDE, que ocupa casi todo este capítulo. 
• Su parte "Basic" indica que aquellas tareas que no se pueden realizar a través de las 
herramientas gráficas (que no pueden ser dibujadas), son posibles a través de un 
lenguaje de programación basado en el legendario lenguaje de propósito general 
llamado Código de Instrucciones Simbólicas Multipropósito para Principiantes 
(BASIC) con el que prácticamente se puede desarrollar cualquier cosa. 
Visual Basic no es sólo producto, también es tecnología aplicada: su parte "Visual" está 
basada en tecnología orientada a objetos (00), su parte "Basic" es de tipo procedural, y la 
mezcla de estas dos tecnologías dan lugar a productos híbridos, orientados a eventos (EO). 
 
Entorno Integrado de Desarrollo 
Al iniciar una sesión en Visual Basic, entra en contacto con lo que se llama IDE. Este 
entorno es un conjunto de herramientas y elementos que le permiten diseñar y 
programar aplicaciones interactuando con Visual Basic. 
 
Nota: Es el momento adecuado de que instale los archivos que complementan este 
libro, mismos que se encuentran en el sitio Web 
http://www.enlace.net/ramirez2; descargue el archivo AVBP.ZIP en el 
directorio raíz de su disco duro, y ejecútelo para su instalación. 
 
>> Cómo iniciar sesión en Visual Basic. [01.01] 
 A continuación aprenderá la forma de iniciar una sesión de trabajo en Visual Basic. 
1. En el escritorio de Windows haga clic en el botón Inicio, seleccione Programas, 
Microsoft Visual Basic 6.0 y la opción Microsoft Visual Basic 6.0. 
 
 
 
 
 
 
 
 
Capítulo 1; Visual Basic como plataforma de desarrollo 7 
 
Nota: Visual Basic inicia una sesión mediante la ejecución del programa VB6.EXE; 
si tiene definidos los accesos directos a Microsoft Visual Basic 6.0 y su computadora no lo 
encuentra, puede buscar el programa ejecutable para iniciar la sesión. También puede estar 
como miembro de un grupo de programas Microsoft Visual Studio 6.0; depende de su 
instalación. 
 
 
Al iniciar Visual Basic, aparecerá la ventana Nuevo proyecto que se muestra en la 
figura 1.1. 
 
 
 
 
Figura 1.1 
Ventana Nuevo 
proyecto 
 
2. En la ficha Nuevo, haga clic en el icono EXE estándar, que de manera predeterminada está 
seleccionado. 
3. Haga clic en el botón de comando Abrir. 
 
 
 
Lo inesperado: Si se fija, en la parte inferior de la ventana Nuevo proyecto aparece la 
casilla de verificación "No mostrar este cuadro de diálogo en el futuro", si alguien antes que 
usted le dijo a Visual Basic que no apareciera la ventana Nuevo proyecto al iniciar, la ventana 
de la figura 1.1 no aparecerá. Si ese es su caso, para seguir con la práctica vaya al menú 
Archivo - Nuevo proyecto, que mostrará una ventana similar. Este cambio no es para siempre, 
ya que puede modificarlo a través del 
 
 
 
8 Parte 1: Entorno Integrado de Desarrollo 
menú Herramientas - Opciones... - Entorno, seleccionando la opción Preguntar por un proyecto del 
área Cuando se inicie Visual Basic. 
 
>> Cómo cerrar una sesión en Visual Basic. [01.02] 
Enseguida conocerá la forma de cerrar una sesión de trabajo en Visual Basic. 
1. Seleccione el menú Archivo - Salir. También es válida la combinación de teclas 
Alt+Q, o el estándar para todas las aplicaciones de Windows: A1t+F4. 
 
Ediciones de Visual Basic 
En la ventana Nuevo proyecto aparece un conjunto de iconos, mismos que deberá 
seleccionar de acuerdo a lo que desee realizar en Visual Basic. Si tiene la oportunidad 
de trabajar en varios lugares con Visual Basic, tal vez se percate de que no siempre 
aparecen los mismos iconos en la ventana Nuevo proyecto; el número de iconos dis-
ponibles depende de la edición de Visual Basic que tenga instalada; en la versión 6.0 
del producto, se tienen las siguientes ediciones: 
• Edición de aprendizaje. Esta edición de Visual Basic permite a los programa-
dores crear aplicaciones robustas para Windows 95, Windows 98, Windows 2000 y 
Windows NT. Incluye todos los controles intrínsecos, además de los de cuadrícula, 
de fichas y los enlazados a datos. La documentación proporcionada con esta 
edición incluye el CD "Aprenda Visual Basic ya", junto con el de la biblioteca de 
Microsoft Developer Network (MSDN) que contiene documentación completa en 
pantalla. Una desventaja de esta versión con respecto a la versión 5.0 es que 
anteriormente se acompañaba el Crystal Reports, módulo para elaborar informes en 
papel, mismo que ahora tiene que comprarse por separado. Visual Basic suple esta 
herramienta con un diseñador llamado Data Report, que es un producto más 
modesto. Para el que desea iniciarse en Visual Basic, comprar la edición de 
aprendizaje pueden ser los cien dólares mejor gastados; claro, ¡no olvidando 
comprar este libro que tiene en sus manos! 
• Edición profesional. Proporciona a los profesionales un conjunto completo de 
herramientas para desarrollar soluciones para terceros. Incluye todas las caracterís-
ticas de la edición de aprendizaje, así como controles ActiveX adicionales, el di-
señador de aplicaciones para Internet Information Server y Visual Database Tools 
and Data. La documentación que se proporciona con la edición profesional incluye 
el libro Características empresariales de Visual Studio más los CDs de Microsoft 
Developer Network, la cual contiene documentación completa en pantalla. 
• Edición empresarial. Permite a los profesionales crear sólidas aplicaciones dis-
tribuidas en un entorno de trabajo en equipo. Si decide utilizar a Visual Basic 
 
 
 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 9 
para proyectos grandes, complejos y que involucren un número considerable de 
programadores trabajando en un mismo proyecto simultáneamente, o bien si piensa 
que Visual Basic será el componente front end de un esquema cliente/servidor, la 
compra de esta edición es casi obligatoria. Incluye todas las características de la 
edición profesional, así como herramientas de enlace con productos Back Office 
como SQL Server, Microsoft Transaction Server, Internet Information Server, Visual 
SourceSafe, SNA Server, etcétera. La documentación impresa que se proporciona 
con la edición empresarial incluye el libro Características empresariales de Visual 
Studio más los CDs de Microsoft Developer Network, la cual contiene 
documentación completa en pantalla. 
Entre más completa sea la edición, más capacidades tendrá; el número de iconos es unindicador de ese hecho. Entre más iconos haya en la ventana Nuevo proyecto, obviamente, 
mayor será el costo. 
 
Nota: Aunque la documentación de Visual Basic hace referencia a los Libros en pantalla, 
éstos no son parte del producto. En la versión 5.0, al momento de la instalación se generaba 
dentro del menú de Microsoft Visual Basic 5.0 una opción que decía Libros en línea, que a 
través de hipertexto dinámico proporcionaba la documentación del producto. En la versión 6.0, 
tiene que instalar la MSDN Library Visual Studio 6.0 (otro producto) para disponer de ayuda. 
MSDN Library es una referencia técnica muy completa, de más de 1 GB de información de los 
productos que integran Visual Studio 6.0; si usted está dispuesto a consumir más de 1 GB en 
información de Visual C++, Visual Basic 6.0, Visual InterDev, Visual FoxPro, Visual J++ y 
Visual SourceSafe, adelante. Por otro lado, puede decidir que no desea información de 
productos que no le interesan, e instalar sólo la ayuda de Visual Basic con la finalidad de no 
consumir mucho espacio en disco. Esto es posible, pero se puede llevar la sorpresa de que 
algunos componentes compartidos por varios productos no se integren si usted solicita instalar 
únicamente información de Visual Basic. O instala toda la información de MSDN Library que 
comparten todos los productos de Visual Studio 6.0, o corre el riesgo que algo que necesite 
consultar no se encuentre instalado. 
 
Elementos del IDE 
Una vez que haya abierto un proyecto como EXE estándar, aparecerá el IDE (vea la figura 
1.2). 
 
Nota: La distribución del IDE es bastante parecida en todos los productos de Visual Studio 6.0 
(Visual C++, Visual InterDev, etcétera), así como en los módulos basados 
 
 
 
 
 
 
10 Parte 1: Entorno Integrado de Desarrollo 
en Visual Basic para Aplicaciones (nuevo manejo de macros de la Suite Microsoft 
Office), por lo que identificarse con la distribución de los elementos para aprender 
Visual Basic proporciona el beneficio adicional de reducir la curva de aprendizaje que 
usted tendrá si desea aprender otras herramientas. 
 
Figura 1.2 
Entorno 
Integrado de 
Desarrollo 
 
 
 
 
 
 
 
 
 
 
 
 
El ID
porci
No to
pued
Esto 
 
Not
núm
que 
tona
dera
sopo
de c
 
 
 
 
 
 
E contiene todos los elementos y herramientas gráficas que Visual Basic pro-
ona para desarrollar una aplicación. 
dos los elementos se requieren todo el tiempo, por lo que a través del menú Ver 
e decidir qué elementos desea utilizar, y por tanto, tener presentes en la pantalla. 
es importante porque en ocasiones el espacio en la pantalla es muy preciado. 
 
a: Al estar desarrollando en Visual Basic, es importante disponer del mayor 
ero de elementos del IDE para realizar las tareas. Esto se dificulta en virtud de 
el espacio en la pantalla es reducido y los elementos aparecen demasiado amon-
dos. Si desarrollará profesionalmente un monitor de 17" o más, sería una verda-
 bendición; si su presupuesto no se lo permite, aumente la resolución máxima 
rtada por su monitor, aunque su vista pedirá un poco de piedad ante lo diminuto 
iertas figuras. 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 11 
Visual Basic respeta las preferencias del desarrollador, de tal forma que si distribuye en 
la pantalla los elementos del IDE a su gusto, la próxima vez que inicie sesión en Visual 
Basic, los elementos del IDE se encontrarán donde los dejó la última vez. 
>> Cómo activar los elementos del IDE. [01.03] 
A continuación aprenderá a activar los elementos del IDE. 
Para activar los elementos del IDE que no se encuentren actualmente en la pantalla, 
haga lo siguiente: 
1. Abra un nuevo proyecto EXE estándar de Visual Basic. 
2. Seleccione el menú Ver — Explorador de proyectos (Ctrl+R). 
3. Seleccione el menú Ver — Ventana Propiedades (F4). 
4. Seleccione el menú Ver — Ventana Posición del formulario. 
5. Seleccione el menú Ver — Cuadro de herramientas. 
 
 
 
 
 Nota: Observe detenidamente las figuras que aparecen a la izquierda de las op-
ciones que se encuentran en el menú Ver. Esto es importante porque dichas figuras 
también se encuentran en la barra de herramientas, por lo que puede hacer clic en 
ellas para activarlas en lugar de utilizar la barra de menús. 
 
El IDE se compone de los siguientes elementos: 
• La barra de menús 
• La barra de herramientas Estándar 
• El Diseñador de formularios 
• La ventana Propiedades 
• La ventana Posición del formulario 
• La ventana Explorador de proyectos 
• El Cuadro de herramientas 
 
 
 
 
 
12 Parte 1: Entorno Integrado de Desarrollo 
 
A continuación se definirán cada uno de los elementos del IDE, así como los con-
ceptos que están asociados con él y que son indispensables para comprender su uti-
lidad. 
La barra de menús 
La barra de menús (vea la figura 1.3) proporciona los menús que contienen 
comandos que Visual Basic tiene disponibles para su uso en aplicaciones 
desarrolladas, o para la administración de su propio entorno. 
Figura 1.3 
La barra 
 de menús 
 
 
 
La barra de herramientas 
La barra de herramientas (vea la figura 1.4) es un conjunto de botones que pro-
porcionan un acceso rápido a comandos más comunes que Visual Basic tiene dispo-
nibles para su uso en aplicaciones desarrolladas o para la administración de su 
propio entorno. 
Figura 1.4 
La barra de herramientas 
 
 
 Nota: La existencia de la barra de herramientas sigue con la tradición de los pro-
gramas basados en Windows. Seguramente usted reconocerá algunos botones que 
son estándar para todas las aplicaciones, como Abrir, Guardar, Cortar, Copiar, 
Pegar y Deshacer. 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 13 
Figura 1.5 
Formulario 
 
Todo proyecto en Visual Basic inicia y se desarrolla en un formulario; un formulario 
es una ventana, tal y como las hemos utilizado toda la vida; en ella pueden encon-
trarse objetos que responden a nuestras acciones, pueden minimizarse, maximizarse, 
cerrarse, etcétera (vea la figura 1.5). 
 
Un formulario es un objeto contenedor, es decir puede contener a otros objetos, en 
este caso, botones de comando, cuadros de texto, imágenes, botones de opción, 
etcétera. 
Modos de trabajo con formularios: SDI y MDI 
En Visual Basic existen dos modos de trabajo con formularios: 
• Interfaz de Documentos Simples (SDI). Una aplicación SDI se compone de un 
solo formulario; al cerrar el formulario se cierra la aplicación. Un ejemplo puede ser 
la aplicación Notepad.exe de Windows. Sólo permite editar un documento a la vez 
y si cierra el documento se cierra la aplicación. 
• Interfaz de Documentos Múltiples (MDI). Una aplicación MDI se compone de 
un formulario maestro y éste puede contener uno o más formularios. Un ejemplo 
 
 
 
 
 
 
 
 
14 Parte 1: Entorno Integrado de Desarrollo 
de este upo de aplicaciones es WinWord.exe; se pueden tener muchos 
documentos abiertos al mismo tiempo, y cada uno es un formulario. Al cerrar un 
documento (formulario dependiente) no necesariamente se cierra Word 
(formulario maestro). 
 
Trabajemos en SDI o MDI, siempre habrá un formulario principal (objeto inicial). 
La diferencia entre SDI y MDI es que en SDI el formulario maestro es el único que 
existe. 
 
Podemos configurar el entorno de Visual Basic de tal forma que resulte conveniente 
para el trabajo, dependiendo de si elaboramos una aplicación SDI o MDI. Actual-
mente tenemos el entorno adecuado para MDI, pero los primeros programas que 
desarrollaremos serán de un solo formulario, por lo que resultaría conveniente cam-
biar el entorno a SDI. De manera predeterminada Visual Basic se instala en MDI. 
>> Cómo establecer el entorno de desarrollo a SDI. [01.04] 
 
A continuación aprenderá a establecer su entorno de desarrollo en modo SDI. 
Observe el entorno tal y como lo tiene actualmente. 
1. Seleccione el menú Herramientas - Opciones... - Avanzado. Aparecerá elcuadro de 
diálogo que se muestra en la figura 1.6. 
2. Active la casilla de verificación Entorno de desarrollo SDI. 
 
3. Haga clic en el botón de comando Aceptar. 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 15 
La modificación que acaba de realizar requiere iniciar nuevamente la sesión en Visual 
Basic. Aparecerá la ventana Microsoft Visual Basic (vea la figura 1.7), informándole 
ese hecho. 
 
Figura 1.7 
Mensaje de 
Visual Basic 
 
 
 
 
 
4. Haga clic en el botón de comando Aceptar cuando Visual Basic le informe que el 
cambio de la opción MDI/SDI será efectivo la próxima vez que inicie el entorno 
de desarrollo. 
5. Cierre la sesión de Visual Basic. 
6. Inicie Basic nuevamente una sesión en Visual. 
7. ¿Qué cambios nota en el entorno? 
 
 
 
8. En el menú Herramientas - Opciones - Avanzado, desactive la casilla de veri-
ficación Entorno de desarrollo SDI, cierre la sesión y vuelva a entrar, para dejar 
el entorno como estaba. 
 
Entre los beneficios que puede obtener al desarrollar en SDI, es que los elementos 
del IDE se comportan como ventanas independientes de Windows, muy conveniente 
si considera que en MDI el hecho de mover o cambiar el tamaño de los elementos en 
ocasiones resulta un problema, pues se ajustan entre sí (se acoplan) de manera arbi-
traria y complican la distribución de los objetos en la pantalla. 
 
 Nota: El acople inesperado de los elementos del IDE, en SDI o MDI, se controla 
desde el menú Herramientas - Opciones - Acople. El modo SDI se ajusta más a lo 
que queremos del entorno de desarrollo en estos momentos; sin embargo, mantendre-
mos la configuración predeterminada de Visual Basic, es decir, MDI. Es sólo 
cuestión de práctica dominar ambos modos. 
 
 
 
 
16 Parte 1: Entorno Integrado de Desarrollo 
 
Tecnología orientada a objetos y Visual Basic 
Al inicio del capítulo decíamos que Visual Basic es una mezcla de tecnologías. La 
más importante de ellas es la tecnología orientada a objetos, ya que en Visual Basic 
todo termina siendo un objeto. 
Aprendamos un poco al respecto, ya que nos ayudará mucho para entender cómo 
desarrollar eficientemente utilizando Visual Basic. Esta práctica requiere de mucha 
imaginación; de ser posible genere en su mente las imágenes de lo que vamos a men-
cionar a continuación. 
• Usted está sentado en una silla, frente a un escritorio. 
• Sobre ese escritorio se encuentran dos cosas: un sombrero de mago y un botón rojo. 
• Al presionar el botón rojo que se encuentra sobre el escritorio, del sombrero del 
mago sale un conejo. A dicho conejo usted le llama "Fred". 
• Usted presiona nuevamente el botón rojo y sale otro conejo igual al anterior, al cual 
usted llama "Angus". 
• En este momento sobre el escritorio se encuentran dos conejos, de igual color, ta-
maño y peso (mismas propiedades), y éstos corren alegremente sobre el escritorio. 
• Sólo los puede diferenciar por el nombre, pero como saltan de un lugar a otro, es 
posible que en un momento determinado no sepa quién es Fred y quién es Angus. 
• A usted le gustaría que Fred fuera más pequeño, y de otro color que Angus. 
• Usted toca a Fred y como por arte de magia (y como en nuestra imaginación todo 
es posible), Fred se transforma en un conejo más pequeño y de un color diferente 
que el de Angus. 
Volvamos a lo técnico. En un mundo orientado a objetos, tenemos que: 
• Lo que sale del sombrero del mago cada que presiona el botón rojo es un animal 
de una naturaleza bastante definida, en este caso, un Conejo. Decimos entonces 
que Conejo es una clase. 
• Debido a que se presionó dos veces el botón rojo, se generaron dos instancias de 
la clase. A las instancias de una clase las llamamos objetos. 
• La clase define todas las propiedades que heredarán los conejos, es por ello que 
Fred y Angus son iguales, y sólo se diferencian por el nombre, ya que no 
puede haber dos objetos con el mismo nombre. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 17 
• Fred y Angus no son inertes, por sí mismos hacen algo, a veces saltan en el escritorio. 
Lo que ellos pueden hacer por sí mismos se le llama método. Los métodos que un 
objeto puede realizar, son sólo aquellos que la clase tiene definidos y permitidos. Ni 
Fred ni Angus pueden ladrar; no está en su clase. 
• A Fred le sucedió una transformación, que no se llevó a cabo sino hasta que usted lo 
tocó. Lo que le sucede a un objeto por el hecho de interactuar con usted, se le llama 
evento. Los eventos que le pueden suceder a un objeto, son sólo aquellos que la clase 
tiene definidos y permitidos. 
• La clase Conejo existe, pero no se manifiesta sino a través de sus instancias, mismas 
que son generadas solamente a través del uso del botón rojo. Si no se presiona el botón 
rojo, no hay conejos en el escritorio. Al elemento que sirve para crear la instancia de 
una clase se le denomina control. 
• El escritorio sería el objeto contenedor de los objetos. Cumple con la misma función 
que cumplirá el formulario en sus aplicaciones de Visual Basic. 
Suponga que Angus se queda inmóvil, gráficamente tendríamos lo siguiente: 
 
 
 
 
 
 
Figura 1.8 
Esquema de 
clase – objeto- 
propiedad 
 
 
 
 
 
18 Parte 1: Entorno Integrado de Desarrollo 
Controles 
Los controles son representaciones gráficas que permiten generar elementos de inter-
faz de Windows, tales como botones de comando, cuadros de texto, gráficos, listas 
desplegables, etiquetas, etcétera. Estos controles invocan una clase determinada, con 
base en la cual se generan objetos con una forma y comportamiento predefinido. Los 
controles en Visual Basic se encuentran en el elemento IDE llamado Cuadro de he-
rramientas. 
Clase 
Una clase es la definición formal de un elemento de interfaz de Windows. Una clase 
actúa como plantilla para cada una de las instancias generadas a partir de un deter-
minado control cuando es agregado a un formulado; la clase define las propiedades de 
un objeto y los métodos y eventos utilizados para controlar su comportamiento. Visual 
Basic trata los términos clase y control como uno solo, ya que la clase no se manifiesta 
sino a través de un control. 
 
 
Objetos 
Los objetos son ocurrencias de una clase en un formulario. Son controles una vez que 
son insertados en una aplicación; el desarrollador les dará las propiedades que necesite 
y el comportamiento que requiera. Puede haber un solo control llamado 
CommandButton, pero muchos objetos generados a partir de él, es decir, múltiples 
botones en el formulario. 
Por cuestiones prácticas, en ocasiones los términos control y objeto se utilizan como 
sinónimos; es posible usarlos de esta manera, pero no pierda de vista que son dife-
rentes. Un control es un medio para generar un objeto; un objeto es una ocurrencia del 
control (que a su vez es el ejercicio de una clase), con nombre, tamaño, colores y otras 
especificaciones particulares. 
 
Nota: No somos partidarios del uso como sinónimos de las palabras "Objeto" y 
"Control", porque evidentemente no son lo mismo. No obstante. Visual Basic tiene 
muchos mensajes del sistema que utilizan dichos términos como equivalentes, y en la 
ayuda en línea en ocasiones los utilizan de manera indistinta. 
 
 
 
 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 19 
 Cuadro de herramientas 
 
 
El Cuadro de herramientas (vea la figura 1.9) es la ventana que muestra todos los 
controles disponibles para la generación de objetos en una aplicación de Visual Basic. 
El Cuadro de herramientas debería llamarse cuadro de controles, pero por cuestiones 
históricas del producto su nombre persiste. 
 
Figura 1.9 
Cuadro de 
herramientas 
Los controles están representados de manera gráfica; por ejemplo, el control Label 
está representado por una letra "a" mayúscula (A). 
Si desconoce qué representación gráfica le corresponde a un determinado control, sólo 
coloque el puntero del ratón sobrelas figuras del Cuadro de herramientas, y 
aparecerá un texto identificando el control del que se trata. Dicho texto se conoce 
como Información sobre herramientas. 
 
Nota: Visual Basic tiene una capacidad de expansión increíble; tal vez su carac-
terística más sobresaliente, base de su éxito, sea la de integrar controles de terceros 
 
 
 
 
 
 
 
20 Parte 1: Entorno Integrado de Desarrollo 
(conocidos como controles ActiveX u OCX). Al integrar un control ActiveX, su repre-
sentación gráfica se agregará al Cuadro de herramientas, por lo que es comprensible 
que la misma no siempre luzca igual. 
Si tiene la necesidad de un control que no está en el Cuadro de herramientas, puede 
buscar entre los controles ActiveX que tiene en su equipo, y si no lo tiene, puede com-
prar uno que alguien haya hecho (hay cientos en el mercado, casi siempre orientados a 
una determinada función, como estadística, graficación, bases de datos, etcétera.) En el 
peor de los casos, si el control que necesita no ha sido desarrollado por terceros o no 
quiere pagar por él, tiene la opción de desarrollarlo usted mismo. 
Aunque tal vez sobre decirlo, Microsoft no se hace responsable de los controles que no 
vienen integrados en Visual Basic de manera intrínseca. 
 
Los controles que aparecen en el Cuadro de herramientas de manera intrínseca y 
como parte del IDE, pueden dividirse en las siguientes categorías: 
• Controles básicos: Definen objetos que permiten elaborar una interfaz de usuario 
básica. 
 Label 
TextBox 
CommandButton 
• Controles de selección: Definen objetos que permiten elegir un valor sin que sea 
necesario teclear nada. 
OptionButton 
CheckBox 
 ComboBox 
 
ListBox 
 HScrollBar 
 VScrollBar
 
 
 
 
 
 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 21 
• Controles contenedores: Definen objetos que pueden contener a otros objetos. 
 Frame 
• Controles gráficos: Definen objetos que permiten el manejo de gráficos e imágenes. 
 PictureBox (también es contenedor) 
 Image 
 Shape 
 Line 
 
• Controles de gestión de archivos: Definen objetos que permiten gestionar el sistema 
de archivos de la máquina. 
 DriveLlstBox 
 DirListBox 
 FileListBox 
• Controles de tiempo: Definen objetos que permiten manejar intervalos de ejecución 
de una aplicación. 
 Timer 
• Controles de datos: Definen objetos que permiten tener acceso a bases de datos. 
 Data 
• Controles de vínculo: Definen objetos que permiten tener acceso otras aplicaciones o 
funciones dentro del sistema. 
 OLE 
 
 
 
 
 
22 Parte 1: Entorno Integrado de Desarrollo 
Los controles que aparecen en el Cuadro de herramientas pueden incrementarse en la 
medida en que se necesiten. En su momento verá cómo incluir algunos de suma 
utilidad. 
 
Nota: Si no tiene un formulario activo, los controles no aparecerán en el Cuadro de 
herramientas. Esto es lógico, ya que no tiene en dónde insertar las ocurrencias de los 
controles, es decir, los objetos. 
>> Ubicación de los controles. [01.05] 
A continuación aprenderá a identificar los controles mediante la consulta de los 
Información sobre herramientas. 
 
 
1. Si coloca el puntero del ratón sobre las imágenes del Cuadro de herramientas, 
aparecerá información relativa al control del que se trata (esta información es llamada 
Información sobre herramientas [vea la figura 1.10]). 
 
 
 
 
 
 
 
Figura 1.10 
 Información sobre
herramientas: le 
ayuda a identificar 
los controles del 
cuadro de 
herramientas 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Información sobre 
herramientas 
 
Capitulo 1: Visual Basic como plataforma de desarrollo 23 
2. Coloque al lado de cada una de las figuras representativas de los 
controles, la Información sobre herramientas que aparece al colocar 
el puntero del ratón sobre cada control. 
 
 
 
Propiedades 
Cada uno de los objetos que conforman un formulario, desde el formulario mismo 
hasta los botones de comando, cuadros de texto, botones de opción, cuadros de imá-
genes, y demás objetos contenidos en él, tienen características particulares que los 
hacen diferentes uno de otro. A estas características se les llama propiedades; las 
propiedades le indican a Visual Basic la posición de un objeto en el formulario, su 
nombre, alto, ancho, comportamiento inicial, valor predeterminado, etcétera. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
24 Parte 1: Entorno Integrado de Desarrollo 
Quizá la propiedad más importante sea la que identifica a los objetos dentro de una 
aplicación: Name. Esta propiedad permite referir a un objeto determinado al momento 
de programar en Visual Basic. 
 
Métodos 
Los métodos son órdenes predefinidas que realizan tareas específicas sobre los objetos. 
Los métodos son muy útiles porque permiten manipular los objetos y sus carac-
terísticas asociadas. 
Los objetos se crean en tiempo de diseño y en tiempo de ejecución se modifican las 
características de estos objetos (propiedades) y se ejecutan tareas sobre los objetos 
(métodos). 
 
Ejemplificación de objeto - propiedad - método 
Suponga que tiene un objeto llamado "Saxofón". 
 
Saxofón 
Dicho objeto podría tener muchas características, tales como tamaño, color, marca, 
etcétera. Actualmente aparece en color blanco, por lo que puede interpretarse que la 
propiedad Color del objeto Saxofón es igual a Blanco. 
Para Visual Basic eso se codificaría de la siguiente manera: 
Saxofón. Color = Blanco 
Cambiar una propiedad modifica al objeto, por ejemplo, si cambiamos la propiedad 
Color del objeto Saxofón a Amarillo, obtendríamos lo siguiente: 
 
 
 
 
 
 
 
Capítulo 1; Visual Basic como plataforma de desarrollo 25 
 
 
 
Saxofón. Color = Amarillo 
En Visual Basic es una regla de sintaxis que las propiedades se refieran en conjunto 
con el objeto al que pertenecen y se separan por un punto. En elcaso "Saxofón. 
Color", "Color" es la propiedad del objeto "Saxofón". 
Los métodos se refieren de la misma forma que las propiedades, pero éstos en lugar de 
establecer una característica para un objeto, realizan una tarea sobre o a través del 
objeto. Un método posible a través del objeto Saxofón es que éste toque música. 
Por ejemplo: 
 
Saxofón.TocarMúsica 
Explorador de proyectos 
La ventana Explorador de proyectos es una ventana que muestra los componentes del proyecto 
Visual Basic, llamados módulos. A través de esta ventana puede ubicar y activar cualquier 
módulo del proyecto; esto es especialmente útil cuando el proyecto se hace muy grande y que 
cuenta con muchos módulos, de tal manera que resulta incómodo tener presente a todos los 
componentes del proyecto en la pantalla. 
Los módulos que se pueden tener en la ventana Explorador de proyectos son: 
• Módulos de formulario (extensión .FRM). Puede contener objetos y los valores de sus 
propiedades. También puede contener declaraciones a nivel formulario 
26 Parte 1: Entorno Integrado de Desarrollo 
de constantes, variables y procedimientos externos, procedimientos de evento, y 
procedimientos generales. 
• Módulos de clase (extensión .CLS). Son similares a los módulos de formulario, 
a excepción de que no tienen una interfaz visible. 
• Módulos estándar (extensión .BAS). Pueden contener declaraciones públicas o 
a nivel módulo de tipos de datos, constantes, variables, procedimientos externos 
y procedimientos públicos. 
 
 
 
Figura 1.11 
Ventana 
Explorador 
de proyectos 
La ventana Explorador de proyectos muestra una estructura de jerarquía 
similar a la del Explorador de Windows; los componentes que se pueden 
seleccionar se encuentran a nivel módulo. En la figura 1.11 se puede apreciar 
que está seleccionado el único formulario, Form1 (Form1), que se tiene en 
el proyecto. 
En la parte superior de la ventana aparecen tres botones: 
• Ver código. Permite ver el código que se ha escrito del módulo que está 
seleccionado. 
• Ver objeto. Permite ver el objeto en el IDE. 
• Alternarcarpetas. Oculta y muestra las carpetas en el Explorador de 
proyectos. 
>> Cómo ocultar y mostrar formularios. [01.06] 
A continuación aprenderá a ocultar y mostrar formularios utilizando la ventana Ex-
plorador de proyectos. 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 27 
1. En este ejercicio asumimos que tiene un proyecto EXE estándar abierto. Si no lo 
tiene, inicie sesión en Visual Basic. 
2. En la jerarquía de elementos que aparece en la ventana Explorador de proyectos, 
ubíquese donde aparece Proyecto1 (Proyecto1). Al lado izquierdo aparece un 
pequeño símbolo, que puede ser de más (+) o de menos (-), dependiendo de si la 
jerarquía está expandida o comprimida. 
3. Haga clic en el símbolo hasta que se coloque un símbolo de más (+). Esto significa 
que se comprimirá la jerarquía. 
4. ¿Qué sucede con el formulario? 
 
 
 
5. Expanda la jerarquía haciendo clic en el símbolo que aparece a la izquierda, tanto 
en Proyecto1 (Proyecto1) como en Formularios, hasta que ambos sean 
símbolo de menos (-). 
6. Seleccione Form-1 (Form-1). El 
formulario se desplegará. 
 
7. Haga clic en el botón Ver objeto. 
La utilidad de estas funciones se apreciará cuando veamos proyectos MDI, en 
donde hayan varios formularios en el mismo proyecto. 
Tiempos de desarrollo de Visual Basic 
El IDE de Visual Basic le permite diseñar la interfaz que utilizará para realizar una 
determinada tarea. Esto lo logra agregando objetos a los formularios, estableciendo 
propiedades a los objetos, agregando código, etcétera. Prácticamente "dibuja" la in-
terfaz. 
Una vez que concluye el diseño de la interfaz, puede poner en ejecución la interfaz 
diseñada; en dicha ejecución puede modificar algunas cosas establecidas en tiempo 
de diseño, por lo que es posible que el diseño se pueda afectar en tiempo de ejecu-
ción. Prácticamente se modifica "lo dibujado" con anterioridad. 
En conclusión, en Visual Basic se determinan dos tiempos de desarrollo: 
• Tiempo de diseño. Son las labores de desarrollo de aplicaciones que se realizan a 
través del IDE, con la disponibilidad de todos sus elementos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
28 Parte 1: Entorno Integrado de Desarrollo 
• Tiempo de ejecución. Son las labores de desarrollo de aplicaciones que se reali-
zan durante la ejecución de un formulario, a través de código. 
 
¿Cómo saber en qué tiempo se encuentra? Muy simple, si está utilizando el IDE con 
la disponibilidad de todos los elementos para su uso, está en tiempo de diseño; si 
está ejecutando un formulario y no dispone de todos los elementos del IDE para su 
uso, está en tiempo de ejecución. Otra forma más fácil de saberlo es la siguiente: en 
tiempo de diseño, en la ventana principal de Visual Basic aparecerá la palabra 
"diseño". Más obvio no podía ser. 
 
Hay cosas que sólo se pueden hacer en tiempo de diseño, por ejemplo, asignar el 
nombre a los objetos, y hay otras cosas que sólo se pueden hacer en tiempo de 
ejecución, como ver la Información sobre herramientas establecida para un 
determinado objeto. En tiempo de diseño todo se hace visualmente, mediante el uso 
de elementos del IDE, tales como el Cuadro de herramientas o la ventana 
Propiedades; en tiempo de ejecución, todo se hace mediante el código que forma 
parte del formulario. 
 
Ya que conocemos los tiempos de desarrollo de Visual Basic, podemos establecer 
una diferencia entre las propiedades y los métodos; las propiedades pueden 
establecerse en modo de diseño y, la mayoría de las veces, también en tiempo de 
ejecución. En cambio, los métodos no pueden ejecutarse más que en tiempo de 
ejecución. 
============================================================ 
Nota: En capítulos posteriores de este libro se explicarán los controles que se en-
cuentran en el Cuadro de herramientas. Se profundizará en cuáles son sus propie-
dades más útiles, así como los métodos más importantes que les aplican. 
============================================================ 
Ventana Propiedades 
La ventana Propiedades (vea la figura 1.12) es aquella en donde se identifica un 
objeto y en donde se pueden modificar en tiempo de diseño las propiedades de dicho 
objeto. Sus componentes son: 
• Lista desplegable de objetos 
• Cuadrícula de propiedades 
• Cuadro de información de propiedades 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capitulo 1: Visual Basic como plataforma de desarrollo 29 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 1.12 
 Ventana Propiedades 
 
 
En la parte superior de la ventana Propiedades siempre se muestra una lista desple-gable, llamada 
Lista desplegable de objetos (vea la figura 1.13); esta lista contiene el nombre del objeto activo (que 
se encuentra en negritas) y el tipo de control en el que está basado dicho objeto (Form). 
Figura 1.13 
Lista desplegable 
de objetos 
 
 
 
Posteriormente, se encuentra una lista de propiedades válidas para el objeto que se 
está modificando; la distribución consiste en dos columnas, que forman la Cua-
drícula de propiedades. Las propiedades se encuentran clasificadas alfabéticamente 
o por categorías; dicha lista aparece en forma de cuadrícula: en la columna izquierda 
se muestra el nombre de las propiedades, y en la columna derecha aparecen los valo-
res que de manera predeterminada se le asignan a un objeto (vea la figura 1.14). 
 
30 Parte 1; Entorno Integrado de Desarrollo 
 
 Figura 1.14 
Cuadrícula de 
propiedades 
 
Algunos valores de las propiedades se pueden modificar directamente, editando el 
valor que aparece en la columna derecha de la propiedad que queremos modificar; 
algunas propiedades tienen valor abierto, es decir, se puede colocar cualquier cosa 
como valor, mientras que otras propiedades tienen valor limitado, es decir, tienen un 
universo reducido de valores válidos que les pueden ser asignados, mismos que 
aparecerán a manera de listas desplegables. De una u otra forma. Visual Basic siempre 
sugiere, a través de los valores predeterminados, qué tipo de valor puede asignarse a 
cada propiedad (texto, número, booleano, representación hexadecimal) y si el valor es 
abierto o limitado. 
En la parte inferior de la ventana Propiedades aparece el nombre de la propiedad en 
la que está trabajando y la explicación de su utilidad, es decir, para qué sirve. A esta 
área se le conoce como Cuadro de información de propiedades. 
Uso de la ventana Propiedades. [01.07] 
A continuación aprenderá algunas de las capacidades de la ventana Propiedades. 
1. Observe los gráficos utilizados en este texto y apóyese en el proyecto que actualmente 
tiene en su computadora. Haga clic en el formulario que se encuentra en su IDE. 
Conteste lo siguiente: 
 
a) La ventana Propiedades 
indica que está trabajando sobre 
un objeto. ¿Cómo se llama? 
(Identifíquelo por el texto en negritas en 
la Lista desplegable de objetos; 
también basta con ver el título de la 
ventana Propiedades, que dirá 
Propiedades - <nombre del objeto>.) 
 
 
 
 
 
 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 31 
 
 
 
b) ¿Qué tipo de control es? 
(Identifíquelo por el texto que no 
está en negritas en la Lista 
desplegable de objetos.) 
 
c) ¿Está viendo la Lista de 
propiedades alfabéticamente o 
por categorías? 
 
d) ¿La propiedad Caption es 
de valor abierto o limitado? 
 
 
e) ¿La propiedad 
Appearence es de valor 
abierto o limitado? 
 
f) ¿Cuáles son los 3 valores 
posibles que puede tener la 
propiedad PaletteMode? 
 
 
g) Mencione para qué sirve la 
propiedad 
StartUpPosition. 
(Consulte el Cuadro de información 
de propiedades.) 
 
 
 
El contenido de la ventana Propiedades dependerá del objeto que tenga seleccionado, 
es decir, las propiedades que aparecen al tener seleccionado un objeto basado en el 
control Form no son las mismas que aparecen cuando selecciona otro objeto basado en 
el control TextBox. 
Si no tiene seleccionado ningún objeto, la ventana Propiedades estará vacía.Ventana Posición del formulario 
En versiones anteriores de Visual Basic, era muy importante la posición en la que se 
encontraba la ventana al estar en tiempo de diseño, ya que dicha posición determinaba 
el lugar en donde el formulario se ubicaría al ejecutar la aplicación. En Visual Basic 
6.0 la posición del formulario en tiempo de diseño es irrelevante, ya que existe una 
ventana llamada Posición del formulario (vea la figura 1.15). 
 
 
 
 
32 Parte 1: Entorno Integrado de Desarrollo 
 
 Figura 1.15 
Ventana posición 
 del formulario 
 
 
 
En la ventana Posición del formulario aparece representada la pantalla de un monitor 
y el formulario que está diseñando dentro de ella; usted puede determinar dónde 
quiere que aparezca su formulario en el momento en que sea ejecutado, arrastrando la 
pequeña representación de su formulario dentro de la representación de la pantalla. 
 
Pasos para crear una aplicación en Visual Basic 
Para desarrollar una aplicación en Visual Basic, desde no tener nada hasta tener los 
discos de distribución de su aplicación, transcurren siete pasos básicos: 
• Crear la interfaz de usuario. Consiste en dibujar la interfaz con la que el usuario 
va a interactuar. En este paso, lo importante es colocar en la interfaz la cantidad 
suficiente de objetos, con los tamaños adecuados y la organización óptima para que 
su uso sea más fácil. 
• Establecer las propiedades de los objetos. Consiste en asignar los valores de 
inicio para cada uno de los objetos, mismos que determinan la apariencia y com-
portamiento de dichos objetos. 
• Escribir el código de los eventos. Consiste en escribir el código que ha de eje-
cutarse como respuesta a algo que sucede en la interfaz del usuario. 
• Guardar el proyecto. Consiste en guardar, en algún medio de almacenamiento, el 
proyecto que esté creando. Guarde su trabajo con regularidad, a efecto de reducir al 
máximo el riesgo de perderlo. 
• Probar y depurar la aplicación. Consiste en ejecutar la aplicación que ha creado, 
detectar errores y corregirlos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 1: Visual Basic como plataforma de desarrollo 33 
 
• Compilar el ejecutable (EXE). Consiste en procesar la aplicación a efecto 
de que se pueda ejecutar de manera independiente al entorno de desarrollo de 
Visual Basic. 
• Crear los discos de instalación. Consiste en utilizar el Asistente para empa-
quetado y distribución, a efecto de crear los discos que instalen su aplicación 
de manera profesional. 
 
Cada uno de estos pasos se explicará en los capítulos subsecuentes; el paso de 
crear los discos de instalación se verá cuando tengamos un ejemplo lo 
suficientemente representativo para la tarea. 
La explicación se hará a través de su primer programa en Visual Basic, que 
comenzará en el siguiente capítulo. 
 
________________________________________________________________________ 
Resumen 
 
En este capítulo: 
• Vimos cuál es el objeto de la programación. 
• Vimos por qué Visual Basic es más que un simple lenguaje de programación. 
• Vimos de manera esquemática los conceptos que definen la orientación a 
objetos de Visual Basic. 
• Identificamos todos y cada uno de los componentes del IDE y explicamos para 
qué sirven (no se preocupe por saber cómo se utilizan; en los siguientes capítu-
los lo sabrá). 
• Vimos qué ediciones tiene Visual Basic 6.0. 
• Vimos qué controles se encuentran disponibles en el Cuadro de herramientas 
y a qué categoría pertenecen. 
• Vimos en qué consisten los modos SDI y MDI. 
• Vimos cuáles son los tiempos de desarrollo en Visual Basic. 
• Vimos los conceptos objeto, control, propiedad, método y la relación que 
guardan entre ellos. 
• Vimos cuáles son los pasos para desarrollar una aplicación en Visual Basic. 
Antes de seguir, es importante que domine todos los puntos anteriores. 
 
 
 
 
 
 
 
 
 
 
34 Parte 1: Entorno Integrado de Desarrollo 
 
Algunas respuestas a los ejercicios 
[01.04] Cómo establecer el entorno de desarrollo a SDI. 
7. Los elementos del IDE aparecen como ventanas independientes. Ya no hay una 
ventana que contenga todos los elementos. 
[01.06] Cómo ocultar y mostrar formularios. 
3. Desaparece. 
[01.07] Uso de la ventana Propiedades. 
a) Forml. 
b) Form. 
c) Alfabéticamente. 
d) Abierto. 
e) Limitado. 
f) Halftone, UseZOrder, Custom. 
 
g) Devuelve o establece un valor que especifica la posición de un formulario cuando 
aparece por primera vez. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Capítulo 
2 
Creación de la interfaz 
de usuario 
 
 
 
Objetivo 
Conocer los pasos para crear una interfaz de usuario efectiva para una aplicación 
de Visual Basic. 
Al finalizar este capítulo deberá: 
• Saber cómo insertar objetos 
• Saber cómo trazar objetos 
• Conocer la forma de establecer la posición y las dimensiones de un objeto 
• Conocer la forma en que se manejan las opciones del menú Formato 
• Saber cómo manejar la ventana Posición del formulario 
• Felicidades: comenzará a desarrollar su primer proyecto de Visual Basic 
En este capítulo comenzará a desarrollar su primer programa; quizá piense "en 
otros libros desde el primer capítulo se crea un programa". No se desespere: la 
diferencia entre "copiar" un programa de un libro sin entenderlo y "hacer" un 
programa es mucha. Preferimos que desarrolle una aplicación con todo el 
conocimiento posible, de tal forma que pueda reproducir los procedimientos sobre 
aplicaciones basadas en necesidades propias cuando así lo requiera. 
Le aseguramos que una vez que haya visto los pormenores de la programación en 
Visual Basic con el primer ejemplo, el libro tomará velocidad con respecto a los 
demás 
35 
 
 
 
 
 
 
 
 
 
 
 
36 Parte 1: Entorno Integrado de Desarrollo 
ejemplos, y lo mejor de todo, usted podrá ir a la misma velocidad que el libro, para 
después ya no depender de él. 
 
El punto de partida: ¿Qué desea hacer? 
Para crear su aplicación, debe revisar el producto del análisis (saber qué quiere) y 
comenzar el diseño. 
Su primer programa será algo muy simple, pero que nos permitirá revisar todo el 
proceso de desarrollo de aplicaciones en Visual Basic. 
La figura 2.1 muestra la forma en que se debe ver la interfaz a diseñar. 
 
Figura 2.1 
interfaz a diseñar. 
 
 
La figura 2.2 muestra lo que debe suceder cuando haga clic en el botón de comando 
Mostrar Mensaje. 
Figura 2.2 
Respuesta 
 esperada al hacer 
 clic en Mostrar 
 Mensaje. 
Al hacer clic en el botón de comando Salir, la aplicación deberá cerrarse. 
 
 
 
 
 
 
Capítulo 2: Creación de la interfaz de usuario 37 
 
Paso 1: Crear la interfaz de usuario 
Los objetivos de este paso son los siguientes: 
• Tener la cantidad de objetos necesarios para hacer lo que se quiere con la 
aplicación. En la interfaz sólo debe tener los objetos que necesita; colocar objetos 
innecesarios sólo hace confusa su interfaz y hace que su aplicación sea más 
demandante de recursos, principalmente memoria RAM. La pregunta básica aquí 
es: ¿cuántos objetos se necesitan para realizar la tarea? 
• Tener los tipos de objetos adecuados para hacer lo que se quiere con la apli-
cación. Los objetos creados a partir de un determinado control tienen una deter-
minada función (TextBox, introducir datos; OptionButton, seleccionar una 
opción; Label. mostrar un texto, etcétera.). Pretender realizar con un objeto una 
tarea contraria a su naturaleza puede complicar el uso de la interfaz; una mala 
elección de objetos puede hacer de su labor de desarrollo una pesadilla; no hay que 
pedirles a los controles un imposible. La pregunta básica aquí es: ¿en qué controles 
nos basaremos para definir los objetos? 
• Definir la posición y las dimensiones adecuadas para los objetos. Es importante 
colocar los objetos de acuerdo a una distribución que sea apegada a los estándares 
del entorno de trabajo en Windows, con dimensiones proporcionadas, bienalineadas. Para tomar ideas, analice los programas basados en Windows, 
principalmente los desarrollados por Microsoft (Excel, Word, PowerPoint, et-
cétera), y vea cómo están distribuidos los objetos en los cuadros de diálogo. La 
pregunta básica aquí es: ¿dónde debemos colocar los objetos y de qué tamaño? 
• Distribución funcional. Los objetos deben estar distribuidos de tal forma que 
faciliten el uso de la interfaz. La pregunta básica aquí es: ¿la captura se realiza de 
manera natural y sencilla? Responder "NO" a esta pregunta es inadmisible. 
 
Inserción de objetos 
Si quisiera desarrollar la aplicación de la figura 2.1, requerirá lo siguiente: 
 
• Un control Form en donde colocar el resto de los objetos. El formulario es una 
ventana. 
• Un control Label donde mostrar el mensaje. 
• Un control CommandButton que al hacer clic en él muestre el mensaje en la eti-
queta. 
• Un control CommandButton que permita salir de la aplicación. 
 
 
 
 
 
 
 
38 Parte 1: Entorno Integrado de Desarrollo 
 
Total de objetos requeridos: 4 
Tipos de objetos requeridos: 1 Form 
1 Label 
2 CommandButton 
>> Cómo insertar un objeto en la interfaz. [02.01] 
A continuacióna aprenderá cómo insertar objetos en un formulario. 
1. Inicie una sesión de Visual Basic y genere un nuevo proyecto EXE estándar. 
2. En la ventana principal de Visual Basic (donde se encuentra la barra de menús y 
la barra de herramientas Estándar) debe aparecer el encabezado Proyectol -
Microsoft Visual Basic (diseño). En este caso, Proyectol es el nombre que 
Visual Basic les asigna de manera predeterminada a los proyectos al inicio. Tome 
en cuenta que trabajaremos con proyectos EXE estándar solamente, hasta que 
las necesidades del libro marquen lo contrario. 
3. Aparecerá un formulario en blanco. En un proyecto de tipo EXE estándar siem-
pre debe existir al menos un formulario, por lo que al crear un proyecto de ese 
tipo siempre dispondrá del primer objeto de la interfaz de usuario creada. 
 
4. Para insertar un objeto, haga doble che en el control CommandButton, que se 
encuentra en el Cuadro de herramientas. Aparecerá un objeto de tipo Com-
mandButton en el centro del formulario (vea la figura 2.3); dicho objeto mostrará 
el texto Cominandi (todos los objetos tienen valores predeterminados en Visual 
Basic). Cuando agregamos un objeto haciendo doble che en un control del 
Cuadro de herramientas, se dice que agregamos un objeto en modo de in-
serción. 
 
============================================================
Nota: Si hace un solo clic, también puede insertar objetos, en lo que se llama modo 
de trazo. Dicho modo será explicado más adelante en este capítulo; si hizo un solo 
clic en lugar de doble clic, seguramente el puntero del ratón es una cruz delgada, que 
indica que está en modo de trazo. Cancele este modo haciendo clic en el control 
Puntero del Cuadro de herramientas. El control Puntero es el único del Cuadro 
de herramientas que no genera un objeto en la interfaz. 
============================================================ 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 2: Creación de la interfaz de usuario 39 
 
 
 
Figura 2.3 
Objeto insertado al
hacer doble clic en 
el control 
CommandButton 
del Cuadro de 
herramientas 
 
 
 
a) La ventana Propiedades indica 
que está trabajando sobre un obje- 
to. ¿Cómo se llama? 
 
b) ¿En qué tipo de control está 
basado? 
 
c) El objeto que acaba de crear 
tiene un nombre predeterminado. 
¿Usted se lo asignó o lo hizo Visual 
Basic? 
 
 
 
 
 
 
 
Consideremos qué ha hecho hasta ahora: 
• Creó un nuevo proyecto EXE estándar, por lo que se agregó un formulario nuevo. De 
manera predeterminada, este formulario tiene diversas propiedades asignadas por 
Visual Basic, entre las que se encuentran un nombre (Name), una posición (Top, 
Left) y un tamaño predefinidos (Height, Width). 
 
 
 
 
 
 
 
 
 
 
 
 
 
40 Parte 1: Entorno Integrado de Desarrollo 
• Utilizando el Cuadro de herramientas agregó un objeto basado en el control 
CommandButton. El objeto CommandButton, al igual que el formulario, 
tiene diversas propiedades asignadas de manera predeterminada por Visual Basic, 
entre las que se encuentran un nombre, una posición y un tamaño predefinidos. 
 
En el formulario aparecerá un conjunto de puntos espaciados de forma regular, lla-
mados cuadrícula estándar. La cuadrícula estándar sólo aparece mientras está dise-
ñando su aplicación en el Entorno Integrado de Desarrollo (IDE), y sirve como refe-
rencia para distribuir los objetos de manera organizada y simétrica. 
Nota: De manera predeterminada, los puntos de la cuadrícula están organizados cada 
120 twips. Si desea modificar la distancia o eliminar la cuadrícula, seleccione 
Herramientas - Opciones - General. Muy pronto sabrá qué es un twip. 
El objeto CommandButton aparece bordeado por ocho recuadros llamados contro-
ladores de tamaño (vea la figura 2.4); éstos sirven para modificar las dimensiones de 
un objeto. 
 Figura 2.4 
Controladores 
de tamaño 
 
Arrastre hacia abajo para hacer 
más ancho el objeto. 
Arrastre hacia abajo para hacer 
más ancho y más alto el objeto. 
Arrastre hacia abajo para hacer 
más alto el objeto. 
 
Se le llama objeto activo al objeto sobre el cual está trabajando 
actualmente. Los con-troladores de tamaño, además de permitir la 
modificación de las dimensiones de un objeto, permiten identificar de 
manera visual qué objeto es el que está activo; esto es muy importante, ya 
que si no ubica con precisión a los objetos, puede estar trabajando con un 
objeto que no quería trabajar, lo que sería tiempo perdido. 
Una forma adicional para identificar qué objeto es el objeto activo, es 
revisando la lista desplegable de objetos que se encuentra en la ventana 
Propiedades (vea la figura 2.5), o bien, observando la barra de título de la 
ventana Propiedades; esta última opción no es muy confiable, ya que es 
inexacta cuando se tienen seleccionados varios objetos al mismo tiempo. 
 
 
 
 
 
 
Capítulo 2: Creación de la interfaz de usuario 41 
 
Es un objeto basado en 
el control 
CommandButton. 
El objeto activo se llama 
Command1. 
El objeto activo será el que aparezca en la barra de título de la ventana Propiedades (en 
este caso. Propiedades – Command1) 
 
Propiedades de posición y dimensión 
 
En Visual Basic no todos los objetos que se agregan en un formulario se ven en la 
interfaz al ejecutar la aplicación, por lo que podemos decir que hay objetos visibles y 
objetos invisibles en tiempo de ejecución; todos los objetos visibles que sean agregados 
tendrán una posición dentro del formulario, así como un tamaño. 
 
A las propiedades que determinan la posición de un objeto se les llaman propiedades de 
posición, las cuales determinan el punto a partir del cual el objeto se comenzará a trazar, 
a dibujar; dicho punto es llamado punto de inicio, y siempre es la esquina superior 
izquierda del objeto. El tamaño del objeto está determinado por las propiedades de 
dimensión, mismas que especifican la distancia entre el punto de inicio y la esquina 
inferior derecha del objeto. 
 
El tamaño de un objeto en Visual Basic está determinado en twips. Un twip es la vi-
gésima parte de un punto, y si consideramos que un punto es 1/72 de pulgada, un twip 
sería 1/1440 de pulgada. No se quiebre la cabeza tratando de encontrar un significado 
para "twip"; la unidad de medida pudo haberse llamado "xwin" o "flox", o como fuera. 
 
 
 
 
 
42 Parte 1: Entorno Integrado de Desarrollo 
Las propiedades de posición son: 
Top Muestra la posición con respecto al margen superior de la pantalla 
o del objeto contenedor. 
 
Left Muestra la posición con respecto al margen izquierdo de la 
pantalla o del objeto contenedor. 
Las propiedades de dimensión son: 
Height Altura del objeto. 
Width Ancho del objeto. 
 
La figura 2.6 muestra gráficamente cómo se interpretan las propiedades de 
posición ylas propiedades de dimensión. Vea como las dimensiones de Height 
y Width comienzan a partir del punto de inicio. 
 
Figura 2.6 
Propiedades 
de posición 
y dimensión de 
los objetos 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 2: Creación de la interfaz de usuario 43 
Las formas para cambiar la posición de los objetos son: 
• Arrastrando el objeto 
• Utilizando las combinaciones de teclas Ctrl+<Flechas de dirección> Las formas para 
cambiar el tamaño de los objetos son; 
• Arrastrando los controladores de tamaño 
• Utilizando las combinaciones de teclas Mayús+<Flechas de dirección> 
>> Cómo cambiar la posición o las dimensiones de un objeto. [02.02] 
A continuación aprenderá la forma de modificar las dimensiones y la posición a los objetos 
que han sido agregados a un formulario. 
 
1. Si no tiene seleccionado el objeto Command1, selecciónelo haciendo clic en el objeto. 
Sabrá que el objeto está seleccionado si los controladores de tamaño se encuentran 
alrededor de él. Observe dónde está ubicado y qué tamaño tiene. 
================================================================== 
Lo inesperado: Puede ser que queriendo seleccionar el objeto Command1 a través de un 
clic, haya hecho doble clic. Si hace eso, aparecerá la ventana Código. 
Aunque dicha ventana es muy importante, no es lo que queremos analizar en este momento, 
por lo que deberá cerrarla. Presione Alt+F4, en tal caso. 
================================================================== 
2. En la ventana Propiedades localice las propiedades de posición y las propiedades de 
dimensión; tome nota de los valores que tienen asignados en este momento. 
 
Command1.Top = _____________________ 
Command1 .Left = _____________________ 
Command1.Height = _____________________ 
Command1.Width = _____________________ 
 
 
 
 
 
 
 
 
 
 
44 Parte 1: Entorno Integrado de Desarrollo 
 
3. Arrastre el controlador de tamaño que se encuentra en la esquina inferior derecha del 
objeto; trate de dejar el botón de comando al doble de su ancho y de su alto actual. 
¿Qué valores tienen ahora las propiedades de dimensión? 
Command1.Height = _____________________ 
Command1.Width = _____________________ 
4. Coloque el puntero del ratón en el centro del objeto y arrástrelo de tal forma que el 
punto de inicio (esquina superior izquierda) quede cerca de la esquina superior 
izquierda del formulario. ¿Qué valores tienen ahora las propiedades de posición? 
Command1.Top = _____________________ 
Command1.Left = _____________________ 
5. Seleccione el objeto Command1 haciendo clic en él y presione la tecla Mayús y 
manténgala presionada; al mismo tiempo utilice las teclas de movimiento (flechas) 
hasta dejar el botón de comando de un tamaño similar al que tenía al inicio de esta 
práctica. Suelte las teclas. 
 
6. Presione la tecla Ctrl y manténgala presionada; al mismo tiempo utilice las teclas de 
movimiento hasta dejar el botón de comando en la posición similar a la que tenía al 
inicio de esta práctica. Suelte las teclas. 
 
7. El botón de comando está en el centro del formulario; oriéntelo hacia la izquierda. 
Ahora ya sabe cómo cambiar el tamaño y la posición de un objeto que se encuentra en un 
formulario, ya sea con el ratón o con el teclado. ¿Y qué pasa con el formulario? 
El formulario tiene algunas consideraciones especiales: 
 
• Si el entorno se encuentra en modo SDI, el formulario no está dentro de ningún objeto 
contenedor y al seleccionarlo no se colocan controladores de tamaño. 
• Si el entorno se encuentra en modo MDI, el formulario está dentro de un objeto 
contenedor, en este caso la Ventana de proyecto; al seleccionar el formulario se 
colocarán los controladores de tamaño. 
• Se muestren o no los controladores de tamaño, es posible cambiar el tamaño del 
formulario. 
 
 
 
 
 
 
 
 
 
 
Capítulo 2: Creación de la interfaz de usuario 45 
>> Cómo seleccionar un formulario. [02.03] 
A continuación aprenderá cómo seleccionar el objeto Form. 
1. Para seleccionar un formulario tiene que hacer clic en cualquier parte del formu-
lario que no esté ocupado por algún otro objeto (de preferencia que no sea en la 
barra de título). 
============================================================= 
Nota: Una forma de "hacer clic en cualquier parte del formulario, que no sea la 
barra de título y que no esté ocupado por otro objeto" es hacer clic en cualquier 
pequeño punto de la cuadrícula estándar. Si puede ver el punto de la cuadrícula están-
dar, resulta obvio que no tiene un objeto que lo cubre. 
============================================================= 
2. Seleccione el formulario como se indicó en el punto 1. Si tenía seleccionado 
cualquier otro objeto, éste ya no lo estará más. 
3. Revise la lista desplegable de objetos que se encuentra en la ventana Propiedades, 
en donde debe aparecer Form1 Form. 
>> Cómo cambiar el tamaño de un formulario. [02.04] 
A continuación aprenderá cómo modificar et tamaño de un objeto Form. 
1. Coloque el puntero del ratón exactamente sobre las esquinas del formulario y sobre 
los márgenes superior, inferior, derecho e izquierdo, estén o no visibles los 
controladores de tamaño (no deben estar presentes porque nos encontramos en 
modoSDI). 
2. Arrastrando la esquina inferior derecha del formulario, reduzca el tamaño de su 
formulario a un tamaño suficiente para el desarrollo estético del ejemplo mostrado 
en la figura 2.1. 
3. Haga los movimientos necesarios para que el formulario tenga las siguientes 
dimensiones: que su alto sea aproximadamente 4 veces el alto del botón, y que su 
ancho sea aproximadamente 4 veces el ancho del botón de comando. La figura 2.7 
muestra cómo debe tener hasta este momento su formulario. 
 
 
 
 
 
 
 
 
 
 
 
 
46 Parte 1: Entorno Integrado de Desarrollo 
 
 
Figura 2.7 
Vista parcial 
del formulario, 
hasta este 
momento 
 
>> Cómo guardar su trabajo. [02.05] 
A continuación aprenderá la forma de guardar su trabajo en Visual Basic. 
 
Aunque es muy poco lo que ha hecho hasta ahora (aunque es mucho lo que ha apren-
dido con ese "poco"), no hay nada que desmoralice más a un programador que perder su 
trabajo y tener que volver a hacerlo. Aquí le diremos rápidamente cómo guardar su 
trabajo, aunque este tema se trata con mayor profundidad en capítulos posteriores. 
1. Haga clic en el botón Guardar proyecto, que aparece en la barra de 
herramientas. Recuerde que por organización del libro, deberá guardar sus 
prácticas en /avbp/capnn, donde nn es el número del capítulo donde se desarrolla 
la práctica. En este caso, lo que guarde en esta práctica debe ir a /avbp/cap02. 
2. Aparecerá la ventana Guardar archivo como...; como Nombre de archivo, escriba 
frmMensaje; en Guardar como tipo, debe estar seleccionado Formulario 
(*.frm), mismo que aparece seleccionado de manera predeterminada. 
3. Haga clic en Guardar. 
4. Enseguida aparecerá la ventana Guardar proyecto como...; como Nombre de 
archivo escriba Saludo; en Guardar como tipo, debe estar seleccionado Proyecto 
(*.vbp), mismo que aparece seleccionado de manera predeterminada. 
 
 Los conceptos Formulario, Proyecto y Grupo de proyectos se analizarán a detalle 
en el capítulo 5. Las ventanas Guardar... aparecerán sólo la primera vez que 
guarde el proyecto y el formulario; después bastará con hacer clic en el botón 
Guardar proyecto para almacenar los cambios hechos al trabajo. 
Ya vimos que agregar objetos en modo de inserción es muy fácil: haciendo doble clic 
en cualquier control del Cuadro de herramientas. El problema es que siempre se 
 
 
 
 
 
 
 
 
Capítulo 2: Creación de la interfaz de usuario 47 
agregarán en el centro del formulario; al agregar varios objetos de manera rápida, 
provocará un juego de movimientos necesarios para poder disponer de cada uno de los 
objetos (quitarle a un objeto los que tiene arriba). Lo ideal es agregarlos objetos en el 
lugar en donde cree que deben quedar de manera definitiva. Eso se realiza agregando 
los objetos en modo de trazo, que no es otra cosa que hacer clic en un control que desea 
agregar, para después trazar en el formulario el espacio que desea que ocupe el objeto 
que quiere agregar. 
>> Cómo agregar objetos en modo de trazo. [02.06] 
A continuación aprenderá la forma de agregar objetos al formulario en modo de 
trazo. 
 
En este momento faltan de agregar dos objetos al formulario: un botón de comando 
(CommandButton) y una etiqueta (Label). 
 
Podríamos hacer doble clic en los controles CommandButton y Label para 
insertarlos, tal y como lo hicimos con el primer botón de comando. En este ejercicio 
optaremos por trazar los objetos. 
 
1. Haga clic en el control CommandButton. Traslade el puntero del ratón a un área 
no ocupada del formulario. Podrá darse cuenta que el puntero del ratón ha cambiado 
su forma: dentro del formulario aparece como una cruz delgada. Este puntero del 
ratón indica que está en modo de trazo. 
2. Trace el área que desea que ocupe el botón de comando que está agregando. La figura 
2.8 muestra cómo trazar ese objeto. En el proceso aparecerá un recuadro de 
Información sobre herramientas que muestra el ancho por alto en twips del objeto que 
está trazando. Deliberadamente provoque que el nuevo botón de comando que está 
agregando sea un poco más grande que el primer botón de comando que ya había 
insertado. 
 
 
 Figura 2.8 
Adicion de un 
Objeto en modo
De trazo 
 
 
 
 
 
 
 
48 Parte 1: Entorno Integrado de Desarrollo 
3. Acomode los botones de tal forma que queden más o menos a la misma altura, en la 
parte inferior del formulario. 
4. Trace el objeto Label arriba de los botones de control. La figura 2.9 muestra cómo 
debe verse el formulario hasta el momento. De manera predeterminada, Visual Basic 
le asigna nombres a cada uno de los objetos, en este caso, los nombres asignados a 
cada objeto son visibles: Form1, Label1. Command1 y Command2. 
Deliberadamente el objeto Command2 fue definido más grande que Command1. 
 
 
 
 
Figura 2.9 
Vista parcial 
 del formulario, 
hasta este 
momento 
 
 
 
Organización de los objetos en el formulario 
Probablemente no esté del todo satisfecho con el resultado obtenido, ya que los objetos están 
desproporcionados y no están bien distribuidos; en pocas palabras, el formulario no se ve bien. 
Visual Basic proporciona un conjunto de herramientas que facilitan la organización y 
distribución de los objetos, a través de su menú Formato. 
Algunas de las opciones de dicho menú funcionan para un solo objeto activo, otras funcionan 
para un conjunto de objetos activos, a lo que se le llama modo de grupo, y otras funcionan para 
ambos casos. 
Cada que selecciona un objeto, los controladores de tamaño aparecen bordeándolo en forma de 
recuadros azules. Cuando seleccione varios objetos en modo de grupo, se dará cuenta que todos 
están rodeados por controladores de tamaño, sin embargo, sólo uno de los objetos tendrá los 
controladores de tamaño de color azul y el resto los tendrán de color blanco. Aquel objeto que 
tenga los controladores de color azul será el objeto principal del grupo; esto es muy importante, 
ya que todos los demás objetos del grupo lo seguirán en sus propiedades. 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 2: Creación de la interfaz de usuario 49 
>> Selección de objeto activo, en forma individual o en modo de grupo. [02.07] 
A continuación aprenderá la forma de seleccionar los objetos en modo de grupo y 
comprobará que a medida que agrupa objetos, la ventana Propiedades muestra sólo 
aquellas propiedades que son aplicables a todos los objetos que conforman el grupo. 
1. Para seleccionar un objeto y establecerlo como objeto activo, basta con hacer clic en 
el objeto. Seleccione Command1 como objeto activo. 
2. Presione la tecla Tab. ¿Qué sucede? 
 
 
 
 
 
3. Seleccione el objeto Command1 . Vea en la ventana Propiedades. ¿Qué valor tiene 
la propiedad Name y la propiedad CausesValidation?: 
Command1 .Name = __________________ 
Command1 .CausesValidation = __________________ 
 
 
4. Seleccione en modo de grupo a los dos botones de comando; tiene dos opciones para 
hacerlo. La primera, seleccione el botón de comando Command1 . presione la tecla 
Mayús y no la suelte, haga clic en el botón de comando Command2 . suelte la tecla 
Mayús. La segunda, trazando un cuadro o línea imaginaria que abarque el área que 
ocupan los dos botones de comando. La figura 2.10 muestra cómo se ve su 
formulario cuando selecciona en modo de grupo los objetos Command1 y 
Command2 . 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
50 Parte 1: Entorno Integrado de Desarrollo 
 
 
 
 
 
 
 
 
 
 
5. Vea en la ventana Propiedades. ¿Qué valor tiene la propiedad Name y la propiedad 
CausesValidation?: 
Name = _________________ 
CausesValidation= _________________ 
 
¿Por qué cree que la propiedad Name ya no está disponible y CausesValidation sí? 
 
 
 
 
6. Presione la tecla Mayús y sin dejar de presionarla haga clic en el objeto Label1. 
7. Vea en la ventana Propiedades. ¿Qué valor tiene la propiedad Name y la propiedad 
CausesValidation?: 
Name = _________________ 
 CausesValidation= _________________ 
 
Capítulo 2: Creación de la interfaz de usuario 51 
¿Por qué cree que la propiedad CausesValidation ya no está disponible? 
 
 
 
Hasta el momento ya sabe seleccionar, cambiar el tamaño y mover los objetos. Lo que 
no 
ha visto es cómo determinar la posición de un formulario. Para ello, utilice la ventana 
Posición del formulario. 
>> Cómo determinar la posición de un formulario en la pantalla. [02.08] 
A continuación aprenderá la forma de determinar la posición de un formulario en la 
pantalla. 
Utilizará la ventana Posición del formulario, misma que no hace otra cosa que modi-
ficar visualmente los valores de las propiedades de posición del objeto Form. 
1. Seleccione el formulario. 
2. Vea qué valores tiene actualmente: 
 Form1.Top = ______________________ 
 Form1.left = ______________________ 
3. Lo más sencillo es arrastrar el formulario tomándolo de la barra de título, si está en 
SDI; en caso de que trabaje en MDI, utilice la ventana Posición del formulario. 
4. Otra forma es utilizando la ventana Posición del formulario. Seleccione el menú 
Ver - Ventana Posición del formulario. Aparecerá la ventana que se muestra en la 
figura 2.11. 
 
 
 
 
 
 
 
 
 
 
 
 
52 Parte 1: Entorno Integrado de Desarrollo 
 
Figura 2.11 
Ventana Posición 
del formulario 
 
 
 
5. La ventana representa la pantalla de un monitor, y dentro de dicha pantalla aparece 
lo que sería su formulario (Form1). 
6. Coloque el puntero del ratón sobre la representación de su formulario, hasta que el 
puntero del ratón cambie a . 
7. Arrastre el pequeño formulario a la posición que desea que ocupe en la pantalla en 
modo de ejecución. 
8. Qué valores tiene actualmente en las siguientes propiedades: 
 Form1.Top = ______________________ 
 Form1.left = ______________________ 
 
============================================================ 
LO inesperado: Es posible que no aparezca formulario alguno en la ventana 
Posición del formulario. Seleccione el menú Ejecutar - Iniciar (también puede opri-
mir la tecla F5). Esto provoca que su aplicación se ejecute (se coloque en tiempo de 
ejecución); lo que su formulario haga en este momento no es relevante. Seleccione el 
menú Ejecutar - Terminar (regresa a tiempo de diseño). 
La ventana Posición del formulario deberá mostrar ya la representación de su for-
mulario. 
 
============================================================ 
 
Cómo establecer las aplicaciones para diferentes 
resoluciones de monitores 
Es posible que usted desarrolle una aplicación que le parece vistosa y bien distribui-
da. Cuando libere la aplicación, no se impresione si uno de los usuarios de éstase 
queja de que la distribución de su aplicación en la pantalla es inadecuada ¿dónde está 
el problema? 
 
Capítulo 2: Creación de la interfaz de usuario 53 
Recuerde que sugeríamos un monitor más grande (17" o 19") para desarrollar cómo-
damente. Seguir esa recomendación puede llevarlo a una involuntaria pérdida de per-
spectiva: con seguridad los usuarios finales de la aplicación dispondrán de un monitor 
más reducido. Para asegurarse de que su aplicación tiene las dimensiones adecuadas 
para los diferentes tipos de monitores y resoluciones que existen en el mercado, la 
ventana Posición del formulario puede ayudarle, si establece lo que se conoce como 
Guías de resolución, que sugieren las dimensiones de su aplicación, comparada 
relativamente con el espacio de trabajo de las resoluciones más comunes de los 
monitores actuales. 
>> Cómo establecer las Guías de resolución. [02.09] 
A continuación aprenderá la forma de establecer las Guías de resolución. 
En el proyecto Saludo.vbp utilizará la ventana Posición del formulario. 
1. Coloque el puntero del ratón en la ventana Posición del formulario. 
2. Haga clic con el botón derecho del ratón y seleccione la opción Guías de resolución 
del menú contextual que aparece (vea la figura 2.12). 
 
Figura 2.12 
 La opción Guías 
 de resolución 
3. En la figura 2.13 se muestra la forma en que se han agregado las Guías de resolución. 
Ahora podrá dimensionar su aplicación, de acuerdo con el espacio real que el usuario 
final puede tener. 
Figura 2.13 
 Guías de reso-
lución en la 
ventana Posición 
del formulario 
 
 
 
 
 
 
54 Parte 1: Entorno Integrado de Desarrollo 
>>Cómo utilizar las herramientas del menú Formato para organizar objetos. [02.10] 
A continuación aprenderá a organizar los objetos con las herramientas que Visual 
Basic tiene en su menú Formato. También aprenderá por qué es importante el orden 
en que los objetos sean seleccionados. 
1. Seleccione el objeto Label1y el menú Formato - Centrar en el formulario — 
Horizontalmente, 
2. Seleccione en modo de grupo los objetos Command1 y Command2. Asegúrese de 
que Command1 , que es el botón de comando más grande, quede como objeto prin-
cipal del grupo (controladores de tamaño en azul). 
3. Seleccione el formulario, lo que implica dejar de tener seleccionados los botones de 
comando. 
4. Haga clic en el objeto Command1 , presione la tecla Mayús y no la suelte, haga clic 
en el objeto Command2, deje de presionar la tecla Mayús. Los controladores de 
tamaño del objeto Command1 deberán ser blancos, mientras que los del objeto 
Command2 son azules. El último objeto integrado al grupo permanece como objeto 
principal de grupo. 
5. Seleccione el menú Formato - Igualar tamaño - Ambos. Observe que los objetos 
del grupo siguen las características del objeto principal del grupo. 
6. Deshaga la modificación que acaba de realizar. Para ello seleccione el menú Edición 
- Deshacer tamaño (también puede presionar Ctrl+Z). 
7. Para seleccionar otro objeto como objeto principal de grupo, haga clic en el objeto 
que desee como objeto principal del grupo. Teniendo seleccionados en modo de 
grupo a los objetos Command1 y Command2. haga clic en el objeto Command1 . 
Los controladores de tamaño del objeto Command2 deberán ser blancos, mientras 
que los del objeto Command1 deberán ser azules. 
8. Seleccione el menú Formato - Igualar tamaño - Ambos. Observe que los objetos 
del grupo siguen las características del objeto principal del grupo. 
9. Todavía teniendo los objetos Command1 y Command2 seleccionados en modo de 
grupo, seleccione el menú Formato - Espacio horizontal - Aumentar. 
10. Seleccione el menú Formato - Bloquear controles. 
11. Trate de mover cualquier objeto dentro del formulario. Comprobará que no se 
puede; asimismo, cada que seleccione un objeto, los controladores de tamaño no 
serán azules como lo eran antes, ahora son blancos. 
12. Seleccione el menú Formato - Bloquear controles. Se deshabilitará el bloqueo de 
los objetos; ahora ya podrá moverlos. 
13. Su formulario deberá verse aproximadamente como se muestra en la figura 2.14. 
 
 
 
 
 
 
Capítulo 2: Creación de la interfaz de usuario 55 
Figura 2.14 
Vista parcial 
del formulario 
hasta este momento 
 
14. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra 
de herramientas Estándar. 
____________________________________________________
Resumen 
En este capítulo: 
• Vimos cuáles son los objetivos que se persiguen al crear una interfaz de 
usuario. 
• Vimos cómo se insertan objetos en un formulario. 
• Vimos cómo se agregan objetos a un formulario en modo de trazo. 
• Vimos qué son los controladores de tamaño. 
• Vimos qué es un objeto activo, la selección de un objeto, la selección de 
objetos en modo de grupo y el establecimiento de un objeto como principal 
del grupo. 
• Vimos cómo mover y darle dimensión a los objetos. 
• Vimos cómo establecer la posición de un formulario en la pantalla. 
• Vimos para qué sirven las opciones del menú Formato de Visual Basic. 
• Vimos cómo guardar nuestro trabajo. 
Es importante que domine todos esos puntos antes de continuar. 
 
 
 
 
56 Parte 1: Entorno Integrado de Desarrollo 
Algunas respuestas a los ejercicios 
[02.01] Cómo insertar un objeto en la interfaz. 
5.a) Command1 
5.b) CommandButton 
5.c) Visual Basic lo asignó de manera predeterminada. 
[02.07] Selección de objeto activo, en forma individual o en modo de grupo. 
2. El control se mueve al siguiente objeto. Otro objeto es ahora el objeto activo. 
3. Command1. Name = Command1 , Command1.CausesValidation = True. 
5. Porque Name es una propiedad específica para un solo objeto; en virtud de que los 
dos objetos no pueden compartir un mismo nombre de objeto, la propiedad Name 
ya no está disponible. CausesValidation es una propiedad no exclusiva para 
un solo objeto, y como aplica a los objetos basados en CommandButton y 
ambos están basados en CommandButton, es posible asignarlo en modo de 
grupo. 
7. Porque no se aplica a todos los objetos del grupo. Puesto que los objetos basados 
en el control Label no cuentan con la propiedad CausesValidation, ésta 
desaparece en un grupo en donde se encuentre un objeto basado en el control 
Label. 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 
3 
Cómo establecer 
las propiedades 
de los objetos 
Objetivo 
Aprender a establecer las características particulares de los objetos, en tiempo de di-
seño y en tiempo de ejecución. 
Al finalizar este capítulo deberá: 
• Dominar el manejo de la ventana Propiedades 
• Saber cómo modificar la propiedad de identificación (Name) 
• Saber cómo modificar las propiedades de apariencia y comportamiento 
• Conocer la sintaxis que se sigue para modificar los valores de las propiedades en 
tiempo de ejecución 
• Saber cómo conformar una tabla de objetos y propiedades para las aplicaciones de 
ejemplo de este libro 
57 
 
 
 
 
 
 
 
58 Parte 1: Entorno Integrado de Desarrollo 
Consideraciones de diseño en Visual Basic 
El diseño de las aplicaciones en Visual Basic no es tan sencillo como parece; no es 
sólo agregar objetos en un formulario de manera estética y proporcionada. 
En Visual Basic el desarrollo es minimalista, detallado, específico. Esto no puede ser 
de otra manera debido a que la plataforma es orientada a eventos, es decir, cualquier 
cosa que suceda en la interfaz de usuario, por mínima que sea, puede desencadenar 
una tarea. Hacer un clic con el ratón, presionar una tecla determinada, pasar el puntero 
del ratón sobre un objeto, arrastrar un objeto, cualquier cosa puede disparar una 
acción; es donde las cosas se complican ya que usted tiene que anticiparse y prevenir 
todo lo que puede pasar. 
Lo primero que puede hacer para que su aplicación haga solamente lo que usted desea, 
es establecer las propiedades adecuadas. 
Al principio, la aplicación Saludo parecía muy sencilla. Al momento de estardise-
ñando la aplicación los detalles aparecen por todos lados. Es un hecho que su aplica-
ción, tal como está, ni luce como usted quiere, ni hace lo que usted quiere. 
Observe las especificaciones de la aplicación desde el punto de vista de diseño de 
Visual Basic, es decir, cómo se espera que se vean y sucedan las cosas: 
• En la barra de título del formulario debe aparecer Mensaje. 
• Al ejecutarse la aplicación, el formulario debe colocarse en el centro de la pantalla. 
• Al iniciar la ejecución de la aplicación, la etiqueta donde se mostrará el mensaje no 
debe tener contenido. 
• La etiqueta donde aparecerá el mensaje ¡¡¡Bienvenido a Visual Basic!!! debe estar 
bordeado con el efecto 3-D estándar de Windows. 
• El botón de comando (CommandButton) que sirva para desplegar el mensaje de 
bienvenida debe decir Mostrar Mensaje; además, debe establecerse como tecla 
de método abreviado para ese botón la combinación Alt+M, siendo visible dicha 
capacidad en el estándar de Windows (la letra "M" debe aparecer subrayada). 
• El botón de comando que sirva para salir de la aplicación debe decir Salir; además, 
debe establecerse como tecla de método abreviado para ese botón la com-
binación Alt+S, siendo visible dicha capacidad en el estándar de Windows (la 
letra "S" debe aparecer subrayada). 
• Hacer clic en el botón de comando Mostrar Mensaje debe provocar que en la eti-
queta aparezca ¡¡¡Bienvenido a Visual Basic!!! 
• Hacer clic en el botón de comando Salir debe provocar la salida de la aplicación 
(terminación de la ejecución). 
 
 
 
 
 
 
Capítulo 3: Cómo establecer las propiedades de los objetos 59 
Todas las especificaciones anteriormente listadas son controladas a través de la asig-
nación de propiedades, excepto la relativa a lo que sucederá cuando se haga clic en los 
botones Mostrar Mensaje, y Salir; esta tarea sólo puede ser realizada a través de 
programación, en los procedimientos asociados a dicho uso de la interfaz. 
Paso 2: Establecer las propiedades de los objetos 
Los objetivos de establecer las propiedades de los objetos son: 
• Validar que ya se tienen todos los objetos que se requieren en el formulario. 
Consiste en revisar que ya se tienen todos los objetos que la interfaz requiere. Para ello 
se utiliza la ventana Propiedades. 
• Asignar el nombre adecuado a cada uno de los objetos. Consiste en darle un 
nombre específico a cada uno de los objetos, a efecto de poder hacer referencia a 
ellos en la aplicación y realizar operaciones con ellos, La propiedad de identificación 
es la propiedad Name. Es necesario que respete las convenciones de prefijo de 
objetos que son reconocidas mundialmente para código Visual Basic. 
• Establecer las propiedades de apariencia y comportamiento. Consiste en asignar 
los valores necesarios a las propiedades para que los objetos luzcan y se comporten 
como el diseño lo requiere. Las propiedades diferentes a la propiedad Name son 
llamadas propiedades de apariencia y comportamiento. 
 
Validar que ya se tienen todos los objetos 
que se requieren en el formulario 
Al inicio de este capítulo se estableció lo siguiente para la aplicación de ejemplo: 
Total de objetos requeridos: 4 
Tipos de objetos requeridos: 1 Form 
1n Label 
2 CommandButton 
 
 
 
 
 
 
 
 
60 Parte 1: Entorno Integrado de Desarrollo 
Debe verificar que efectivamente en este momento tiene en el formulario todos los 
objetos requeridos; debe tener la cantidad suficiente de objetos que le permita cubrir 
las especificaciones del diseño, de tal forma que exista un balance exacto entre la 
estética y la funcionalidad, con aplicación estricta de los estándares de todo programa 
basado en Windows. 
============================================================ 
Nota: Uno de los atributos del entorno de Windows es que la interfaz de los 
programas cuenta con convencionalismos de funcionalidad que permiten que una 
persona, una vez que aprenda a manejar un programa, pueda manejar cualquier otro; 
todos se parecen. 
Usted puede hacer magia con la interfaz, pero si no se apega a los estándares de Win-
dows será un programa incómodo para los usuarios. Uno de los atributos más valio-
sos de la interfaz de una aplicación es que sea fácil de usar y de aprender. 
No rompa paradigmas de manera radical, a menos que sea estrictamente necesario. 
============================================================ 
 Aparte de tener el número correcto de objetos, es muy importante que sean el tipo de 
objeto que necesita. Un error frecuente al desarrollar en Visual Basic es confundir los 
controles, por ejemplo agregar al formulario un objeto basado en el control 
TextBox en lugar de un objeto que debió estar basado en el control Label. 
¿Qué pasará si hace esto? Al codificar hará referencia a propiedades del objeto tipo 
Label creyendo que tiene uno de ese tipo definido en el formulario. En el momento 
en que haga referencia a una propiedad que no esté disponible para el objeto que 
definió (TextBox), su programa marcará error. 
Si incurre en este error, necesita eliminar el objeto equivocado y agregar el correcto. 
Esto es trabajo extra que puede ahorrarse con una verificación sencilla, que no le 
quita mucho tiempo y que debe establecer en su forma de trabajo como un hábito útil 
para la programación en Visual Basic. 
Evite ese trabajo extra verificando desde un principio si tiene los objetos que requie-
re, en cantidad y tipo. La lista desplegable de objetos de la ventana Propiedades 
sirve para tal efecto. 
 >> Cómo validar la cantidad y el tipo de objetos requeridos en una aplicación. [03.01] 
A continuación aprenderá a verificar cuántos objetos tiene definidos en un formulario 
y de qué tipo son. 
1. Seleccione el formulario. Para ello haga clic en cualquier parte del formulario que 
no sea la barra de título y que no esté ocupada por otro objeto. Otra forma de 
decirlo, haga clic en cualquier punto de la cuadrícula. 
2. Haga clic en la lista desplegable de objetos de la ventana Propiedades. La figura 
3.1 muestra cómo se debe desplegar la información. 
 
 
 
 
Capítulo 3: Cómo establecer las propiedades de los objetos 61 
 
Figura 3.1 
Verificación de 
la cantidad de 
obetos y sus 
tipos, utilizando 
la Lista 
desplegable de 
objetos 
haciendo clic en esta 
lista, aparecerán todos 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
los objetos que 
componen el 
formulario, incluyendo 
el objeto contenedor 
3. Marque afirmativamente si se da el caso: 
¿Tiene definido un objeto basado en el control Form? 
¿Tiene definido un objeto basado en el control Label? 
¿Tiene definidos dos objetos basados en el control CommandButton? 
¿Los anteriores son los únicos objetos definidos en la lista? 
Si marcó afirmativamente a todas las preguntas anteriores, puede continuar con el 
capítulo. Si no es así, éstas son las alternativas que tiene: 
• Si sobran objetos. Seleccione los que no sean necesarios y presione la tecla Supr. 
Con esto se eliminarán. 
• Si faltan objetos. Agregúelos y acomódelos como debe ser (vea el capítulo 
anterior). 
 
 
 
 
 
 
62 Parte 1: Entorno Integrado de Desarrollo 
 
• Si tiene la cantidad de objetos correcta, pero uno no es del tipo que esperaba. 
Deberá seleccionar el objeto basado en un control equivocado, y eliminarlo 
presionando la tecla Supr; posteriormente deberá agregar el objeto que haga falta 
con el tipo de control correcto. 
 
Cómo asignar el nombre adecuado 
a cada uno de los objetos 
En un formulario puede tener tantos objetos como la memoria RAM de la compu- 
tadora lo permita; esto puede significar muchos objetos, algunos basados en el mismo 
control. 
 
Ya hemos visto que Visual Basic asigna un nombre predeterminado a cada uno de los 
objetos que es agregado al formulario, a través de la propiedad Name (Form1, 
Label1, Command1. Command2. son ejemplos de ello). 
============================================================ 
Nota: Un solo proyecto puede contenerhasta 32,000 "identificadores" (cualquier 
palabra clave no reservada), asociados a nombres de formularios, controles, módulos, 
variables, constantes, procedimientos, funciones y objetos. El número real de identi- 
ficadores se limita a la memoria disponible. 
============================================================ 
 
Utilizar los nombres proporcionados de manera predeterminada a los objetos no oca- 
siona problemas en aplicaciones pequeñas, pero suponga que tiene un formulario con 
diez botones de comando (Command1, Command2,...., Command10) y cada uno de 
ellos tiene una función específica e importante que no debe confundirse con la 
función de los otros botones de comando; en este caso, sería complicado mantener la 
referencia de los objetos. 
Para evitar estas complicaciones. Visual Basic permite modificar la propiedad Name 
de los objetos, de tal forma que éstos sean identificados con un nombre acorde a su 
función. Aquí surge una problemática nueva: aparte de que puede haber varios 
objetos basados en un mismo control, puede haber objetos basados en otros 
controles. 
Para aquel que desarrolla aplicaciones en Visual Basic, lo ideal es tener un nombre 
de objeto altamente significativo, que dé a entender para qué sirve un objeto deter- 
minado, así como en qué control está basado. De esa manera podrá saber qué 
propiedades estarán disponibles, así como el comportamiento y la apariencia que es 
posible definir. 
Por ejemplo, si tiene una etiqueta (Label) que servirá para desplegar un texto deter- 
minado, podría asignarle el siguiente nombre: 
 
Texto 
 
 
 
 
 
 
 
Capitulo 3: Cómo establecer las propiedades de los objetos 63 
Sin embargo, este nombre por sí mismo no proporciona información relativa al control 
sobre el cual está basado el objeto; podría ser un objeto basado en el control Label. por 
lo que para desplegar un mensaje tendría que modificar la propiedad Caption; pero 
también podría ser un objeto basado en el control TextBox, por lo que para desplegar 
un mensaje tendría que modificar la propiedad Text. Si no conoce con exactitud el tipo 
de control sobre el cual está basado el objeto, podría utilizar propiedades que no se 
apliquen a un objeto (por ejemplo, modificar la propiedad Text de un control un 
Label, o la propiedad Caption de un control un TextBox), lo que generaría un error 
en tiempo de ejecución. 
¿Qué le parece este otro nombre para el objeto? 
 
lblTexto 
El prefijo lbl indica que el objeto está basado en el controLabelbel, y por otro lado, 
el resto del nombre (Texto) nos da una idea en relación con el uso del objeto. 
En Visual Basic se tienen las siguientes convenciones para los objetos: 
 
 
 
 
 
64 Parte 1: Entorno Integrado de Desarrollo 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 3: Cómo establecer las propiedades de los objetos 65 
 
A medida que vaya conociendo más controles agregará las convenciones de prefijos para 
cada uno de ellos. Revise el apéndice 1: Convenciones, para ver la lista completa de 
prefijos, entre otras cosas. 
La propiedad Name de un objeto, al igual que los nombres de variables de memoria en 
Visual Basic, debe comenzar con 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, 
espacios en blanco, caracteres compuestos o caracteres especiales. Le recomendamos el 
uso sólo de letras, números y el carácter de subrayado. Un formulario no puede tener el 
mismo nombre que otro objeto público como Clipboard, Screen o App. 
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. 
 
=============================================================== 
Lo inesperado: Si por equivocación intenta ponerle a un objeto un nombre ya 
utilizado por otro objeto, Visual Basic asume que desea crear una matriz de controles 
(varios objetos identificados por un mismo nombre, diferenciados por un subíndice). La 
utilidad de una matriz de controles se verá en otro capítulo; si por descuido intenta en 
este momento repetir nombres, cuando Visual Basic le pregunte ¿Desea crear una matriz 
de controles?, conteste No. Este es uno de los casos en que Visual Basic utiliza el 
término "controles" cuando debería utilizar "objetos". 
=============================================================== 
 
Si analizamos nuestro ejemplo, podríamos asignar los siguientes nombres de objeto: 
frmMensaje (Form1), lblTexto (Label1), cmdDespliega (Command1) y 
cmdSalir (Command2) (vea la figura 3.2). 
 
 
 
 
 
 
 
 
 
 
 
66 Parte 1: Entorno Integrado de Desarrollo 
 
>> Cómo modificar la propiedad Name de los objetos. [03.02] 
A continuación aprenderá a modificar la propiedad Name de los objetos. 
1. Seleccione el formulario. 
2. Asegúrese de que la cuadrícula de propiedades esté en orden alfabético. 
3. Haga doble clic en la cuadrícula de propiedades donde diga Name. Observe que el 
valor asignado actualmente, en este caso Form1, se sombrea en azul al hacer doble 
clic en el valor asignado a la propiedad. 
4. Escriba frmMensaje. Presione la tecla Intro. 
 
=============================================================== 
Nota: Las propiedades se asignan cuando presiona la tecla Intro, o bien cuando traslada 
el control hacia otra propiedad u objeto; se dice que la propiedad se acepta. Mientras no 
acepte un nuevo valor para una propiedad, puede presionar la tecla Esc y dar marcha atrás 
a los cambios que haya realizado. 
=============================================================== 
 
5. Vea que en la lista desplegable de objetos aparecerá frmMensaje Form, lo que 
indica que el objeto de tipo Form ahora se llama frmMensaje. Usted ha cambiado 
el nombre del objeto. 
6. En la lista desplegable de objetos seleccione Label1 Label; haga doble clic en la 
cuadrícula de propiedades donde diga Name, escriba lbITexto. 
 
 
 
 
 
 
 
 
 
Capítulo 3: Cómo establecer las propiedades de los objetos 67 
7. En la lista desplegable de objetos seleccione Command1 CommandButton; haga 
doble clic en la cuadricula de propiedades donde diga Name, escriba cmdDes-
pliega. 
8. En la lista desplegable de objetos seleccione Command2 CommandButton; haga 
doble clic en la cuadrícula de propiedades donde diga (Name), escriba cmdSalir. 
9. Vea el contenido actual de la lista desplegable de objetos de la ventana. Debe decir 
Propiedades, como se muestra en la figura 3.3. 
 
Cómo establecer las propiedades de apariencia y 
comportamiento 
Cambiar el valor de la propiedad Name y cambiar el valor de cualquier otra propiedad 
es exactamente igual. 
Para establecer el valor de una propiedad en tiempo de diseño: 
• Seleccione el objeto al que pertenece la propiedad que desea modificar. Esto lo 
puede hacer de dos formas: seleccionando el objeto en la lista desplegable de objetos, 
o bien haciendo clic en el objeto. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
68 Parte 1: Entorno Integrado de Desarrollo 
• Busque en la cuadricula de propiedades la propiedad que desea modificar. Haga doble clic en 
el nombre de la propiedad que desea modificar (columna izquierda de la cuadrícula de 
propiedades). 
• Escriba o seleccione el valor deseado. 
 
=================================================================== 
Nota: Un formulario es un objeto contenedor (es decir, puede contener objetos basados en otros 
controles); existe un límite fijo de 254 nombres diferentes de objetos. 
=================================================================== 
 
Para establecer el valor de una propiedad en tiempo de ejecución: 
• Debe realizar una igualación entre la propiedad de un objeto y el valor que se desea asignar. 
 
Ejemplo: 
Usted quiere establecer, para la propiedad Caption del objeto frmMensaje, la siguiente 
expresión: Mensaje. 
Sintaxis: 
Objeto.Propiedad = ValorAEstablecer 
Ejemplo: 
frmMensaje.Caption = "Mensaje" 
 >>Cómo modificar las propiedades de apariencia y comportamiento. [03.03] 
Enseguida aprenderá a modificar las propiedades de apariencia y comportamiento. El diseño nos 
dice lo siguiente: 
• En la barra de título del formulario debe aparecer Mensaje. 
• Al ejecutarse la aplicación, el formulario debe colocarse en el centro de la pantalla. 
1. Seleccione el objeto frmMensaje. El título de la ventana Propiedades debe decir 
Propiedades - frmMensaje. 
 
=================================================================== 
Nota: Si el título de la ventana Propiedades no dice Propiedades - frmMensaje, quiere decir 
que usted está modificando las propiedades de otro objeto. Ese es el primer paso para arruinar el 
funcionamiento de su aplicación. Cerciórese de que está modificando las propiedades del objeto 
que realmente desea afectar. 
=================================================================== 
 
 
 
 
 
 
Capítulo 3: Cómo establecer las propiedades de los objetos 69 
2. Localice en la cuadrícula de propiedades la propiedad Caption. Haga doble clic en el 
nombre de la propiedad; se iluminará en azul el valor actual de la propiedad. Escriba Mensaje 
y acepte la propiedad. Esto sería en tiempo de diseño; en tiempo de ejecución el código que 
modificaría la propiedad sería: 
frmMensaje.Caption = "Mensaje" 
3. Localice en la cuadrícula de propiedades la propiedad StartUpPosition, haga doble clic 
en el nombre de la propiedad; como esta propiedad es de valor limitado, necesita seleccionar 
en la lista desplegable el valor que requiera (vea la figura 3.4). 
 
4. Seleccione el valor 2- Center Screen. Esto sería en tiempo de diseño; en tiempo de ejecución 
el código que modificaría la propiedad sería: 
frmMensaje.StartUpPosition = 2 
 
 =================================================================== 
Nota: StartUpPosition es un ejemplo de aquellas propiedades que se ven afectadas por 
otros movimientos y asignaciones realizadas posteriormente. StartUpPosition con valor 
2 establece que al cargarse el formulario para su ejecución, éste se colocará exactamente en el 
centro de la pantalla. Si después de haber colocado dicho 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
70 Parte 1: Entorno Integrado de Desarrollo 
valor a la propiedad usted mueve el formulario de posición, ya sea arrastrando el formulario por 
su barra de título o utilizando la ventana Posición del formulario, la propiedad cambiará de 
forma automática a O (Manual). 
Al ejecutar la aplicación se preguntará ¿por qué no se colocó en el centro si yo se lo especifiqué? 
Simplemente porque hizo algo en tiempo de diseño que ocasionó modificaciones automáticas en 
la propiedad que así lo establecían. 
 =================================================================== 
El diseño nos dice: 
• Al iniciar la ejecución de la aplicación, la etiqueta, donde se mostrará el mensaje no debe tener 
contenido. 
• La etiqueta donde aparecerá el mensaje ¡¡¡Bienvenido a Visual Basic!!! debe estar bordeado 
con el efecto 3-D estándar de Windows. 
5. Seleccione el objeto indicado, en este caso lblTexto. (La ventana Propiedades debe decir 
en su barra de título Propiedades - lblTexto.) 
6. Localice en la cuadrícula de propiedades la propiedad Caption, haga doble clic en el 
nombre de la propiedad, y presione la tecla Supr para eliminar el contenido; acepte la 
propiedad. En tiempo de ejecución el código que modificaría la propiedad sería: 
lblTexto.Caption = "" 
 
7. Localice en la cuadrícula de propiedades la propiedad BorderStyIe, haga doble clic en el 
nombre de. la propiedad y seleccione el valor 1 - Fixed single. Esto sería en tiempo de 
diseño; en tiempo de ejecución el código que modificaría la propiedad sería: 
lblTexto.BorderStyle = 1 
El diseño nos dice: 
• El botón de comando que sirva para desplegar el mensaje de bienvenida debe decir Mostrar 
Mensaje; además, debe establecerse como tecla de método abreviado para ese botón de 
comando la combinación Alt+M, siendo visible dicha capacidad en el estándar de Windows 
(la letra "M" debe aparecer subrayada). 
8. Seleccione el objeto indicado, en este caso cmdDespliega. (La ventana Propiedades debe 
decir en su barra de título Propiedades - cmdDespliega.) 
9. Localice en la cuadrícula de propiedades la propiedad Caption, haga doble clic en el 
nombre de la propiedad, escriba &Mostrar Mensaje. Esto sería en tiempo 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 3: Cómo establecer las propiedades de los objetos 71 
de diseño; en tiempo de ejecución el código que modificaría la propiedad sería 
(vea la figura 3.5): 
cmdDespliega.Caption = "&Mostrar Mensaje" 
 
 =================================================================== 
Nota: Al establecer la propiedad Caption de los objetos, anteponer a cualquier letra un signo 
"&" hace que dicha letra sea asignada como tecla de método abreviado. En tiempo de 
ejecución, presionar Alt+<letra> es lo mismo que seleccionar el objeto por otro medio. 
Es importante que planee las teclas de método abreviado, a efecto de que no tenga dos iguales 
en un mismo formulario. 
 =================================================================== 
10. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra de 
herramientas Estándar. 
 
Debido a que es poco usual tener un botón de comando con dos líneas de contenido, es 
recomendable ampliar el tamaño del objeto. 
 
 =================================================================== 
Nota: Los objetos deben tener el tamaño suficiente en relación con su contenido. Si el 
contenido excede el tamaño del objeto, dicho contenido se truncará o se dividirá. En el caso 
de nuestro ejemplo, el contenido se dividió en dos líneas. 
 =================================================================== 
 
 
 
 
 
 
 
72 Parte 1: Entorno integrado de Desarrollo 
11. Localice en la cuadrícula de propiedades la propiedad Width, haga doble clic en el nombre 
de la propiedad, escriba 1500. Esto sería en tiempo de diseño; en tiempo de ejecución el código 
que modificaría la propiedad sería: 
 cmdDespliega.Width = 1500 
 
12. Con este cambio, el tamaño de los botones de comando queda desproporcionado. Para 
corregir el problema seleccione en modo de grupo los objetos cmdDespliega y cmdSalir, 
cuidando que el objeto cmdDespliega sea el objeto principal del grupo; después seleccione 
el menú Formato - Igualar tamaño - Ambos. Los dos botones de comando deben tener 
establecida su propiedad Width a 1500 twips. 
El diseño nos dice: 
• El botón de comando (CommandButton) que sirva para salir de la aplicación debe decir 
Salir; además, debe establecer como tecla de método abreviado para ese botón la combinación 
Alt+S, siendo visible dicha capacidad en el estándar de Windows (la letra "S" debe aparecer 
subrayada). 
13. Seleccione el objeto indicado, en este caso cmdSalir. (La ventana Propiedades debe decir 
en su barra de título Propiedades - cmdSalir.) 
14. Localice en la cuadrícula de propiedades la propiedad Caption, haga doble clic en el 
nombre de la propiedad, escriba &Salir. Esto sería en tiempo de diseño; en tiempo de 
ejecución el código que modificaría la propiedad sería; 
 cmdSalir. Caption = "&Salir" 
15. Como ya no hay más modificaciones de tamaño ni de dimensión, se recomienda bloquear los 
controles para no mover de manera involuntaria la interfaz que ya creó. Seleccione el objeto 
frmMensaje y el menú Formato - Bloquear controles. 
16. Guarde su trabajo haciendo clic en el botón Guardar proyecto de la barra 
de herramientas. 
 ==================================================================== 
Nota: De ahora en adelante, grabe su trabajo cada que lo considere conveniente. Le 
recomendamos que lo haga antes de ejecutar una aplicación, ya que en el transcurso de la 
ejecución podría surgir un anidamiento permanente o un error que impida hacerlo 
posteriormente. 
==================================================================== 
En este momentoya estableció todas las propiedades de su aplicación. 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 3: Cómo establecer las propiedades de Sos objetos 73 
Tablas de objetos y propiedades 
Sugerir los objetos y las propiedades a utilizar, así como los valores que deberán asignarse en 
tiempo de diseño a las propiedades, puede ser algo muy complejo si se realiza de manera 
narrativa, como tal vez lo haya notado en la práctica 03.03. 
Para simplificar el proceso, recurriremos a una alternativa esquemática: una tabla en donde se 
listará lo siguiente: 
• Contenedor. La identificación del objeto sobre el que deberá trabajar. 
• Objeto. Indica en qué clase ha de basarse el objeto a integrar a la interfaz. 
• Propiedad. Indica la propiedad que ha de modificarse en tiempo de diseño. 
• Valor. Representa el valor que debe asignarse a la propiedad. 
• Orden. El orden en que se mencionan los objetos en la tabla, es el sugerido para la interfaz. 
A esta tabla la llamaremos tabla de objetos y propiedades; vea cómo quedaría la tabla de objetos 
y propiedades para la aplicación que hemos estado desarrollando: 
Tabla de objetos y propiedades de frmMensaje 
 
 
Formulario: frmMensaje.frm 
Objeto Propiedad Valor 
Project 
 
(Name) 
 
Saludo 
 (Name) frmMensaje 
StartUpPosition 2-CenterScreen 
Form 
 
Caption Mensaje 
(Name) lblTexto 
Caption Borre el texto 
Label 
 
BorderStyle 1-Fixed Single 
(Name) cmdDespliega 
Caption &Mostrar Mensaje 
CommandButton 
 
Width 1500 
(Name) cmdSalir 
Caption &Salir 
CommandButton 
 
Width 1500 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
74 Parte 1: Entorno Integrado de Desarrollo 
_________________________________________________ 
Resumen 
En este capítulo: 
• Vimos que algo simple en teoría, se puede complicar al especificar el diseño de la aplicación. 
• Vimos cómo validar la cantidad y tipos de objeto que se requieren para una aplicación. 
• Vimos cómo establecer el valor de la propiedad de identificación. 
• Vimos cómo utilizar la ventana Propiedades. 
• Vimos las convenciones para identificar objetos en Visual Basic, atendiendo a la función y el 
tipo de control en el que están basados los mismos. 
• Vimos cómo establecer valores a las propiedades de apariencia y comportamiento, tanto en 
tiempo de diseño como en tiempo de ejecución. 
• Vimos cómo se conforma una tabla de objetos y propiedades, herramienta que nos será de 
mucha utilidad en el desarrollo de programas detallados de este libro. 
Es importante que comprenda muy bien todos estos puntos antes de continuar con el libro. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 
 4 
Escritura del código 
 de los eventos 
 
 
Objetivo 
Conocer la forma en que el código de programación es escrito y ejecutado en Visual Basic. 
 
Al finalizar este capítulo deberá: 
• Conocer en qué consiste la programación orientada a eventos 
• Saber utilizar todas las características que brinda el editor de código de Visual Basic 
• Conocer la estructura de los procedimientos de evento 
• Conocer algunos caracteres con significado especial en la codificación en Visual Basic 
75 
 
 
 
 
 
 
 
 
 
 
76 Parte 1: Entorno Integrado de Desarrollo 
Paso 3: Escribir el código de los eventos 
Antes de escribir código de eventos, es necesario entender en qué consisten los eventos y 
la forma de trabajo orientado a eventos que plantea Visual Basic. 
Un evento es una acción reconocida por un formulario o control. Los eventos pueden 
ocurrir como el resultado de una acción determinada por el usuario, por el código de 
programa, o bien puede ser invocada por el sistema. Puede escribir el código que desee 
que se ejecute cuando ocurra un evento; en Visual Basic prácticamente cualquier cosa 
está asociado a un evento, lo que le proporciona un control muy estricto sobre todo lo que 
sucede en su aplicación. Si presiona una tecla, es un evento, si deja de presionarla, otro 
evento, si hace clic es un evento, si mueve el puntero del ratón, también; 
como puede ver, casi todo es un evento. La pregunta ahora es: ¿qué desea que ocurra 
cuando se presente un evento? 
Los siguientes son ejemplos de eventos: 
Change Cuando cambia algo en el objeto 
Cllck Cuando hace clic en el objeto 
DblClick Cuando hace doble clic en el objeto 
KeyPress Cuando presiona alguna tecla 
MouseMove Cuando mueve el puntero del ratón en un objeto 
La programación en Visual Basic se basa en la existencia y reconocimiento de los 
eventos, por lo cual se dice que es una. programación orientada a eventos. En este tipo 
de programación, la aplicación responde a los eventos causados por el teclado, ratón o 
por el sistema operativo. 
=============================================================== 
Nota: No descarte algunos otros dispositivos de entrada, tales como lectores de código 
de barras, tarjetas electrónicas, etcétera. 
=============================================================== 
Dependiendo de la clase o el control en el que esté basado un objeto, serán los eventos 
disponibles para dicho objeto. 
El código de una aplicación de Visual Basic se divide en bloques menores llamados 
procedimientos, que no son otra cosa que un conjunto de órdenes que se ejecutan de 
manera secuencial, que tienen un nombre, un principio y un fin. Un procedimiento 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 77 
de evento es el procedimiento que se ejecutará para cuando a un objeto le suceda un evento. 
Como vimos en el capítulo anterior, las propiedades deben asociarse al objeto al que pertenecen 
(Objeto. Propiedad); pues bien, de la misma forma, los eventos deben asociarse al objeto al que le 
suceden o afectan. Una representación óptima sería: 
Objeto_Evento 
Ejemplo: 
CmdDespliega_Click 
Volviendo a los requerimientos del ejemplo que nos ha acompañado en los primeros capítulos de este 
libro, necesitamos de la aplicación lo siguiente: 
• Hacer clic en el botón de comando Mostrar Mensaje debe provocar que en la etiqueta que sirva para 
mostrar el mensaje aparezca ¡¡¡Bienvenido a Visual Basic!!! 
• Hacer clic en el botón de comando Salir debe provocar la salida de la aplicación (terminación de la 
ejecución). 
La figura 4.1 muestra cómo se manejaría el código en Visual Basic: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
78 Parte 1: Entorno Integrado de Desarrollo 
Analicemos la estructura de los procedimientos de evento. Tomaremos el procedimiento 
que se ejecutará cuando haga clic en el objeto cmdDespliega (vea la figura 4.2). 
Se ve simple. Analicémoslo. 
 
 Todos los procedimientos de evento tienen un inicio (Sub) y un fin (End Sub). El 
inicio y el fin delimitan la totalidad del código que se va a ejecutar cuando suceda el 
evento. 
El evento Click existe para todos los objetos que lo permiten. Por tal motivo, es 
necesario identificar a qué objeto le sucede el evento. 
 
El nombre del procedimiento de evento siempre estará compuesto por el nombre del 
objeto ... 
... y el nombre del evento, separados por un carácter de subrayado. 
Todas las líneas de código que se encuentren entre el inicio y el fin del procedi-
miento de evento se llama código de evento. El código de evento es lo que se ejecutará 
de manera secuencial en el momento en que sucede un evento. 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 79 
 
=============================================================== 
Nota: Es posible que antes de la palabra Sub, en el inicio del procedimiento aparezca 
automáticamente Private o Public, que indica el alcance del procedimiento. 
Analizaremos posteriormente el alcance de los procedimientos. 
=============================================================== 
 
Todo el código debe encontrarse en el área de declaraciones generales, procedimientos 
de usuario o procedimientos de evento. Si agrega código fuera de cualquiera de estas 
zonas, nunca se ejecutará. Por ejemplo: 
SubcmdDespliega_Cllck() 
 
LbITexto.Caption = "¡ ¡ ¡Bienvenido a Visual Basic! ! !” 
 End Sub 
frmMensaje.Caption = "Bienvenida" 
 
Sub cmdSalir_Cllck() 
 
End 
 End Sub 
La línea frmMensaje.Caption = "Bienvenida" no se ejecutará nunca, ya que no forma 
parte del código de evento de ningún procedimiento. 
 
El editor de código de Visual Basic 
Visual Basic posee una poderosa herramienta para editar código; entre las ventajas del 
editor podemos mencionar las siguientes: 
• Clasificación de elementos por colores que le permiten identificar los elementos del 
programa. 
• Reconoce los objetos y asiste en el uso de propiedades y métodos. 
• Interpreta el lenguaje mientras se escribe el código; detecta errores de sintaxis al 
momento de editar. 
• Posee ayuda interactiva y contextual. 
 
 
 
 
 
 
80 Parte 1: Entorno Integrado de Desarrollo 
Antes de ver las posibilidades de edición, es necesario que comprendamos que un 
lenguaje de programación siempre tiene reglas que determinan su estructura, tanto de 
forma como de significado: 
• Reglas de sintaxis (o sintácticas): Determinan la única forma de manifestar ins-
trucciones y expresiones, correctas y completas. 
• Reglas de semántica (o semánticas): Determinan la validez del uso de expre-
siones dentro de una sintaxis correcta. El cumplimiento de las reglas semánticas 
por lo general se ve en tiempo de ejecución, cuando se sabe el significado de las 
expresiones. 
 
 
=============================================================== 
Nota: Por expresión se debe entender todo valor o referencia de un valor: 
• "A" & "B" (concatenación) es una expresión de tipo carácter que equivale a 
"AB". 
• 20/5 (división) es una expresión numérica que equivale a 4. 
• 5 > 3 (comparación) es una expresión lógica que es True (verdadera). 
=============================================================== 
 
 Es importante comprender estos dos conceptos en virtud de que los errores en Visual 
Basic serán violaciones a las reglas sintácticas o semánticas. Los errores de sintaxis no 
deben preocuparle, ya que Visual Basic los reconoce en el mismo instante en que los 
comete y le sugiere corregirlos, pero los errores de semántica pueden convertirse en 
verdaderos dolores de cabeza, ya que son difíciles de identificar; es una buena práctica 
que documente sus desarrollos a efecto de evitar errores. 
En Visual Basic sólo podrá incluir como código instrucciones y funciones del lenguaje, 
funciones y procedimientos definidos por el usuario, operadores y expresiones, cuidando 
siempre la sintaxis y la semántica. 
Al editor de código de Visual Basic se le llama ventana Código; ésta se puede utilizar 
para escribir, mostrar y editar código de Visual Basic. El código de Visual Basic está 
asociado a un módulo, por lo que puede abrir tantas ventanas Código como módulos 
tenga, lo que facilita ver el código en diferentes formularios o módulos y copiarlo y 
pegarlo entre ellos. En estos momentos, en su proyecto sólo tiene un módulo creado, que 
es el formulario mismo. 
Puede abrir una ventana Código: 
 
• Utilizando la ventana Explorador de proyectos, seleccionando un formulario o módulo 
y haciendo clic en el botón Ver código. 
• Haciendo doble clic en un control o formulario. 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 81 
• Seleccionando el menú Ver - Código. 
• Presionando F7. 
>> Cómo abrir la ventana Código. [04.01] 
A continuación aprenderá cómo abrir la ventana Código. 
1. En la ventana Explorador de proyectos seleccione el módulo frmMensaje. 
2. Haga clic en el botón Ver código 
3. Presione Alt+F4 para cerrar la ventana Código. 
4. Presione la tecla F7. 
5. Presione Alt+F4 para cerrar la ventana Código. 
6. Seleccione el menú Ver - Código. 
7. Presione Alt+F4 para cerrar la ventana Código. 
8. Haga doble clic en el objeto cmdDespliega. 
9. Presione la tecla Ctrl+F4 para cerrar la ventana Código. 
Elementos de la ventana Código 
La ventana Código está compuesta de los siguientes elementos: 
• Cuadro Objeto, Muestra el nombre del objeto seleccionado. Haga clic en la flecha 
situada a la derecha del cuadro de lista para mostrar una lista de todos los objetos 
asociados con el formulario. 
• Cuadro Procedimiento/Evento. Presenta una relación de todos los eventos re-
conocidos por Visual Basic para un formulario o control mostrado en el cuadro 
Objeto. Cuando seleccione un evento, el procedimiento de evento asociado con ese 
evento se muestra en la ventana Código. 
• Barra de división. Si arrastra hacia abajo esta barra, la ventana Código se divide en 
dos paneles horizontales, cada uno de los cuales tiene sus propias barras de 
desplazamiento. Puede ver diferentes partes del código a la vez. La información 
que aparece en los cuadros Objeto y Procedimiento/Evento se aplica al código del 
panel que tiene el enfoque. Si arrastra la barra a la parte superior o inferior de la 
ventana o hace doble clic en ella, se cierra un panel. 
• Botón Ver procedimiento. Muestra el procedimiento seleccionado. En la 
ventana Código sólo se muestra un procedimiento a la vez. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
82 Parte 1: Entorno integrado de Desarrollo 
• Botón Ver módulo completo. Muestra todo el código del módulo. 
La figura 4.4 muestra dónde se localizan cada uno de los componentes. 
 
>> Cómo manejar los componentes de la ventana Código. [04.02] 
A continuación aprenderá a manejar los elementos de la ventana Código. 
1. Seleccione el objeto frmMensaje. 
2. Presione la tecla F7. 
3. Haga clic en el botón Ver procedimiento. Observe que solamente se mostrará el 
procedimiento que tiene el enfoque. 
 
=============================================================== 
Nota: En Visual Basic, aquel objeto o elemento que posee el cursor (que puede res-
ponder al teclado) tiene el enfoque. 
=============================================================== 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 83 
4. Haga clic en el botón Ver módulo. Se mostrarán todos los procedimientos defi-
nidos hasta el momento. 
5. En el cuadro Objeto seleccione el objeto cmdSalir. 
6. En el cuadro Procedimiento/Evento seleccione LostFocus. 
7. Arrastre la barra de división hasta que quede a la mitad de la ventana Código. 
Debe verse aproximadamente como se muestra en la figura 4.5. 
 
 
 
8. Puede editar en cualquiera de las dos mitades. Esta característica es muy 
valiosa en proyectos con código muy extenso. Haga doble clic en la barra de 
división para eliminarla. 
9. Marque todo el código que tenga en la ventana Código y presione Supr para 
eliminarlo. La ventana Código debe quedar sin contenido. 
10. Presione Alt+F4 para cerrar la ventana Código. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
84 Parte 1: Entorno Integrado de Desarrollo 
 
=============================================================== 
Nota: La ventana Código tiene la misma funcionalidad que cualquier editor de texto 
basado en Windows, por lo que seleccionar texto, eliminar, copiar, pegar, reemplazar, 
etcétera, se realiza de la misma forma que si lo estuviera haciendo en Word, WordPad o 
Notepad. 
=============================================================== 
 
Caracteres especiales 
Antes de que comencemos con la edición de código, es recomendable que sepa la exis-
tencia de caracteres especiales con significado en el lenguaje de Visual Basic. 
• Apóstrofe (‘). Todo el código que continúe en la misma línea (hasta encontrar fin de 
línea) será interpretado como comentario. 
• Comillas dobles ( “ ”). Siempre engloban una expresión de tipo carácter, por lo que 
siempre que abra unas comillas, tendrá que cerrarlas. 
• Carácter de subrayado ( _ ). Es el continuador de línea de Visual Basic. Antes de 
éste siempre debe haber cuando menos un espacio en blanco, y después de éste nunca 
debe haber nada, o de lo contrario se generará un error. 
 
 
Asistencia en la ediciónde código 
Una de las capacidades más sobresalientes de Visual Basic es el soporte a la edición que 
da la ventana Código. Cuando edita código en algún procedimiento, se dice que está en 
modo de edición de código. El soporte se brinda de varias maneras: 
• Manejo de colores. Permite identificar por colores lo que se está editando; las 
palabras reservadas e instrucciones de Visual Basic aparecerán en azul, los errores de 
sintaxis que Visual Basic detecte en tiempo de edición aparecerán en rojo, las 
expresiones aparecerán en negro y los comentarios que se hagan en el código 
aparecerán en verde; lo que aparezca en verde carecerá de significado para el 
compilador. 
• Sugerencia de propiedades y métodos en modo de edición. Visual Basic sugiere qué 
propiedades y métodos son aplicables para un objeto determinado, reconocido por el 
simple hecho de formar parte de un formulario. 
• Sugerencia de sintaxis. Muestra en modo de edición de código la sintaxis correcta de 
la función o instrucciones que está a punto de escribir. 
• Ayuda contextual. Proporciona ayuda contextual sobre lo que está tecleado, siempre 
y cuando exista ayuda disponible. 
• Formato de texto. Aplica autoformato al código, a efecto de que sea más legible y 
estándar en cuanto al estilo. 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 85 
>> Manejo de colores y autoformato al editar código. [04.03] 
A continuación aprenderá a utilizar las formas de asistencia en la edición de código que 
proporciona Visual Basic. 
1. Haga doble clic en el objeto cmdDespliega. Visual Basic determina que el proce-
dimiento de evento más común para un objeto basado en el control 
CommandButton es Click, por lo mismo procede a editar de manera 
predeterminada dicho procedimiento. 
¿De qué color están las palabras Sub y End Sub, y por qué tienen ese color? 
Color: ______________ 
¿Por qué? 
 ________________________________________________________ 
 
=============================================================== 
Nota: En Visual Basic una línea de código no es evaluada y aceptada hasta que cambia 
de línea, ya sea utilizando las flechas de dirección o la tecla Intro. 
=============================================================== 
 
2. Teclee lo siguiente como código de evento (el primer carácter es un apóstrofe). 
' Instrucción que emite sonido por el altavoz 
¿De qué color se puso la línea y por qué tiene ese color? 
Color: ______________ 
¿Por qué? 
________________________________________________________ 
3. Teclee la siguiente línea de código debajo del comentario que acaba de escribir 
(escríbalo todo en mayúsculas). 
BEEP 
 
¿Aplicó Visual Basic autoformato a su instrucción?. ______________________ 
 
 
 
 
 
 
 
 
 
86 Parte 1: Entorno Integrado de Desarrollo 
Hasta el momento su código debe lucir como se muestra en la figura 4.6. 
 
>>Compilación y detección de errores en modo de edición. [04.04] 
1. Continúe editando el código; escriba la siguiente línea (escriba hasta el punto, pero 
NO ACEPTE LA LÍNEA TODAVÍA): 
MiObjeto. 
 
¿Existe algún objeto en su formulario llamado MiObjeto?. _______________ 
¿Al teclear el punto Visual Basic respondió de alguna forma?. _______________ 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 87 
 
2. Ahora sí, acepte la línea (utilice las flechas de dirección o Intro para pasar a la siguiente 
línea). Visual Basic detecta un error de sintaxis y envía un error, como se muestra en la 
figura 4.7. Observe que la línea que causa el error se pone en rojo; cualquier línea en 
rojo en modo de edición de código es sinónimo de problemas. 
 
 
3. Elimine la línea que causa el problema. 
 >> Sugerencia de propiedades y métodos en modo de edición. [04.05] 
1. A continuación teclee una línea de código, pero hágalo en partes, sin presionar 
 Intro y sin cambiarse de línea, comenzando con lo siguiente: 
LblTexto. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
88 Parte 1: Entorno Integrado de Desarrollo 
 
 
 Observe que al llegar al punto, Visual Basic determina que efectivamente existe un 
objeto llamado lblTexto, identifica en qué tipo de control está basado el objeto 
(Label) y muestra todas las propiedades y métodos válidos para dicho control (vea la 
figura 4.8) a través de un cuadro de lista combinado de sugerencias. Vea que de 
momento no está seleccionada ninguna propiedad o método de la lista. 
2. En cuanto comience a teclear un poco más, alfabéticamente se ubicará en la lista la 
propiedad o método que corresponda con lo que está tecleando (vea la figura 4.8). 
 
 
Proyect 
3. Continúe tecleando en la misma línea lo siguiente: 
lblTexto.Ca 
4. Observe que el simple hecho de comenzar a teclear la continuación de la línea, 
encuentra la probable palabra que desea. Teclee sólo las letras que requiera basta 
encontrar la palabra Caption. 
5. Una vez que esté seleccionada la opción que desea, en este caso Caption (vea la 
figura 4.9), presione la barra espaciadora y Visual Basic colocará el nombre de la 
propiedad por usted. Quizá en propiedades como Top o Left le resulte más 
 
 
 
 
 
 
 
 
 
 
 
 
Capítuio 4: Escritura del código de los eventos 89 
 
simple teclear de manera completa el nombre de la propiedad; sin embargo, algunos 
objetos tienen propiedades de nombre muy largo, como StartUpPosition, en donde 
una ayuda no está de más. Un beneficio adicional: dejar que Visual Basic le asista en el 
nombre de las propiedades le garantiza que no tendrá errores de sintaxis, debido a 
nombres de propiedades mal escritos. 
 
 
6. Termine de capturar, de tal forma que la línea completa quede como se muestra a 
continuación: 
lblTexto.Caption = "¡¡¡Bienvenido a Visual Basic!!!" 
7. Borre todo el código que tenga tecleado y cierre la ventana Código. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
90 Parte 1: Entorno Integrado de Desarrollo 
El evento predeterminado de los objetos 
Como puede ver. Visual Basic y su editor de código permiten una interacción intuitiva 
entre los objetos y lo que puede hacer con ellos; ya comprobó que cada objeto, al 
momento de hacer doble clic en él en tiempo de diseño, activa la ventana Código en el 
procedimiento de evento que Visual Basic considera como el más usual, a lo que 
llamaremos evento predeterminado. 
Por ejemplo, cada objeto creado basado en el control CommandButton tendrá como 
evento predeterminado al evento Click; ¿para qué puede servir un botón, si no es para 
hacer clic en él? 
No obstante, en ocasiones no desea editar el evento predeterminado. Para editar cualquier 
otro evento, puede utilizar el cuadro Objeto (la lista desplegable que aparece a la 
izquierda, debajo de la barra de título de la ventana Código) y del cuadro Proce-
dimiento/Evento (la lista desplegable que aparece a la derecha, debajo de la barra de 
título de la ventana Código). Puede, sin necesidad de estar haciendo doble clic en los 
objetos que tiene en modo de diseño, editar todos los procedimientos de todos los objetos 
disponibles en la interfaz. 
>> Uso de los cuadros Objeto y Evento para la selección y codificación de un proce-
dimiento de evento determinado. [04.06] 
1. Haga doble clic en el objeto cmdDespliega. 
 ¿Qué procedimiento de evento se puso en modo de edición? 
 
 
2. Escriba el siguiente código en dicho procedimiento: 
Private Sub cmdDespliega_Click() 
' Instrucción que emite sonido por el altavoz 
 Beep 
' Cambia en modo de ejecución la propiedad 
' Caption del objeto lblTexto 
 
lblTexto.Caption = "¡¡¡Bienvenido a Visual Basic!!!" 
End Sub 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 91 
 
3. Despliegue la lista del cuadro Procedimiento/Evento; aparecerán los eventos 
disponibles para el objeto cmdDespliega. Seleccione el evento GotFocus. El 
procedimiento deberá agregarse en la ventana Código. 
4. Despliegue nuevamente la lista del cuadroProcedimiento/Evento. 
 ¿Qué diferencia existe, visualmente, entre Cllck y GotFocus? 
 
 
 
5. Seleccione nuevamente GotFocus y escriba el siguiente código (asegúrese de dar 
entrada a la línea de código, tecleando Intro al final de la línea): 
 
Private Sub cmdDespliega_GotFocus() 
' Comentario de prueba 
End Sub 
6. Despliegue nuevamente la lista del cuadro Procedimiento/Evento. Debe verse como 
se muestra en la figura 4.10. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
92 Parte 1: Entorno Integrado de Desarrollo 
¿Qué significa si un nombre de evento aparece en negritas? 
 
 
 
7. Cierre la ventana Código y seleccione el objeto cmdDespliega (haciendo clic en 
él). 
8. Abra la ventana Código (F7). 
9. Despliegue la lista del cuadro Objeto. Seleccione lblTexto. 
¿Fue necesario hacer doble clic en el objeto lblTexto, en tiempo de diseño en el for-
mulario para poder editar su código? 
____________________ 
10. Cierre la ventana Código. 
¿Por el hecho de haber solicitado editar código para el objeto lblTexto, el objeto 
cmdDespliega dejó de estar seleccionado? 
____________________ 
 >>Uso del carácter de subrayado y la ayuda contextual en modo de edición. [04.07] 
1. Ya debe tener tecleadas todas las líneas del procedimiento cmdDespliega _Click 
sin errores. Colóquese en la última línea que tecleó, exactamente después del signo de 
igual ( = ) y antes de las comillas, teclee un espacio en blanco, seguido de un carácter 
de subrayado (_), y después teclee Intro. El continuador de línea hizo su trabajo. 
2. Ahora colóquese después la palabra "Bienvenido", inserte un espacio, teclee un 
carácter de subrayado ( _ ) y después teclee Intro. Vaya una línea más abajo en el 
código. Generará error, un continuador de línea nunca debe dejar incompleta 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 93 
una expresión. Corrija el problema eliminando el continuador de línea que causó el 
error. 
3. Su procedimiento debió haber quedado como se muestra a continuación: 
Private Sub cmdDespliega_Click() 
' Instrucción que emite sonido por el altavoz 
 Beep 
' Cambia en modo de ejecución la propiedad 
' Caption del objeto lblTexto 
lblTexto.Caption = _ 
"¡¡¡Bienvenido a Visual Basic!!!" 
End Sub 
 
 
=============================================================== 
Lo inesperado: En la figura 4.3 se mostró el esquema de un procedimiento de 
evento. En dicha figura no se hace referencia a la palabra Private, que como vemos en 
los subsecuentes ejemplos, sí aparece. Esa palabra se agrega de manera predeterminada e 
indica el alcance del procedimiento; no es obligatoria. Con o sin la indicación Private, 
el procedimiento funciona; quisimos dejarla para que no se sorprenda cuando la vea. 
=============================================================== 
4. En el cuadro Objeto seleccione el objeto cmdSalir y en el cuadro Procedimien-
to/Evento seleccione Click. Escriba el siguiente código: 
 
Private Sub cmdSalir_Click() 
 
End 
End Sub 
5. ¿Para qué sirve la instrucción End? Para saberlo, coloque el cursor exactamente sobre la 
palabra End( entre la "E" y la "n" estaría bien). Presione F1. Aparecerá la ventana de 
ayuda de Visual Basic con la ayuda relativa a la orden. Si tiene dudas de alguna 
instrucción o función, esta ayuda contextual puede ser de gran utilidad. Cierre la 
ventana de ayuda presionando Alt+F4. En este caso, End termina con la ejecución de 
la aplicación. 
 
 
 
 
 
 
 
94 Parte 1: Entorno Integrado de Desarrollo 
6. Estando en la ventana Código, presione Alt+F4 para cerrar dicha ventana. 
Una de las cosas más importantes al estar codificando en Visual Basic es la de dar már-
genes a la izquierda, a lo que se llama sangría. Vea lo siguiente: 
 
 
Observe que la distribución A deja en claro cuál es el código de evento, dónde inicia y 
dónde termina el procedimiento. La distribución B es más confusa, y una vez teniendo más 
procedimientos y estructuras de control en el código, el problema se complica. 
Al estar detallando los ejemplos en este libro, pondremos las tabulaciones ideales; 
trate de escribir el código tal y como aparece en el texto. Aunque en este libro también 
ponemos la línea de inicio y de conclusión del procedimiento (Sub, EndSub), usted no 
tendrá que teclear esas líneas, pues Visual Basic las escribe automáticamente. 
Convenciones para la codificación 
Hasta ahora, en el libro ha visto que para codificar un procedimiento de evento, per-
teneciente a un objeto, decimos "seleccione el objeto y presione F7, o bien haga doble clic 
en el objeto"; también podemos decir "abra la ventana Código y en el cuadro Objeto 
seleccione el objeto que desea codificar, después en el cuadro Procedimiento/Evento, 
seleccione el evento que desea codificar". 
Suponga que deseamos editar en el procedimiento cmdSalir_click, por lo cual 
diríamos "seleccione el objeto cmdSalir y presione F7, o bien haga doble clic en el 
objeto cmdSalir en tiempo de diseño en el formulario"; también podemos decir "abra la 
ventana Código, despliegue el cuadro Objeto, seleccione el objeto cmdSalir y en el 
cuadro Procedimiento/Evento, seleccione Click". ¡Qué tedioso! Es más fácil hacerlo 
que leerlo. 
Puesto que en este libro codificará todo el tiempo y seguirá siempre estos procedimientos, 
es recomendable que establezcamos una convención para decir lo mismo, pero más fácil. 
¿Qué le parece lo siguiente? 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 95 
 Editar código: cmdSalir, Evento: Clíck. 
Con ello asumimos que no tendremos que repetir que en caso de que no se encuentre en la 
ventana Código, es necesario que la abra; asimismo, no será necesario que le digamos a 
detalle cómo llegar a editar el procedimiento de evento mencionado para el objeto referido. 
Estamos seguros de que está de acuerdo con nosotros en que entender de una vez esto le 
puede ahorrar mucha lectura de lo que ya resulta obvio. Después de todo, siempre sabrá 
qué objeto es el que desea codificar, y en qué evento. 
También sabemos que todo procedimiento tiene inicio y fin: 
Private Sub cmdSalir_Click() 
End 
End Sub 
Por lo tanto no es necesario que coloquemos las líneas de inicio y fin todo el tiempo; por 
ejemplo, para obtener el código anterior sería suficiente lo que se muestra a continuación: 
Editar código: cmdSalir, Evento: Click. 
End 
 
Existen algunas excepciones que es recomendable precisar para el funcionamiento óptimo 
de esta convención; por ejemplo, su formulario se llama frmMensaje, y es el objeto 
contenedor de todos los demás objetos. Si lo busca en el cuadro Objeto de la ventana 
Código, se topará con la sorpresa de que es el único objeto de su interfaz que no aparece. 
Esto se debe a que dicho objeto actúa como contenedor del módulo, y Visual Basic lo 
llama, para efecto de los eventos, simplemente Form, llámese como se llame el objeto 
Form. 
También es importante que sepa que sí es posible editar código fuera de un procedimiento, 
siempre y cuando se escriba al principio de toda codificación, en una parte conocida como 
declaraciones generales. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
96 Parte 1: Entorno Integrado de Desarrollo 
Para editar las declaraciones generales podemos decir: "escriba en las declaraciones 
generales el siguiente código", o bien. Editar código: (General) Evento: (Declarations). 
También será necesario, con aquellos procedimientos muy largos, agregar código después 
de la última línea que hayamos codificado; para ello haremos la referencia: 
Continuar editando código: cmdSalir, Evento: Click. 
Que indica que continuaremos codificando después de la última línea que hayamos 
codificado del procedimiento en cuestión. 
En caso de que necesitáramos agregar código en una parte que no está después de la última 
línea codificada, haremos la siguiente referencia: 
Modificar código: cmdSalir, Evento: Click. 
Privatesub cmdSalir_Click( ) 
MsgBox "Muchas gracias por utilizar este programa" 
End 
Se hace la referencia del evento a modificar, se escriben las líneas que se mantienen 
intactas en letra normal, y lo que se modifica se pone en negritas. 
Especificaciones de codificación 
Será la forma en que se codificarán los programas en este libro. Las especificaciones de 
codificación estarán integradas por las siguientes partes: 
• Identificación del módulo (formulario) sobre el que hay que trabajar. 
• Especificación de código a agregar. Abrir la ventana Código, seleccionar el objeto del 
que desea editar un procedimiento de evento, a través del cuadro Objeto; seleccionar el 
evento en el que desea agregar código de evento, a través del cuadro 
Procedimiento/Evento. Escribir el código de evento. 
• Especificación de código a editar. Seleccionar el procedimiento de evento que está 
inconcluso, y continuar con la codificación. 
• Especificación de código a modificar. Seleccionar el procedimiento de evento que se va a 
modificar, haciendo los cambios deseados. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 97 
En nuestro ejemplo, la codificación quedaría cómo se muestra a continuación: 
Codificación de frmMensaje 
• Editar código: cmdDespliega, Evento: Click. 
 
‘ Instrucción que emite sonido por el altavoz 
 Beep 
 lblTexto.caption = _ 
"¡¡¡ Bienvenido a Visual Basic!!!" 
• Editar código: cmdSalir, Evento: Click. 
End 
 
¿Qué hacer con los procedimientos de evento sin código? 
Visual Basic asume muchas cosas con tal de facilitarle el trabajo. Por ejemplo, ya vimos 
que al hacer doble clic en modo de diseño en un botón de comando, automáticamente se 
abre la ventana Código sobre el procedimiento de evento Click para dicho objeto; Visual 
Basic hace esto porque asume que la tarea más común que se hace con un botón de 
comando es hacer clic en él para desencadenar una tarea. 
Cada objeto, dependiendo del control sobre el que esté basado, tendrá un procedimiento de 
evento predeterminado que se editará con el simple hecho de que invoque la ventana 
Código cuando el objeto está seleccionado. 
Sin embargo, hay ocasiones en las que no se desea editar un determinado procedimiento 
que Visual Basic coloca de manera predeterminada al invocar la ventana Código. Quizá 
resulte molesto tener que eliminar procedimientos que usted no haya agregado La figura 
4.5 muestra muchos procedimientos que realmente no se utilizan. 
No se preocupe por aquellos procedimientos de evento que no tienen código de evento 
(procedimientos que entre el inicio y fin del procedimiento no tienen nada de código). Para 
visual Basic es como si no existieran. 
Al momento de ejecutar la aplicación. Visual Basic detectará que no tienen código de 
evento, y procederá a borrarlos automáticamente. 
 
 
 
 
 
 
 
 
 
98 Parte 1: Entorno Integrado de Desarrollo 
__________________________________________________________________________ 
Resumen 
En este capítulo: 
• Vimos qué son los eventos y los procedimientos de evento. , 
• Vimos qué nomenclatura se aplica a los procedimientos de evento. 
• Vimos la utilidad de las herramientas que están integradas en la ventana Código. 
• Vimos los elementos que componen a la ventana Código. 
• Vimos qué caracteres especiales tienen significado particular en la codificación en Visual 
Basic. 
• Vimos la asistencia en modo de edición, mediante colores. 
• Vimos la asistencia en modo de edición, a través de sugerencias de propiedades y 
métodos. 
• Vimos la importancia de la distribución del código para que éste sea legible. 
• Establecimos convenciones para utilizar en el resto del libro. 
Es muy importante que domine todos los puntos antes mencionados, para que el proceso de 
codificación sea lo más asistido posible. 
 
Algunas respuestas a los ejercicios 
[04.03] Manejo de colores y autoformato al editar código. 
1. Color: Azul, ¿por qué? Porque son palabras reservadas de Visual Basic. 
2. Color: Verde, ¿por qué? Porque es un comentario, sin significado para el compilador de 
Visual Basic. 
3. Sí lo aplicó. 
[04.04] Compilación y detección de errores en modo de edición. 
1. No existe ningún objeto llamado MiObjeto. Al llegar al punto después de MiObjeto, 
Visual Basic no respondió de ninguna forma. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Capítulo 4: Escritura del código de los eventos 99 
[04.06] Uso de los cuadros Objeto y Evento para la selección y codificación de un 
procedimiento de evento determinado. 
1. Click 
4. Click está en negritas y GotFocus no lo está. 
6. Si está en negritas indica que el evento para el objeto en cuestión tiene código escrito 
dentro de sí. 
9. No 
10. No 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
100