Visualbasico6 PDF

CENTRO NACIONAL DE
CAPACITACIÓN Y CALIDAD
Coordinación de Informática
Visual Basic 6.0

Básico
VISUAL BASIC 6.0 BÁSICO
TABLA DE CONTENIDO
Presentación ........................................................................................................................................................................ 3
Introducción ........................................................................................................................................................................ 4
Módulo I Elementos generales ....................................................................................................................................... 5
Algoritmos........................................................................................................................................................................ 5
Diagramas de Flujo .......................................................................................................................................................... 5
Pseudocódigos ................................................................................................................................................................. 6
Módulo II El entorno de trabajo en Visual Basic ............................................................................................................. 9
La ventana de Visual Basic 6.0 ........................................................................................................................................ 9
Proyectos (Project) ........................................................................................................................................................ 15
Modo Diseño y Modo Ejecución ..................................................................................................................................... 17
Módulo III La programación en Visual Basic ............................................................................................................... 25
Tipos de Programas ....................................................................................................................................................... 25
Rutinas o procedimientos .............................................................................................................................................. 25
Errores frecuentes ......................................................................................................................................................... 27
Estructuras de Control ................................................................................................................................................... 37
Expresión condicional................................................................................................................................................. 37
If… Then .................................................................................................................................................................... 37
Select Case................................................................................................................................................................. 38
Do While .................................................................................................................................................................... 39
Do Until ...................................................................................................................................................................... 39
For… Next .................................................................................................................................................................. 39
Módulo IV Controles y objetos especiales .................................................................................................................. 40
Puntero (Pointer) ....................................................................................................................................................... 40
Formulario (Form) ...................................................................................................................................................... 41
Editor de menús (Menu Editor).................................................................................................................................. 44
Etiqueta (Label) ......................................................................................................................................................... 46
Cuadro de texto (TextBox) ........................................................................................................................................ 46
Botón de comando (CommandButton) ...................................................................................................................... 48
Marco (Frame) ........................................................................................................................................................... 48
Casilla de verificación (CheckBox) ............................................................................................................................. 49
Botón de opción (OptionButton) ................................................................................................................................ 49
Cuadro de lista (ListBox) ............................................................................................................................................ 50
Cuadro combinado (ComboBox) ................................................................................................................................ 51
Imagen (Image) ........................................................................................................................................................ 52
Control de datos (Data) ............................................................................................................................................. 52
Variables ........................................................................................................................................................................ 60
Option Explicit ................................................................................................................................................................ 60
Ámbito de una variable.................................................................................................................................................. 60
Formas para declarar variables ..................................................................................................................................... 61
Página 2 de 62
Presentación
La informática hoy día se significa como un instrumento estratégico en la consolidación del concepto de calidad, al
interior y exterior de cualquier organización. Mayor productividad, eficiencia y confiabilidad; en breve, mayor
competitividad. Es lo que el desarrollo de ésta rama ha devuelto en los procesos donde se involucra el manejo de
información, los cuales, están presentes en cualquier actividad y en todos los ámbitos.
La capacitación en éste rubro, por consiguiente, es más que necesaria, pues es el medio a través del cual se pueden
plantear propuestas de solución asociadas a los problemas que se generan de la administración de datos en una
organización; en este sentido, el desarrollo de programas implica una conciencia plena de esta problemática y también
una visión creativa en busca de alternativas que satisfagan las necesidades y requerimientos particulares en los
centros de trabajo.
En este contexto las herramientas como Visual Basic constituyen una alternativa viable en esa constante demanda de
conocimientos y actitudes que establezcan una mejor y más eficaz gestión de la información.
El Instituto Mexicano del Seguro Social conjuntamente con el Sindicato Nacional de Trabajadores del Seguro Social
comprometidos con la superación y actualización del personal, impulsan la Capacitación en materia de Informática,
Humanística, Promocional y de Programas Institucionales que se vinculen a la solución de los problemas de la
operación, favoreciendo el otorgamiento de servicios de calidad.
La Coordinación de Informática del Centro Nacional de Capacitación y Calidad, cumple con la tarea de Diseñar los
cursos de capacitación y elaborar los Materiales de Apoyo Didáctico para sustentar los programas de capacitación en
Informática que integran el Plan de Trabajo de esta Coordinación y que están abiertos a todos nuestros compañeros
trabajadores.
Así pues, se presenta a continuación el Material de Apoyo Didáctico del Participante “Visual Basic 6.0 Básico”, mismo
que ha sido elaborado con información actualizada y los sustentos pedagógico y didáctico, que garantizan el
cumplimiento del propósito para el cual fue elaborado: conducir el aprendizaje de los trabajadores, promoviendo la
autosuficiencia en la construcción de aplicaciones de software de uso específico que atiendan las necesidades
concretas en las diferentes áreas laborales.
Este material de apoyo está distribuido en cinco unidades temáticas que se describen a continuación:
Módulo I Elementos generales
Módulo II El entorno de trabajo en Visual Basic
Módulo III La programación en Visual Basic
Módulo IV Controles y objetos especiales

Cada uno de estos contiene información detallada de los términos, componentes y procedimientos empleados con
mayor frecuencia en la gestión y operación de las herramientas descritas.
Resulta más que obligada la práctica cotidiana de los temas tratados en este material de apoyo didáctico, sólo de esta
forma podrá observar un aprendizaje significativo y una mejora efectiva en su desempeño laboral.
Página 3 de 62
Introducción
Visual Basic fue creado originalmente como una herramienta de programación sencilla y gráfica, permitiendo que
cualquier usuario, con conocimientos mínimos de programación, pudiera utilizarlo para crear rápidamente aplicaciones
sin muchas pretensiones. Con el paso del tiempo, la sencillez de esta herramienta le permitió ganar popularidad,
generando una importante comunidad de programadores adeptos. La versión Visual Basic 3.0 agregó un componente
fundamental: la posibilidad de hacer que cualquier aplicación trabajara con bases de datos de todo tipo y tamaño, sin
más trámite que el de dibujar un control sobre un formulario. Esto significó la posibilidad de crear aplicaciones
empresariales, que hicieran uso de grandes bases de datos cliente/servidor, con la sencillez que siempre caracterizó a
Visual Basic.
La popularidad de programadores VB creció hasta convertirlo en el lenguaje más utilizado en todo el mundo.
Sucesivamente fueron lanzadas las versiones 4, 5 y 6, poniendo el producto a tono con las novedades de cada
momento. Primero fue el desarrollo en 32 bits para Windows 95; después, la utilización de clases y componentes
Activex; finalmente, la posibilidad de crear aplicaciones para Internet.
Las posibilidades de manejo de bases de datos también se fueron ampliando. Al principio, DAO y el motor Jet
permitían manejar bases de datos de escritorio (Access, xBase, Btrieve, Paradox) en forma directa y bases de datos
cliente/servidor a través de ODBC. Después se agregó RDO para mejorar el manejo de datos remotos. Finalmente
llegaron ADO y OLE DB, prometiendo brindar una única interfaz y un único mecanismo para manejar datos de todo
tipo, locales o remotos, y bajo cualquier arquitectura. Cada uno de estos métodos, en lugar de reemplazar a los
anteriores, los enriqueció.
Actualmente existe una variedad muy amplia de recursos y tecnologías para diseñar aplicaciones, entre las cuales
destaca, por supuesto, Visual Basic, con la simplicidad que ofrece en el desarrollo de software.
Página 4 de 62
Módulo I Elementos generales
Algoritmos
Un algoritmo es un conjunto de pasos o acciones que llevan una secuencia lógica y sistemática con el objeto de
resolver un problema específico. El desarrollo de algoritmos implica tres etapas básicas y tres módulos de operación.
Las Etapas…
1. Análisis del problema. Consiste en identificar el problema: sus elementos, condiciones, causas, efectos…
2. Construcción del algoritmo. Es la descripción de una solución posible al problema.
3. Verificación del algoritmo. Tiene que ver con la prueba de la solución planteada.
Los Módulos de operación…
1. Entrada de datos. Es la acción de introducir datos al sistema, captura.
2. Procesamiento de datos. La ejecución de operaciones secuenciales, lógicas y organizadas cuyo propósito
es generar un resultado al procesar los datos.
3. Salida de datos. Incluye esas acciones que permiten enviar al exterior los resultados obtenidos.
Así también, en cualquier algoritmo deben identificarse tres características: son precisos, determinísticos y finitos. El
algoritmo es preciso, puesto que indica el orden que llevará cada acción en la solución del problema; es determinístico
porque siempre ha de arrojar el mismo resultado; y es finito, en función de que posee una acción concluyente o final.
Se conocen diversas técnicas para resolver problemas (diseñar algoritmos) entre las que mencionamos:
Diagramas de Flujo
Es la representación gráfica de las funciones que realiza un sistema y el flujo que siguen los datos en los procesos que
tienen lugar dentro del mismo. Tal representación describe los pasos que se siguen para resolver una situación
concreta y utiliza símbolos normalizados y estandarizados para expresar cada una de las acciones y operaciones que
tienen efecto en el interior del sistema al que se refiere. Dicho de otra manera, un diagrama de flujo es la
representación gráfica de un algoritmo.
Parte de la simbología elemental que se emplea en el diseño de diagramas de flujo se ilustra a continuación:
Proceso Flujo de
Inicio/Fin Leer/Escribir Automático Decisión Base de
Datos
Datos
Al diseñar diagramas de flujo deben considerarse ciertas estructuras, que permitan establecer la manera en que
interaccionan los datos entre sí, en los procesos en los cuales se han incluido, a estos elementos se les conoce con el
nombre de estructuras Algorítmicas, siendo tres tipos los que se manejan comúnmente:
I. Secuencial: muestra que después de una acción sigue otra y así sucesivamente hasta el término del proceso.
Acción 1
Acción 2
Acción 3
Acción …n
Página 5 de 62
II. Selectiva: representa la evaluación de una condición lógica y, según el resultado de esa evaluación, se ejecutan
ciertas acciones.
Condición
Verdadero
Falso
Acciones
III. Repetitiva: expresa la repetición de una o varias acciones; un número determinado de veces, mientras una
condición establecida se cumpla o hasta que una condición determinada resulte verdadera.
Acción 1
Verdadero Acción 2
Condición
Falso
Pseudocódigos
Un pseudocódigo (llamado también falso lenguaje), es una serie de normas léxicas y gramaticales parecidas a la
mayoría de los lenguajes de programación, pero sin llegar a la rigidez de sintaxis de estos ni a la fluidez del lenguaje
coloquial. Esto permite codificar un programa con mayor agilidad que en cualquier lenguaje de programación, con la
misma validez semántica, normalmente se utiliza en las fases de análisis o diseño de Software, o en el estudio de un
algoritmo. Forma parte de las distintas herramientas de la ingeniería de software.
No hay ningún compilador o intérprete de pseudocódigos informáticos (en el caso de que los hubiera, serían los
mismos usuarios y lectores del pseudocódigo), por lo tanto no puede ser ejecutado en un equipo de cómputo, pero las
similitudes con la mayoría de los lenguajes informáticos lo hacen fácilmente convertible.
El pseudocódigo describe un algoritmo utilizando una mezcla de frases en lenguaje común, instrucciones de
programación y palabras clave que definen las estructuras básicas; su objetivo es permitir que el programador se
centre en los aspectos lógicos de la solución a un problema.
No siendo el pseudocódigo un lenguaje formal, varían de un programador a otro, es decir, no hay una estructura
semántica ni arquitectura estándar para crearlos. Sin duda representan una herramienta ágil para el estudio y diseño
de aplicaciones; no obstante, su empleo exige el conocimiento de las estructuras de control de datos secuencial,
selectiva y repetitiva, cuyos modelos pueden observarse en la siguiente página.
Página 6 de 62
Estructuras de control
 Secuencial
Acción 1
Acción 2
Acción …n
 Selectiva
 Simple
Si <condición> entonces
Acción 1
Acción 2
Acción …n
Fin de si
 Doble
Si <condición> entonces
Acción 1
Acción 2
Acción …n
Si no
Acción 3
Acción 4
Acción …n
Fin de si
 Anidada
Si <condición1> y <condición2> y <condición3> y <condición4> entonces
Acción 1
Acción 2
Acción …n
Fin de si
 Múltiple
Seleccionar Caso objeto
Caso 1
Acción(es) 1
Caso 2
Acción(es) 2
Caso 3
Acción(es) 3
Caso …n
Acción(es) 4
Caso distinto
Acción(es) 5
Fin de Selección
 Repetitiva
 Hasta
Hacer hasta <condición>
Acción 1
Acción 2
Acción …n
Repetir
Página 7 de 62
 Mientras
Hacer Mientras <condición>
Acción 1
Acción 2
Acción …n
Repetir
 Para
Para <contador> = valor_inicial Hasta valor_final
Acción 1
Acción 2
Acción …n
Siguiente
Ejemplo de Algoritmo, Diagrama de flujo y Pseudocódigo.

Problema: Elaborar el algoritmo de la suma de dos números con una calculadora convencional.
Algoritmo:
1. Digitar el primer valor a sumar
2. Oprimir o seleccionar el operador suma (+)
3. Digitar el segundo valor a sumar
4. Oprimir el botón que muestre el resultado de la operación (=)
Diagrama de Flujo: Pseudocódigo:

Inicio
Inicia Leer Valor1
Leer +
Leer Valor2
R = Valor1 + Valor2
Valor 1 Escribir R
Operador + Fin
Valor 2
R = Valor 1 + Valor 2
Términa
Página 8 de 62
Módulo II El entorno de trabajo en Visual Basic
Una vez que hayas instalado Visual Basic 6.0 en el equipo de cómputo, utliza el siguiente procedimiento para
ejecutarlo y comenzar una sesión de trabajo:
1. Haga clic en el menú Inicio.
2. Seleccione la opción Programas o Todos los programas.
3. Localice la carpeta Microsoft Visual Basic 6.0, si la versión instalada es la versión Profesional;
seleccione Microsoft Visual Studio, si la versión instalada es la versión Corporativa.
4. Finalmente haga clic en Microsoft Visual Basic 6.0.
De manera predeterminada, cada vez que inicias una sesión de trabajo en Visual Basic, se muestra el cuadro de
diálogo Nuevo Proyecto, en el que puedes seleccionar la creación de algún proyecto nuevo, trabajar en un proyecto
existente o tal vez buscar entre aquellos que recientemente fueron utilizados en el equipo.
La ventana de Visual Basic 6.0

Después de haber seleccionado la opción conveniente, se mostrará en pantalla la ventana de Visual Basic 6.0
Profesional, la cual tiene una apariencia similar a la de la imagen siguiente…
Visual Basic 6.0 Profesional
Página 9 de 62
Inicialmente, en esta ventana deberás identificar cinco elementos básicos:

Cuadro de herramientas (ToolBox) Formulario (Form)
Explorador de proyectos (Project Explorer) Ventana de Propiedades (Window Properties)
Ventana Posición de Formulario (Form Layout)
Cuadro de herramientas. Proporciona las herramientas que permiten ubicar los controles en un formulario
durante el diseño del mismo. La ficha General establece de manera predeterminada el grupo de botones con los
que contaremos al iniciar nuevos proyectos en Visual Basic. El cuadro de herramientas puede activarse desde el
menú Ver, Cuadro de Herramientas, o haciendo clic en el botón Cuadro de herramientas de la barra
estándar.
Formulario. Es el área sobre el cual se diseña la interfaz de la aplicación. Cada formulario está contenido en
una ventana llamada ventana de formulario. Los formularios se muestra desde el menú Ver, opción Objeto;
combinando las teclas Shift + F7 o haciendo clic en el botón Ver objeto, en el Explorador de Proyectos.
Explorador de proyectos. Contiene y muestra todos los ficheros (formularios, módulos, clases, recursos…)
que conforman una aplicación ó proyecto; para visualizar esta sección combina las teclas Ctrl + R; del menú
Ver selecciona Explorador de Proyecto, o bien, haz clic en el botón del mismo nombre en la barra estándar.
Página 10 de 62
Ventana Propiedades. Cada objeto lleva asociado un conjunto de propiedades (nombre, apariencia, posición,
tamaño, color, etc.); para especificar los valores de esas propiedades, utilizaremos la ventana de propiedades.
Para mostrarla presiona la tecla F4, o bien; selecciona la opción Ventana de Propiedades, del menú Ver, o
da clic en el botón Ventana de Propiedades de la barra estándar.
Ventana de Posición de formulario. Esta sección permite establecer manualmente la posición que tendrá
cada formulario en pantalla al ejecutarse. Para mostrar este elemento, haz clic en el menú Ver y selecciona la
opción Ventana Posición de formulario.
Como otras aplicaciones de Microsoft, Visual Basic 6.0 posee una colección de barras de herramientas, cuatro en total,
mismas que se ilustran enseguida:
 Barra Estándar:
 Barra Edición:
 Barra Depuración:
 Barra Editor de formularios
Práctica 1: Los componentes de la ventana de Visual Basic 6.0

Iniciar sesión de trabajo
1. Abre el menú Inicio, selecciona el submenú Programas o Todos los programas; selecciona la carpeta
Microsoft Visual Basic 6.0 y haz clic en el icono Microsoft Visual Basic 6.0.
2. En el cuadro de diálogo Nuevo Proyecto, selecciona la pestaña Nuevo; haz clic en el icono Exe estándar y
oprime el botón Abrir.
Inserción de controles del cuadro de herramientas
3. En el cuadro de herramientas, haz doble clic en el botón Etiqueta (Label) , aparecerá un objeto con el
texto Label1 sobre el Formulario, como se muestra en la siguiente imagen.
4. Pulsando continuamente la tecla Control y ayudándote de las teclas de navegación ( y ),

mueve la etiqueta a la esquina superior izquierda del formulario, de forma que quede ubicada como se
observa en la imagen de la siguiente página.
Página 11 de 62
5. Nuevamente haz doble clic en la herramienta Etiqueta y coloca al nuevo objeto debajo del anterior.
6. Ahora haz doble clic en el botón Cuadro de texto (TextBox) , aparecerá sobre el formulario un
control con el texto Text1. Desplázalo hacia arriba para dejarlo ubicado a la derecha de la etiqueta Label1:
7. Repite las acciones del punto anterior y desplaza al cuadro de texto junto a la etiqueta Label2.
8. Haz doble clic en la herramienta Botón de Comando (CommandButton) , se mostrará sobre el

formulario el objeto Command1, colócalo a la derecha del cuadro de texto Text1. Repite esta acción para
mostrar el Command2 y sitúalo a la derecha del cuadro de texto Text2. El formulario deberá visualizarse así:
Página 12 de 62
Definción de propiedades de los controles
9. Selecciona el formulario y desde la Ventana Propiedades define las siguientes características:
Propiedad Valor o Contenido

Nombre frmAcceso
BackColor &H80000001&
BorderStyle 1 - Fixed Single
Caption Pantalla de Acceso
StartUpPosition 2 - CenterScreen
10. Selecciona la etiqueta Label1 y define las siguientes propiedades:

Nombre lblAcceso
Autosize True
BackStyle 0 - Transparent
Caption Usuario:
Font MS Sans Serif, estilo Normal, tamaño 14
ForeColor &H00FFFFFF&
11. Para la etiqueta Label2, aplica los siguientes valores:

Nombre lblPassword
Autosize True
Caption Password:
ForeColor &H00FFFFFF&
12. Selecciona el cuadro de texto Text1 y modifica las propiedades como se describe abajo.

Nombre txtUsuario
ForeColor &H80000001&
Left 1500
MaxLenght 10
Text
ToolTipText Escribe aquí tu nombre de usuario o inicio de sesión
Width 1600
Página 13 de 62
13. Para el cuadro de texto Text2, aplica los siguientes valores:

Nombre txtPassword
Left 1500
MaxLenght 10
PasswordChar *
Text
ToolTipText Escribe aquí tu contraseña o password
Width 1600
14. Ahora selecciona el objeto Command1, y ajusta las propiedades:

Nombre cmdAceptar
Caption &Aceptar
Font MS Sans Serif, estilo Negrita, tamaño 10
Style 1 - Graphical
15. Para el control Command2, utiliza los valores siguientes:

Nombre cmdCancelar
Caption &Cancelar
Font MS Sans Serif, estilo Negrita, tamaño 10
Style 1 - Graphical
Al concluir esta fase de definición de propiedades, que es parte esencial en el diseño de una aplicación, el formulario
deberá tener una apariencia similiar a la del gráfico siguiente:
Más adelante, el instructor te dará más información sobre las propiedades de los controles y la manera en que éstas
afectan su apariencia y comportamiento. Por lo pronto sólo utilizamos algunas aquí para verificar la utilidad de la
ventana propiedades.
Página 14 de 62
Proyectos (Project)
Visual Basic administra la información concerniente a las aplicaciones que se desarrollan, en un tipo especial de archivo
llamado proyecto; estos pueden estar conformados por distintos tipos de archivos: formularios, módulos, módulos de
clase y ficheros de recursos. El código que activa los controles de un formulario es almacenado con el formulario
mismo en archivos independientes. El código general compartido por todos los formularios de una aplicación puede ser
dividido en varios módulos, que se guardan también de forma independiente.
No obstante, aunque Visual Basic almacena separadamente los archivos que forman un proyecto, hace un seguimiento
de la ubicación de los archivos y su contenido, creando para ello un archivo de proyecto, al que asigna la extensión
.vbp (de Visual Basic Program/Project).
Los formularios se almacenan con la extensión .frm y contienen una imagen del formulario y de todos los controles
que pertenecen a él, incluidas sus propiedades. También pueden contener subrutinas de manejo de eventos,
procedimientos generales, declaraciones de variables y de constantes a nivel de formulario, además de procedimientos
externos. Un módulo estándar contiene código Visual Basic que no está asociado a ningún formulario en particular. Los
procedimientos que se encuentran en el módulo, pueden ser accedidos desde cualquier otro procedimiento de la
aplicación. Se almacenan con la extensión .bas. Los módulos de clase tienen la extensión .cls y contienen subrutinas,
funciones, métodos y procedimientos para crear descripciones genéricas de objetos. Estos módulos contienen
propiedades que describen el comportamiento de una clase, así como el código que define sus propiedades y
métodos. Los archivos de recursos se almacenan con la extensión .res y contienen bitmaps, cadenas de texto, o
cualquier otra información que pueda ser modificada sin tener que regenerar el código de la aplicación.
En la imagen de arriba, que corresponde al Explorador de proyectos, puede apreciarse cómo es que se organizan los
diversos tipos de archivo que integran un proyecto en Visual Basic 6.0.
En resumen, un proyecto se define como el grupo de archivos que integran una aplicación (formularios, módulos,
clases, recursos…). Todo proyecto nuevo por defecto asume el nombre Proyecto1.
Los atributos generales de un proyecto son:
 Nombre: En el nombre de un proyecto puedes utilizar el mnemónico vbp, como en su extensión; este
puede modificarse en la Ventana Propiedades o en el campo Nombre de Proyecto, de la pestaña
General, que se localiza en el cuadro de diálogo Propiedades de Proyecto…, del menú Proyecto.
La propiedad Nombre de los objetos utilizados en Visual Basic sólo permite caracteres alfanuméricos y el
guión bajo, como carácter especial.
 Tipo: indica el tipo de proyecto en el que estamos trabajando (generalmente EXE estándar).
 Objeto inicial: indica el nombre del objeto a partir del cual se ejecutará el proyecto (usualmente el
formulario o procedimiento principal). Por defecto está asignado como objeto inicial Form1, que es el
único archivo que integra cualquier proyecto inicialmente.
Página 15 de 62
Almacenar un proyecto
16. En el Explorador de proyectos, selecciona Proyecto1 (Proyecto1)
17. En la ventana Propiedades, en la propiedad nombre (la única visible en esta sección para el proyecto),
escribe vbpAcceso. Ello hará que en el mismo Explorador de proyectos se actualice el nombre de este.
18. Ahora, abre el menú Archivo y selecciona la opción Guardar Proyecto. Se mostrará el cuadro de diálogo
Guardar archivo como, haciendo referencia al único formulario existente, que es parte de la aplicación en
desarrollo. Por defecto, Visual Basic envía cada nuevo proyecto a la carpeta VB98, que se localiza dentro de la
carpeta Microsoft Visual Studio, contenida en la carpeta Archivos de Programa, del disco local C:\;
dentro de esta, crea una carpeta personal (asígnale tu nombre o algo que la identifique como tu carpeta
precedido del texto Prácticas VB).
Página 16 de 62
19. Abre tu carpeta personal y en ella crea otra carpeta, esta vez con el nombre Proyecto Acceso e igualmente
la abres.
20. Por último, comprueba que en el campo Nombre, aparezca el nombre del formulario (frmAcceso) y de ser
así oprime el botón Guardar.
21. Después deberás verificar el nombre del archivo de proyecto (vbpAcceso), mismo que estableciste con
anterioridad, para después presionar nuevamente el botón Guardar.
Modo Diseño y Modo Ejecución

Visual Basic 6.0 de Microsoft puede mostrar el contenido de un proyecto en dos modos distintos de trabajo: modo
diseño y modo ejecución. En modo diseño, el usuario construye interactivamente la aplicación, colocando controles en
el formulario, definiendo sus propiedades, y desarrollando rutinas de acción para gestionar información. La aplicación
se prueba en modo de ejecución. En ese caso el usuario actúa sobre el programa (ejecuta eventos) y prueba cómo
responde el programa. Algunas propiedades de los controles deben establecerse en modo de diseño, otras pueden
cambiarse en tiempo de ejecución desde el programa escrito en Visual Basic 6.0.
Desde que comienzas una sesión de trabajo en Visual Basic 6.0, te encontrarás trabajando en el modo diseño; para
cambiar al modo ejecución, puedes utilizar cualquiera de las opciones siguientes:
 Selecciona el comando Iniciar, ubicado en el menú Ejecutar.
 O bien, haz clic en el botón Iniciar, que se localiza en la barra de herramientas estándar.
 O bien, presiona la tecla F5.
Para regresar al modo diseño, después de haber verificado el funcionamiento de la aplicación, realiza cualquiera de las
siguientes acciones:
 Combina las teclas Control + F4
 O, si lo prefieres, abre el menú Ejecutar y haz clic en la opción
Terminar
 O bien, haz clic en el botón Terminar, ubicado en la barra
Página 17 de 62
estándar.
Si en este momento ejecutamos el Proyecto Acceso, lo único que podremos hacer es escribir dentro de los dos
cuadros de texto del formulario y oprimir los botones Aceptar y Cancelar, sin que nada más ocurra después, ya que no
hemos establecido qué acciones se llevarán a cabo al generar algún evento sobre los controles mencionados, y, en
consecuencia, no se apreciará mucha diferencia entre el modo diseño y el modo ejecución. Por esta razón,
agregaremos un poco de código a los controles situados en el formulario de acceso.
Programando controles
22. Haz doble clic sobre el cuadro de texto txtUsuario. Aparecerá en pantalla la ventana que contiene el código
asociado al formulario y sus controles:
23. En la esquina superior izquierda verás el nombre del control desde el

cual hiciste doble clic, para llegar a esta ventana, (en este caso el
cuadro de texto txtusuario). En la esquina superior derecha, donde se
alcanza a leer el texto Change (el nombre de un evento), haz un clic
en el botón desplegable y selecciona de la lista el nombre del evento o
procedimiento KeyPress (Oprimir tecla).
El resultado será:
24. En la posición donde quedó el cursor parpadeando, escribe las instrucciones que aparecen entre las líneas
Private Sub y End Sub. Con ellas, lograremos que, al presionar la tecla Enter, cuando el cursor se
encuentre parpadeando dentro del control txtUsuario, este se mueva a txtPassword.
25. Al terminar de escribir las instrucciones, combina las teclas Shift + F7, para regresar al formulario.
Página 18 de 62
26. Haz doble clic ahora sobre el cuadro de texto, txtPassword. Aparecerá nuevamente la ventana donde está el
código; tendrás que cambiar el evento Change por el evento KeyPress, como en el caso anterior.
27. Escribe las instrucciones que se muestran en la imagen siguiente desde la posición del cursor. En este caso, al
presionar la tecla Enter, el cursor será desplazado al botón de comando cmdAceptar del formulario.
28. Muestra el formulario combinando las teclas Shift + F7.

29. Haz doble clic sobre el botón Aceptar para mostrar nuevamente la ventana de código. En este caso, te
encontrarás con el nombre del evento Click, en la esquina superior izquierda de la ventana. Desde la posición
que guarda el cursor, entre las líneas Private Sub y End Sub, escribe las instrucciones que se presentan en
la imagen de la página siguiente. Estas señalan que si el nombre de usuario escrito en el formulario es idéntico
a tu nombre (Juan, Carlos, Silvia, Laura…) y la contraseña escrita es el texto imss, entonces te aparecerá un
mensaje de bienvenida al curso de Visual Basic y terminará la ejecución del programa; pero si el nombre de
usuario es distinto a tu nombre y la contraseña no es imss, se te notificará con otro cuadro de mensaje,
además, se borrará el texto que hayas escrito en ambos casos y el cursor quedará ubicado en el cuadro de
texto txtUsuario, para intentarlo otra vez.
30. Regresa al formulario con Shift + F7.

31. Haz doble clic sobre el botón Cancelar.
32. En la posición del cursor, escribe la expresión End. Esta instrucción da por terminada la aplicación.
33. Presiona la tecla F5 para ejecutar la aplicación y verifica el funcionamiento de los controles ya programados.
34. Guarda los cambios efectuados en el proyecto y cierra Visual Basic.
Página 19 de 62
Práctica 2 - Proyecto Colores

a) Inicia una nueva sesión de trabajo en Visual Basic 6.0
b) Asigna como nombre al proyecto: vbpColores.
c) Asigna las siguientes características a las propiedades del formulario existente:

Nombre frmColores
BackColor &H00E0E0E0&
BorderStyle 3 - Fixed Dialog
Caption Selección de Colores
Height 4000
Width 5000
d) En el cuadro de herramientas, localiza y selecciona el control Marco (Frame) y realiza un trazo

rectangular sobre el formulario, como se muestra en la imagen siguiente.
e) Establece los siguientes valores para las propiedades del objeto Frame.

Nombre fraColores
Caption Opciones
Height 3000
Width 2800
f) Ahora selecciona del cuadro de herramientas el control Forma (Shape) y dibuja un rectángulo a la
derecha del marco en el formulario.
Página 20 de 62
g) Establece las siguientes propiedades para el nuevo control:

Nombre shpColor
BackStyle 1 - Opaque
BorderStyle 0 - Transparent
Height 1400
Shape 3 - Circle
Width 1400
h) Selecciona del cuadro de herramientas, el control botón de opción (OptionButton) y traza una
figura rectangular en la parte superior del frame.
i) Define las siguientes propiedades para el control Option1:

Nombre optBlanco
Caption Blanco
Página 21 de 62
Height 500
Style 1 - Graphical
Width 2300
j) Utilizando el botón de opción, inserta tres controles más, debajo de optBlanco.
k) Para los tres nuevos botones de opción, utiliza los mismos valores que seleccionaste para el primer botón en
las propiedades BackColor, Font, ForeColor, Height, Style y Width. Nombre y Caption quedarían como se
describe en las tablas siguientes:
Option1 Option2 Option3
Propiedad Valor o Contenido Propiedad Valor o Contenido Propiedad Valor o Contenido

Nombre optAzul Nombre optRojo Nombre optNegro
Caption Azul Caption Rojo Caption Negro
Al concluir estas acciones el formulario lucirá así:
l) Selecciona del cuadro de herramientas, el control botón de comando (CommandButton) y

dibuja un objeto de estos debajo de la forma circular shpColor.
Página 22 de 62
m) Establece los valores siguientes para este nuevo control en el formulario:

Nombre cmdCerrar
Caption &Cerrar
Height 615
Style 1 - Graphical
TabIndex 0
Width 1455
Al finalizar, el formulario se verá así:
Ahora agregaremos código a los controles del formulario. Cada vez que se oprima alguno de los botones que
contienen el nombre de un color, la forma circular se rellenará con el color seleccionado. El botón Cerrar
servirá para terminar la ejecución de la aplicación.
n) Haz doble clic en el botón Blanco. Se mostrará en pantalla la ventana de código. Escribe la instrucción que se
muestra en la imagen:
Página 23 de 62
o) Regresa al formulario (Shift + F7) y haz doble clic en el botón Azul. En la ventana de código escribe la
instrucción:
p) Regresa otra vez al formulario y ahora haz doble clic en el botón Rojo. En la ventana de código escribe la
instrucción que se muestra entre Private Sub y End Sub.
q) Regresa nuevamente al formulario y haz doble clic sobre el botón Negro. Escribe en la ventana código la
siguiente instrucción:
r) Vuelve al formulario y ahora haz doble clic en el botón Cerrar. Escribe como instrucción la palabra End.
s) Ejecuta la aplicación para verificar el funcionamiento de los botones.

t) Guarda el archivo de proyecto y el formulario en una carpeta que tenga por nombre Proyecto Colores,
misma que ubicarás en tu carpeta personal (Proyectos VB Tu_nombre). Cierra Visual Basic.
Página 24 de 62
Módulo III La programación en Visual Basic
Un programa o aplicación puede definirse como una serie de instrucciones estructuradas y organizadas lógicamente,
las cuales, al ejecutarse, permiten que la computadora realice una tarea determinada y cumple así con un objetivo
concreto. Todos los programas realizan un cierto proceso sobre los datos de entrada indicados por el usuario, para
finalmente, generar los resultados que den respuesta al problema planteado. Los lenguajes de programación son
códigos que agrupan símbolos, funciones, instrucciones especiales y una estructura formal, cuya manipulación permite
el desarrollo de software.
Visual Basic 6.0 es uno de los lenguajes de programación que más entusiasmo despiertan entre los programadores de
PCs, tanto expertos como novatos. En el caso de los programadores expertos por la facilidad con la que desarrollan
aplicaciones complejas en poquísimo tiempo (comparado con lo que cuesta programar en Visual C++, por ejemplo).
En el caso de los programadores novatos por el hecho de ver de lo que son capaces a los pocos minutos de empezar
su aprendizaje. El precio que hay que pagar por utilizar Visual Basic 6.0 es una menor velocidad o eficiencia en las
aplicaciones. Visual Basic 6.0 es un lenguaje de programación visual, también llamado lenguaje de 4ª generación. Esto
quiere decir que un gran número de tareas se realizan sin escribir código, simplemente con operaciones gráficas
realizadas con el ratón sobre la pantalla.
Tipos de Programas
En los primeros tiempos de las computadoras los programas eran de tipo secuencial (también llamados tipo batch) Un
programa secuencial es un programa que se arranca, lee los datos que necesita, realiza los cálculos e imprime o
guarda en el disco los resultados. De ordinario, mientras un programa secuencial está ejecutándose no necesita
ninguna intervención del usuario. A este tipo de programas se les llama también programas basados u orientados a
procedimientos o a algoritmos (procedural languages). Este tipo de programas siguen utilizándose ampliamente en la
actualidad, pero la difusión de los PCs ha puesto de actualidad otros tipos de programación.
Los programas interactivos exigen la intervención del usuario en tiempo de ejecución, bien para suministrar datos, bien
para indicar al programa lo que debe hacer por medio de menús. Los programas interactivos limitan y orientan la
acción del usuario.
Por su parte los programas orientados a eventos son los programas típicos de Windows, tales como Word, Excel o la
calculadora. Cuando uno de estos programas ha arrancado, lo único que hace es quedarse a la espera de las acciones
del usuario, a las que se les llama eventos. El usuario decide si quiere abrir y modificar un archivo existente, o bien
comenzar a crear un archivo desde el principio. Estos programas pasan la mayor parte de su tiempo esperando las
acciones del usuario (eventos) y respondiendo a ellas. Las acciones que el usuario puede realizar en un momento
determinado son muy diversas y exigen un tipo especial de programación: la programación orientada a eventos. Este
tipo de programación es sensiblemente más complicada que la secuencial y la interactiva, pero Visual Basic 6.0 la hace
especialmente sencilla y agradable.
Visual Basic 6.0 está orientado a la realización de programas para Windows, pudiendo incorporar todos los elementos
de este entorno informático: ventanas, botones, cajas de diálogo y de texto, botones de opción y de selección, barras
de desplazamiento, gráficos, menús, etc. Prácticamente todos los elementos de interacción con el usuario de los que
dispone Windows pueden ser programados en Visual Basic 6.0 de un modo muy sencillo. En ocasiones bastan unas
pocas operaciones con el ratón y la introducción a través del teclado de algunas sentencias para disponer de
aplicaciones con todas las características de Windows.
Rutinas o procedimientos
Se le llama rutina o procedimiento a cada bloque de código (grupo de instrucciones) que puede ser ejecutado en un
programa; éstos bloques se encuentran contenidos en una ventana especial llamada ventana código y se refieren, casi
siempre, a un control u objeto gráfico ubicado dentro de un formulario determinado y a una acción específica de
usuario (evento).
La estructura general de un procedimiento en Visual Basic es la siguiente:
Private Sub nombre del control _ nombre del evento (lista de argumentos)
Declaraciones
Acciones
End Sub
Página 25 de 62
En la primera línea se muestra la sentencia Private Sub, misma que deberá interpretarse como rutina o
procedimiento exclusivo(a); es decir, que únicamente en cierta momento, al encontrarse en ejecución el programa,
éste bloque de instrucciones podrían llevarse a efecto. Nombre del control se refiere específicamente al objeto gráfico
(formulario, etiqueta, cuadro de texto, cuadro combinado, imagen, etc.) con el cual se asocia o relaciona el bloque de
código. Nombre del Evento es el nombre del suceso o acción específica que el usuario tendría que realizar sobre el
control descrito para iniciar el evento. Lista de argumentos es una serie de valores que deberán especificarse y que
son requeridos en el procedimiento para ejecutar las acciones contenidas en este; algunos procedimientos no exigen el
uso de argumentos.
La zona de Declaraciones se ha de utilizar para dimensionar constantes, variables o manejadores de error, para lo cual
se ha destinado un apartado especial en el módulo siguiente de este material didáctico. La zona de Acciones contendrá
cada instrucción o acción concreta que deberá ocurrir al ejecutarse el procedimiento. La expresión End Sub señala la
conclusión del procedimiento.
Ejemplo 1:
Ejemplo 2:
La ventana de código incluye dos apartados esenciales, con los cuales tenemos que familiarizarnos y debemos ubicar
muy bien al escribir instrucciones: el apartado de controles y el apartado de eventos.
Controles Eventos
Página 26 de 62
El apartado de controles u objetos contiene y despliega los nombres de los distintos elementos gráficos añadidos al
formulario, como parte de la interfaz de usuario:
La sección de eventos, contiene los nombres de las acciones de usuario programables para cada control, en la imagen
que sigue se muestran algunos de los eventos correspondientes a un botón de comando:
Ya en el módulo anterior, en los proyectos vbpAcceso y vbpColores tuviste que trabajar con un poco de código,
debido a que resulta complicado trabajar la parte visual de una aplicación de manera aislada, sin instrucciones, los
controles no contienen ni ejecutan procedimientos por sí sólos, así que desarrollaremos un nuevo proyecto para
identificar mejor las etapas en la construcción de una aplicación, mismas que ya habrás reconocido: 1) Se incorporan
los controles al formulario, 2) Se determinan los valores que almacenarán las propiedades de los controles; 3) Se
escriben el código asociado a cada control con un evento en particular; 4) Se ejecuta la aplicación, para comprobar el
funcionamiento del la misma.
Errores frecuentes
Durante la fase de la programación (o escritura del código), cada vez que se nombra alguno de los controles y se
escribe punto (.) delante de este, el editor de Visual Basic 6.0 despliega de forma automática un listado que contiene
los nombres de las propiedades y métodos utilizables en ese control en particular, elementos que se muestran
organizados alfabéticamente. De esta manera, podemos localizar con facilidad el atributo a manipular de cierto control
y seleccionarlo con un par de clics o con la tecla tabulación, sin siquiera tener que escribirlo, ya que el propio editor lo
puede hacer. Esto permite reducir en buena medida el empleo de nombres incorrectos de los controles, sus
propiedades y métodos, durante la edición de algún procedimiento; digamos que es parte del sistema de ayuda que
ofrece Visual Basic 6.0 al programador.
Cuando se utiliza el nombre incorrecto de un control, al momento de escribir el código, el editor de Visual Basic no
tiene forma de notificarlo, pero tú si lo puedes advertir, si después de escribir el supuesto nombre del control, no se
muestra el listado de propiedades y métodos, “Alto… Error… Detente”, no debes continuar, porque de nada servirá
esa línea de código, puesto que el objeto no existe. Al ejecutar una aplicación, manteniendo errores en los nombres de
los controles, Visual Basic te enviaría un mensaje de error como el que se muestra enseguida.
Página 27 de 62
Cuando el error tipográfico se refiera al nombre de alguna propiedad o método, de cualquier control, Visual Basic 6.0
tampoco te lo avisará en el modo diseño, lo hará al ejecutar la aplicación, mostrando un mensaje como el siguiente.
Cuando al pretender modificar el valor de una propiedad, de cualquier objeto, se omite el supuesto nuevo valor, Visual
Basic mostrará una advertencia como la siguiente:
Cuando una línea de código está incompleta o rompe la sintaxis de la expresión que se pretendía formular, el Editor de
Visual Basic 6.0 lo notifica con un mensaje de advertencia como el siguiente…
Si el error consiste en haber utilizado una propiedad como si fuese un método, es decir, simplemente mencionarla o
anunciarla, entonces se mostraría una notificación como esta:
Cuando se ha escrito alguna expresión que no se refiere a ninguna propiedad, método, función o control en la
aplicación, el mensaje de error es el siguiente:
Página 28 de 62
En todos los casos de error, la aplicación se interrumpe señalando la línea de código donde existe el error, para
realizar la corrección conveniente. Después de hacer la corrección, usualmente se detiene la interrupción del proyecto
utilizando el comando Terminar de Visual Basic, para reestablecer, restaurar o actualizar la aplicación.
Escribir código, entonces, tiene cierta dificultad y esta radica en completar las expresiones que servirán como
instrucciones en la aplicación, además de no infringir la sintaxis en cada una de ellas.
Práctica 3 - Proyecto Calculadora
Utiliza como referencia la imagen de arriba, para situar de manera conveniente a los controles que se utilizarán en el
Formulario1 de este proyecto.
1) Inicia un nuevo proyecto en Visual Basic 6.0
2) Nombra al proyecto vbpCalculadora.
3) Define las siguientes características para el Formulario1 (Form1):

Nombre frmCalculadora
BorderStyle 1 – Fixed Single
Caption Calculadora Aritmética
Font Berlin Sans FB, estilo Normal, tamaño 16
Height 3700
Icon Icono ubicado en:
Escritorio\Icons\Computer\KEYBRD02
Width 5500
4) Dibuja un control de Imagen (Image) en el extremo

derecho del formulario y ajusta sus propiedades de acuerdo a los valores de la siguiente tabla:
Página 29 de 62

Nombre imgCalculadora
Height 2600
Picture Imagen AG00021_.gif ubicada en:
C:\Archivos de programa\Microsoft Office\CLIPART\PUB60COR\
Width 1800
5) Inserta un control Etiqueta (Label) en el extremo superior

izquierdo del formulario y define las siguentes propiedades:

Nombre lblValor1
Autosize True
Caption Valor 1:
6) Inserta dos nuevas etiquetas, debajo de la anterior y define

sus propiedades.
Label1 Label2
Propiedad Valor o Contenido Propiedad Valor o Contenido

Nombre lblValor2 Nombre lblResultado
Autosize True Autosize True
BackStyle 0 - Transparent BackStyle 0 - Transparent
Caption Valor 2: Caption Resultado:
7) Coloca un control Cuadro de texto (TextBox) delante de

cada etiqueta en el formulario. Utiliza los siguientes valores para modificar sus propiedades.
Text1 Text2 Text3

Nombre txtValor1 Nombre txtValor2 Nombre txtResultado
Alignment 1 - Right Justify Alignment 1 - Right Justify Alignment 1 - Right Justify
Height 465 Height 465 Height 465
Text Text Text
Width 1500 Width 1500 Width 1500
8) Dibuja una nueva Etiqueta (Label) entre los controles

txtValor1 y txtValor2. Los valores para las propiedades de este nueva etiqueta son los siguientes:

Nombre lblOperador
Alignment 2 - Center
Autosize True
Página 30 de 62
Caption op.
9) Inserta un botón de comando (CommandButton) entre

los controles txtValor2 y txtResultado y asígnale las siguientes propiedades:

Nombre cmdResultado
BackColor &H00C0C0C0&
Caption =
Style 1 - Graphical
Width 1500
Agregaremos un par de menús al formulario actual; para ello tienes que abrir el Editor de menús de Visual
Basic 6.0. El primero se llamará Operaciones y mostrará los nombres de las operaciones de cálculo que podrá
ejecutar la calculadora y el segundo, de nombre Opciones, contendrá los comandos Borrar y Cerrar.
10) Abre el menú Herramientas y selecciona la opción Editor

de menús, se mostrará un cuadro de diálogo con el mismo nombre:
Página 31 de 62
11) En el apartado Caption: escribe Operaciones, el primero de

los menús; y en la sección Name: escribe mnuOperaciones (para los menús emplea el prefijo mnu…).
Después de esto, ya podrás visualizar el primer menú en lista, en la zona inferior del cuadro de diálogo.
12) Presiona el botón Siguiente, para agregar un nuevo

elementos de menú. Los campos Caption y Name quedarán vacíos para recibir la información de este.
13) D
el menú Operaciones dependerán las opciones Suma, Resta, División, Multiplicación, Potencia y Raíz.
Para obtener ese efecto visual en el formulario, debes presionar el botón FlechaDerecha
con el que establecerás la dependencia del nuevo menú con relación al anterior.
14) A
hora escribe en Caption el texto Suma y en el campo Name escribe mnuSuma; presiona otra vez el botón
Siguiente. Continua escribiendo los textos y nombres del resto de opciones hasta terminar con el menú Raíz.
Menú Caption Name

Resta Resta mnu Resta
División División mnu División
Multiplicación Multiplicación mnu Multiplicación
Potencia Potencia mnuPotencia
Raiz Raiz mnuRaiz
Página 32 de 62
15) Ahora crearemos el segundo de los menús, de nombre Opciones. Para ello es necesario eliminar la
dependencia de este nuevo elemento con respecto del menú Operaciones; Presiona el botón Siguiente y
oprime el botón FlechaIzquierda.
16) En Caption escribe Opciones y en Name escribe mnuOpciones.

17) Oprime nuevamente el botón Siguiente.
18) Presiona el botón FlechaDerecha.
19) Agrega los menús dependientes Borrar y Cerrar, utilizando esos textos como Caption; y mnuBorrar,
además de mnuCerrar como nombres respectivamente. Actualmente la lista de elementos de menú debe ser
similar a la de la imagen siguiente:
20) Finalmente oprime el botón Aceptar.

El formulario debe contar ya con una apariencia similar a la de la imagen de la página 30 de este material.
Ahora se requiere de agregar el código correspondiente a cada control.
21) Selecciona el formulario y presiona la tecla F7, para abrir la ventana de código del formulario. De manera
predeterminada, Visual Basic 6.0 muestra el procedimiento más común asociado al último control gráfico
seleccionado en el formulario, o al formulario mismo. En el apartado de controles, asegúrate de que aparezca
Form, y en el de eventos, verifica que se visualice Load.
22) Escribe las instrucciones siguientes, entre las líneas Private Sub y End Sub. Cuando el formulario sea
cargado o ejecutado, los controles txtValor1, txtValor2, txtResultado y cmdIgual se encontrarán inhabilitados;
es decir, no podrán utilizarse. Además, la etiqueta lblOperador no mostrará ningún texto o carácter.
23) Selecciona de la lista de controles al objeto mnuSuma, se mostrará un nuevo procedimiento con el evento
Click como opción predeterminada. Escribe el código siguiente para el procedimiento mnuSuma_Click.
Estas instrucciones producen un resultado completamente opuesto a aquellas establecidas al cargarse el

formulario. En este caso, los controles que originalmente se encuentran inhabilitados, ahora no lo están, hecho
que nos permitirá utilizarlos sin mayor problema.
Página 33 de 62
24) Selecciona ahora el control mnuResta y escribe las líneas de código contenidas en la imagen de la página
siguiente.
Como puedes observar, el código utilizado para el menú Resta es idéntico al empleado en el menú Suma, o
cuando menos las primeras cuatro líneas y la última, por lo que lo estamos duplicando código y ese es un
error que no debemos cometer, puesto que aún falta programar los menús de las cuatro operaciones de
cálculo restantes y tendríamos que utilizar instrucciones similares, prácticamente lo único distinto sería el signo
u operador de cálculo a mostrarse de acuerdo a la opción elegida (el Caption de la etiqueta lblOperador).
Vamos a utilizar como alternativa de solución, para así evitarnos duplicar lo menos posible código, la creación
de un procedimiento independiente (de cualquier control y evento), un procedimiento que pueda ser
compartido por los distintos objetos del proyecto, del formulario y que puede ser ejecutado en distintos
momentos durante la puesta en marcha de la aplicación.
25) Corta las instrucciones correspondientes al procedimiento mnuSuma_Click, suprime las del procedimento
mnuResta_Click y desplaza el cursor al final de la ventana de código.
26) Escribe en la posición del cursor el texto Sub Activar_Controles y presiona la tecla Enter. Se mostrará un
nuevo procedimiento en la ventana…
27) Pega en la ubicación del cursor las instrucciones que cortaste anteriormente del procedimiento
mnuSuma_Click… y elimina la última línea (lblOperador.Caption = ”+”). El procedimiento quedará así:
28) Ahora busca e inserta en el procedimiento mnuSuma la instrucción que actualiza el contenido de la etiqueta
lblOperador con el símbolo + y escribe en la línea de abajo, el nombre del procedimiento que habilitará los
controles, Activar_Controles.
Página 34 de 62
29) Copia las dos líneas del procedimiento mnuSuma_Click, enseguida localiza el procedimiento
mnuResta_Click y pega el código. Sólo cambia el símbolo + por el símbolo -.
30) Busca y selecciona de la lista de controles el objeto mnuDivisión y vuelve a pegar el código de mnuSuma;
asegúrate de cambiar el símbolo + por el símbolo /.
31) Repite las aciones anteriores para el control mnuMultiplicación y utiliza como símbolo a *.
32) Repite de nuevo las acciones anteriores con el objeto mnuPotencia y utiliza el símbolo ^ para la etiqueta
lblOperador, pero además se modificará el Caption de las etiquetas lblValor1 y lblValor2, por Número y
Potencia respectivamente.
33) Selecciona y copia las instrucciones del procedimiento anterior para pegarlas en el procedimiento
mnuRaíz_Click y además de cambiar el operador ^ por Rz, actualiza el caption de la etiqueta lblValor2 por
el texto Raíz.
Hasta aquí, verifica el comportamiento de los controles en el formulario ejecutando la aplicación; debes
cerciorarte de que cada bloque de instrucciones codificado funcione según fue programado. Al cargarse el
formulario no debe ser posible situar el cursor en ninguno de los cuadros de texto, como tampoco será posible
orpimir el botón de comando, ya que éstos se encuentran inactivos. Solamente cuando elijas del menú
Operaciones cualquiera de ellas, entonces podrás comprobar la habilitación de los controles mencionados, el
cambio en el operador de cálculo que se muestra en la etiqueta lblOperador y en los casos de Potencia y
Raíz, verás el cambio en el Caption de la etiqueta lblValor2. Encontrarás un defecto después de utilizar
estos dos últimos controles, detéctalo e intenta solucionarlo, considera este hecho como una oportunidad para
poner a prueba tu razonamiento lógico y tu creatividad en la solución de problemas.
Las opciones Borrar y Cerrar del menú Opciones, aún no contienen instrucciones específicas, por lo que no
sucederá nada si las seleccionas durante la ejecución.
Página 35 de 62
El objeto mnuBorrar deberá eliminar cualquier valor almacenado en los cuadros de texto y en la etiqueta que
muestra el símbolo asociado a la operación de cálculo seleccionada. También deberá devolver a las etiquetas
lblValor1 y lblValor2 su contenido original e inhabilitar los controles, como al iniciarse la aplicación.
34) Detén la ejecución del proyecto y regresa a la ventana de código.
35) Selecciona del apartado de controles el objeto mnuBorrar y escribe el siguiente código:
36) Selecciona el control mnuCerrar y escribe la instrucción End.
Ejecuta y prueba nuevamente la aplicación.

37) En la ventana de código selecciona, del apartado de controles, el botón de comando cmdIgual. Este control
deberá mostrar el resultado de la operación de cálculo seleccionada; si se eligió la operación Suma, Resta,
División o cualquier otra, el botón arrojará el resultado de la operación de cálculo en el cuadro de texto
txtResultado. De faltar alguno de los dos valores numéricos en sus respectivos controles, se mostrará un
aviso gráfico sugiriendo ingresar el dato faltante y no se podrá continuar con la operación. Adicionalmente,
cuando se genere el resultado, los cuadros de texto y el mismo botón de comando quedarán inactivos.
El código a ingresar para el control cmdIgual se muestra en la pantalla siguiente:
38) Verifica por última vez el funcionamiento global de la aplicación e intenta corregir el código escrito si llegas a
localizar algún error.
39) Guarda los archivos de formulario y proyecto, dentro de la carpeta Proyectos VB Tu_Nombre, en un nuevo
contenedor llamado Proyecto Calculadora.
Página 36 de 62
Estructuras de Control
Al ocurrir cierto evento durante la ejecución de una aplicación, Visual Basic responde llamando al procedimiento
asociado con el control que reconoce tal evento. La orientación a eventos, característica de los programas
desarrollados en Visual Basic, se traduce en que la mayoría de las operaciones disponibles en las aplicaciones, serán
ejecutadas mediante procedimientos de eventos. El código permite procesar la entrada de datos, el cálculo de nuevos
valores y la salida de información, entre otras tareas. Puedes crear procedimientos capaces de responder a cualquier
situación en la medida en que conozcas y apliques estructuras de control: las estructuras de decisión, que se
utilizan para comparar variables, propiedades y valores; y los bucles, que nos dan la posibilidad de ejecutar un grupo
de sentencias una y otra vez un número determinado de veces, mientras o hasta que se cumpla determinada
condición.
Expresión condicional
Una de las herramientas más útiles en el procesamiento de información es la expresión condicional, que forma parte
de una sentencia de programa que realiza preguntas que requieren respuestas lógicas o boleanas (del tipo True o
False, Yes o No…) sobre una propiedad o variable en el código del programa.
La siguiente expresión condicional: Precio = 180; resultará Verdadera, si la variable precio contiene un valor similar a
180, en caso contrario resultará Falsa. En este tipo de expresiones se utilizan operadores de relación:
Operador Significado
= Igual que…
<> Distinto de…
> Mayor que…
< Menor que…
>= Mayor o igual que…
<= Menor o igual que…
If… Then
La estructura If… Then permite evaluar una condición en el programa y llevar a cabo una serie de instrucciones,
según sea el resultado de dicha condición. Cuando solamente se requiere de la ejecución de acciones al cumplirse la
condición especificada (alternativa simple), tendría que utilizarse una sintaxis similar a la siguiente:
If condición Then
Instrucción 1
Instrucción 2
Instrucción n
End if
En la primera práctica de este curso, ya tuviste la posibilidad de utilizar esta estructura, en los dos cuadros de texto del
formulario de acceso:
“Si se oprime la tecla Enter, entonces, el cursor se coloca en el control que tiene por nombre txtpassword”
Página 37 de 62
Cuando se espera que, al no cumplirse la condición, tenga lugar una serie de instrucciones opuestas o diferentes a las
que ocurrirían en caso de cumplirse esta (alternativa doble), entonces la sintaxis de If … then mantendría una
estructura similar a la siguiente:
If condición Then
Instrucción 1
Instrucción 2
Instrucción n
Else
Instrucción 1
Instrucción 2
Instrucción n
End if
En el mismo formulario de acceso de la práctica 1 de este curso empleaste esta estructura:
“Si el nombre de usuario es tu_nombre y la contraseña es imss, entonces se mostrará el mensaje de bienvenida al
curso de Visual Basic y terminará ahí la aplicación; de lo contrario, aparecerá un mensaje advirtiendo un error en el
nombre de usuario y/o la contraseña, se borrarán los datos ingresados y el cursor quedará situado en el control que
tiene por nombre txtUsuario”
Select Case
Esta estructura se utiliza cuando se tiene que comprobar el valor de una variable y en función de este valor,
seleccionar y ejecutar una serie de instrucciones específicas (alternativa múltiple). La sintaxis a manejar con Select
Case es la siguiente.
Select Case variable
Case 1 el primer valor posible en la variable
Instrucción 1
Instrucción 2
Instrucción n
Case 2 el segundo valor posible en la variable
Instrucción 1
Instrucción 2
Instrucción n
Case 3 el tercer valor posible en la variable
Instrucción 1
Instrucción 2
Instrucción n
Case Else algún otro valor en la variable, distinto de los anteriores
Instrucción 1
Instrucción 2
Instrucción n
End Select
Página 38 de 62
Justo en el último procedimiento programado en la práctica 3 del curso, tuviste que añadir y utilizar la estructura
Select Case. Recordarás que, de acuerdo al caption de la etiqueta lblOperador, se realiza determinada operación de
cálculo y el valor obtenido queda almacenado en el control txtResultado.
Do While
Permite ejecutar un grupo de acciones mientras cierta condición resulte verdadera; los bucles con DO se utilizan
cuando no se conoce con exactitud el número de ocasiones en las que se repetirá el conjunto de instrucciones. La
sintaxis común en esta estructura es la siguiente:
Do While condición
Instrucción 1
Instrucción 2
Instrucción n
Loop delimita el bloque de instrucciones a repetir en el bucle.
Do Until
Permite ejecutar un grupo de sentencias hasta la condición determinada se cumpla. La sintaxis habitual para esta
estructura es la siguiente:
Do Until condición
Instrucción 1
Instrucción 2
Instrucción n
Loop delimita el bloque de instrucciones a repetir en el bucle.
For… Next
Permite ejecutar un conjunto de sentencias contenidas en un procedimiento, un número determinado de veces.
For contador=ValorInicial To ValorFinal delimita el número de repeticiones del bucle.
Instrucción 1
Instrucción 2
Instrucción n
Next indica ejecutar la siguiente repetición del bucle.
En las prácticas de los capítulos siguientes, incorporaremos procedimientos que incluyan el uso de bucles, para
mostrar la funcionalidad de las extructuras Do y For.
Página 39 de 62
Módulo IV Controles y objetos especiales
Puede definirse al objeto como un conjunto complejo de datos y programas que poseen cierta constitución e integran
una organización. Un objeto no puede ser un dato simple, sino que guarda en su interior un número determinado de
componentes bien organizados; tampoco puede ser un ente aislado, ya que siempre forma parte de un sistema o
entidad. La composición de un objeto habitualmente considera tres elementos:
Relaciones. Permiten que el objeto se inserte en la organización (sistema, aplicación, proyecto…) y están
formadas esencialmente por vínculos a otros objetos.
Propiedades. Distinguen a un objeto del resto que forma parte de la misma organización y tiene valores que
dependen de la propiedad de que se trate. Las propiedades de un objeto son heredadas a sus descendientes en
la organización; se les llama también atributos.
Métodos. Son las operaciones que pueden realizarse sobre el objeto, normalmente incorporados en forma de
programas (código) que el objeto es capaz de ejecutar y que también pone a disposición de sus descendientes
a través de la herencia. Sinónimos de método: función, rutina, programa.
Los objetos son pues, entidades o elementos hacia los cuáles están dirigidas ciertas acciones en un
programa.
Mnemónicos:
Se le llama Mnemónico a la abreviatura o prefijo que se añade al nombre de un objeto o cosa; ésta permite identificar
rápidamente el área, materia o clase a la que pertenece, y deja ver también sus posibles cualidades, características,
funciones y otros elementos componentes. En Visual Basic se recomienda hacer uso de ciertos mnemónicos para tener
un mejor control de los objetos que se han incluido en la aplicación en desarrollo; no es una regla que tenga que
seguirse al pie de la letra, sin embargo la facilidad y rapidez con la que es posible identificar a los diferentes elementos
que integran el proyecto, tanto en la fase de diseño de formularios, como en la etapa de codificación, precisamente se
debe al uso de los mnemónicos.
Puntero (Pointer)
En la fase de diseño del formulario funciona como un simple selector o posicionador de controles. La selección de un
solo elemento se produce dando un click sobre el objeto deseado; si se requiere de seleccionar dos o más elementos,
se tendrá que presionar de forma continua la tecla <Shift> mientras se da click sobre el resto de objetos.
Cuando los controles están seleccionados, será posible el arrastre de los mismos hacia otra zona dentro del formulario
activo, los podremos copiar o mover hacia otras ventanas de formulario, si resulta conveniente hacerlo. Si se da doble
click en alguno de los controles o en el mismo formulario, se mostrará la ventana Código, en cuyo caso escribiríamos
algún procedimiento o subalgoritmo.
Durante la ejecución del proyecto, el puntero permitirá la asignación una o más funciones conocidas en Windows,
doble click, arrastrar y colocar, menú contextual, entre otras. Así también podrás observar una apariencia distinta a la
habitual, siempre que se indique con anticipación en la propiedad MousePointer del formulario y los controles; o
bien, desde el código, para señalar al usuario cierto tipo de acciones (espera, inserción de texto, selección, arrastre…).
Algunos de los punteros preestablecidos son:
 Default: predeterminado en windows
 Arrow: flecha
 ArrowHourGlass: flecha y reloj de arena
 ArrowQuestion: flecha y signo de interrogación
 CrossHair: cruz
 HourGlass: reloj de arena
 Ibeam: en forma de I
 UpArrow: flecha hacia arriba
 Custom: se emplea para personalizar el icono del puntero. (archivos *.ico, *.cur)
Página 40 de 62
Formulario (Form)
Se ha descrito ya que el formulario sirve como plano para dibujar controles, es decir, una pantalla sobre la cual
organizamos los elementos que el usuario deberá utilizar para comunicarse e interactuar con la aplicación.
En Visual Basic se trabaja con dos tipos de formulario: Formulario SDI (Single Document Interface) y Formulario
MDI (Multiple Document Interface). Los formularios SDI se comportan como ventanas independientes dentro de la
aplicación, es decir, se abren, cierran, minimizan, restauran o maximizan en su propio espacio, aunque integren junto
con otros formularios la misma aplicación. Por su parte los formularios MDI actúan como contenedores de formularios
secundarios o subventanas dentro de la aplicación. Esos subformularios, en realidad son formularios SDI, que se
comportan como ventanas hijas del formulario MDI al haber manipulado la propiedad correspondiente.
Importante: sólo puede haber un formulario SDI por proyecto.
De acuerdo al tipo de formulario seleccionado en el proyecto, Visual Basic muestra un icono distinto para cada uno,
que nos permite diferenciarlos entre sí; tal icono se muestra en la barra de título de los formularios y en el explorador
de proyectos junto al nombre de éstos:
Las propiedades que con mayor frecuencia se manipulan de un formulario son las siguientes:
 Nombre (Name): Por defecto, todos los formularios que se van añadiendo a un proyecto llevan por
nombre Form, seguido del número secuencial que corresponde al orden en que han sido incorporados a
la aplicación (Form1, Form2, Form3, Form4, Form5…). En un formulario se emplea el mnemónico
frm. Ejemplos: frmventas, frmclientes, frmacceso.
 Appearance: Permite establecer si los controles situados en el formulario se mostrarán con el efecto 3D o
se verán planos; los valores posibles son:
☞ 0 - Flat
☞ 1 - 3D
 Backcolor: con esta propiedad se fija un color de fondo para el formulario.
 Borderstyle: es posible determinar uno de seis estilos de borde para el formulario en la etapa de diseño.
El estilo seleccionado modifica la apariencia del formulario y el estado de los botones de control. Los
estilos disponibles son:
☞ 0 - None
☞ 1 - Fixed Single
☞ 2 - Sizable
☞ 3 - Fixed Dialog
☞ 4 - Fixed ToolWindow
☞ 5 - Sizable ToolWindow
 Caption: sirve para modificar el texto contenido en la barra de título del formulario.
Página 41 de 62
 Enabled: todos los objetos poseen esta propiedad y se utiliza para activar o desactivar el objeto, es decir
para que pueda responder o no a las acciones que el usuario ejecuta sobre él. Esta es una propiedad
boleana y sólo reconoce dos valores que son:
☞ True
☞ False
 Font: establece automáticamente el estilo, tamaño, efecto y la fuente con que se mostrará la información
contenida en los controles dibujados en el formulario.
 Height: determina la altura del formulario.
 Icon: permite adecuar el icono que se muestra en la barra de título del formulario. Los archivos que
pueden utilizarse en esta propiedad son iconos o cursores (*.ico, *.cur).
 MaxButton: muestra u oculta el botón maximizar del formulario. Sus valores son:
☞ True
☞ False
 MinButton: muestra u oculta el botón minimizar del formulario. Sus valores son:
☞ True
☞ False
 MouseIcon: Permite establecer un icono personalizado para el puntero, cuando la propiedad MousePointer
corresponde a 99 – Custom.
 MousePointer: Permite modificar la apariencia del puntero cuando éste se desplace por encima del
formulario, durante la ejecución del programa.
 Moveable: determina si en el tiempo de ejecución el formulario podrá o no ser desplazado; para ello se
cuenta con dos valores:
☞ True
☞ False
 Picture: permite agregar una imagen a la superficie del formulario. La imagen que se carga en formulario
asume una posición fija dentro del mismo y no permite modificar su tamaño.
 ScaleMode: esta propiedad establece le unidad de medida que se utilizará al dibujar controles. Las
opciones disponibles son las siguientes:
☞ 0 - User
☞ 1 - Twip (unidad predeterminada para todos los controles)
☞ 2 - Point
☞ 3 - Pixel
☞ 4 - Character
☞ 5 - Inch
☞ 6 - Millimeter
☞ 7 - Centimeter
 ShowInTaskBar: indica si el formulario se mostrará o no en la barra de tareas durante la ejecución.
☞ True
☞ False
 StartUpPosition: permite definir la ubicación inicial que ocupará el formulario al mostrarse enla pantalla:
☞ 0 - Manual
☞ 1 - CenterOwner
☞ 2 - CenterScreen
☞ 3 - Windows Default
Página 42 de 62
 Width: permite establecer el ancho del formulario.

 WindowState: determina el estado de la ventana del formulario al ser abierto; los posibles estados son:
☞ 0 - Normal
☞ 1 - Minimized
☞ 2 - Maximized
Algunos de los métodos que pueden utilizarse sobre un formulario son, entre otros:
 Hide: oculta el formulario, pero no lo descarga.
 Load: carga el formulario señalado.
 PrintForm: envía a la impresora la imagen del formulario activo.
 SetFocus: lleva el enfoque al formulario indicado.
 Show: muestra el formulario indicado.
 Unload: descarga el formulario indicado.
Para agregar formularios a la aplicación pueden seguirse tres vías:
Desde la Barra de menús…
 Menú Proyecto
 Agregar Formulario
Desde la Barra estándar…

 Clic en el botón Agregar formulario
Desde el Explorador de Proyectos…

 Clic derecho en el fichero Formularios
 Seleccionar Agregar
 Seleccionar Formulario
En los tres casos se mostrará el cuadro de diálogo Agregar formulario, ilustrado en la siguiente página.
Página 43 de 62
Visual Basic ofrece dos alternativas al ejecutar la instrucción Agregar formulario, puede ser un formulario Nuevo o
un formulario existente. Si se tuviesen otros proyectos, los formularios almacenados en dichos proyectos podrían
insertarse en la aplicación activa, considerando únicamente la recomendación de guardar con otro nombre y en otra
carpeta, cada formulario insertado de esta forma, ya que de modificarse en el proyecto origen, perdería las
características asignadas dentro del proyecto en el cual se agregó, pues se inserta como un archivo vinculado.
Editor de menús (Menu Editor)

Como es sabido un Menú es una lista de opciones disponibles en una aplicación. Suelen utilizarse en la ejecución de
instrucciones muy concretas y la mayoría de éstas nos devuelve pantallas adicionales para especificar datos. La
creación de Menús en Visual Basic no nos lleva al cuadro de herramientas, a diferencia de los controles anteriores; se
debe utilizar un recurso llamado Editor de Menús (Menu Editor), al que se puede acceder desde el menú
Herramientas (Tools); o bien, desde la barra Estándar de Visual o con el método abreviado CONTROL + E.
La pantalla del editor de menús se muestra en el siguiente gráfico:
Página 44 de 62
Para un menú pueden definirse distintas propiedades, entre las que mencionamos:
 Name: a diferencia de los controles que hasta ahora se han mencionado, los menús no adoptan un
nombre de manera automática. El nombre de un menú tiene que ser asignado por el usuario, para ello se
sugiere emplear el mnemónico Mnu. Por ejemplo: mnuCatálogos, mnuOperaciones, mnuArchivo…
 Caption: esta propiedad debe contener el texto que el usuario verá en pantalla. Con bastante frecuencia
nos encontramos con un carácter subrayado en el texto de un menú, que facilita el acceso al mismo en
combinación con la tecla Alt o la tecla de función F10. Para obtener ese tipo de comportamiento en
nuestros menús, es necesario que se agregue en el Caption del menú, justo a la izquierda del carácter
que deseemos mostrar subrayado, el símbolo ampersand (&) y listo. Ejemplo:
 Shortcut: con ella podemos definir una combinación de teclas o método abreviado para acceder de
manera rápida a alguna de las opciones de menú que tengan que comportarse como instrucciones o
comandos específicos durante la ejecución del programa. Esta opción no podrá utilizarse con menús de
primer nivel o submenús.
 Enabled: propiedad que determina si una opción de menú estará disponible o no en tiempo de ejecución.
 Visible: establece si la opción de menú será visible o no por defecto al ejecutarse la aplicación.
 WindowList: define un menú como contenedor de la lista de ventanas que dependen de un formulario
MDI, del cual dependen varios SDI Child‟s.
Jerarquía
La jerarquía de un menú está condicionada por su dependencia con algún otro. Podemos decir que un menú que
depende de otro es realmente un submenú. Para crear submenús se utiliza el botón Flecha Derecha, localizado en el
Editor de menús. Este botón empuja al nuevo menú a la derecha, haciendo que dependa del inmediato superior.
Si por razón alguna es necesario reorganizar la posición de los menú o redefinir la dependencia entre estos, bastará
con utilizar el resto de los botones con flechas según se requiera.
Página 45 de 62
Etiqueta (Label)
Las etiquetas muestran texto que el usuario no puede cambiar directamente cuando la aplicación está abierta; esto
sólo es posible en la fase de diseño o durante la ejecución de algún procedimiento en el que se incluya la actualización
del contenido de la etiqueta. Con este control podemos mostrar rótulos (el nombre de una sección o campo, por
ejemplo), los resultados de una operación de cálculo, la fecha, la hora o cualquier otro dato que resulte necesario
dentro de un formulario. Las propiedades que se gestionan con mayor frecuencia en una etiqueta son:
 Nombre (Name): Por defecto aparecen como Label1, Label2, Label3..., de acuerdo al orden de
creación. El mnemónico que emplean es lbl. Ejemplos: lblmatricula, lblnombre, lblprecio, lblfecha.
 Appearance: establece si la etiqueta se muestra con efecto 3D o plana.
☞ 0 - Flat
☞ 1 - 3D
 Autosize: determina si el tamaño de la etiqueta se ajustará automáticamente a la extensión del texto que
contiene.
☞ 0 - True
☞ 1 - False
 BackColor: permite definir un color de relleno o fondo a la etiqueta.
 BackStyle: determina si el relleno de la etiqueta será visible o no.
☞ 0 - Transparent
☞ 1 - Opaque
 BorderStyle: determina si la etiqueta llevará borde o no.
☞ 0 - None
 Caption: es la propiedad utilizada para adecuar el texto que se mostrará como etiqueta.
 Font: permite ajustar la fuente, tamaño, estilo y efectos del texto en la etiqueta.
 ForeColor: permite modificar el color del texto en la etiqueta.
 Height: esta propiedad establece la altura que tendrá la etiqueta.
 ToolTipText: es una propiedad que permite mostrar un texto alternativo que sugiera u oriente al usuario,
cuando el puntero del ratón pase por encima de la etiqueta.
 Visible: determina si la etiqueta estará visible u oculta en tiempo de ejecución.
☞ 0 - True
☞ 1 – False
 Width: permite definir el ancho o largo que tendrá la etiqueta dentro del formulario.
Cuadro de texto (TextBox)

Este control puede mostrar información determinada por el usuario, ya sea en la etapa de diseño o mediante código,
en tiempo de ejecución; no obstante, el uso más frecuente que se le da consiste en permitir la entrada de datos que
puedan gestionarse en otro momento por otros controles. Algunas propiedades de los cuadros de texto…
 Nombre (Name): Se muestran originalmente como Text1, Text2, Text3...; los cuadros de texto
utilizan el mnemónico txt, ejemplos: txtedad, txtnombre, txtsalario.
 Alingment: establece el formato de alineación que mantendrán los datos dentro del cuadro de texto,
habiendo tres posibilidades:
☞ 0 - Left Justify
☞ 1 - Right Justify
☞ 2 - Center
Página 46 de 62
 Appearance: establece si el control se mostrará en relieve o plano.

☞ 0 - Flat
☞ 1 - 3D
 BackColor: determina el color de relleno del cuadro de texto
 BorderStyle: determina si el cuadro de texto mostrará borde o no.
☞ 0 - None
 Enabled: determina si el objeto estará activo en tiempo de ejecución.
☞ 0 - True
☞ 1 - False
 Font: permite ajustar la fuente, tamaño, estilo y efectos del texto en el cuadro.
 ForeColor: permite modificar el color del texto en el cuadro.
 Height: permite establecer la altura del cuadro de texto.
 Left: permite fijar la distancia del borde izquierdo del cuadro de texto con respecto del de su contenedor.
 MaxLenght: establece el número máximo de caracteres que puede contener el cuadro de texto. 65535.
 MousePointer: Permite modificar la apariencia del puntero cuando éste se desplace por encima del
cuadro de texto, durante la ejecución del programa.
 MultiLine: determina si el control aceptará o no múltiples líneas de texto.
 PasswordChar: permite establecer el carácter opcional con el que será enmascarado el texto digitado
por el usuario. Los caracteres podrían ser, por ejemplo: *, #, „, <, °, +, ^, etc. Se llama PasswordChar,
puesto que es común trabajar esta propiedad en cuadros de texto en los que habrán de manejarse
contraseñas, claves confidenciales o NIP‟s.
 ScrollBars: indica si el cuadro de texto contendrá o no barras de desplazamiento.
☞ 0 - None
☞ 1 - Horizontal
☞ 2 - Vertical
☞ 3 - Both
 TabIndex: establece el orden de tabulación del cuadro de texto en el formulario.
 TabStop: indica si el usuario podrá usar la tecla TAB para pasar el enfoque del cuadro de texto a otro
objeto.
☞ 0 - True
☞ 1 - False
 Text: establece el texto contenido en el control.
 ToolTipText: permite mostrar una etiqueta de texto emergente, cuando el puntero se sitúe sobre el
cuadro de texto durante la ejecución.
 Top: permite fijar la distancia del borde superior del cuadro de texto con respecto del de su contenedor.
 Visible: determina si el control estará visible u oculto en tiempo de ejecución.
☞ 0 - True
☞ 1 – False
 Width: permite definir el ancho del cuadro de texto.
El método más frecuente en un botón de comando es:
 SetFocus: lleva el foco o cursor al cuadro de texto referido.
Página 47 de 62
Botón de comando (CommandButton)

Tiene la forma de un “botón” y se usa para iniciar, interrumpir o terminar un proceso, como pudieran ser, calcular el
resultado de una operación aritmética, mostrar un formulario, cerrar un formulario, enviar información a otra
aplicación, etc. Vease aquí la descripción de sus propiedades elementales:
 Nombre (Name): Se muestran originalmente con la leyenda Command1, Command2, Command3...;
los botones de comando emplean el mnemónico cmd, ejemplos: cmdeliminar, cdmsalir, cmdexportar...
 BackColor: determina el color de fondo del botón de comando, acción que podrá comprobarse sólo si la
propiedad Style está en modo gráfico.
 Caption: esta propiedad contiene el texto que se mostrará en el interior del botón.
 Font: permite ajustar la fuente, tamaño, estilo y efectos del texto en el botón de comando, siempre que
la propiedad Style se mantenga en modo gráfico.
 Picture: permite establecer el archivo de imagen que se mostrará sobre el botón de comando, cuando la
propiedad Style esté en modo gráfico.
 Style: determina la apariencia del botón, ya sea con el estilo clásico de Windows o con una imagen
personalizada.
☞ 0 - Standard
☞ 1 - Graphical
 TabIndex: establece el orden de tabulación que corresponde al botón dentro del formulario.
 TabStop: indica si el usuario podrá usar la tecla TAB para pasar el enfoque del botón de comando a otro
objeto.
☞ 0 - True
☞ 1 - False
 ToolTipText: permite mostrar una etiqueta de texto emergente, cuando el puntero se sitúe sobre el
botón de comando durante la ejecución.
 Visible: determina si el control estará visible u oculto en tiempo de ejecución.
☞ 0 - True
☞ 1 – False
El método que más comunmente se utiliza con los botones de comando es:
 SetFocus: lleva el enfoque al botón indicado.
Marco (Frame)
Esta herramienta permite agrupar una serie de controles, que se vuelven “dependientes” del marco; es decir, son
afectados por algunas instrucciones que se dirijan a su comportamiento. Si en algún momento el marco se oculta o
permanece inactivo, los controles en su interior heredan los mismas cambios. Las propiedades sobresalientes de un
Frame son:
 Nombre (Name): Frame1, Frame2, Frame3... son los nombres por defecto; con los frames tenemos
que usar el mnemónico fra. Ejemplos: frabotones, fradatos, frapagos...
 Appearance: establece si el marco se mostrará en relieve o plano.
 BackColor: determina el color de fondo de marco.
 Caption: esta propiedad contiene el texto que se mostrará en el borde del marco.
 Font: permite ajustar la fuente, tamaño, estilo y efectos del texto en el marco.
 ForeColor: permite modificar el color del texto en el rótulo del marco.
 Height: permite establecer la altura del marco.
 Width: permite definir el ancho del marco.
Página 48 de 62
Casilla de verificación (CheckBox)

Con este control en Visual Basic podemos seleccionar o desactivar, según se requiera, una o varias opciones en un
grupo de alternativas. La casilla de verificación sólo asume dos valores generalmente: checked o unchecked y las
propiedades que habitualmente se gestionan de esta clase de control son las siguientes:
 Nombre (Name): los nombres por defecto para las casillas de verificaión son Check1, Check2… y el
mnemónico empleado con éstas es chk, ejemplos: chkimss, chkispt…
 Alingment: define la posición que guardará la casilla respecto al texto que le acompaña, las opciones
disponibles son:
 Appearance: establece si la casilla se mostrará en relieve o plana.
 BackColor: define el color del área de la casilla de verificación.
 Caption: contiene el texto que se mostrará junto a la casilla.
 Height: determina la altura que tendrá el área de la casilla.
 Left: establece la distancia a la que se ubicará la casilla con relacion al borde izquierdo del formulario o
marco donde se haya colocado.
 Picture: permite mostrar un gráfico en la casilla cuando el estilo de la misma es gráfico.
 Style: se utiliza para modificar la apariencia del control, que puede ser…
☞ 0 - Standard
☞ 1 - Graphical
 TabIndex: permite definir el orden de tabulación de la casilla dentro del formulario.
 Top: establece la distancia de la casilla con relación al borde superior del formulario o marco dentro del
que se sitúe.
 Value: define el valor por default con que se mostrará la casilla al ejecutarse el programa, ofrece tres
posibilidades…
☞ 0 - Unchecked
☞ 1 - Checked
☞ 2 - Grayed
 Visible: determina si el control se mostrará o estará oculto al iniciar la ejecución.
 Width: permite definir el ancho del área de la casilla.
El método más utilizado en las casillas verificación es:
 SetFocus: lleva el foco o cursor a la casilla referida.
Botón de opción (OptionButton)

Se le conoce también como botón excluyente debido al comportamiento que asume cuando hay más botones de su
tipo dentro del formulario o marco en el cual se sitúen éstos. En un grupo de botones de opción sólo uno puede ser
seleccionado, de ahí que se le llame excluyente. Algunas de las propiedades con las que se trabaja frecuentemente de
este control, son…
 Nombre (Name): los nombres prestablecidos para los botones de opción son Option1, Option2,
Option3… y el mnemónico que utilizan es opt; ejemplos: optMasculino, optFemenino…
 Alingment: define la posición que guardará el botón de opción respecto al texto que le acompaña, las
opciones disponibles son:
Página 49 de 62
 Appearance: permite seleccionar la apariencia del área del botón, que puede ser plana o tridimensional.
 BackColor: define el color del área del botón de opción.
 Caption: contiene el texto que se mostrará junto al botón.
 Height: determina la altura que tendrá el área del botón.
 Left: establece la distancia a la que se ubicará el botón de opción respecto al borde izquierdo del
formulario o marco donde se haya colocado.
 Picture: permite dar al botón una apariencia gráfica, cuando la propiedad Style se ha definido como
Graphical.
 Style: se utiliza para modificar la apariencia del control, que puede ser…
☞ 0 - Standard
☞ 1 - Graphical
 TabIndex: permite definir el orden de tabulación que corresponderá al botón dentro del formulario.
 Top: establece la posición del botón con relación al borde superior del formulario o marco dentro del que
se sitúe.
 Value: define el valor automático con que se mostrará el botón al ejecutarse el programa, sólo presenta
dos posibilidades…
☞ True
☞ False
 Visible: determina si el control se mostrará o estará oculto al iniciar la ejecución.
 Width: permite definir el ancho del área del botón.
El método utilizado con mayor frecuencia en los botones de opción es:
 SetFocus: lleva el foco o cursor al botón de opción referido.
Cuadro de lista (ListBox)

Los cuadros de lista contienen un grupo de opciones que son elegibles dentro de una aplicación; generalmente
muestran una barra de desplazamiento que permite al usuario navegar o desplazarse entre el conjunto de alternativas
disponibles dentro del mismo. Las propiedades básicas de esta clase de control se describen enseguida.
 Nombre (Name): por defecto al insertar un nuevo cuadro de lista sobre el formulario activo, Visual Basic
asigna el nombre List, sucedido del número consecutivo que a éste le toque según corresponda en orden
de creación: List1, List2, List3… Hemos de utilizar el mnemónico lst para los cuadros de lista, ejemplos:
lstPaís, lstProvincia, lstEstadoCivil, etc.
 Appearance: permite seleccionar la apariencia que tendrá el cuadro de lista, ésta puede ser plana o 3D.
☞ 0 - Flat
☞ 1 - 3D
 BackColor: propiedad con la que se define el color de relleno o fondo del cuadro de lista.
 Columns: se utiliza para especificar si el cuadro de lista contendrá una barra de desplazamiento vertical u
horizontal. Para ello se tienen que indicar los valores 0 ó 1, respectivamente.
 Enabled: determina si el cuadro de lista podrá ser gestionado o no durante la ejecución del programa.
 List: nos permite agregar el conjunto de elementos que se mostrarán en el cuadro de lista.
 Multiselect: propiedad que establece si el cuadro de lista permitirá o no selecciones múltiples.
☞ 0 - None
☞ 1 - Simple
☞ 2 - Extended
Página 50 de 62
 Sorted: esta propiedad se emplea para ordenar los elementos contenidos en el cuadro de lista;
usualmente el ordenamiento es de tipo ascendente (A-Z).
 Style: con ella se puede establecer si dentro del cuadro de lista, los elementos se mostrarán como
simples textos, o bien, como un grupo de opciones con casillas de verificación. En el primer caso, sólo
podría seleccionarse un solo elemento de la lista; sin embargo en el segundo caso se tiene la posibilidad
de seleccionar varios de estos elementos o todos, si fuera necesario.
Los métodos que incluye una caja de lista son:
 AddItem: agrega un elemento de lista a la caja.
 Clear: elimina el contenido de la caja de lista referida.
 RemoveItem: borra un elemento de la lista que existe en la caja.
 SetFocus: lleva el enfoque a la caja de lista.
Cuadro combinado (ComboBox)

El cuadro combinado es un objeto que agrupa las características del cuadro de texto con las del cuadro de lista; es
decir, nos permite escribir dentro del mismo, aunque de manera predeterminada éste contiene ya una lista de
opciones. Al escribir dentro de un cuadro combinado generalmente no agregamos datos, pero sí podemos
desplazarnos a la opción más próxima o parecida. Las propiedades generales de un cuadro combinado son…
 Nombre (Name): cada vez que se agrega un cuadro combinado en el formulario activo, Visual Basic da
por defecto el nombre Combo1, Combo2, Combo3… El mnemónico asignado a los cuadros combinados
es cbo, por ejemplo: cboPuesto, cboDepartamento, cboÁrea, cboArtículo, etc.
 BackColor: propiedad con la que se define el color de relleno del cuadro combinado
 Enabled: determina si el cuadro combinado podrá ser gestionado o no durante la ejecución del
programa.
 Font: permite ajustar la fuente, tamaño, estilo y efectos del texto en el cuadro combinado.
 ForeColor: permite modificar el color del texto en el cuadro combinado.
 ItemData: permite definir un número específico para cada elemento de lista del cuardo combinado.
 List: nos permite agregar el conjunto de elementos que se mostrarán en la lista del cuadro combinado.
 Locked: esta propiedad define si el usuario podrá escribir o no dentro del cuadro combinado.
 Sorted: esta propiedad ordena los elementos de lista contenidos en el cuadro combinado; el tipo de
ordenamiento utilizado es ascendente (A-Z).
 Style: permite seleccionar el formato o estilo del cuadro combinado; cada estilo determina el
comportamiento del combo al estar en ejecución el programa y para ello Visual Basic ofrece las tres
opciones siguientes:
☞ 0 - DropDownCombo
☞ 1 - Simple Combo
☞ 2 - DropDownList
 TabIndex: establece el orden de tabulación que corresponderá al cuadro combinado dentro del
formulario contenedor.
 Text: establece el texto que mostrará por default el cuadro combinado en tiempo de ejecución. Sólo en el
caso de haber seleccionado el estilo DropDownList esta propiedad no tiene efecto alguno.
Los métodos que incluye el cuadro combinado son similares a los de una caja de lista:
 AddItem: agrega un elemento de lista al cuadro combinado.
 Clear: elimina el contenido del cuadro combinado.
 RemoveItem: borra un elemento de la lista que contiene el cuadro combinado.
 SetFocus: lleva el enfoque al cuadro combinado.
Página 51 de 62
Imagen (Image)
Este control se utiliza para mostrar gráficos sobre los formularios; soporta prácticamente cualquier formato de imagen
conocido. Las propiedades que no deben pasar desapercibidas de un control imagen son las siguientes:
 Nombre: Por defecto, cada nuevo control de imagen que se añade a un formulario ennun proyecto, ésta
aperece nombrado como image1, image2, image3… según el orden secuencial en el que se agreguen.
El mnemónico que se utiliza en esta clase de control es img.
 BorderStyle: Permite aplicar un borde a la imagen.
 Height: Establece la altura del área donde se mostrará laimagen.
 MousePointer: Determina la imagen del puntero, cuando éste se coloque por encima de la imagen,
durante la ejecución del programa.
 Picture: Permite establecer el archivo gráfico que contendrá el control de imagen (archivos con formato
bmp, dib, cur, ico, gif, jpg, wmf, emf)
 Stretch: establece si la imagen podrá ajustarse o no a la superficie trazada para el control de imagen.
 Width: Establece el ancho del área donde se mostrará laimagen.
Control de datos (Data)

Este objeto nos da la posibilidad de gestionar información contenida en bases de datos de formatos diversos:
visualizar, agregar, eliminar o actualizar registros (como Access, Dbase, Excel, FoxPro, Paradox y Lotus). El control de
datos tiene que relacionarse con otros objetos en Visual Basic para finalmente poder verificar que la gestión de la base
de datos se realiza de manera conveniente.
El uso del control de datos implica utilizar las propiedades DataSource y DataField de cuadros de texto, etiquetas,
cuadros de lista, casillas de verificación, imágenes, cajas de imagen y cuadros combinados, para operar de forma
conveniente el archivo de la base de datos que se pretenda. DataSource debe referirse al nombre del control de
datos disponible en el formulario y que gestiona la información que nos interesa para el objeto seleccionado;
DataField tendrá como valor el nombre del campo o atributo a partir del cual el objeto en uso desplegará
información.
Antes de intentar vincular cualquier control con una base de datos es necesario considerar las siguientes propiedades
del control de datos:
 Nombre (Name): Los controles de datos se nombran consecutivamente Data1, Data2, Data3…
Emplean el mnemónico dat, y como ejemplos mencionamos datClientes, datProveedores, datLibros.
 Align: propiedad con la que se define la ubucación del control de datos con respecto del formulario donde
se ha situado. Visual Basic da cinco posibilidades en esta propiedad:
☞ 0 - None
☞ 1 - Align Top
☞ 2 - Align Bottom
☞ 3 - Align Left
☞ 4 - Align Right
 Appearance: determina si el control de datos tendrá aspecto plano o tridimensional.
 BOFAction: establece la posible acción que se ejecutará si se presioan el botón Ir al Inicio, del
control de datos.
 Caption: determina el texto que se mostrará en el dorso del control de datos. Usualmente el texto debe
hacer referencia al origen de datos o tabla que alimenta al objeto.
 Connect: esteblece el formato de la base da datos con la cuál se pretende conectar el control de datos.
 DataBaseName: se utiliza para definir la ruta y nombre del archivo de base de datos con el que se
realizará la conexión.
Página 52 de 62
 EOFAction: establece la acción que se ejecutará si se presiona el botón Ir al Final, del control
de datos.
 ReadOnly: determina si será posible editar la base de datos desde el control de datos o si por el
contrario sólo se visualizará la información.
 RecordSetType: permite indicar el tipo de objeto que utilizará el control de datos para manipular la
información. Lo más común es manejar tablas, así pues se sugiere seleccionar tal opción. No obstante,
desde el código se pueden utilizar sentencias SQL que filtren información proveniente de la Base de datos
y la descarguen en el control de datos.
 RecordSource: se conoce también como origen de datos, es decir, ésta propiedad debe señalar el
nombre de la tabla o consulta proveniente de la base de datos que alimentará al recordset del control de
datos. Cuando se desee manejar un query o filtro desde el código, la propiedad recordsetype deberá
contener la opción dynaset, debido a que se trata de un objeto dinámico.
Práctica 4 - Proyecto Ventas

1. Inicia un nuevo proyecto en Visual Basic 6.0
2. En el Explorador de proyectos, haz clic derecho sobre el objeto Form1 y selecciona la opción Quitar
Form1, para comenzar desde cero esta aplicación; momentáneamente el proyecto se quedará sin archivos.
3. Llama al proyecto vbpVentas.
4. Abre el menú Proyecto y selecciona la opción Agregar formulario MDI…
No existen plantillas o asistente para el diseño de un formulario MDI, así que, en el cuadro de diálogo
Agregar formulario MDI sólo presiona el botón Abrir.
5. Define las siguientes propiedades para el nuevo formulario…

Nombre MDIVentas
Caption Sistema Automatizado de Ventas [Pantalla Principal]
Icon Icono ubicado en:
Escritorio\Icons\Office\GRAPH01
WindowState 2 - Maximized
6. Abre el editor de menús e inserta los siguientes elementos:
Página 53 de 62
7. Guarda el formulario MDI y el proyecto en la carpeta Proyecto Ventas que crearás dentro de tu carpeta
personal.
8. Agrega un formulario SDI nuevo y define las siguientes propiedades para este objeto…

Nombre frmClientes
BorderStyle 2 - Sizable
Caption Módulo de Clientes
WindowState 2 - Maximized
MDIChild True
MinButton False
9. Guarda este formulario en la carpeta Proyecto Ventas.

10. Inserta cuatro etiquetas en el formulario y utiliza las siguientes propiedades para estas:
Label1 Label2 Label3
Nombre lblId Nombre lblNombre Nombre lblRfc
Autosize True Autosize True Autosize True
BackStyle 0 - Transparent BackStyle 0 - Transparent BackStyle 0 - Transparent
Caption Id de Cliente: Caption Nombre: Caption R.F.C.
Font Bookman Old Style, Font Bookman Old Style, Font Bookman Old Style,
estilo normal, estilo normal, estilo normal,
tamaño 14 tamaño 14 tamaño 14
ForeColor &H00C00000& ForeColor &H00C00000& ForeColor &H00C00000&
Label4

Nombre lblDomicilio
Autosize True
Caption Domicilio Fiscal
Font Berlin Sans FB,
estilo normal,
tamaño 16
ForeColor &H00C00000&
11. Inserta un cuadro de texto por cada etiqueta en el formulario y adecua sus propiedades.
Página 54 de 62
Text1 Text2 Text3
Nombre txtId Nombre txtNombre Nombre txtRfc
Alignment 1 - Right Justify Alignment 0 - Left Justify Alignment 0 - Left Justify
Font Berlin Sans FB, Font Berlin Sans FB, Font Berlin Sans FB,
Forecolor &H00404040& Forecolor &H00404040& Forecolor &H00404040&
MaxLenght 5 MaxLenght 50 MaxLenght 13
Text Text Text
ToolTipText Clave o ID del ToolTipText Nombre o Razón ToolTipText Registro Federal de
cliente Social del cliente Contribuyentes
Text4
Nombre txtDomicilio
Alignment 0 - Left Justify
estilo normal,
tamaño 16
Forecolor &H00404040&
Height 850
MaxLenght 100
Multiline True
Text (Texto)
ToolTipText Domicilio Fiscal del
cliente
Width 7000
12. Inserta un marco debajo del control txtDomicilio, que actualmente se encuentra en el formulario, y define
sus propiedades según la tabla.

Nombre fraRegion
Caption Región
Font Berlin Sans FB, estilo normal, tamaño 16
Height 1125
Width 7000
13. Dentro del marco dibuja cuatro botones de opción con las características que se muestran en las tablas de
abajo.
Option1 Option2 Option3

Nombre optNorte Nombre optOriente Nombre optSur
BackColor &H00E0E0E0& BackColor &H00E0E0E0& BackColor &H00E0E0E0&
Caption &Norte Caption &Oriente Caption &Sur
Font Berlin Sans FB, Font Berlin Sans FB, Font Berlin Sans FB,
ForeColor &H00C00000& ForeColor &H00C00000& ForeColor &H00C00000&
Option4

Nombre optPoniente
Caption &Poniente
estilo normal,
tamaño 16
Width 1500
14. Inserta enseguida cuatro botones de comando situados debajo del marco anterior y utiliza los valores que se
muestran en las tablas.
Command1 Command2 Command3

Nombre cmdNuevo Nombre cmdAceptar Nombre cmdCancelar
BackColor &H00E0E0E0& BackColor &H00E0E0E0& BackColor &H00E0E0E0&
Caption Caption Caption
Height 735 Height 735 Height 735
Picture Icono ubicado en: Picture Icono ubicado en: Picture Icono ubicado en:
Escritorio\Icons\ Escritorio\Icons\ Escritorio\Icons\
Arrows\POINT06 Misc\CHECKMRK Writing\ERASE02
Style 1 - Graphical Style 1 - Graphical Style 1 - Graphical
ToolTipText Haz clic aquí para ToolTipText Haz clic aquí para ToolTipText Haz clic aquí para
agregar un nuevo guardar el registro borrar los datos
registro insertados y/o
Width 1575
cancelar el registro
Width 1575
actual
Width 1575
Command4
Nombre cmdCerrar
Caption
Height 735
Picture Icono ubicado en:
Escritorio\Icons\
Writting\NOTE04
Style 1 - Graphical
ToolTipText Haz clic aquí para
cerrar el formulario
Width 1575
15. Guarda los cambios y abre la ventana de código para escribir las instrucciones convenientes.
16. Cuando el formulario sea ejecutado, no deberán estar habilitados los cuadros de texto, los botones de opción y
los botones de comando cmdAceptar y cmdCancelar no serán visibles. Únicamente estarán activos los
botones cmdNuevo y cmdCerrar; para ello crearemos un procedimiento general, cuyo nombre será
Inactivo; sitúa el cursor en la zona más baja de la ventana código y escribe las instrucciones que se
muestran en la imagen siguiente:
17. Adicionalmente, los cuadros de texto y los botones de opción deberán mostrarse sin valores predeterminados
y para ello crearemos otro procedimiento de nombre BorrarDatos.
18. Ambos procedimientos tendrán efecto cuando el formulario se cargue. Localiza y selecciona del apartado de
controles al objeto Form e inserta las siguientes líneas:
Página 57 de 62
19. Ahora selecciona del listado de controles al objeto cmdNuevo para escribir el código que habilite los objetos
necesarios en la captura de un nuevo registro y muestre los botones cmdAceptar y cmdCancelar para
ejecutar las acciones correspondientes. Imprimirá, además, la clave del nuevo cliente y dejará el cursor
parpadeando dentro del cuadro de texto txtNombre.
20. Durante la ejecución del programa, después de escribir el nombre o razón social del cliente, el usuario podrá
presionar la tecla Enter para colocar el cursor en el siguiente cuadro de texto, txtRfc. Entonces, selecciona
del apartado de controles al objeto txtNombre y busca para este el evento KeyPress; enseguida inserta el
código correspondiente:
21. Después de ingresar el RFC del cliente, el usuario volverá a presionar la tecla Enter para desplazar el cursor al
objeto txtDomicilio. Selecciona del apartado de controles al objeto txtRfc y busca para este el evento
KeyPress; enseguida inserta el código correspondiente:
22. Una vez capturado el domicilio fiscal, el usuario deberá seleccionar una zona para el cliente y entonces
presionar el botón cmdAceptar para continuar con la captura de un nuevo registro; pero además, el botón
verificará que no falte ningún dato del cliente; de ser así, el programa notificará al usuario sobre la
información faltante con un cuadro de mensaje y sólo cuando el registro esté completo, o en su defecto, se
cancele la operación, el formulario quedará vacío.
Las instrucciones serían las siguientes:
Página 58 de 62
23. Cuando el usuario desee cancelar el proceso de captura de un cliente, sólo tendrá que oprimir el botón del
mismo nombre; la información hasta ese momento capturada será borrada y los controles del formulario, en
su mayoría, quedarán incativos, como al inicio. Despliega la lista de controles y selecciona cmdCancelar,
aparecerá por defecto el evento Click ligado a este control. Escribe el código siguiente:
24. Cuando se oprima el botón cerrar, el formulario se descargará completamente, una vez confirmada la
operación. El código para el botbón cmdCerrar es el siguiente:
25. Guarda los cambios efectuados en el proyecto y en el formulario.

26. Abre el formulario principal, MDIVentas.
27. Haz clic en el menú Catálogos y selecciona la opción Clientes (control + C).
28. En la ventana de código escribe la siguiente instrucción.
29. Ejecuta el proyecto, oprimiendo la tecla F5.

30. Verifica el funcionamiento de los controles, de acuerdo a la secuencia de acciones que se ha establecido a lo
largo de este ejercicio. Si encuentras algún error o quisieras adaptar algo del comportamiento de los objetos,
intenta corregirlo o comenta al instructor qué clase de modificación quisieras implementar.
31. Guarda el proyecto.
Página 59 de 62
Variables
Una variable es un objeto que guarda un valor que cambia durante la ejecución de un programa; en Visual Basic se
pueden utilizar los siguientes tipos de datos en las variables:
Nombre del tipo de Descripcion del tipo de
Rango de valores Espacio requerido
dato dato
Integer (entero) Numérico, entero de -32768 a 32767 16 bits (2 bytes)
Long (Largo) Numérico, entero de -2147483648 a 2147483647 32 bits (4 bytes)
String (cadena) Texto de 0 a 65500 caracteres aprox. 8 bits (1byte) por carácter
de –922337203685477,5807 a
Currency (moneda) Numérico decimal fijo 64 bits (8 bytes)
9223372036854777,5807
De +- 1.40x1045
Single (simple) Numérico real 32 bits (4 bytes)
A +- 1.79x10308
De +- 4.94x10324
Double (doble) Numérico real 64 bits (8 bytes)
a +- 1.79x10308
Byte Carácter 0 a 255 1 byte
Boolean Bolean True / false 2 bytes
Date Fecha / Hora 1/01/100 al 31/12/9999 8 bytes
Variant (variable) Adaptable Cualquiera de los anteriores Depende del valor almacenado
Object Objeto Referencia a objetos
Antes de utilizar una variable debe declararse su tipo. Por ejemplo:

Dim I As Integer
Dim R As Double
Dim Nombre As String
Dim F As Currency
Dim L As Long
Dim X As Currency
Dim Hoy As Date
Dim Excel As Object
Las sentencias anteriores declaran I como una variable entera, R como una variable de coma flotante de precisión
doble, Nombre como una variable para contener una cadena de caracteres de longitud variable, F como una variable
tipo moneda…
Option Explicit
Obliga a declarar previamente las variables que se vayan a usar. De no haberla declarado antes de usarla, el programa
dará una comunicación de error.
Ámbito de una variable
Denominamos ámbito de una variable a las partes del programa donde esa variable está declarada. Un programa VB
tiene uno o varios formularios. Cada formulario tiene varios controles. Tanto el formulario como cada uno de sus
controles tienen una parte del programa, justamente la parte relacionada con cada uno de los eventos que pueden
suceder bien al formulario o a los controles. A estas partes las habíamos llamado Procedimientos. Podemos tener
procedimientos que no estén relacionados con ningún evento ocurrido al formulario o a sus controles. (Los
Procedimientos que iremos insertando a lo largo de la aplicación)
Aparte de formularios y controles, un programa puede tener Módulos, y en cada uno de los módulos podemos insertar
cuantos Procedimientos y Funciones queramos.
Página 60 de 62
Si se declara una variable dentro de un procedimiento o Función, esa variable "NO SALE" del Procedimiento o Función
donde se declaró. El procedimiento puede estar en un Formulario (Cualquier procedimiento de un control o un
procedimiento creado por nosotros) o en un Módulo (En este caso, el procedimiento solo puede ser creado por
nosotros)
En un Formulario, una variable puede declararse de dos formas: Privada o Pública. Para declarar una variable a nivel
de formulario debe hacerse en la sección de declaraciones, que está la ventana de código Objeto = General, Proc. =
Declaraciones. Si se declara Privada, esa variable se puede mover por todo el formulario, (es decir, por todos los
procedimientos de todos los controles del formulario y por los Procedimientos que pudiésemos insertar en ese
formulario), pero no sale de dicho formulario. Si se declara como Pública, esa variable puede moverse por todo el
formulario, de la misma forma que lo haría declarada como Privada, y además puede ser usada desde otro Formulario
o Módulo, citándola con el nombre del Formulario, seguido del nombre de la variable (Formulario.Variable)
En un Módulo una variable puede declararse como Privada, con lo que no saldrá de ese Módulo, o Pública, pudiendo
en este caso usarse en todo el programa. Cuando se declara una variable como pública en un Módulo, basta referirse
a ella por su nombre, sin citar el nombre del Módulo donde se declaró.
En VB es posible declarar varias veces las variables, es decir, pueden declararse a nivel de formulario, en su apartado
de declaraciones, y esa variable conservará su valor en todas las partes de ese formulario. Sin embargo, si se declara
una variable con el mismo nombre a un nivel inferior, por ejemplo al principio de un procedimiento, esa variable será
una variable distinta a la anterior, aunque tenga el mismo nombre, a al declararla en un Procedimiento, solamente
será válida en ese Procedimiento. Una vez que hayamos salido de ese procedimiento, la variable con ese nombre
volverá a ser la declarada en el Formulario. En realidad, lo que tenemos son dos variables distintas, pero con el mismo
nombre, una declarada para todo el formulario excepto para el procedimiento donde se volvió a declarar, y otra para
ese procedimiento concreto.
Formas para declarar variables
Sentencia DIM. Es la forma más común de declarar una variable como Privada. Puede emplearse en un
Procedimiento, Función, Formulario o Módulo. La sintaxis es de la siguiente forma:
Dim nombre_variable As Integer
Declarando una variable con la sentencia DIM, en un formulario, Función, procedimiento o módulo, el entorno de la
variable será el explicado anteriormente para una variable declarada como Privada. Es decir, esa variable no sale del
formulario, procedimiento ó módulo donde se declaró. Cada vez que entremos al formulario, procedimiento o módulo,
esa variable tomará el valor cero (si es numérica) o nulo (si es string).
Sentencia PRIVATE. Es la forma de declarar una variable como Privada. Puede emplearse solamente en la sección de
declaraciones de un Formulario o Módulo. La sintaxis es de la siguiente forma:
Private nombre_variable As tipo_dato
Declarando una variable mediante la sentencia PRIVATE en un Formulario o Módulo, esa variable puede usarse en
todo ese Formulario o Módulo (En todos sus Procedimientos y Funciones), pero NO fuera del Formulario o Módulo
donde se declaró.
La sentencia Private no puede usarse en un procedimiento o función.
Sentencia PUBLIC Es la forma de declarar una variable como Pública. Puede emplearse solamente en la sección de
declaraciones de un Formulario o Módulo. La sintaxis es de la siguiente forma:
Public nombrevariable As Tipovariable
Declarando una variable de esta forma en la sección de declaraciones de un Módulo, esa variable puede usarse en
cualquier parte del programa citándola simplemente por su nombre.
Si se declara de esta forma en la sección de declaraciones de un Formulario, esa variable puede usarse en toda el
programa. Para nombrarla, si estamos en el Formulario donde se declaró basta con citarla por su nombre. Si no
estamos en ese Formulario, habrá que citarla por el nombre del Formulario, seguido del nombre de la variable,
separados por un punto:
Formulario.Variable
Página 61 de 62
En un Módulo puede usarse también la sentencia Global en vez de Public:

Sentencia GLOBAL. Declara una variable que es válida en todo el programa. La sintaxis es:
Global nombrevariable As tipovariable
La sentencia Global sólo puede usarse en el apartado de declaraciones de un Módulo. Mediante la sentencia Global
la variable puede usarse en todo el espacio del programa.
Página 62 de 62

Visualbasico6 PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Visualbasico6 PDF

Загружено:

Авторское право:

Доступные форматы

CENTRO NACIONAL DE

Visual Basic 6.0

Módulo I Elementos generales

Módulo II El entorno de trabajo en Visual Basic

Módulo III La programación en Visual Basic

Módulo IV Controles y objetos especiales

Módulo I Elementos generales

Ejemplo de Algoritmo, Diagrama de flujo y Pseudocódigo.

Diagrama de Flujo: Pseudocódigo:

Módulo II El entorno de trabajo en Visual Basic

La ventana de Visual Basic 6.0

Visual Basic 6.0 Profesional

Inicialmente, en esta ventana deberás identificar cinco elementos básicos:

Explorador de proyectos (Project Explorer) Ventana de Propiedades (Window Properties)

Ventana Posición de Formulario (Form Layout)

 Barra Editor de formularios

Práctica 1: Los componentes de la ventana de Visual Basic 6.0

4. Pulsando continuamente la tecla Control y ayudándote de las teclas de navegación ( y ),

8. Haz doble clic en la herramienta Botón de Comando (CommandButton) , se mostrará sobre el

Definción de propiedades de los controles

9. Selecciona el formulario y desde la Ventana Propiedades define las siguientes características:

Propiedad Valor o Contenido

10. Selecciona la etiqueta Label1 y define las siguientes propiedades:

Propiedad Valor o Contenido

11. Para la etiqueta Label2, aplica los siguientes valores:

Propiedad Valor o Contenido

Propiedad Valor o Contenido

13. Para el cuadro de texto Text2, aplica los siguientes valores:

Propiedad Valor o Contenido

14. Ahora selecciona el objeto Command1, y ajusta las propiedades:

Propiedad Valor o Contenido

15. Para el control Command2, utiliza los valores siguientes:

Propiedad Valor o Contenido

Modo Diseño y Modo Ejecución

 O bien, haz clic en el botón Terminar, ubicado en la barra

23. En la esquina superior izquierda verás el nombre del control desde el

28. Muestra el formulario combinando las teclas Shift + F7.

30. Regresa al formulario con Shift + F7.

Práctica 2 - Proyecto Colores

Propiedad Valor o Contenido

d) En el cuadro de herramientas, localiza y selecciona el control Marco (Frame) y realiza un trazo

Propiedad Valor o Contenido

g) Establece las siguientes propiedades para el nuevo control:

Propiedad Valor o Contenido

i) Define las siguientes propiedades para el control Option1:

Propiedad Valor o Contenido

j) Utilizando el botón de opción, inserta tres controles más, debajo de optBlanco.

Propiedad Valor o Contenido Propiedad Valor o Contenido Propiedad Valor o Contenido

Al concluir estas acciones el formulario lucirá así:

l) Selecciona del cuadro de herramientas, el control botón de comando (CommandButton) y

m) Establece los valores siguientes para este nuevo control en el formulario:

Propiedad Valor o Contenido

Al finalizar, el formulario se verá así:

s) Ejecuta la aplicación para verificar el funcionamiento de los botones.

Módulo III La programación en Visual Basic

Práctica 3 - Proyecto Calculadora

Propiedad Valor o Contenido

4) Dibuja un control de Imagen (Image) en el extremo

Propiedad Valor o Contenido

5) Inserta un control Etiqueta (Label) en el extremo superior

Propiedad Valor o Contenido

6) Inserta dos nuevas etiquetas, debajo de la anterior y define

Propiedad Valor o Contenido Propiedad Valor o Contenido