Cuaderno de Trabajo Visual Basic Con BD PDF

CUADERNO DE TRATRABAJO
BAJO
VISUAL BASIC con Base
B
de Datos
Cuaderno de Trabajo Visual Basic se encu

encuentra bajo una Licencia Creative Commons Atribución-No
Atribución Comercial-
Licenciamiento Recíproco 3.0 Unported. Diciembre – IDSystems
Contenido
INTRODUCCION ..........................................................................................................................................................4
EJERCICIOS SOBRE EL ARCHIVOS ................................................................................................................................5
Ejercicio 06 – Texto y RTF .......................................................................................................................................6
Ejercicio 07 – Leer datos desde un archivo ............................................................................................................7
Ejercicio 08 – Usar output para grabar un archivo .................................................................................................9
Ejercicio 09 – Usando APPEND para agregar informacion al archivo.................................................................. 11
Ejercicio 10 – Creando archivos de configuracion para aplicaciones .................................................................. 13
Ejercicio 11 – Usando Write e Input .................................................................................................................... 15
Ejercicio 12 – Usando archivos aleatorios ........................................................................................................... 18
Ejercicio 13 – Usando archivos aleatorios y registros ......................................................................................... 21
Ejercicio 14 – Ecuacion de 2º. Grado ................................................................................................................... 24
Ejercicio 15 – Agenda .......................................................................................................................................... 27
Ejercicio 16 – Editor de texto con RTF ................................................................................................................. 34
Ejercicio 17 – Editor de texto con formularios MDI ............................................................................................ 38
PRACTICAS 1-5 ......................................................................................................................................................... 47
EJERCICIOS SOBRE EL BASES DE DATOS .................................................................................................................. 48
Ejercicio 18 – Formulario de Datos...................................................................................................................... 49
Ejercicio 19 – BD Navegar .................................................................................................................................... 53
Ejercicio 20 - Connection to an Access Database Using the VB Data Control .................................................... 53
Ejercicio 21 – Using Navigation Buttons with Data Control ................................................................................ 55
Ejercicio 22 – Using the BOF Action and EOF Action Properties of the Data Control ........................................ 57
Ejercicio 23 – Using the EOF and BOF Properties with Navigation Buttons ........................................................ 58
Ejercicio 24 – Adding, Updating and Deleting Records ....................................................................................... 58
Ejercicio 25 – BD Navegar por codigo.................................................................................................................. 61
Ejericio 26 – BD Altas, Bajas y Busqueda ............................................................................................................. 62
Ejercicio 27 – Using the Validate Event ............................................................................................................... 64
Ejercicio 28 – Using the Find Methods ................................................................................................................ 70
Ejercicio 29 – Using the MSFlexGrid Control ....................................................................................................... 78
Ejercicio 30 – Using the DBGrid Control .............................................................................................................. 80
Ejercicio 31 – Conectando VB con ACCESS 2007 y un control OLE DB de datos. ................................................ 81
Ejercicio 32 – Usando código con el control OLE DB. .......................................................................................... 89
Ejercicio 33 – Control Data con Archivos de Texto.............................................................................................. 89
Cuaderno de Trabajo Visual Basic con Base de Datos Página 2

Ejercicio 34 – Control Data con Archivos de Excel .............................................................................................. 91
Ejercicio 35 –Control Data con Imágenes OLE..................................................................................................... 92
Ejercicio 36 –Control Data con Imágenes Vinculadas ......................................................................................... 96
Ejercicio 37 –Control Data OLE DB con MySQL ................................................................................................. 102
Ejercicio 38 –Control Data OLE DB con MySQL y Strings................................................................................... 109
Ejercicio 39 - VideoLeccion 11: Introducción a Visual Basic 6.0 Con Base de Datos ......................................... 111
Ejercicio 40 - VideoLeccion 12: Registro de Usuarios y Sesión de Login ........................................................... 111
Ejercicio 41 - VideoLeccion 13: Registro de Usuarios y Sesión de Login ........................................................... 113
Ejercicio 42 - VideoLeccion 14: Modificar Registro de Usuarios ....................................................................... 113
Ejercicio 43 - VideoLeccion 15: Búsqueda de Registro de Usuario ................................................................... 113
Ejercicio 44 – BD Consulta SQL .......................................................................................................................... 114
PRACTICAS 6 – 10 .................................................................................................................................................. 114
Ejercicio 45 – Ordenando una tabla .................................................................................................................. 115
Leccion 46 - VideoLeccion 16: Relacionando Tablas - Mantenimiento Completo de Clientes ......................... 117
Leccion 47 - VideoLección 17: Mantenimiento Productos ................................................................................ 117
Ejercicio 48 – BD Varias Tablas .......................................................................................................................... 117
Ejercicio 49 – BD Suma con SQL ........................................................................................................................ 118
Ejercicio 50 – BD Funciones con SQL ................................................................................................................. 119
Ejercicio 51 – BD Visor de SQL ........................................................................................................................... 119
Ejercicio 52 – BD Consultas SQL ........................................................................................................................ 121
Ejercicio 53 – BD con DAO ................................................................................................................................. 122
Ejercicio 54 – BD con DAO validacion de campos ............................................................................................. 124
Ejercicio 55 – BD Crystal Report ........................................................................................................................ 129
Leccion 56 - VideoLección 21: Reportes simples y con parámetros ................................................................. 130
Leccion 57 - VideoLección 22: Reporte de Factura ........................................................................................... 130
Leccion 58 - VideoLección 23: Reportes Avanzandos usando dos o más tablas ............................................... 131
Leccion 59 - VideoLección 24: Últimos Arreglos, Empaquetado y distribución ................................................ 131

INTRODUCCION
Este es el Apendice A o Cuaderno de Trabajo II de Visual Basic. Es la continuacion del primer cuaderno el cual
esta lleno de ejercicios practicos llamados Actividades de Aprendizaje. A diferencia de los ejercicios (los cuales
son paso a paso) y las practicas (que no se da ninguna solucion), estos ejercicios contienen una imagen del
resultado y el codigo que debe ser tecleado. No asi, las propiedades de los controles y otros elementos graficos.
Estos ejercicios fueron tomados de Visual Basic Programacion para Docentes y agradezco a Mirta Echeverria y
Manuel Perez Valdez quienes tienen una excelente pagina de ejercicios. Sin embargo, hubo que clasificarlos en
bloques de temas para llevaran un orden de aprendizaje de acuerdo a la mayoria de los cursos de Visual Basic.
Por lo que dicha atribucion es nuestra.
Recomendamos ampliamente consultar los dos Cuadernos de Trabajo, asi como su Guia de Estudio.
Y tomar las notas resumidas en las clases presenciales de su profesor.

EJERCICIOS SOBRE EL ARCHIVOS
A continuacion se presentan algunos ejemplos de manejo de archivos simples con Visual Basic. Algunos archivos
de tipo texto, documento o configuracion que son usados por algunas aplicaciones.

Ejercicio 06 – Texto y RTF
En este Ejercicio vamos a ver como hacemos para directamente desplegar un texto ya copiado y
grabado en un archivo con extensión TXT, que podemos tipear en cualquier editor como el NotePad,
por ejemplo y otro texto con formato RTF (Rich Text File, o sea archivo de texto enriquecido) . Este
formato puede grabarse en el Word, vamos a grabar como... y allí seleccionamos RTF.
Se llama texto enriquecido porque permite incluir distintos tipos de letras, colores y tamaños o sea
más variantes en su formato. Y el control que vamos a usar para desplegar este texto con formato RTF
es el RichTextBox 8es un control no estándar, por lo tanto debemos traerlo de Componentes), para el
texto común o sea con formato TXT, usaremos un TextBox de la caja de herramientas estandar. El
formulario tendrá el siguiente aspecto:
Tenemos dos controles para desplegar el texto: un Text1 y un RichTextBox1, y dos botones en cuyos
eventos Click se desplegarán por código los archivos mencionados en los controles de texto. Primero
debemos crear un archivo en el NotePad o en el Word y grabarlo como TXT y otro con variaciónes en el
tipo, color y tamaño de la letra y grabarlo como rtf. Luego abrimos visual y en creamos un nuevo
proyecto grabandolo en el mismo directorio y carpeta que tenemos los archivos: txt y rtf. El código de
cada botón es el siguiente:
Option Explicit 'Esta expresión nos fuerza a declarar las variables.
Private Sub Command1_Click() 'Este boton es el que carga el 'archivo TXT

Dim pepe As String 'Declaramos una variable para identificar el 'archivo
Dim renglon As String 'Esta variable guardará el tamaño de 'cada renglón del archivo
renglon = Chr(13) & Chr(10) ' corta a otra línea
Text1.Text = "" Open App.Path & "\rtf.txt"
For Input As #1
' Abre (Open) y da
'entrada (Input) el archivo
'ubicado en el mismo directorio y carpeta en que está la
'aplicación. App.path significa en la ruta actual de la'aplicación.
'Sino hay que indicar cual es el Path.
While Not EOF(1)
' esto realiza un bucle o sea repite la acción
'hasta que se llegue al final del archivo 1 (End of File)

Line Input #1, pepe$
' le da entrada a la linea 1 del archivo
Text1.Text = Text1.Text & pepe & renglon
'concatena con & el 'texto del archivo y el tamaño del reglón.
Wend
'repite las ordenes en tanto la condición es verdadera, en
'este caso hasta tanto no termine el texto del archivo.
Close #1
' cierra el archivo al terminar de cargarlo.
End Sub
Private Sub Command2_Click()

RichTextBox1.LoadFile (App.Path & "\rtf.rtf")
'como podemos 'ver con el Control RichTextBox es más sencillo el manejo de
'archivos, con la sentencia LoadFile se carga el archivo
'indicando el camino para encontrarlo.
End Sub
Ejercicio 07 – Leer datos desde un archivo
Este ejercicio es para repasar como leemos un archivo de texto usando la instrucción INPUT.
Primeramente creamos una interfaz como la siguiente:
La cual contiene una caja de texto, botones de comando y un frame para enmarcar el diseño.
La caja de texto tiene la propiedad Multiline = true, y la propiedad Scrollbars como 2 – Vertical.
Ahora he aquí el codigo a teclear:
En el boton de salir:
Unload Me

En el boton de Borrar TextBox
' Borramos el contenido de text1
Text1 = ""
Y en el boton de Cargar Archivo:
' Esta variable contendrá el path del archivo que queremos acceder
Dim Archivo As String
' Linea almacenará los datos del archivo "Historia.txt"
Dim Linea As String
' Asignamos a la variable Archivo la ruta correcta. El objeto _
App.Path nos devuelve el directorio donde se encuentra nuesta _
aplicación. Luego le agregamos la barra invertida y el nombre _
del archivo.
Archivo = App.Path & "\" & "Historia.txt"
' Abrimos el archivo con la variable Archivo, y como el acceso será de lectura _
utilizamos el modo Input seguido del número de archivo "#1"
Open Archivo For Input As #1
' Creamos un bucle para controlar que después de llegar al final del archivo _
la sentencia Input, no continue leyendo y se produzca un error en tiempo de eje _
cucíon. Para ello utilizamos la condición Not EoF(1), que traducido quiere decir _
mientras no llegue al final del archivo, que continúe leyendo línea por línea. _
' Dentro del bucle asignamos al control Text1 el valor de la variable Linea mas _

el contenido que ya estaba guardado en el text box, Por que de lo contrario, el text Box _
solo mostraría el último contenido de la variable "Linea"
While Not EOF(1)
Line Input #1, Linea
Text1.Text = Text1.Text & Linea
Wend
' Cerramos el archivo
Close #1
Ejercicio 08 – Usar output para grabar un archivo
Este ejercicio utiliza la instrucción OUTPUT para crear un archivo y grabar la informacion.
Los controles que lleva son:
a) 2 Cajas de texto
b) 1 boton de comando
c) Etiquetas
d) Frame
e) Un control de timer para que muestre la hora del sistema actual en tiempo real
Codigo

' Archivo que contendrá el path del archivo a usar
Dim archivo As String
'Asignamos el path al archivo con el objeto app.Path
archivo = App.Path + "\" + "HorayFecha.txt"
' Abrimos el archivo en modo Output
Open archivo For Output As #1
'Con las sentencia print escribimos en la primera linea el valor de text1 _
' Luego en la segunda linea egrabamos el contenido del text2
Print #1, Text1

Print #1, Text2
'Cerramos el archivo
Close #1
End Sub
Private Sub Timer1_Timer()

' Utilizamos un Control Timer para mostrar en los text el dia y la _
hora del sistema. La propiedad intervalo del control timer esta en 1000 milisegundos
Text1 = Time
Text2 = Date
End Sub

Ejercicio 09 – Usando APPEND para agregar informacion al archivo
Cuando no queremos eliminar un archivo existente podemos agregar informacion al archivo usando la
setencia APPEND del comando OPEN.
Controles:
a) Caja de texto
b) 3 botones de comando
c) Frame
Codigo:
' Definimos las variables

Dim texto As String
Dim mensaje As String
' asignamos a la variable archivo la ruta correcta
archivo = App.Path + "\" + "Prueba.txt"
' Asignamos a texto el contenido de text1

texto = Text1
' Abrimos el archivo en modo aPPend para agregar datos al _

archivo que ya contiene datos
Open archivo For Append As #1

' Escribimos un salto de carro y el contenido de la variable texto
Print #1, vbCrLf + texto

Close #1
' Creamos un mensaje para dar la opción de ver o no los cambios en el archivo _
con los nuevos datos agregados
mensaje = MsgBox("¿ Deseas ver ahora el contenido del archivo con,los datos agregados", vbYesNo +
vbInformation, "Consulta")
' Evaluamos la condicion. Si es verdadera abrimos el archivo para leerlo _

con la sentencia input
If mensaje = vbYes Then
Open archivo For Input As #1
Text1 = "" ' Borramos el contenido de text1 para que no vuelva _
a imprimir lo que estaba escrito
While Not EOF(1)
Line Input #1, texto
Text1 = Text1 + texto + vbCrLf
Wend
Else
Exit Sub
End If
Close #1
End Sub

' Limpiamos el contenido del text1
Text1 = ""
End Sub

End
End Sub

Ejercicio 10 – Creando archivos de configuracion para aplicaciones
Este ejercicio nos permite mostrar una pantalla de bienvenida al cargar una aplicación. Mediante un
control checkbox, podemos indicarle que muestre o no la misma pantalla las siguientes veces que
ejecutemos el programa. Se grabara entonces en un archivo de datos, dicho valor para que cuando se
ejecute el programa carguemos la pantalla de bienvenida o no. Un clasico ejemplo de muchos programas
de software cuando dan la bienvenida.
Necesitaras crear un proyecto con 2 formas, donde la primera es la pantalla de bienvenida (form1) y la
segunda es la aplicación (form2)
CONTROLES PARA FORM1
a) Etiqueta
b) Frame
c) CheckBox
d) Boton de comando

CONTROLES PARA FORM2
a) Etiqueta
b) Frame
c) Boton de comando
CODIGO PARA FORM1
' Esta variable almacena el path del archivo "Config.dat"


' Establecemos el path
archivo = App.Path & "\" & "Config.dat"
' Comprobamos si está presionado el control check1. Si lo está _

crea un archivo igual "config.dat" y escribe la cadena "noAbrir" _
, para que la próxima vez no muetre el formulario de bienvenida.
If Check1.Value = Checked Then

Open archivo For Output As #1
Print #1, "noAbrir"
Close ' Cierra el archivo
End If
Unload Me ' descarga este formulario
Form2.Show ' muestra el otro form
End Sub
Private Sub Form_Load()

Dim MiVAriable As String ' Variable para almacenar la cadena que se lea _
del archivo "config.dat"
archivo = App.Path & "\" & "Config.dat"

Open archivo For Input As #1 ' Abre el archivo para leerlo
Line Input #1, MiVAriable ' Almacenamos el valor

Close ' Cerramos el archivo
If MiVAriable = "noAbrir" Then ' Hacemos la comprobación
Unload Me
Form2.Show
End If
End Sub

Ejercicio 11 – Usando Write e Input
En este ejercicio usaremos la sentencia WRITE en lugar de la sentencia PRINT para grabar los datos
como campos. Se realizara una simulacion de agenda con varios campos, para grabar el archivo.
CONTROLES
1) 5 cajas de texto
2) Etiquetas
3) Botones de comando
4) Frame
5) Caja de lista (listbox)
CODIGO
' Variables globales para almacenar los datos cuando grabemos o leamos _
los mediante las sentencias write e input
Dim apellido As String
Dim nombre As String
Dim telefono As String
Dim direccion As String
Dim dni As String

'********************************************************* _
procedimientos
'*********************************************************
' Procedimiento para agregar datos separados por comas con la _

sentencia Write
Private Sub agregarEntrada(apellido As String, nombre As String, telefono As String, direccion As

String, dni As String)
' Las variables que van en los parámetros del procedimiento _
contienen el valor de los textBox
archivo = App.Path + "\" + "datos.dat" ' variable que almacena el path del archivo datos.dat
Open archivo For Append As #1 ' Abrimos el archivo en modo Append _
para agregar datos al final del archivo
Write #1, apellido, nombre, telefono, direccion, dni ' Grabamos los _
datos pasandole como parámetro a la sentencia Write las variables se _
paradas por comas
Close ' Cerramos el archivo
End Sub
' Procedimiento para leer los datos del archivo y mostrarlos en los _
textBox cuando hacemos click en un nombere del list1
Private Sub mostrarDatos()

Dim contador As Integer ' variable que almacena un valor que _
luego se comparará con la propiedad listindex del list1, para _
saber cuales son los datos que tenemos que recupera y mostrar _
las cajas de texto
archivo = App.Path + "\" + "datos.dat"
Open archivo For Input As #1 ' Abrimos el archivo para leer los datos _
mediante la sentencia Input
While Not EOF(1) ' Comenzamos a leer el archivo
Input #1, apellido, nombre, direccion, telefono, dni
If contador = List1.ListIndex Then ' if contador es igual al elemento _

que seleccionamos en el list, entonces imprimimos los valores y _
salimos de la rutina con Exit Sub. Si no es igual el contador se _
va incrementando en 1 hasta que en algun punto coincide con el _
numero del elemento seleccionado

texApe.Text = apellido
texNom.Text = nombre
texDir.Text = direccion
texDni.Text = dni
texTel.Text = telefono
Close
Exit Sub
End If
contador = contador + 1
Wend
Close
End Sub
Private Sub cargarDatos()

List1.Clear ' Borramos los datos previos para que no vuelva a duplicar los datos
archivo = App.Path + "\" + "datos.dat"
Open archivo For Input As #1

While Not EOF(1) ' Mientras no se llegue al fin de archivo que _
valla recuperando los datos y agregue solo el apellido en el _
control List
Input #1, apellido, nombre, direccion, telefono, dni
List1.AddItem apellido
Wend
Close
End Sub

On Error GoTo mensaje
cargarDatos ' Llamamos a la rutina para cargar los datos

Exit Sub
mensaje:
MsgBox "No hay datos para cargar", vbInformation + vbOKOnly, "Mensaje"
End Sub

' Esta rutina es para que no se puedan grabar datos si el _
campo "Apellido" está vacío, mostrando un mensaje y luego sali _
endo de la rutina. Si esta todo bien ignora lo anterior y se eje _
cuta la rutina "agregarEntrada", que lleva como parámetros el con _
tenido de las cajas de texto
If texApe.Text = "" Then

MsgBox "El campo Apellido no puede estar vacio", vbInformation + vbOKOnly, "Advertencia"
Exit Sub
End If
agregarEntrada texApe, texNom, texDir, texTel, texDni
End Sub
Private Sub List1_Click()

mostrarDatos 'Llamamos a la rutina que recupera los datos cada vez que seleccio _
namos un elemento del control List1
End Sub
Ejercicio 12 – Usando archivos aleatorios
Este simple programa muestra como grabar datos y recuperar los mismos en un archivo Aleatorio. El
programa consta de 2 procedimientos principales. Uno llamado "grabarDatos", que grabará los datos en
el archivo "datos.dat". Los parámetros que lleva este procedimiento son los valores de los textBox.
Cuando presionemos el botón "grabar", se llamará al procedimiento y grabará los datos en el n° de

registro que hayamos seleccionado en el combo1. Este combo está cargado con numeros del 1 al 100.
El procedimiento "leerDatos" recuperará los datos del registro que especifiquemos en el combo2.

CONTROLES
1) Cajas de texto
2) Etiquetas
3) Caja combo (combobox)
4) Frame
5) Boton de comando
CODIGO
'Aquí declaramos una estructura de datos con tres campos de longi _

tud fija. O sea que cada registro que grabemos tendrá el tamaño de _
50 bytes.
Private Type T_personas

Apellido As String * 20
Nombre As String * 20
edad As String * 10
End Type
'Esta variable está asociada a la estructura T_personas, que luego _

nos servirá para grabar o leer datos en el archivo datos.dat
Dim persona As T_personas

'Esta variable almacenará el valor del combo para obtener el n° de regis _
tro donde grabar o leer datos
Dim nRegistro As Integer
'
' Pasamos los parámetros de los textBox al procedimiento que grabará _
los datos
grabarDatos Texape, Texnom, Texedad
End Sub

'Llamamos al procedimiento para leer los datos del archivo
leerDatos
End Sub

' Aquí cargamos los combos con valores del 1 al 100 cuando inicia el form
Dim x As Integer
For x = 1 To 100

Combo1.AddItem x
Combo2.AddItem x
Next x
End Sub
' Procedimiento para grabar registros

Private Sub grabarDatos(Apellido As String, Nombre As String, edad As String)
'Abrimos el archivo en modo aleatorio y le pasamos el tamaño de la _

estructura
Open App.Path + "\" + "datos.dat" For Random As #1 Len = Len(persona)
'Asignamos a los campos de la extructura Type los valores que recibe _

de los parámetros del procedimiento y que contiene los valores de los textBox
persona.Apellido = Apellido
persona.Nombre = Nombre
persona.edad = edad
' Almacenamos aquí el numero de registro donde grabar los datos

nRegistro = Combo1.Text
' Grabamos los datos

Put #1, nRegistro, persona

Close
End Sub
Private Sub leerDatos()
'Abrimos el archivo en modo aleatorio y le pasamos el tamaño de la

' Almacenamos aquí el numero de registro de donde leer los datos

' Leemos los datos y los almacenamos en la variable "Persona"

Get #1, nRegistro, persona
Close
' Mostramos en los labels los valores leidos

Lblape = persona.Apellido
Lblnom = persona.Nombre

Lbledad = persona.edad
End Sub
Ejercicio 13 – Usando archivos aleatorios y registros
Este ejercicio es igual al ejercicio anterior con el agregado de un botón que comprueba cuantos registros
tenemos grabados en el archivo “datos.dat" utilizando para ello la función FileLen
CODIGO
'Acá declaramos una estructura de datos con tres campos de longi tud fija.
'O sea que cada registro que grabemos tendrá el tamaño de 50 bytes.
Private Type T_personas

Apellido As String * 20
Nombre As String * 20
edad As String * 10
End Type
'Esta variable está asociada a la extructura T_personas, que luego _

nos servirá para grabar o leer datos en el archivo datos.dat
Dim persona As T_personas
'Esta variable almacenará el valor del combo para obtener el n° de regis _

tro donde grabar o leer datos
Dim nRegistro As Integer

' Pasamos los parámetros de los textBox al procedimiento que grabará los datos
grabarDatos Texape, Texnom, Texedad
End Sub

'Llamamos al procedimiento para leer los datos del archivo
leerDatos
End Sub

Dim tamaño As Integer
tamaño = FileLen(App.Path & "\" + "datos.dat") / Len(persona)

MsgBox "El archivo datos.dat contiene: " & tamaño & " registros", vbInformation + vbOKOnly
End Sub

'Cargamos los combos con valores del 1 al 100 cuando inicia el form
Dim x As Integer
Open App.Path & "\" + "datos.dat" For Random As #1 Len = Len(persona)

Close
For x = 1 To 100
Combo1.AddItem x
Combo2.AddItem x
Next x
End Sub
' Procedimiento para grabar registros

Private Sub grabarDatos(Apellido As String, Nombre As String, edad As String)
'Abrimos el archivo en modo aleatorio y le pasamos el tamaño de la _
estructura de datos
'Asignamos a los campos de la estructura Type los valores que recibe _

de los parámetros del procedimiento y que contiene los valores de los textBox
persona.Apellido = Apellido
persona.Nombre = Nombre
persona.edad = edad
' Almacenamos en nRegistro el numero de registro donde grabar los datos

' Grabamos los datos

Put #1, nRegistro, persona

Close
End Sub
Private Sub leerDatos()
'Abrimos el archivo en modo aleatorio y le pasamos el tamaño la estructura

' Almacenamos el numero de registro de donde leer los datos

' Leemos los datos y los almacenamos en la variable "Persona"

Get #1, nRegistro, persona
Close
' Mostramos en los labels los valores leidos

Lblape = persona.Apellido
Lblnom = persona.Nombre
Lbledad = persona.edad
End Sub

Ejercicio 14 – Ecuacion de 2º. Grado
Este ejercicio utiliza funciones matemáticas como cálculo de raíz cuadrada. Y un control especial
CommonDialog que convoca a las ventanas estándar de Windows, que asociados a los métodos Put y
Get nos permiten Abrir y Guardar un fichero como txt. El código del ejercicio es el siguiente:
Dim a As Single, b As Single, c As Single 'Variable de los Datos

Dim x1 As Single, x2 As Single 'Variable de las respuestas
Dim del As Single 'Variable para los sumandos dentro del radical
Private Sub cmdCalcular_Click()
del = (b ^ 2 - 4 * a * c)
If del >= 0 Then 'Si las raíces son reales e iguales
x1 = (-b + Sqr(del)) / (2 * a)
x2 = (-b - Sqr(del)) / (2 * a)
txtX1.Text = Format(x1, "###,##0.00")
txtX2.Text = Format(x2, "###,##0.00")
Else 'Si son complejas
x1 = Format((-b) / (2 * a), "###,##0.00")
x2 = Format((Sqr(-del)) / (2 * a), "###,##0.00")
txtX1.Text = x1 & " + " & x2 & " i"
txtX2.Text = x1 & " - " & x2 & " i"
End If
End Sub
Private Sub cmdSalir_Click()

End
End Sub

'Inicializar las variables
a=1
b=2
c=1
'Inicializar las cajas de texto

txtA.Text = a
txtB.Text = b
txtC.Text = c
End Sub
Private Sub mnuAbrir_Click()

Dim Fichero As String 'Variable para el nombre del Fichero
CommonDialog1.Action = 1 'Ventana Abrir
Fichero = CommonDialog1.FileName
If Fichero = "" Then
Exit Sub
Open Fichero For Random As #1 'Abrir el Fichero
'Tomar los valores del Fichero
Get #1, 1, a
Get #1, 2, b
Get #1, 3, c
Get #1, 4, x1
Get #1, 5, x2
Close #1
'Asignar los valores a las cajas de texto.
txtA.Text = a
txtB.Text = b
txtC.Text = c
cmdCalcular_Click 'Mandar a calcular
End Sub
Private Sub mnuSalvar_Click()

Dim Fichero As String
If Fichero = "" Then
mnuSalvarComo_Click
Exit Sub
End If
Open Fichero For Random As #1 'Abrir el Fichero.
'Guardar el valor de las variables en el Fichero.
Put #1, , a
Put #1, , b
Put #1, , c
Put #1, , x1
Put #1, , x2
Close (1)
End Sub
Private Sub mnuSalvarComo_Click()

Dim Fichero As String
CommonDialog1.Action = 2 'Abrir la ventana Salvar como.
Fichero = CommonDialog1.FileName
If Fichero = "" Then Exit Sub
Open Fichero For Random As #1 'Abrir el Fichero.
'Guardar el valor de las variables en el Fichero.
Put #1, , a
Put #1, , b
Put #1, , c
Put #1, , x1

Put #1, , x2
Close (1)
End Sub
Private Sub txtA_LostFocus()

If IsNumeric(txtA.Text) Then 'Si el dato es numérico
a = txtA.Text 'Asignar el valor del TextBox a la variable
Else
MsgBox "Valor incorrecto", vbInformation
txtA.SetFocus 'Poner el foco en el TextBox
End If
End Sub
Private Sub txtA_Change()

'Limpiar los resultados si hay un cambio de dato en el texto.
txtX1.Text = ""
txtX2.Text = ""
End Sub
Private Sub txtA_GotFocus()

'Seleccionar los textos
txtA.SelStart = 0
txtA.SelLength = Len(txtA.Text)
End Sub
Private Sub txtB_Change()

txtX1.Text = ""
txtX2.Text = ""
End Sub
Private Sub txtB_GotFocus()

txtB.SelStart = 0
txtB.SelLength = Len(txtB.Text)
End Sub
Private Sub txtB_LostFocus()

If IsNumeric(txtB.Text) Then
b = txtB.Text
Else
txtB.SetFocus
End If
End Sub
Private Sub txtC_Change()

txtX1.Text = ""
txtX2.Text = ""
End Sub
Private Sub txtC_GotFocus()

txtC.SelStart = 0
txtC.SelLength = Len(txtC.Text)
End Sub

Private Sub txtC_LostFocus()
If IsNumeric(txtC.Text) Then
c = txtC.Text
Else
txtC.SetFocus
End If
End Sub
Ejercicio 15 – Agenda
Agenda muy simple en Visual basic utilizando Ficheros de acceso aleatorio o también denominados Random ,
para almacenar los datos de los contactos de la Agenda.
Una vista del ejemplo:
Para manipular los datos se utiliza una estructura o UDT que tiene las siguientes variables:

1. ' Estructura para los datos de los contactos de la agenda
2. Private Type Contacto
3. Nombre As String * 40
4. Apellido As String * 50
5. Telefono As String * 40
6. Mail As String * 70
7. Nota As String * 250
8. End Type
Como se puede ver en la imagen, tiene una opción para buscar un registro y especificar por que
campo buscar, ya sea por el nombre del contacto, el Apellido, el telefono o el correo electrónico.
Pasos a seguir para armar el formulario con los controles:
Agregar en un Formulario 6 controles TextBox con los siguiente nombres:
1. txtNombre
2. txtApellido
3. txtTelefono
4. txtMail
5. txtNota
6. txtBuscar
Luego agregar 7 CommandButton con los siguientes nombres:
1. CmdAnterior : Botón para ir al anterior registro

2. cmdSiguiente : Botón para ir al siguiente registro
3. cmdGuardar : Botón para guardar los cambios cuando se seleccionó previamente la opción
Nuevo Registro
4. cmdEliminar: Elimina el registro actual
5. cmdNuevo : Añade un nuevo reg
6. cmdBuscar : Para buscar
7. Cmdsalir : Descarga el Form
Ahora, agregar un control ComboBox llamado Combo1. A este combo, establecerle en la

propiedad Style el valor 2 ( DropDownList ) y agregarle los siguientes valores en la propiedad
List: Nombre, Apellido, Telefono e Mail en ese orden
Nota: Para agregar datos en la propiedad List desde la ventana de propiedades, debes mantener la
tecla Ctrl presionada y presionar la tecla Enter para añadir un nuevo dato o Item.
Por último, agregar un control Label llamado lblStatus que servirá para poder mostrar cuando
nos desplazamos por los registros, con los botones anterior y siguiente, el número del registro
actual y la cantidad de registros que hay en el archivo. Este Label lo puedes situar en la parte
inferior del formulario o donde quieras.

Colocar el código fuente en el formulario:
1. Option Explicit
2.
3. 'Variables
4. '##################################################
5.
6. ' Estructura para los datos de los contactos de la agenda
7. Private Type Contacto
8. Nombre As String * 40
9. Apellido As String * 50
10. Telefono As String * 40
11. Mail As String * 70
12. Nota As String * 250
13. End Type
14.
15. 'Variables para utilizar la estructura anterior
16. Dim Datos As Contacto
17. Dim DatosTemp As Contacto
18.
19. 'Variables para el archivo de los datos de contacto y temporal
20. Dim FileFree As Integer
21. Dim FileTemp As Integer
22.
23. 'Variables para la posición del primer y último registro
24. Dim RegActual As Long
25. Dim RegUltimo As Long
26. ' Variable para la posición Temporal del registro
27. Dim RegActualTemp As Long
28.
29. Dim Pos As Integer, p As Integer
30.
31.
32.
33.
34. '######################################################
35. 'Funciones y procedimientos
36. '######################################################
37.
38.
39.
40. ' Subrutina que guarda los datos en el archivo
41. '#############################################
42.
43. Private Sub GuardarDatos()
44.
45. 'Asignamos los datos de la estructura con el contenido de los textBox
46. With Datos
47.
48. .Nombre = txtNombre.Text
49. .Apellido = txtApellido
50. .Telefono = txtTelefono.Text
51. .Nota = txtNota.Text
52. .Mail = Trim(txtMail)
53.
54. End With
55.
56. 'Escribimos los datos en el archivo y en la posición
57. Put #FileFree, RegActual, Datos
58. End Sub
59.

60. ' Subrutina que Visualiza los datos en los textBox
61. '##################################################
62.
63. Private Sub VisualizarDatos()
64.
65. 'Lee del fichero en el registro posicionado y almacena los datos_ _
66. en la la variable UDT
67. Get #FileFree, RegActual, Datos
68.
69. ' Mostramos los datos en las cajas de texto
70. With Datos
71. txtApellido = Trim(.Apellido)
72. txtNombre = Trim(.Nombre)
73. txtTelefono = Trim(.Telefono)
74. txtMail = Trim(.Mail)
75. txtNota.Text = Trim(.Nota)
76. End With
77.
78. 'Mostramos en el control Label la posición del registro actual _
79. y la cantidad o Total de registros que hay en el archivo
80. lblStatus.Caption = "Registro Actual: " & CStr(RegActual) & vbNewLine _
81. & " Total de registros: " & CStr(RegUltimo)
82.
83. End Sub
84.
85. 'Botón que elimina un registro del archivo
86. '############################################
87.
88. Private Sub cmdEliminar_Click()
89.
90. Pos = RegActual
91.
92. If MsgBox(" Está seguro de eliminar el contacto ? ", vbYesNo) = vbNo Then
93.
94. txtNombre.SetFocus
95.
96. Exit Sub
97. End If
98.
99. ' Verificamos que el archivo temporal no exista, si existe se elimina
100. If Dir("Temporal.tmp") = "Temporal.tmp" Then
101. Kill "Temporal.tmp"
102. End If
103.
104. FileTemp = FreeFile
105. 'Abrimos y creamos un nuevo fichero temporal
106. Open "Temporal.tmp" For Random As FileTemp Len = Len(DatosTemp)
107.
108. RegActual = 1
109. RegActualTemp = 1
110.
111. 'Se recorren los registros del archivo
112.
113. For p = 1 To RegUltimo - 1
114.
116.
117. 'Este es el registro que se elimina
118. If RegActualTemp = Pos Then
119. RegActual = RegActual + 1
120. End If

121.
123.
124.
125. With DatosTemp
126. .Apellido = Trim(Datos.Apellido)
127. .Nombre = Trim(Datos.Nombre)
128. .Telefono = Trim(Datos.Telefono)
129. .Mail = Trim(Datos.Mail)
130. .Nota = Trim(Datos.Nota)
131. End With
132.
133. 'Escribe en el archivo temporal los datos
134.
135. Put #FileTemp, RegActualTemp, DatosTemp
136.
138. RegActualTemp = RegActualTemp + 1
139.
140. Next
141.
142.
143. Close FileFree
144. 'Elimina el archjivo con los datos
145. Kill "Datos.dat"
146. Close FileTemp
147.
148. 'Renombra el archivo temporal a datos.dat
149. Name "Temporal.tmp" As "Datos.dat"
150.
151.
152. ' Mostramo los datos en los textbox
153. Cargar
154. RegActual = Pos
155. VisualizarDatos
156.
157. End Sub
158.
159. Private Sub cmdGuardar_Click()
160. GuardarDatos
161. End Sub
162.
163. Private Sub Cmdsalir_Click()
164. 'Guarda los cambios en el archivo antes de salir
165. GuardarDatos
166.
167. 'cierra el archivo abierto
168. Close #FileFree
169. End
170. End Sub
171.
172. Private Sub form_load()
173.
174. 'Carga el primer registro del archivo
175. Cargar
176. 'Selecciona en el combo para la búsqueda de datos
177. Combo1 = Combo1.List(0)
178.
179. Cargarcaptions
180.
181. End Sub

182. Private Sub Cargar()
183.
184. FileFree = FreeFile
185. Open "Datos.dat" For Random As FileFree Len = Len(Datos)
186.
187. RegActual = 1
188. ' Almacenamos la posición del último registro
189. RegUltimo = LOF(FileFree) / Len(Datos)
190.
191. If RegUltimo = 0 Then
192. RegUltimo = 1
193. End If
194.
195. 'Cargamos los datos en los Textbox
197. End Sub
198.
199. 'Botón que agrega un nuevo registro
200. '#####################################
201.
202. Private Sub cmdNuevo_click()
203.
204. RegUltimo = RegUltimo + 1
205.
206.
207. 'Limpia los datos de la estructura para poder agregar un nuevo registro
208. With Datos
209. .Apellido = ""
210. .Nombre = ""
211. .Telefono = ""
212. .Mail = ""
213. .Nota = ""
214.
215. End With
216.
217. ' Graba datos vacios en el nuevo registro hasta que se presione el botón
_
218. Guardar que graba los verdaderos datos
219. Put #FileFree, RegUltimo, Datos
220.
221. RegActual = RegUltimo
222.
223.
226. End Sub
227.
228.
229. 'Botón para posicionar en el siguiente registro
230. '##############################################
231.
232.
233. Private Sub cmdSiguiente_click()
234.
235. If RegActual = RegUltimo Then
236. MsgBox " Ultimo registro ", vbInformation
237. Else
238. 'Incrementa la posición
240. 'Cargamos los datos en el textbox del siguiente registro

242. End If
244. End Sub
245.
246. 'Botón para posicionar en el Anterior registro
247. '##############################################
248.
249. Private Sub CmdAnterior_click()
250.
251. If RegActual = 1 Then
252. MsgBox " Primer registro ", vbInformation
253. Else
254. 'Decrementamos la variable que mantiene la posición del registro actu
al
255. RegActual = RegActual - 1
256. 'Mostramos los datos en las cajas de texto
258. End If
259.
261.
262. End Sub
263.
264. 'Botón para Buscar datos
265. '##############################################
266.
267. Private Sub cmdBuscar_click()
268.
269. Dim Encontrado As Boolean, PosReg As Long, tmp As Contacto
270.
271. If txtBuscar = "" Then txtNombre.SetFocus: Exit Sub
272.
273. Encontrado = False
274.
275. 'Recorremos desde el primer hasta el último en busca del registro a busca
r
276.
277. For PosReg = 1 To RegUltimo
278.
279. 'Leemos el registro
280. Get #FileFree, PosReg, tmp
281.
282. 'Si es el dato es igual salimos del bucle
283. If UCase(txtBuscar) = UCase(Trim(BuscarPor(tmp))) Then
284. Encontrado = True
285. Exit For
286. End If
287.
288. Next
289.
290. If Encontrado Then
291.
292. RegActual = PosReg
293. 'Cargamos los datos en los text
295.
296. Else
297. MsgBox "Nombre: " & txtBuscar & " No se ha encontrado el registro"
298. End If
300.

301. End Sub
302.
303. 'Función que retorna el valor de la búsqueda
304. '#############################################
305.
306. Private Function BuscarPor(t As Contacto)
307.
308. Select Case Combo1.ListIndex
309.
310. Case 0: BuscarPor = t.Nombre
311. Case 1: BuscarPor = t.Apellido
312. Case 2: BuscarPor = t.Telefono
313. Case 3: BuscarPor = t.Mail
314.
315. End Select
316.
317. End Function
318.
319. ' Establece los captions de los controles Command del formulario
320.
321. Private Sub Cargarcaptions()
322. Me.Caption = " Agenda simple utilizando archivos aleatorios "
323. CmdAnterior.Caption = " Anterior "
324. cmdSiguiente.Caption = " Siguiente "
325. cmdGuardar.Caption = " Guardar "
326. cmdEliminar.Caption = " Eliminar "
327. cmdNuevo.Caption = " Nuevo "
328. cmdBuscar.Caption = " Buscar "
329. Cmdsalir.Caption = " Salir "
330. End Sub
Ejercicio 16 – Editor de texto con RTF
Este es un código fuente de un editor de texto muy simple tipo Bloc de notas.
El ejemplo es de lo mas fácil, ya que utiliza el control RichTextBox , y en realidad este control hace
casi todo por si solo, por ejemplo para leer un archivo y cargarlo en el RichTextBox se utiliza el
método LoadFile, y para Guardar en disco el Método SaveFile ( En el código está mas o menos
comentado los parámetros de dichas funciones y métodos).
El ejemplo tiene opciones para Crear , Abrir y Guardar los archivos en varias extenciones ( las
soportadas por el RichTextBox).
Los comandos clásicos de Cortar , Copiar, Pegar texto etc... También para Colorear la fuente
seleccionada en el control, Imprimir el documento, Aplicar algunos Atributos al texto (
Negrita, subrayado, Cursiva), en fin, se le pueden agregar infinidad de opciones extras.
Nota: Lo ideal es crearle un menú clásico " Menú Archivo ", " Menú Edición " etc..., y los botones
hacerlos con un Toolbar por ejemplo, ya sea utilizando el control toolBar del visual basic o
fabricandose una barra propia, ya que el ejemplo solo utiliza botones CommandButton para las

opciones, para que sea un poco mas entendible. Y otra cosa también usar un formulario MDI para
tener multiples documentos abiertos en la misma aplicación
A continuación se describen los pasos para crear el ejemplo:
Agregar los siguiente controles en un formulario:
• Un control Commondialog llamado Commondialog

• Un control RichTextBox llamado RichTextBox
• Un CommandButton llamado cmdOpcion, y en la propiedad index colocarle el valor 0, para
formar un array y poder crear los demás en tiempo de ejecución
Nota: Colocar los controles en cualquier posición de la pantalla y no colocarles nada en el Caption
ni el tamaño ni nada, ya que se hace por código, es decir se les asigna el caption y se
redimensionan en tiempo de ejecución .
Pegar el código en el formulario
1. Option Explicit
2.
3.
4. Const FILTRO_EXTENSIONES As String = "Archivos de texto (txt)|*.txt|" & _
5. "Rich Text Formato (RTF)|*.rtf|" & _
6. "Archivos INI|*.ini|Archivos HTML|" & _
7. "*.htm|Todos los archivos|*.*"
8.
9. Private Sub Iniciar()
10. Dim i As Integer
11.
12. 'Acomodamos el primer botón en la esquina superior izquierda
13. cmdOpcion(0).Move 50, 10, 1000, 250
14.
15. For i = 1 To 10
16. Load cmdOpcion(i)
17. cmdOpcion(i).Visible = True
18. Next
19.
20. 'Caption de los CommandButton para las opciones
21. With cmdOpcion
22. .Item(0).Caption = "Nuevo"
23. .Item(1).Caption = "Abrir"
24. .Item(2).Caption = "Guardar"
25. .Item(3).Caption = "Cortar"
26. .Item(4).Caption = "Copiar"
27. .Item(5).Caption = "Pegar"
28. .Item(6).Caption = "Bold"
29. .Item(7).Caption = "Italic"
30. .Item(8).Caption = "Underlined"
31. .Item(9).Caption = "Imprimir"
32. .Item(10).Caption = "Color"

33. End With
34.
35. ' Va posicionando un botón al lado del otro
36. For i = 1 To cmdOpcion.Count - 1
37. cmdOpcion(i).Move cmdOpcion(i - 1).Width * i, 10, 1000, 250
38. Next
39. End Sub
40.
41. Private Sub cmdOpcion_Click(Index As Integer)
42. On Error GoTo men
43.
44. Dim ret As VbMsgBoxResult, cnt As Long
45.
46. Select Case Index
47. ' crear un Nuevo archivo
48. '''''''''''''''''''''''''
49. Case 0
50. ret = MsgBox("Guardar el archivo?", vbQuestion + vbYesNo, App.Title)
51. If ret = vbYes Then
52. RichTextBox.Text = ""
53. 'guardamos el archivo
54. GuardarArchivo
55. End If
56. 'Limpiamos el RichTextBox
57. RichTextBox.Text = ""
58.
59. 'Para Abrir un Archivo con el CommonDialog
60. '''''''''''''''''''''''''''''''''''''''''''''
61. Case 1
62. Call Abrir_Archivo
63. 'Para Guardar un Archivo
64. '''''''''''''''''''''''''''
65. Case 2
66. Call GuardarArchivo
67. 'Opción Para cortar el Texto del RichTexBox Seleccionado
68. ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
69. Case 3
70. 'Pegamos en el portapapeles de windows con ClipBoard
71. Clipboard.SetText RichTextBox.SelText
72. 'Eliminamos lo seleccionado en el RichTextBox
73. RichTextBox.SelText = ""
74. 'Copiar al Clipboard
75. '''''''''''''''''''''''''
76. Case 4
77. Clipboard.SetText RichTextBox.SelText
78. 'Pegar el contenido del portapapeles en el RichTextBox
79. ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
80. Case 5
81. RichTextBox.SelText = Clipboard.GetText
82. 'Texto en negrita con la propiedad SelBold
83. ''''''''''''''''''''''''''''''''''''''''''''
84. Case 6
85. RichTextBox.SelBold = Not RichTextBox.SelBold
86. ' Aplica Italic al texto seleccionado
87. ''''''''''''''''''''''''''''''''''''''''
88. Case 7
89. RichTextBox.SelItalic = Not RichTextBox.SelItalic
90. ' Aplica Underline al texto seleccionado
91. '''''''''''''''''''''''''''''''''''''''''
92. Case 8
93. ' Texto en cursiva

94. RichTextBox.SelUnderline = Not RichTextBox.SelUnderline
95. ' Imprimir el contenido del RichTextBox
96. '''''''''''''''''''''''''''''''''''''''''
97. Case 9
98. 'Titulo del diálogo Imprimir
99. CommonDialog.DialogTitle = "Seleccionar impresora"
100. ' Abre el commondialog para seleccionar impresora
101. CommonDialog.ShowPrinter
102. ' imprimimos el archivo
103. RichTextBox.SelPrint CommonDialog.PrinterDefault, rtfText
104.
105. 'Color del texto
106. ''''''''''''''''''''''
107. Case 10
108. On Error Resume Next
109. CommonDialog.DialogTitle = "Seleccionar color para el texto"
110. 'Abrimos el commondialog
111. CommonDialog.ShowColor
112. 'Establecemos el color en el Texto seleccionado del RichTextBox
113. RichTextBox.SelColor = CommonDialog.Color
114. End Select
115.
116. Exit Sub
117. men:
118. If Err.Number = 424 Then Resume Next
119. End Sub
120.
121. '* Subrutia para guardar el archivo en disco
122. '''''''''''''''''''''''''''''''''''''''''''''''''''''''
123. Private Sub GuardarArchivo()
124.
125. 'Titulo del cuadro de diálogo y otras opciones
126. With CommonDialog
127. .DialogTitle = "Guardar Archivo"
128. .Filter = FILTRO_EXTENSIONES
129.
130. 'Abre el Common Dialog guardar
131. .ShowSave
132. If .FileName = "" Then Exit Sub
133. If .FilterIndex = 2 Then
134. RichTextBox.SaveFile .FileName
135. Else
136. RichTextBox.SaveFile .FileName, rtfText
137. End If
138. End With
139. End Sub
140.
141. '* Sub para Abrir un archivo del disco
142. '''''''''''''''''''''''''''''''''''''''''''''''''''''
143. Private Sub Abrir_Archivo()
144. Dim ret As VbMsgBoxResult
145.
146. If RichTextBox <> "" Then
147. ret = MsgBox(" Guardar el archivo ?", vbQuestion + vbYesNo, App.Titl
e)
148. 'Si elegimos si, entonces guardamos el archivo
149. If ret = vbYes Then GuardarArchivo
150. End If
151.
152. With CommonDialog
153. .DialogTitle = "Abrir Archivo"

154. ' Extenciones del Commondialog
155. .Filter = FILTRO_EXTENSIONES
156. ' Abrimos el Commondialog
157. .ShowOpen
158. If .FileName = "" Then Exit Sub 'Si es un vbNullstring salimos
159. ' Cargamos el fichero en el RichTextBox con el método LoadFile
160. RichTextBox.LoadFile .FileName
161.
162. End With
163. End Sub
164.
165.
166. Private Sub Form_Load()
167. Call Iniciar
168. End Sub
169.
170. Private Sub Form_Resize()
171. 'Redimensionamos el control RichTextBox al tamaño _
172. del formulario usando el método Move del mismo.
173. RichTextBox.Move 0, cmdOpcion(0).Top + cmdOpcion(0).Height, _
174. ScaleWidth, ScaleHeight
175.
176. End Sub
Ejercicio 17 – Editor de texto con formularios MDI
El siguiente ejemplo es un editor de texto muy simple utilizando un formulario Mdi, y formularios
secundarios o hijos para cada archivo de texto, es decir similar a como lo hace el Word u otras
aplicaciones que utilizan múltiples documentos
1 - Pasos para crear el ejemplo:
Iniciar un nuevo proyecto Exe, añadir un formulario MDI y dejarlo por defecto con el nombre Mdi
Form1. También agregar un formulario y renombrarlo a FrmDocumento
Las opciones que tendrá el editor serán:
1. En el menú Archivo: Abrir, Nuevo, guardar , guardar como y salir

2. El menú Edición : Copiar, Cortar, Pegar y seleccionar Todo.
La vista de los menúes quedará similar a los siguientes gráficos:
El menú Archivo:

El menú Edición:
Los nombres de los menues deberán ser los siguientes:
Menú Archivo:
1. Abrir: mnuAbrir
2. Nuevo: mnuNuevo
3. Guardar: mnuGuardar
4. Guardar Como: mnuGuardarComo
5. Salir: mnuSalir
Menú edición
1. Copiar: mnuCopiar
2. Cortar: mnuCortar
3. Pegar: mnuPegar
4. Seleccionar todo: mnuSeleccionar
Nota: si no sabés como crear los menúes con el editor de visual basic, podés chequear este enlace
que explica resumidamente como crear uno:

Crear menúes en visual basic
Ahora hay que especificar en el formulario Mdi, en la propiedad MdiChild, que se encuentre en
True, para que de esta manera los formularios se abran dentro de este.
Ahora indicar en el menú Proyectos > Propiedades de proyecto, que el formulario de inicio sea el
MDI, en la opción Objecto inicial.
Luego agregar un control CommonDialog llamado CommonDialog1 en el formulario Mdi y también

otro en el formulario frmDocumento para poder utilizar los Cuadros de diálogo Abrir Archivo y
Guardar como. ( El control CommonDialog lo accedés desde el menú proyecto, Componentes >
Microsoft Common Dialog Control ).
En el formulario frmDocumento, colocar un control RichTextBox llamado RichTextBox1 y

establecerle a este desde la ventana de propiedades, la propiedad Multiline en True, La propiedad
Scrollbars en 3. ( opara que muestre Ambas barras de desplazamiento)
Por último colocar un módulo bas al proyecto
Agregar el código fuente a los formularios y al módulo bas

Código fuente a colocar en el Formulario Mdi
Option Explicit
Private Sub MDIForm_Initialize()

CommonDialog1.Filter = "Documento de texto|*.txt|Todos los Archivos|*.*"
End Sub
'Menú abrir
Private Sub mnuAbrir_Click()
On Error GoTo errSub
CommonDialog1.ShowOpen
If CommonDialog1.FileName <> "" Then

Set FrmDoc = New frmDocumento
FrmDoc.Show
ActiveForm.Caption = CommonDialog1.FileName
ActiveForm.RichTextBox1.LoadFile CommonDialog1.FileName
End If
Exit Sub
errSub:
Select Case Err.Number

Case 70
ActiveForm.RichTextBox1.LoadFile CommonDialog1.FileName
Resume Next
End Select

End Sub
'Menu Guardar Como

Private Sub mnuGuarcomo_Click()
If Forms.Count = 1 Then
MsgBox "No hay documentos para guardar", vbInformation
Exit Sub
End If
CommonDialog1.ShowSave
If CommonDialog1.FileName = "" Then Exit Sub

ActiveForm.RichTextBox1.SaveFile CommonDialog1.FileName
Exit Sub
errSub:

Case 91
Resume Next
End Select
End Sub
'Menú para guardar el archivo

Private Sub mnuGuardar_Click()

If Forms.Count = 1 Then
MsgBox "No hay documentos para guardar", vbInformation
Exit Sub
End If
If InStr(1, ActiveForm.Caption, sCaption) Then
ActiveForm.RichTextBox1.SaveFile CommonDialog1.FileName
Else
ActiveForm.RichTextBox1.SaveFile ActiveForm.Caption
End If
Exit Sub
errSub:

Case 91
Resume Next
End Select
End Sub
'Menú nuevo archivo

Private Sub mnuNuevo_Click()
Set FrmDoc = New frmDocumento
nForms = nForms + 1
FrmDoc.Caption = sCaption & nForms
FrmDoc.Show
End Sub
'Menú pegar
Private Sub mnuPegar_Click()
On Local Error Resume Next

ActiveForm.RichTextBox1.SelText = Clipboard.GetText
End Sub
'Menú salir
Private Sub mnuSalir_Click()
Set FrmDoc = Nothing
End
End Sub
'Menu para seleccionar todo el texto

Private Sub mnuSeleccionar_Click()
ActiveForm.RichTextBox1.SelStart = 0
ActiveForm.RichTextBox1.SelLength = Len(ActiveForm.RichTextBox1.Text)
End Sub
'Menú Copiar texto

Private Sub mnuCopiar_Click()
Clipboard.SetText ActiveForm.RichTextBox1.SelText
End Sub
'Menú cortar texto

Private Sub mnuCortar_Click()
Clipboard.SetText ActiveForm.RichTextBox1.SelText
ActiveForm.RichTextBox1.SelText = ""
End Sub
Código fuente a colocar en el formulario frmDocumento

Option Explicit
Public flagGuardar As Boolean
Private Sub Form_Resize()

'Redimensionamos el control RichtextBox al ancho y alto del formulario
RichTextBox1.Move ScaleLeft, ScaleTop, ScaleWidth, ScaleHeight
If WindowState = vbMaximized Then
'mdiform1.Caption = Me.Caption
Else
mdiform1.Caption = ""
End If
End Sub
Private Sub Form_Unload(Cancel As Integer)
Dim ret As Integer
If flagGuardar Then
ret = MsgBox(" Guardar cambios", vbYesNoCancel)
End If
Select Case ret

Case vbYes:
If InStr(1, Me.Caption, sCaption) Then

RichTextBox1.SaveFile CommonDialog1.FileName
Else
RichTextBox1.SaveFile Me.Caption
End If
Case vbCancel:

Exit Sub
End Select
Set FrmDoc = Nothing
Exit sub
errSub:

Case 75
Resume Next
End Select
End Sub
Private Sub RichTextBox1_Change()

flagGuardar = True
End Sub
Código fuente a colocar en el Módulo bas
Public FrmDoc As frmDocumento

Public nForms As Integer
Public Const sCaption = "Nuevo documento sin título "
En este enlace está el código fuente para descargar del proyecto anterior, que incluye una barra
de herramientas para las opciones ( abrir, guardar etc.. ) y un cuadro de buscar y reemplazar para
los documentos
vista previa del mdi

PRACTICAS 1-5
1.- Hacer una aplicación que permita abrir un archivo de texto y mostrarlo en una caja de texto. La aplicación
debe permitir seleccionar el archivo de la unidad de disco mediante el cuadro de diálogo Abrir.
2.- Hacer una aplicación que permita almacenar en un archivo con estructura de base de datos los campos:
Nombre, Apellido, Edad y lugar de nacimiento. El programa debe permitir visualizar los registros agregados en un
control ListView. También debe permitir borrar un registro almacenado en el archivo de base de datos.
3.- Hacer una aplicación que permita borrar un archivo de una unidad de disco. El nombre de este archivo y la
unidad donde este se encuentra debe ser especificado en una caja de texto y mediante un botón de Borrar el
programa debe permitir borrarlo. Si el archivo no se encuentra se debe mostrar un mensaje informando al
usuario que ese archivo no existe.
4.- Hacer una aplicación que permita almacenar en un archivo el texto escrito en una caja de texto. El programa
debe permitir al usuario escribir el nombre del archivo y la unidad donde desea guardarlo. Para esto, usted debe
utilizar el cuadro de diálogo Guardar del control Common Dialog.
5.- Hacer una aplicación similar al Bloc de notas de Windows. Debe dar funciones a las opciones del primer
menú (Archivo) y del tercer menú (Fuente). Utilice para esto el control Common Dialog.

EJERCICIOS SOBRE EL BASES DE DATOS
Por ultimo, se presentan algunos ejercicios para ver como Visual Basic interctua con una base de datos, usando
diferentes caracteristicas. La base de datos mas comun a usar en VB es ACCESS por lo que para la realizacion de
las actividades, debera tener lista su base de datos, ya que de lo contrario estas no funcionaran.
Pregunte a su profesor como crear sus bases de datos o como obtenerlas (si es que el se las proporcionara antes
de realizar los ejercicios).

Ejercicio 18 – Formulario de Datos
Visual Basic cuenta con una cantidad importante de Asistentes. Entre ellos el asistente para la creación
de un Formulario de datos, osea un formulario que va a mostrar datos de una Base de datos.
Para incorporar al Asistente vamos a Complementos, Administrador de complementos y alli se nos

abre una ventana desde donde podemos seleccionar cualquiera de los Asistentes.
Seleccionamos VB 6 Data Form Wizard y hacemos doble click, o marcamos en la casilla de selección,
para qu se cargue. Luego hacemos Aceptar y al ir a Complementos veremos la opcion de del asistente
incluida. La seleccionamos y se abrirá una ventanacon la introducción al Asistente.
Pasamos a Siguiente, ya que aquí no podemos cargar la configuración de ningún perfil, porque no
tenemos ninguna configuración o plantilla grabada.

En esta pantalla seleccionamos qué tipo de base de datos vamos a usar, si una de Access o de un
servidor remoto. En este caso elegimos Access. Y pasamos a la pantalla siguiente.
En esta pantalla si hacemos Click en el botón Examinar podemos elegir la base de datos que vamos a
usar.

Aquí aparece una lista de opciones, que nos permite elegir qué tipo de formulario vamos a crear y
como vamaos a mostrar los datos. Registro individual: nos mostrará registro por registro. Cuadrícula: lo
hará en una grilla. Maestro/Detalle: relaciona dos tablas.
FlexGrid mostrará: las tablas con sus resúmenes y totales de los datos existentes en la tabla y Chart lo
hará de manera gráfica. Nosotros vamos a elegir a manera de grilla o Cuadrícula.
En esta pantalla seleccionamos la tabla de la base de datos. Y de ella los campos que queremos
mostrar. Los seleccionamos y con los botones con flecha los vamos pasando a la lista de la derecha. Si
queremos ordenar los datos por un campo determinado lo elegimos del combo desplegable.

Aqui hacemos Click en seleccionar todos los botones o elegimos solo algunso. estos nos permiten
navegar la grilla. La pantalla Siguiente nos pregunta si queremos guardar esta configuración como una
plantilla para futuros formularios. Luego hacemos Finalizar.
Al cerrase la ventana del Asistente veremos en nuestro proyecto estándar un nuevo formulario, si no
usamos el primero o Form1 lo podemos eliminar.
Posicionados en la ventana proyecto con el botón derecho tenemos la opción de eleminarlo. Y

grabamos la aplicación con el formulario que creó el asistente. Sino lo usamos como formulario de
presentación. Como vemos en la ventana código el asistente, ya codificó los botones de navegación y
de cierre de la Aplicación.

Ejercicio 19 – BD Navegar
Este ejercicio es muy simple y nos permite solamente navegar una Base de datos ya existente usando
un control standard de la barra de herramientas de Visual Basic, el Control Data Este control
tiene dos propiedades importantes la DataBaseName, o sea la base de datos a la cual se asocia , en
este caso usaremos la Hwind.mdb una de las dos bases que incluye Visual Basic, la otra es Biblio.mdb. Y
la RecordSource que asocia al control con una tabla específica en este caso Customers, o sea Clientes o
usuarios. Observen que no hemos escrito ni una línea de código y sin embargo podemos recorrer los
registros que componen la tabla a través del control Data. El formulario muestra los campos del
registro a través de cajas de texto cuya propiedad DataField se asocian al campo correspondiente luego
de establecer como DataSource o sea como base de origen la Data1 que es el control creado
anteriormente.
Recuerden que siempre que trabajemos con bases de datos tendrán que cargar el DataBaseName
nuevamente de acuerdo al recorrido de sus máquinas.
Ejercicio 20 - Connection to an Access Database Using the VB Data Control
This tutorial provides a brief introduction to developing database applications with Visual Basic through
a series of nine step-by-step exercises. It should be noted that these exercises use the Data control
with other controls bound to it. The Data control does a lot for you "behind the scenes" and you may be
tempted to use it in your applications, but be advised that the Data control is rarely used in professional
applications â€“ the norm is to write your own database access code so that you have complete control
over the process. These exercises are worthwhile in that you can see what data bound controls are all
about, but again be advised that they should not be used for professional application development. For
further information on why data bound controls are "evil", read this article.
The intrinsic Data control is geared toward MS-Access 97 and earlier databases, although a later VB
service pack added connectivity for Access 2000 databases. These articles use the two sample Access
databases provided with Visual Basic (BIBLIO.MDB and NWIND.MDB). These databases are provided
in Access 97 format. On a default installation of VB6, these databases can be found in the folder:
C:\Program Files\Microsoft Visual Studio\VB98.

To do these exercises, you should make a folder into which you will copy the two database files
mentioned above. Then, within the folder you have created, make separate subfolder for each exercise,
one level below the root of your folder. The DatabaseName property for the Data control in these
exercises assumes that the database file resides one directory level above the folder in which the
exercise project files reside.
STEPS:
1. Open a new Visual Basic project.
2. Put a data control (an intrinsic control, located in the VB toolbox) on the form and set the
properties as follows:
Property Value
(Name) datAuthors
Caption Use the arrows to view
the data
Connect Access (default)
DatabaseName ..\biblio.mdb
DefaultType UseJet (default)
RecordSource Authors (choose from
list)
Notes: When you use the Data Control in a project, the properties that must be set are
DatabaseName and RecordSource, in that order. DatabaseName is the name of the
database you want to use, and the RecordSource is the name of the table in that database
that you want to use.
3. On your form, create a text box for each field in the Authors table, with labels. (If you were to
open the database in Access, you would see that the three fields of the Authors table
are Au_ID, Author, and Year Born.) Set the properties of the three textboxes as follows:
Name DataSource DataField

txtAuthID datAuthors Au_ID
txtAuthor datAuthors Author
txtYearBorn datAuthors Year Born
In addition, set the Enabled property of txtAuthID to False.
When you want a control (such as a text box) to display data from a database, the properties
that must be set are DataSource and Datafield. The DataSource is the name of the data
control on the form (it should already be configured), and the DataField is the name of the
particular field in the database that should be displayed in the control (this field will be in the
table that was chosen for the RecordSource of the data control).

At this point, your form should resemble the screen-shot below:
4. Save and run the project. Use the arrows on the data control to scroll through the data.
5. On any record, change the data in the author name or year born field. Move ahead, then
move back to the record you changed. Note that your changes remain in effect. The data
control automatically updates a record when you move off of the record.
Note that this exercise demonstrated that you can create a simple but functional application that allows the user to
browse through the rows of a database table (or result set) and to update rows in that table without writing any
code.
Ejercicio 21 – Using Navigation Buttons with Data Control
In the previous exercise, you saw that by clicking specific buttons of the data control, you could
move to the first, previous, next, or last record. What is happening is that the data control is
automatically invoking specific methods of the recordset object: namely the MoveFirst,
MovePrevious, MoveNext, and MoveLast methods. You can also invoke these methods
through code, which is what this exercise demonstrates.
STEPS:
1. Copy the files from Exercise #1 into a new folder and open the VBP file in the new
folder.
2. Set the Visible property of the data control (datAuthors) to False.
3. Make four command buttons with the following properties:

Name Caption
cmdMoveNext Next Record
cmdMoveLast Last Record
cmdMovePrevious Previous
Record
cmdMoveFirst First Record
At this point, your form should resemble the screen-shot below:
4. Put the following four lines of code in the appropriate Click events for the buttons:
Event Code
cmdMoveNext_Click datAuthors.Recordset.MoveNext
cmdMoveLast_Click datAuthors.Recordset.MoveLast
cmdMovePrevious_Click datAuthors.Recordset.MovePrevious
cmdMoveFirst_Click datAuthors.Recordset.MoveFirst
5. Save and run your program.
6. Move to the last record and then click the Move Next button twice. What happens? (We will
fix this in Exercise 4.)

Ejercicio 22 – Using the BOF Action and EOF Action Properties of the Data Control
Note: EOF (End Of File) is a Boolean property of the recordset object that becomes true when
an attempt is made to move forward past the last record in a recordset.
BOF (Beginning Of File) is a Boolean property of the recordset object that becomes true when
an attempt is made to move backward past the first record in a recordset.
STEPS:
1. Copy the files from Exercise #1 into a new folder and open the VBP file in the new folder.
2. Click once on the data control and make sure that the following properties are set:
BOFAction = 0 â€“ Move First
EOFAction = 0 â€“ Move Last
3. Run the program and notice what happens when you use the arrows to â€œmove
previousâ€ when you are on the first record already, or â€œmove nextâ€ when you
are already on the last record.
End the program, and set the data control properties as follows:
BOFAction = 1 â€“ BOF
EOFAction = 1 â€“ EOF
Notice what happens to the arrows on the data control when you try to move past the last or
first record.
4. Now set the EOFAction property to 2 â€“ AddNew.
5. Run the program; click the >| arrow on the data control to move to the end of the records;
then click on the > arrow to move to the next record (which does not exist).
6. A blank record should appear. Type some data in all the fields (the author ID will be entered
automatically), then move to a previous record. Move back to the last record to verify that your
data is still there.
7. End the program, then start it again. Verify that the data you entered is still in the database.

Note that this exercise demonstrated that you can create a simple but functional application that not only allows
the user to browse through the rows of a database table and to update rows in that table, but also allows the user
to add a new record to that table without writing any code.
Ejercicio 23 – Using the EOF and BOF Properties with Navigation Buttons
STEPS:
1. Copy the files from Exercise #2 into a new folder and open the VBP file in the new folder.
2. When the user clicks on the MoveNext button, and there is no next record, your code should stay on
the same record (the last one).
Put the following code in the cmdMoveNext_Click() event:
datAuthors.Recordset.MoveNext
If datAuthors.Recordset.EOF = True Then
datAuthors.Recordset.MoveLast
End If
FYI: Instead of Recordset.MoveLast, you could use MoveFirst to let the user loop around to
the first record.
3. Put similar code in the cmdMovePrevious_Click() event. In this case, you will be checking for
Recordset.BOF = True.
4. Save and run the project and test it thoroughly.
Ejercicio 24 – Adding, Updating and Deleting Records
In previous exercises, you saw that with the data control, changes to a record are automatically
updated when the user moves off of that record â€“ this is the Update method of the recordset object of
the data control at work. You also saw that, by setting the EOFAction of the data control to "2 â€“
AddNew", the data control will invoke the AddNew method of the recordset object, which causes all the
bound controls to be cleared so that the user can enter data. In addition to being invoked automatically
through the data control, the Update and AddNew methods can also be invoked through code. The
recordset object also has a Delete method, which can only be invoked through code â€“ it cannot be
accessed automatically through the data control.

This exercise shows you how to invoke the Update, AddNew, and Delete methods of the recordset
object through code.
STEPS:
1. Copy the Exercise #4 files into a new folder and open the VBP file.
2. Add three more buttons to the form and set their properties as follows:
Name Caption Enabled

cmdNewRecord New Record True
cmdSaveRecord Save Record False
cmdDeleteRecord Delete True
Record
Your form should resemble the following:
3. When the user clicks on New Record, your program should enable the Save Data button and
disable the others. Put the following code in the cmdNewRecord_Click() event:
datAuthors.Recordset.AddNew
cmdSaveRecord.Enabled = True
cmdMoveFirst.Enabled = False
cmdMoveLast.Enabled = False
cmdMovePrevious.Enabled = False
cmdMoveNext.Enabled = False

cmdDeleteRecord.Enabled = False
cmdNewRecord.Enabled = False
4. Save and run the program to make sure the buttons are enabled and disabled correctly.
5. When the user clicks on the Save button to save the data that was entered, the Update method
should be called and the buttons should be redisplayed. Place the following code in the
cmdSaveRecord_Click() event:
datAuthors.Recordset.Update
cmdSaveRecord.Enabled = False
cmdMoveFirst.Enabled = True
cmdMoveLast.Enabled = True
cmdMovePrevious.Enabled = True
cmdMoveNext.Enabled = True
cmdDeleteRecord.Enabled = True
cmdNewRecord.Enabled = True
6. Something to watch out for with the Delete method is that when a record is deleted, the recordset is
no longer pointing to a valid record, but the data from the deleted record still remains in the controls. If
the user attempted to update the record at that point, a run-time error would occur. To prevent this from
happening, you should move the user to a valid record immediately following the delete.
Another issue is that if you attempt to delete a record that has a related record in another table, the Jet
(Access) database engine will not allow the delete, and a run-time error will occur. If you don't trap the
error, the program will crash.
Finally, it is good programming practice to ask the user to confirm any destructive action.
Place the following code, which addresses the above-mentioned issues, in the cmdDelete_Click()
event:
On Error GoTo Delete_Error
If MsgBox("Are you sure you want to delete this record?", _
vbQuestion + vbYesNo + vbDefaultButton2, _
"Confirm") = vbNo Then
Exit Sub

End If
'delete the current record
datAuthors.Recordset.Delete
'move to a valid record
cmdMoveNext_Click
Exit Sub
Delete_Error:
' This error will occur if you attempt to delete an author that is
related to
' another table in the biblio.mdb database ...
MsgBox "This record cannot be deleted. Error code = " _
& Err.Number & vbCrLf & Err.Description, _
vbCritical, "Cannot Delete"
7. Save and test your program to make sure all functions work.
Ejercicio 25 – BD Navegar por codigo
En este ejercicio agregamos cuatro botones o sea CommandButton para realizar por código a través
del evento click las acciones correspondientes a: primer registro, siguiente registro, registro previo y
último registro.

Data1.Recordset.MoveFirst ' Se ubica en el primer registro
End Sub

Data1.Recordset.MovePrevious ' Se mueve al registro previo
If Data1.Recordset.BOF Then 'Si es el primero muestra un 'mensaje.
MsgBox "Este es el Primer Registro.", , "Registros"
Data1.Recordset.MoveFirst
End If
End Sub

Data1.Recordset.MoveNext ' Se ubica en el siguiente
If Data1.Recordset.EOF Then ' Si es el último muestra un mensaje
MsgBox "Este es el Último Registro.", , "Registros"
Data1.Recordset.MoveLast ' Se ubica en el último.
End If
End Sub

Data1.Recordset.MoveLast ' Se ubica en el último.
End Sub
Las propiedades BOF y EOF indican el comienzo del archivo: begin of file y el final del archivo: end of
file.
El objeto Recordset que sigue al objeto data identifica al objeto: conjunto de registros.
Ejericio 26 – BD Altas, Bajas y Busqueda
En este ejercicio vamos a seguir avanzando en cuanto a las posibilidades de manipular los contenidos
de la Base de datos. Vamos a agregar y eliminar registros y hacer búsquedas.
El formulario contiene los siguientes controles:

La base con la que trabajamos es Biblio.mdb y la tabla Editores o Publishers. El código correspondiente
a los botones avanzar y Atrás ya los hemos visto en el ejercicio anterior por lo tanto vamos a
centrarnos en los botones Agregar, Eliminar y Buscar cuyos códigos son:

mensaje = MsgBox("Complete los datos y haga un Click" + Chr(10) + "en el botón de registro
siguiente.", vbInformation)
Data1.Recordset.AddNew
Text2.SetFocus
End Sub

mensaje = MsgBox("¿Está seguro de Borrar el registro?", vbOKCancel, "Eliminación de
Registros")
If mensaje = vbOK Then
Data1.Recordset.Delete
Data1.Recordset.MoveNext
If Data1.Recordset.EOF Then
Data1.Recordset.MoveLast
End If
End Sub

buscar = InputBox("Ingrese la Ciudad a Buscar:", "Búsqueda")
Data1.Recordset.FindFirst "City=" & "'" & buscar & "'"
If Data1.Recordset.NoMatch Then
mensaje = MsgBox("No existe la Ciudad Buscada.", vbCritical)
Command4.Enabled = False
Else
Command4.Enabled = True
End If
End Sub

Data1.Recordset.FindNext "City=" & "'" & buscar & "'"
End Sub
El método AddNew nos permite agregar un nuevo registro, y la actualización la podemos hacer a través
de botón grabar o moviendo el puntero al pasar al siguiente registro. Para eliminar un registro lo
hacemos con el Método Delete, previa confirmación a través de un MsgBox de la misma. Para que la
base se mantenga actualizada en el procedimiento Activate del formulario incluimos:
Private Sub Form_Activate()
Data1.UpdateRecord ' esto actualiza la data
End Sub
Y para el procedimiento Buscar abrimos un InputBox que guarde la cadena a buscar, en este caso una
ciudad por ejemplo: New York o Buenos Aires y con el método FindFirst (Buscar primero) y el campo

establecido en este caso City (Ciudad) establece los criterios de la búsqueda. Luego con FindNext
establece el criterio de la segunda búsqueda.
Ejercicio 27 – Using the Validate Event
This exercise will add the following functionality to the form you created in Exercise 5:
• Validating the user's input when they update an existing record or add a new record to the
database.
• An Undo feature which will enable the user to cancel changes that they make to a record.
This exercise introduces the Validate event of the data control, as well as the CancelUpdate and
UpdateControls methods of the data control, the Bookmark and LastModified properties of the
recordset object, and the DataChanged property of bound controls.
The Validate event of the data control occurs prior to a record Move and prior to an Update, Delete,
Unload, Close, or setting of a Bookmark. This means that any code contained in the Validate event
procedure will be executed prior to the execution of a statement containing one of these methods. For
example, if somewhere in your program you code the statement datAuthors.Recordset.Update, when
VB encounters this statement, any code in the Validate event will be executed first.
The Validate event takes in two VB-provided arguments: Action and Save. (For example, the Validate
event procedure header for this exercise will look like this:
Private Sub datAuthors_Validate(Action As Integer, Save As Integer).
The Action argument tells you which particular action (MoveFirst, Update, etc.) caused the Validate
event to fire. The value of Action can be tested by comparing it to a literal integer value (1, 2, 3, etc.) or
with its corresponding VB predefined constant (vbDataActionMoveFirst, vbDataActionUpdate, etc.). In
addition, whatever action triggered the Validate event can be cancelled if you set the value of Action to
zero (or to the predefined constant vbDataActionCancel) prior to exiting the Validate event procedure.
The values of Action and their corresponding predefined constants are as follows:
Constant Value Description

vbDataActionCancel 0 Cancel the operation when the Sub
exits
vbDataActionMoveFirst 1 MoveFirst method
vbDataActionMovePrevious 2 MovePrevious method
vbDataActionMoveNext 3 MoveNext method
vbDataActionMoveLast 4 MoveLast method
vbDataActionAddNew 5 AddNew method
vbDataActionUpdate 6 Update operation (not UpdateRecord)

vbDataActionDelete 7 Delete method
vbDataActionFind 8 Find method
vbDataActionBookmark 9 The Bookmark property has been set
vbDataActionClose 10 The Close method
vbDataActionUnload 11 The form is being unloaded
The Save argument is a Boolean value indicating whether or not bound data has changed. You can set
Save to False to prevent VB from saving changes to a record.
DataChanged is a run-time only Boolean property available with data-bound controls (such as the
textboxes you have been using), typically used in the Validate event. You would typically use
DataChanged as a first test to see if a particular field needs further validation (if the user did not change
the data in a field, why bother doing further validation on that field?) The logic structure would look
something like the following:
If txtMyField.DataChanged Then
If (something is wrong with txtMyField) Then
MsgBox "Invalid data in this field"
End If
End If
The CancelUpdate method is used to cancel any pending updates resulting from an Edit or AddNew
operation. For example, if a user invokes the Edit or AddNew method and hasn't yet invoked the
Update method, CancelUpdate cancels any changes made after Edit or AddNew was invoked.
The UpdateControls method gets the current record from a Data control's Recordset object and
displays the appropriate data in controls bound to a Data control. This method is typically used to
restore the contents of bound controls to their original values, as when a user makes changes to data
and then decides to cancel the changes. This method does not cause the Validate event to fire.
Similarly, the UpdateRecord method (not used in this exercise) saves the current contents of bound
controls to the database during the Validate event without triggering the Validate event again.
Bookmark is a property of the Recordset object that contains a binary string identifying the current
record. If you assign the Bookmark value to a variable and then move to another record, you can make
the earlier record current again by setting the Bookmark property to that string variable.
LastModified is a property of the Recordset object that returns a bookmark indicating the most recently
added or changed record.
STEPS:
1. Copy your files from Exercise 5 into a new folder.
2. Place two new command buttons on your form and set their properties as follows:

cmdUndo Undo True
cmdCancelNew Cancel New Record True
At this point, your form should resemble the following:
3. Place the following statements in the general declarations section of your form:
Private blnAddingNewRecord As Boolean
Private blnValidationError As Boolean
4. Code the event procedure for the new cmdUndo button, which consists of only one statement:
datAuthors.UpdateControls
5. Modify the cmdNewRecord_Click() event procedure to look like the following (new statements are shown in
bold):
datAuthors.Recordset.AddNew
If blnValidationError Then Exit Sub
cmdCancelNew.Enabled = True

cmdUndo.Enabled = False
blnAddingNewRecord = True
Explanation
When the user initiates the process to add a record, the code invokes the AddNew method, which will
cause the Validate event to fire, which will set the blnValidationError flag. This will catch the case where
the user has modified the current record (and has made errors) and then clicks the "New Record" button.
In that case the error is flagged, the AddNew is canceled, and the user must correct the problem with the
current record.
If everything's OK, we enable the "Cancel New" button so that they can cancel the process, and disable
the "Undo" button, because that is only applicable when the user is changing, not adding a record. We
also set the blnAddingNewRecord flag to true, which will be tested in the Validate event (shown in a few
steps below).
6. Modify the cmdSaveRecord_Click() event procedure to look like the following (new statements are shown in
bold):
datAuthors.Recordset.Update
If blnValidationError Then Exit Sub
' make the new record the current record
datAuthors.Recordset.Bookmark _
= datAuthors.Recordset.LastModified
cmdCancelNew.Enabled = False

cmdUndo.Enabled = True
blnAddingNewRecord = False
Explanation
When the user initiates a save for a newly added record, the Update method is invoked (with the
statement datAuthors.Recordset.Update). This will cause the Validate event to fire, where we will set
the blnValidationError flag. When the Validate event terminates, control resumes with the If statement,
where that flag is tested. If there is an error, we want to exit the sub early, which will let the user continue
working on the current record to correct the problem. Otherwise, if the flag is False, that means that all
validation checks passed and we can continue on our merry way.
The statement
datAuthors.Recordset.Bookmark = datAuthors.Recordset.LastModified
causes the newly added record to become the current record. This is necessary if you want to see the
data for the new record on the form after you add it, because the AddNew method and
subsequent Update method does not cause the newly added record to become the "current"
record. Therefore, without this statement, the record that was current before you invoked the
"New Record" operation would be displayed, and you would have to go to the last record to see
the newly added record.
Since this event completes the operation of adding a new record, the cmdCancelNew button is
disabled, the cmdUndo button is enabled and the blnAddingNewRecord flag is set to False.
7. Code the Validate event procedure for the datAuthors data control. Recall that this event fires prior
to a record Move and prior to an Update, Delete, Unload, Close, or setting of a Bookmark. Since
Validate is the default procedure for a data control, you can get the procedure header by double-
clicking on the data control. The code is shown below:
Private Sub datAuthors_Validate(Action As Integer, Save As Integer)
If Action = vbDataActionBookmark Then Exit Sub
If Action = vbDataActionDelete Then Exit Sub
'check to see if a valid author id is entered:

If txtAuthor.DataChanged Or blnAddingNewRecord Then
If Trim$(txtAuthor) = "" Then
MsgBox "Author name must be entered"
txtAuthor.SetFocus
GoTo CancelValidateAction
End If
End If
'check to see if a valid year is entered
If txtYearBorn.DataChanged Or blnAddingNewRecord Then
If Val(txtYearBorn) = 0 Then
MsgBox "Invalid year"
txtYearBorn.SetFocus
GoTo CancelValidateAction
End If
End If
blnValidationError = False
Exit Sub
CancelValidateAction:
blnValidationError = True
Action = vbDataActionCancel
Save = False
End If
End Sub
8. Code the Click event procedure for the cmdCancelNew command button. If the user wants to cancel
the adding of a new record, the CancelUpdate method should be used; then the UpdateControls

method is used to restore the controls on the form to the values of the current record (the record that
was displayed on the form prior to the initiation of the AddNew operation). The code is shown below:
Private Sub cmdCancelNew_Click()
'cancel the AddNew

datAuthors.Recordset.CancelUpdate
datAuthors.UpdateControls
'enable & disable the appropriate buttons
blnAddingNewRecord = False
End Sub
9. Save, run and test the program. Make sure you understand what the code is doing.
Ejercicio 28 – Using the Find Methods
The Recordset object has methods FindFirst, FindLast, FindNext, and FindPrevious. You can use
these to search for a particular record in the Recordset.
The syntax is
datControl.Recordset.FindFirst criteria
where criteria is a string item consisting of a field name, a relational (comparison) operator, and a
value. It is essentially the same as a SQL WHERE clause without the word WHERE. The comparison
operators that can be used are =, >, <, >=, <=, <>, Like, Between, and In. The value on the right-hand
side of the comparison operator must conform to the following rules:
string values must be enclosed in single quotes
numeric values are not enclosed in quotes
date values must be enclosed in #'s (pound signs)

If the criteria is expressed in a literal string, that string must be enclosed in double quotes. Typically, you must use
VB's string-handling functions (especially the "&" for concatenation) to get the desired results.
Examples:
datBooks.Recordset.FindFirst "ISBN = '123-456-789-0' "
datMembers.Recordset.FindNext "Amount > 100"
datMembers.Recordset.FindNext "DateOfBirth < #1/1/1950#"
datBooks.Recordset.FindNext "Amount > " & txtAmount.Text
datMembers.Recordset.FindNext "FirstName = '" & txtName.Text & "'"
The next example assumes that the variable dtmBirthDay is of the Date data type:
datMembers.Recordset.FindNext _
"DateOfBirth < #" & Format$(dtmBirthDay, "mm/dd/yyyy") & "#"
In this exercise, the user selects both the field name and the relational operator from combo boxes, then enters
the search value in a textbox. The criteria for the Find methods are thus formed by statements similar to the
following:
If cboField.Text = "Author" Then
strQuote = "'"
Else
strQuote = ""
txtCriteria.Text = Val(txtCriteria.Text)
End If
strCriteria = _
cboField.Text & " " & cboRelOp.Text & _
" " & strQuote & txtCriteria.Text & strQuote
datAuthors.Recordset.FindFirst strCriteria
Additional Notes:
• If the name of the field in the database table has spaces in its name, you must put square brackets
around the field name, as in the following example:

datBooks.Recordset.FindFirst "[Pay Rate] > 30000"
• For string values, if there is the possibility that the search string will contain an apostrophe, an extra measure
should be taken to "double" the apostrophes in the string â€“ otherwise, the apostrophe embedded in the
string will be interpreted as the end of the string and a syntax error will most likely result. The easiest way to
provide this "insurance" against embedded apostrophes is to use the Replace$ function on the string in
question to replace any occurrences of a single apostrophe with two apostrophes:
datProducts.Recordset.FindFirst _
"ProductName = '" & Replace$(strSearchText, "'", "''") & "'"
For example, if strSearchText contained "Chef Anton's Cajun Gumbo", the criteria in the above
statement would evaluate to
ProductName = 'Chef Anton''s Cajun Gumbo'
and the double apostrophe in "Anton''s" would be correctly interpreted by the SQL parser as a single
apostrophe.
In this particular example, if the Replace function was NOT used (i.e., you simply coded
"ProductName = '" & strSearchText & "'"
for the criteria, the result would be
ProductName = 'Chef Anton's Cajun Gumbo'
which would result in an error: the SQL parser would interpret the criteria to be "Chef Anton" with
extraneous characters ("s Cajun Gumbo") at the end.
The Recordset has a NoMatch property. It is set to False to begin with. If you use a Find method and a
record is not found, then the NoMatch property is set to True. You should use this property to determine
whether or not a record was found. If a match is found, NoMatch will be set to True, and the found
record becomes the current record.
STEPS:
1. Copy the files from Exercise 6 into a new folder. Follow steps 2 through 4 to get your form to
resemble the following:

2. Add four command buttons to the form and set their properties as follows:

cmdFind F&ind True
cmdFindAgain Find &Again False
cmdCancelFind Cance&l Find False
cmdGo &Go! False
3. Add two combo boxes and set their properties as follows (Note: you can set the List property of a
listbox or combo box in the Properties box by typing in values and pressing Ctrl+Enter - this action is
analogous to using the AddItem method in code).
Name Style Enabled List

cboField 2 - Dropdown List False Au_Id
Author
[Year Born]
cboRelOp 2 - Dropdown List False =
>
<
>=
<=

<>
Like
4. Add a textbox called txtCriteria and set its Enabled property to False.
5. Place the following statements in the Form_Load event:
cboField.Text = cboField.List(0)
cboRelOp.Text = cboRelOp.List(0)
6. Code the Click events for the combo boxes (to provide smoother navigation for the user). The Enabled tests
are necessary because the Form_Load event assigns the first element of the their respective List property arrays
to their respective text properties, which automatically invokes the Click event, which will normally perform a
SetFocus. SetFocus cannot be invoked on a disabled control; nor can it be invoked prior to completion of a Form
Load.
Private Sub cboField_Click()
If cboField.Enabled Then
cboRelOp.SetFocus
End If
End Sub
Private Sub cboRelOp_Click()
If cboRelOp.Enabled Then
txtCriteria.SetFocus
End If
End Sub
7. To ensure that strBookmark always references the current record, place this statement
strBookmark = datAuthors.Recordset.Bookmark
at the end of each of these event procedures:
cmdMoveFirst_Click

cmdMoveLast_Click
cmdMoveNext_Click
cmdMovePrevious_Click
This is necessary to ensure that we have a pointer to a valid record available in case the Find method
fails, which leaves the current record pointer undefined.
8. Place the following code in the cmdFindÂ_Click event (disables navigating and updating controls
and enables "Find" controls):
blnFirstFind = True
txtAuthor.Enabled = False
txtYearBorn.Enabled = False
cmdUndo.Enabled = False
cmdFind.Enabled = False
cmdCancelFind.Enabled = True
cmdGo.Enabled = True
cboField.Enabled = True
cboRelOp.Enabled = True
txtCriteria.Enabled = True

9. Place the following code in the cmdGo_Click event (prepares criteria argument for the Find
methods, then performs the Find):
Dim strQuote As String
Dim strCriteria As String
If cboField.Text = "Author" Then
strQuote = "'"
Else
strQuote = ""
txtCriteria = Val(txtCriteria)
End If
strCriteria = _
cboField.Text & " " & cboRelOp.Text & _
" " & strQuote & txtCriteria & strQuote
With datAuthors.Recordset
If blnFirstFind Then
blnFirstFind = False
.FindFirst strCriteria
Else
.FindNext strCriteria
End If
If .NoMatch Then
MsgBox "Data not found"
.Bookmark = strBookmark
cmdFind_Click

cmdFindAgain.Enabled = False
Else
cmdFindAgain.Enabled = True
cboField.Enabled = False
cboRelOp.Enabled = False
txtCriteria.Enabled = False
cmdGo.Enabled = False
End If
End With
10. In the cmdFindAgain_Click event, place the following line (performs the same actions as the
cmdGo_Click event):
cmdGo_Click
11. Place the following code in the cmdCancelFind_Click() event (enables the navigation and
updating controls, disables the Find controls):
txtAuthor.Enabled = True
txtYearBorn.Enabled = True
cmdCancelNew.Enabled = True
cmdFind.Enabled = True

cmdCancelFind.Enabled = False
cmdGo.Enabled = False
cboField.Enabled = False
cboRelOp.Enabled = False
txtCriteria.Enabled = False
12. Run the program and test the Find operations using different fields, relational operators, and search strings.
Ejercicio 29 – Using the MSFlexGrid Control
The MSFlexGrid can be used to display multiple records in a grid. It cannot be used to edit data or add
and delete records. Follow the steps in this exercise to create a Categories and Products master/detail
form similar to the screen-shot shown below:

STEPS:
1. Place two data controls on the form and set their properties as follows:
Name DatabaseName RecordSource Visible

datCategories ..\NWIND.MDB Categories True
datProducts ..\NWIND.MDB (leave blank) False
Set the Caption property of datCategories to "Use Arrow Buttons to Navigate Records".
2. Place three textboxes and one OLE control on the form. Set the DataSource property for each of
these four controls to datCategories.
Set the DataField property for these controls to CategoryID, CategoryName, Description, and
Picture respectively.
Set the Enabled property of the Category ID textbox to False. For the Description text box, set
its MultiLine property to True and set its ScrollBars property to 2 â€“ Vertical.
Add appropriate label controls to accompany the textboxes, and group these four controls into a
frame, as shown in the screen-shot.
3. If necessary, add the MSFlexGrid to your toolbox from the Components item of the Project menu.
Place an MSFlexGrid control on your form, and set its properties as follows:
Property Value
AllowUserResizing 1 â€“
flexResizeColumns
DataSource datProducts
FixedCols 0
Enclose the grid in a frame, as shown in the screen-shot.
4. Place the following line of code in the Form_Load event:
datCategories.Refresh
This will force the controls bound to datCategories to be populated sooner than they would otherwise,
and will also trigger the Reposition event of the datCategories control. (The Reposition event of
a data control occurs whenever a Move method is executed against that control.)
5. Place the following code in the datCategories_Reposition event:
datProducts.RecordSource _
= "SELECT * FROM Products " _
& "WHERE CategoryID = " & txtCatID
datProducts.Refresh

6. Save and run the program.
Ejercicio 30 – Using the DBGrid Control
This exercise uses the DBGrid control, which goes a step further than the MSFlexGrid in that allows
the user to add, update, and delete records.
The DBGrid control does not install automatically when you install Visual Basic 6.0, but it is available on
the VB 6/VS 6 CD. To install the DBGrid control, perform the following steps.
• Locate these three files on your VB6 installation CD: DBGRID32.OCX, DBGRID32.DEP, and
DBGRID.REG. All three files should be located in this folder:
D:\COMMON\TOOLS\VB\CONTROLS (where "D:" is the drive letter of your CD-ROM drive). If you
cannot locate your installation CD, you may download these three files here.
• Copy these three files to your Windows "System" directory (the default system directory varies
depending on the OS being used: On Windows 2000 and NT the default is WINNT\SYSTEM32; on
XP the default is WINDOWS\SYSTEM32, and on 95, 98, and ME it is WINDOWS\SYSTEM).
• Double-click on DBGRID.REG to register the DBGRID32.OCX. You should now see the control
(under the name "Microsoft Data Bound Grid Control 5.0 (SP3)") when you access the Components
dialog by selecting Project|Components within VB. (If not, click on the â€œBrowseâ€¦â€ button in
the Components dialog and locate the DBGRID32.OCX file by browsing to the folder in which you
copied it previously.)
Once you have installed the DBGrid control, proceed with the steps of Exercise 9:
STEPS:
1. Copy your files from Exercise 8 to a new folder and open the project.
2. Delete the MSFlexGrid control.
3. Out of Project | Components, include the Microsoft Data Bound Grid Control.
4. Place a DBGrid on your form in the position previously occupied by the flex grid.
5. Set the DBGrid's properties as follows:
Property Value
AllowAddNew True
AllowDelete True
AllowUpdate True
DataSource datProducts

6. The code can remain as is. Save and run the program; experiment by using the grid to add,
update, and delete records. While this application is certainly not bullet-proof, you'll find that
built-in error-checking will prevent most "illegal" actions attempted by the user (such as trying to
change the primary key, changing a foreign key to a non-existent value, or deleting a record
with a related record in another table).
Download the project files for these exercises here.
Ejercicio 31 – Conectando VB con ACCESS 2007 y un control OLE DB de datos.
Basicamente es seguir los mismos pasos que en el ejercicio 19, al usar un control de datos (Control Data), pero
ahora usando el nuevo manejador para Access 2007.
En primer lugar, necesitamos crear una base de datos en Access 2007 como acostumbramos. Repitamos nuestra
base de datos Agenda, pero con el formato para 2007.
La extensión de la base de datos, puede ser .accdb o .mdb.

Antes de comenzar en VB para facilitar nuestras conexiones, crearemos un enlace a la base de datos usando un
servicio de Windows. En la carpeta donde tengamos nuestro proyecto y nuestra base de datos, pulsamos botón
derecho para crear un nuevo archivo.
1. Nos ubicamos en la carpeta donde tenemos nuestro proyecto

2. Pulsamos botón derecho para crear un nuevo archivo de texto
3. Le damos un nombre y cambiamos la extensión .txt a .udl. Nos preguntara si queremos sobreescribir la
extensión y decimos que si.

4. Ahora veremos que tenemos un nuevo archivo (icono diferente) y debemos indicarle los parámetros de
conexión. Damos doble click para abrirlo.
a) Primero debemos indicarle cual será el proveedor o controlador de Base de datos a usar:
b) Pulsamos en Siguiente, e indicamos el origen de los datos. Esto es, el nombre de nuestro archivo de
base de datos de Access:

Si tuviera una contraseña (por estar protegido) aquí la teclearíamos. Y si queremos saber si la conexión es
correcta, pulsamos el botón de PROBAR CONEXIÓN.
Por ultimo cerramos, pulsando el botón ACEPTAR.
Ahora en Visual Basic, primero debemos poner el control que pueda leer este formato. De la barra de
componentes pulsamos el botón derecho y aparecerá la caja de dialogo para seleccionarlo:

Debemos de marcar la casilla que dice MICROSOFT ADO DATA CONTROL 6.0, con la ubicación de
MSADODC.OCX. Este control se instala cuando instalamos Office 2007 o posterior por lo que el control debe
aparecer en nuestro directorio de Windows\System32.
En caso de no aparecer (no tenemos office 2007 instalado) deberemos descargar los complementos necesarios
MDAC del sitio de Microsoft en Internet.
Ahora, debemos ver que aparece el control en nuestra barra de herramientas, por lo tanto lo arrastramos a
nuestra forma:

Siguiendo con la misma secuencia que para el CONTROL DATA, debemos poner las propiedades de conexión a
este control. Para este control, es mas sencillo dar un click con el botón derecho dentro de el, para que aparezca
un submenú y seleccionar las propiedades:
Dando click en la ultima opción, veremos la caja de dialogo:

Donde en el origen de la conexión, debemos indicarle la ubicación del archivo UDL que acabamos de crear.
Tambien podríamos usar el origen de datos de manera directo o usar la cadena de conexión requerida. Ahora
debemos indicar además el Origen de los registros:
Es importante seleccionar el tipo de comando como TABLE (ver imagen) y después en la caja combo de abajo
aparecerán las tablas de nuestra base de datos. Seleccionamos cual es la que vamos a utilizar. Despues de ello,
podemos dar en ACEPTAR.
Ponemos nuestros controles de etiqueta y cajas de texto, según corresponda a los campos de nuestra tabla. Y en
las propiedades de la caja de texto, debemos indicar el origen de los datos y el campo que esta asociado:

Notemos que el DATASOURCE es el nombre del control que hemos puesto y configurado. Y el DATAFIELD, será el
campo asociado que queremos presentar.
Grabamos nuestro proyecto, ejecutamos y veremos que ya comienza a mostrarnos la información de la tabla.
Todo esto sin escribir una línea de código!.

Ejercicio 32 – Usando código con el control OLE DB.
Al igual que con el ejercicio de Control Data, este control actualizado contiene propiedades similares que nos
permiten crear nuestros propios botones para navegar, agregar, guardar, borrar. Usando este mismo control
crea una nueva versión del ejercicio anterior.
Esto te dara una idea:
Siguiendo las mismas propiedades del Control Data, agrega el código que corresponde a cada uno de los
botones.
Ejercicio 33 – Control Data con Archivos de Texto
Para este ejercicio nuevamente usaremos el Control Data de Visual Basic, pero usando nuestro archivo de texto
secuencial que había creado en los primeros ejercicios. Nuestro archivo de texto secuencial (o datos) debe verse
mas o menos asi:

Donde, la primer fila indican los nombres de los campos que vamos a utilizar. Ademas, los campos están
separados por coma (delimitados).
Creamos un nuevo proyecto en Visual Basic, agregamos nuestro Control Data, pero en las propiedades debemos
especificar lo siguiente:
Donde la conexión, la estamos indicando como TEXT, y seleccionamos nuestro archivo de texto en la siguiente
propiedad. Ademas, debemos seleccionar nuestro RECORDSOURCE:
Y listo. Para el resto de nuestro formulario, pondremos las etiquetas, cajas de texto y las propiedades de
DataSouce y DataField como corresponde.

Ejercicio 34 – Control Data con Archivos de Excel
En este ejercicio, veremos la versatilidad que tiene el control de datos para conectarse a otros tipos de archivo.
Primeramente debemos tener nuestra hoja de calculo (o archivo de Excel) preparada. Este es un ejemplo:
Vemos en la parte superior estarán los nombres de los campos, y en la parte inferior los registros que contiene.
Una vez grabado nuestro archivo de Excel, dentro de Visual Basic, tomamos el control DATA y seleccionamos

como hicimos con el tipo de texto, el formato de Excel 8.0, ubicamos nuestro archivo, incluimos el RecordSource
y lo demas ya lo sabes.
Prueba a practicarlo con este tipo de archivo. Veras que sigue las mismas instrucciones que los anteriores.
Ejercicio 35 –Control Data con Imágenes OLE
Ahora usaremos imágenes dentro de nuestra base de datos. Los campos que permiten almacenar este tipo de
información se llaman campos OLE (Object Linking and Embedding). Las imágenes se guardan dentro de la
misma base de datos y no se recomienda cuando tenemos muchos registros porque el tamaño de nuestro
archivo crecería enormemente. Otra situación se presenta con los formatos de imágenes, que generalmente
tienen que ser en BMP (Estandar) en lugar de JPG o GIF que son imágenes comprimidas.
Primero deberas crear una base de datos que contenga un campo OLE al menos. Esto lo hacemos usando el
Asistente Visual de Datos de VB donde creamos la base de datos, la tabla, los campos.

Ahora usaremos Access para ingresar los datos y las imágenes. Abrimos Access, seleccionamos el archivo y
comenzamos a capturar algunos registros. Luego tenemos que poner las imágenes. Para hacer esto:
1. Nos posicionamos en el campo del registro deseado

2. Pulsamos el botón derecho del raton y se abrirá un submenú
3. En las opciones que aparecen, seleccionamos INSERTAR OBJETO
4. Aparecera una caja de dialogo indicándonos si creamos un nuevo objeto o insertamos uno existente.
Seleccionamos la segunda opción, y pulsamos EXAMINAR para ubicar al archivo deseado. NOTA: SE
RECOMIENDA ALTAMENTE QUE LAS IMÁGENES SEAN BMP (.BMP) PARA QUE PUEDAN SER VISUALIZADAS
CORRECTAMENTE, YA QUE OTROS FORMATOS PUEDEN NO ESTAR DEBIDAMENTE REGISTRADOS (.JPG o .GIF)
A continuación se pulsa ACEPTAR y nuestra imagen queda incrustada en el campo. No la veremos

inmediatamente sino asi:
Ahora, ya tenemos una base de datos con imágenes incrustadas y podemos cerrar la aplicación y regresar a
Visual Basic. Nuestro proyecto queda mas o menos asi:

Vemos que tenemos las etiquetas y cajas de texto correspondientes a los campos, asi como un control de
imagen, botones de navegación Y DOS CONTROLES DATA. Y agregamos también un control de COMMON
DIALOG
En el primer control data (Data1) lo dejaremos VACIO. Ya que lo usaremos mediante código. En el segundo
control data ponemos las propiedades necesarias para accesar a nuestra base de datos de Access como es
conocido:
1. CONNECT
2. DATABASE
3. RECORDSOURCE
Vinculamos las cajas de texto al control de datos DATA2. Y el control de imagen al control de datos DATA1. En
la propiedad de DATAFIELD de la imagen pondremos el nombre del campo que tiene nuestra tabla (foto) aunque
nos aparezca un error. Esto es asi, porque no esta definido todavía el control DATA1.
Ahora pondremos el código para funcionar. Comenzamos con el FORM_LOAD:

Dim basedatos As String
basedatos = App.Path
'si no tiene la bara final la añade

If Right$(basedatos, 1) <> "\" Then basedatos = basedatos & "\"
basedatos = basedatos & "inventarioOLE.mdb"
' Le indica al Data la base de datos

Data1.DatabaseName = basedatos
'Fuente de los registros para el control data

Data1.RecordSource = "Select foto FROM Productos"
'Refresca el control
Data1.Refresh
End Sub
En este espacio (que es cuando se carga la forma) definimos una variable para conocer donde se encuentra
nuestra base de datos y con código, asignamos las propiedades. Notemos que la propiedad RECORDSOURCE
contiene una sentencia SQL específicamente para cargar las fotos (Y NINGUN OTRO CAMPO) de nuestra tabla. Al
final se hace una actualización del control.
Ahora pondremos el código para los botones de Siguiente y Previo:
Private Sub cmdNext_Click()

If Data1.Recordset.EOF = True Then
End If
End Sub
Private Sub cmdPrev_Click()
Data1.Recordset.MovePrevious
If Data1.Recordset.BOF = True Then
End If
End Sub

Aquí observamos que necesitamos poner el movimiento del puntero en los dos controles: uno para nuestros
registros y otro para la imagen.
Por ultimo, si queremos agregar una imagen a nuestra base de datos directamente desde visual basic, en el
botón de comando que creamos pondremos lo siguiente:
Private Sub cmdAddImagen_Click()

CommonDialog1.DialogTitle = " Seleccionar imagen para grabar en campo OLE "
'Crea un nuevo registro con el método AddNew

'Data1.Recordset.AddNew
Data1.Recordset.Edit
' Carga el gráfico seleccionado en el control Picture y al estar enlazado _

se almacena e el campo imagenes
Picture1.Picture = LoadPicture(CommonDialog1.FileName)
'Actualiza el recordset
Data1.Recordset.Update
'Refresca el control Data

'Data1.Refresh
End Sub
Aquí es donde usamos el control Common Dialog para abrir la caja de dialogo y ubicar la imagen, obtener su
nombre, y a) agregar un nuevo registro o b) editar el registro. Mostramos la imagen en pantalla y como nuestro
campo esta vinculado previamente, simplemente actualizamos con RECORDSET.UPDATE.
Ejercicio 36 –Control Data con Imágenes Vinculadas
En este ejercicio vamos a usar una base de datos y vincularla con imágenes. En lugar de que en nuestra tabla
tengamos un campo OLE para presentar como imagen, vamos a vincular las imágenes por separado de una base
de datos de productos.
Veremos la forma como podemos navegar por dicha tabla y ver los productos al mismo tiempo.

La diferencia con el ejercicio anterior, es que las imágenes no se guardaran en la base de datos, sino que estarán
separadas como archivos dentro de la carpeta del proyecto. Aunque también pueden estar en una subcarpeta
donde la referencia de la imagen es igual al campo de código.
Asi por ejemplo:
Campo Codigo Nombre de la Imagen Imagen

A100 A100.jpg

A200 A200.jpg
A300 A300.jpg
Enlazaremos estas imágenes con su correspondiente registro de la base de datos. Vamos a comenzar. En primer
lugar tendremos que tener nuestra base de datos. Esta fue creada usando el Asistente de Visual Basic como
hemos hecho. La llamamos INVENTARIO. Y dentro de esta esta una tabla llamada PRODUCTOS. Que contiene los
siguientes campos:
Campo Tipo Tamaño

Codigo Text 15
Descripcion Text 50
FechaEnt Date / Time 8
Cantidad Integer 2
Depto Text 50
Foto1 Binary 0
Foto2 Text 50
Notas Memo 0
Y aunque tenemos 2 campos para fotos, no utilizaremos ninguna de ellas. En el primer campo de FOTO1, es del
tipo binario (para almacenar la foto dentro de la base de datos que no haremos), y el segundo FOTO2 como tipo
texto por si deseamos grabar la ruta de la foto y usarla en la presentación.
Tenemos que tener algunos datos de prueba, asi como algunas imágenes de los productos que queremos
presentar.

A continuación, debemos crear nuestra forma y debemos agregar los siguientes elementos:
Tenemos nuestras etiquetas y cajas de texto según los campos que contenga la tabla. Tambien debemos poner
un control de IMAGEN en la parte donde queramos y su propiedad STRETCH como TRUE.
Agregaremos los botones correspondientes para navegar por los registros y para agregar, guardar y borar los
datos.
El control data inferior, debe contener la conexión a nuestra base de datos de Access, y los controles de texto
deben estar enlazados a los campos correspondientes.
Comenzemos con nuestro botón SIGUIENTE:
Private Sub cmdSig_Click()
If Data1.Recordset.EOF = True Then Si el registro de datos es el final entonces

Data1.Recordset.MoveLast Mueve el puntero hasta el ultimo registro
End If Fin si
Data1.Recordset.MoveNext Mueve el puntero al siguiente registro
If Len(Text1.Text) = 0 Then Si el campo código esta vacio Entonces
fotoshow = "no_data.jpg" Fotoshow igual a imagen vacia
Else Si no
fotoshow = Text1.Text + ".jpg" Fotoshow igual al código + extensión jpg
End If Fin Si
' Checar si hay o no hay imagen.

Image1.Picture = LoadPicture(fotoshow) Mostrar en control picture la variable fotoshow
End Sub
Como vemos, todo el “truco” esta en identificar la imagen del producto con su correspondiente código y
mostrarla en consecuencia. Por lo que cada producto deberá ser identificado correctamente.
Los botones de previo, inicio y final, contienen el mismo tipo de código para prevenir errores. Los botones
restantes contienen el código visto anteriormente.
El código completo del programa queda asi:
Private Sub cmdAgregar_Click()

Data1.Recordset.AddNew
cmdGuardar.Enabled = True
cmdInicio.Enabled = False
cmdFin.Enabled = False
cmdPrevio.Enabled = False
cmdSig.Enabled = False
cmdEliminar.Enabled = False
cmdAgregar.Enabled = False
End Sub
Private Sub cmdEliminar_Click()
On Error GoTo Delete_Error
If MsgBox("Seguro quiere eliminar este registro?", _

vbQuestion + vbYesNo + vbDefaultButton2, _
"Confirme") = vbNo Then
Exit Sub
End If
'delete the current record

Data1.Recordset.Delete
'move to a valid record

cmdSig_Click
Exit Sub
Delete_Error:
' This error will occur if you attempt to delete an author that is related to
' another table in the biblio.mdb database ...
MsgBox "Este registro no puede ser eliminado. Error code = " _
& Err.Number & vbCrLf & Err.Description, _
vbCritical, "No se puede eliminar"
End Sub

Private Sub cmdFin_Click()
If Len(Text1.Text) = 0 Then
fotoshow = "no_data.jpg"
Else
fotoshow = Text1.Text + ".jpg"
End If
Image1.Picture = LoadPicture(fotoshow)
End Sub
Private Sub cmdGuardar_Click()
Data1.Recordset.Update
cmdGuardar.Enabled = False
cmdInicio.Enabled = True
cmdFin.Enabled = True
cmdPrevio.Enabled = True
cmdSig.Enabled = True
cmdEliminar.Enabled = True
cmdAgregar.Enabled = True
End Sub
Private Sub cmdInicio_Click()
Else
End If
End Sub
Private Sub cmdPrevio_Click()
If Data1.Recordset.BOF = True Then
End If
Else
End If
End Sub

Private Sub cmdSig_Click()
If Data1.Recordset.EOF = True Then

End If
Else
End If
' Checar si hay o no hay imagen.

End Sub
Ejercicio 37 –Control Data OLE DB con MySQL
Podemos usar Visual Basic para que se conecte con el servidor de MySQL también. Para ello tenemos 2
opciones:
1. Por medio del control y conexión de Windows

2. Por medio de código (strings).
Generalmente en las aplicaciones profesionales se utiliza el segundo método porque el programador puede
cambiar muy fácilmente la conexión y no debe configurar nada. No sucede asi con el primer método que aunque
es mas sencillo (visualmente) tiene la desventaja de quedar “anclado” a la computadora donde se realiza.
Antes de continuar, tenemos que asegurarnos de:
1. Tener instalado el servidor de MySQL y ejecutándose en Windows (u otro sistema)

2. O tener instalado un servidor web como XAMPP que contiene MySQL y que este activo y funcionando
3. Y tener el DRIVER para conectarse con el servidor. En este caso el Connecto ODBC 5.1 de MySQL (que se
puede descargar directamente desde la pagina del producto).
¿Como saber si tenemos instalado o no el DRIVER en nuestra computadora? He aquí los pasos:
1. Ir al panel de control
2. Seleccionar HERRAMIENTAS ADMINISTRATIVAS
3. Seleccionar ORIGENES DE DATOS

4. En la caja de dialogo que aparece, ir primero a la pestaña CONTROLADORES. De la caja de lista que se
muestra, recorrerla hasta encontrar (o no) el Driver de MySQL (como se ve en la imagen):

Si no estuviera, debemos descargarlo e instalarlo en la computadora.
Suponemos que nuestro servidor de MySQL esta en ejecución, y que tenemos una base de datos creada en el a
manera de prueba. Para este ejercicio, se creo una base de datos llamada TEST, con una Tabla llamada
CONTACTOS, que contiene los campos:
a) ID
b) Nombre
c) Apellido
d) Direccion
Y a la cual le agregamos unos registros de prueba.
El siguiente paso es crear una conexión permanente a nuestra base de datos desde el entorno de la herramienta
administrativa. (Por eso, este método no es recomendable para aplicaciones profesionales que se tengan que
instalar en varias computadoras, ya que tendríamos que crear esta conexcion en cada una de las maquinas
donde se ejecutara).
Dentro del administrador de orígenes de datos ODBC (del panel de control, herramientas administrativas),
seleccionamos primero la pestaña de DNS de usuario, y a continuación pulsamos el botón de AGREGAR
Aparecera una segunda ventana, que nos indicara cual será el controlador que usaremos (en este caso el de
MySQL):

Al pulsar finalizar, aparece inmediatamente la caja de dialogo del Conector ODBC Mysql:

Donde pondremos un nombre para nuestra conexión en Data Source Name (este es un nombre con lo cual
nosotros identificamos la conexión y ser ausada por Visual Basic mas adelante).
Una descripción de la conexión que es opcional. Y luego la parte mas importante, el nombre del servidor o su
dirección IP (caso de que este en red o en internet). Como ejemplo tenemos:
a) localhost,
b) 127.0.0.1,
c) 192.168.1.74
El numero de puerto donde esta “escuchando” nuestro servidor.Generalmente se queda con el mismo que
identifica.
El nombre del usuario que tiene acceso a la base de datos y su password (contraseña)
Despues, la base de datos a la cual nos queremos conectar, que aparecerá de la caja combo. Aunque hay un
botón que dice PROBAR CONEXIÓN, al momento en que aparezcan las bases de datos en la caja combo significa
que si hubo una conexión exitosa con el servidor MySQL.
Cuando hayamos terminado le damos ACEPTAR.
Y veremos que la conexión queda en la primer ventana:
Ahora si,ya podemos ir a nuestro proyecto de Visual Basic para crear nuestra aplicación. Debemos crear nuestra
forma con los controles ya conocidos:

Aquí vemos que tenemos nuestras etiquetas, cajas de texto y un control ADO. Recordemos que este control
debe ponerse a la caja de herramientas, agregándolo desde complementos como Microsoft ADO
Data Control 6.0 (forma parte de Office 2007).
Pulsamos el botón derecho del raton para que aparezca el submenú del control y nos vamos a la opción de
PROPIEDADES. Aparecera la caja:

Donde seleccionamos la conexión que creamos previamente y aparece en la caja combo del origen de datos
ODBC. Despues, debemos ir a la pestaña de ORIGEN DE REGISTROS y seleccionar la tabla con la cual
trabajaremos:
Pulsamos aceptar, y ya solo nos queda relacionar nuestras cajas de texto con el control de datos y con el campo
dado como hicimos en todos los ejercicios anteriores.

Ejercicio 38 –Control Data OLE DB con MySQL y Strings
Por el contrario con el método de conexiones de cadena, simplemente pondremos el código respectivo en
nuestra forma y enlazaremos nuestros controles.
Sin embargo, debemos de:
1) Tener el servidor MySQL ejecutándose

2) Tener el driver de conector a MySQL
En este nuevo ejecicio, creamos un proyecto y nuestra forma quedara mas o menos asi:
Vemos que tenemos nuestras etiquetas, cajas de texto y unos botones. Tambien tenemos el control de datos
OLE DB (Microsoft ADO Data Control) que estará invisible al usuario.
Aquí, debemos de poner únicamente código. Ni siquiera las cajas de texto tendrán en sus propiedades el enlace
con ningún control. Comenzamos poniendo el código en la sección general de la forma:
Dim bd As ADODB.Connection
Dim rs As ADODB.Recordset
Esto me prepara dos variables que se usaran como objetos para usar las conexiones. Despues, en el
FORM_LOAD(), pondremos:
Set bd = New ADODB.Connection

bd.ConnectionString = "Driver={MySQL ODBC 5.1
Driver};SERVER=localhost;User=root;DATABASE=test;PORT=3306;Option=3;"
bd.Open

Aquí indicamos que se cree un nuevo objeto ADODB (no visible), que contenga la cadena de conexión:
Driver={MySQL ODBC 5.1 Driver};SERVER=localhost;User=root;DATABASE=test;PORT=3306;Option=3;
Y que finalmente se abra dicha conexión.
Como vemos, tenemos que indicar el controlador de la base de datos a usar, el nombre del servidor (o ip), el
usuario, su clave de acceso (si tiene), la base de datos, el puerto (opcional) y la opción 3.
A continuación, pondremos el código para el botón de CHECK que es quien inicializa los valores del programa:
Dim sql As String

Set rs = New ADODB.Recordset
sql = "Select * from contactos"
rs.Open sql, bd, adOpenDynamic, adLockBatchOptimistic
Text1.Text = rs!nombre
Text2.Text = rs!apellido
Lo que hacemos es que preparamos una variable de cadena que contendrá las instrucciones SQL que
necesitamos para mostrar los datos.
Creamos un nuevo objeto de registro de datos no visible, y abrimos dicho registro con la instrucción rs.OPEN.
Finalmente, asignamos a nuestras cajas de texto, los valores de los campos.
Por ultimo, para que podamos navegar como lo hemos estado haciendo, creamos dos botones de siguiente y
previo y este es su código:
Private Sub cmdPrevio_Click()

rs.MovePrevious
If rs.BOF = True Then
rs.MoveFirst
End If
End Sub
Private Sub cmdSiguiente_Click()
rs.MoveNext
If rs.EOF = True Then
rs.MoveLast
End If
End Sub
Que no se diferencia mucho del código “visual” que hemos visto en ejercicios anteriores.

Ejercicio 39 - VideoLeccion 11: Introducción a Visual Basic 6.0 Con Base de Datos
En este ejercicio haremos un repaso de lo aprendido hasta el momento. Ve el video indicando y realiza lo
siguiente:
El video se divide en 2 partes: la primera de conceptos y la segunda de aplicación. Responde brevemente a lo

siguiente:
Pregunta Respuesta
¿Qué es una base de datos?
Menciona las razones por las

que usar una Base de Datos:
¿Cómo interactua Visual Basic

con una Base de datos?
Parte II
Para este ejercicio deberas tener la base de datos NWIND que viene con Visual Basic, de preferencia en una de
las carpetas que indica el video.
1. Crear un nuevo proyecto, y en una nueva forma, grabar y darle nombre a la forma.
2. Crear dos modulos .BAS para poner nuestro código.
3. En un modulo declararemos nuestras variables globales
a. Global Base as New
4. Como no tenemos una referencia a ADO, debemos crearla primero. Nos iremos al menú de PROYECTO.
REFERENCIAS, y en la caja de dialogo veremos que es muy semenjante a la ventana de COMPLEMENTOS,
de ahí seleccionamos el control OLE DB ACTIVEX DATA OBJECTS 2.1 o superior
5. Regresamos a nuestro modulo de declaración y completamos la sentencia:
a. Global Base as New ADODB.Connection
b. Global RsUsuarios As New ADODB.Recordset
6. Ahora en nuestro modulo de Sentencias creamos una función principal que reemplace a la estándar de
VB. Y escribimos:
a. Sub Main()
i. With base

1. .CursorLocation = adUserClient
2. .Open “”
3. LoginForm.Show
ii. End With
b. End Sub
7. Nos falta conocer la cadena de conexión, para lo cual debemos agregar el control ADO que hemos usado
previamente, insertándolo desde la caja de componentes.
a. Una vez puesto en la forma, abrimos la caja de propiedades y seleccionamos la opción de
generar la cadena de conexión.
b. Seleccionamos el proveedor OLE 4.0 y ubicamos donde esta nuestro archivo de base de datos de
Access.
c. Probamos la conexión
d. Damos aceptar y veremos entonces que se nos ha generado la cadena de conexión que
pondremos en el inciso 2 del paso 6.
e. Modificamos un poco la cadena de conexión para eliminar las referencia de ubicación absoluta y
en su lugar usaremos las instrucciones de APP.PATH para ubicarla de manera relativa en nuestro
proyecto.
8. Ahora, necesitamos cambiar las propiedades del proyecto y seleccionamos la opción de PROPIEDADES
del menú PROYECTO para que en lugar de que se cargue la forma login, se ejecute la subrutina SUB
MAIN() que hemos creado.
Ahora creamos el diseño del formulario para crear una ventana de login. Debemos indicar las etiquetas, cajas de
texto, botón de comando y las propiedades que necesitemos según nuestro diseño.
Una vez creada la interfaz, tenemos que agregar el código para el manejo de registros. Asi que debemos abrir
nuevamente el modulo donde tenemos la función MAIN. Ahí creamos una nueva función que llamaremos
USUARIOS.
El código es:
Sub usuarios()
With RsUsuarios
If .state = 1 then .close
.Open “Select * from usuarios”, Base, adOpenStatic, adLockOptimistic
End With
End Sub
Grabamos nuestro modulo y de regreso a nuestro formulario, en el evento LOAD de la forma, debemos llamar a
esta función:

Usuarios
End Sub
El resto del código es:
Private cmdCerrar_Click()
Unload me

End Sub
Private cmdOk_Click()
If txtuser.text = “” then msgbox “Ingrese nombre de Usuario”, vbInformation, “Aviso”: txtUser.SetFocus: Exit
Sub
If txtuser.pass = “” then msgbox “Ingrese clave de Usuario”, vbInformation, “Aviso”: txtpass.SetFocus: Exit
With RsUsuarios
.Requery
.Find “id=’” & trim(txtuser.text) & “’”
If .eof then
Msgbox “Usuario incorrecto”, vbInformation, “Aviso”
Exit sub
Else
If ¡clave=trim(txtpass.text) then
‘ enviar un formulario
‘ NewUserForm.show
Else
Msgbox “Clave incorrecta”,vbInformation, “Aviso”
Exit Sub
End if
End With
End Sub
Ejercicio 40 - VideoLeccion 12: Registro de Usuarios y Sesión de Login
Ejercicio 41 - VideoLeccion 13: Registro de Usuarios y Sesión de Login
Ejercicio 42 - VideoLeccion 14: Modificar Registro de Usuarios
Ejercicio 43 - VideoLeccion 15: Búsqueda de Registro de Usuario

Ejercicio 44 – BD Consulta SQL
En este ejercicio vamos a hacer una pequeña consulta SQL, para los que no conocen la sintaxis de este
lenguaje pueden consultar el archivo SQL.doc que los va a ayudar. En la propiedad RecordSource,
donde seleccionamos la tabla a utilizar en los ejercicios anteriores, también podemos hacer las
consultas SQL directamente, luego veremos que podemos hacerlas a través de un control y modificar
esta propiedad. Lo primero que debemos hacer es seleccionar la base de datos que vamos a utilizar y
vincularla a la propiedad DataBaseName del control data en este caso, seguimos trabajando con la
base Biblio que viene con Visual Basic. Luego de crear el control data1 y determinar su propiedad
DataBasename, agregamos un control databound grid de componentes: Microsoft Data Bound Grid y
lo agregamos. El formulario muestra el siguiente aspecto visual:
Y la consulta que hacemos en la propiedad RecordSource es:
SELECT * FROM Authors ORDER BY Author ASC
Le decimos que seleccione de la tabla Authors todos los registros por eso usamos el asterisco (*) y que
ordene el campo Author en forma ascendente, esto podría ser DESC o sea descendente.
Así vemos mostrarse en la grilla el listado de autores ordenado alfabéticamente.
PRACTICAS 6 – 10
1.- Hacer una aplicación que permite registrar en una base de datos los datos de los empleados de una empresa.
Los campos son: Nombre, Apellido, Edad, Cargo, Sueldo, Dirección, Teléfono y Fecha de contrato. El programa
debe permitir al usuario obtener distintos tipos de reporte, como por ejemplo: los empleados que ganen más de
10,000 pesos, los empleados mayores de 50 años de edad, etc.
2.- Hacer una aplicación que permita gestionar un almacén de un supermercado.

3.- Hacer una aplicación que permita gestionar un sistema de inscripción de una universidad o un colegio.
4.- Crear un pequeño punto de venta. Esto es un sistema que permita vender artículos, imprimir facturas y
generar reportes de ventas.
5.- Crear una pequeña aplicación que permita gestionar el almacén de una farmacia.
Ejercicio 45 – Ordenando una tabla
Este ejercicio nos permite ordenar los registros de una tabla en forma ascendente o descendente. Los
registros se despliegan en una grilla, y también podemos seleccionar la cantidad de registros que
queremos mostrar. Obviamente necesitaremos conexión con una base de datos, para lo que usaremos
un control data. El código es:
Dim tipo As Byte

Dim Orden As String

Dim N As Long
DBGrid1.Visible = True
N = Text1.Text 'Para entrar el número de registros.
Select Case tipo

Case 1
Orden = "DESC"
Case 2
Orden = "ASC"
End Select

'Selecciona a partir de los últimos.
Data1.RecordSource = "SELECT TOP " & N & " * " & _
"FROM Empleados " & _
"ORDER BY IdEmpleado " & Orden
Data1.Refresh
End Sub

End
End Sub

N=3
Text1.Text = 3
Oden = "ASC"
optAscendente_Click
End Sub
Private Sub optAscendente_Click()

If optAscendente.Value Then tipo = 1
DBGrid1.Visible = False
End Sub
Private Sub Option1_Click()
End Sub
Private Sub optDescendente_Click()

If optDescendente.Value Then tipo = 2
End Sub
Private Sub Text1_Change()

End Sub
Private Sub Text1_Click()

Text1.SelStart = 0
Text1.SelLength = Len(Text1.Text)
End Sub
Private Sub Text1_LostFocus()

If IsNumeric(Text1.Text) Then
If ((Text1.Text) >= 1 And (Text1.Text) <= 9) Then
N = Text1.Text
Else
MsgBox "El número de registros debe estar entre 1 y 9", vbInformation
Text1.SetFocus
End If
Else
MsgBox "Entre un valor numérico entre 1 y 9"
Text1.SetFocus
End If
End Sub

Leccion 46 - VideoLeccion 16: Relacionando Tablas - Mantenimiento Completo de
Clientes
Leccion 47 - VideoLección 17: Mantenimiento Productos
Ejercicio 48 – BD Varias Tablas
La idea de este ejercicio es conectar varias tablas desde el formulario, o sea volcar en campos de texto
los datos de distintas tablas. Para esto deben estar definidas como tabla en en la propiedad
RecordType. Siempre usamos la base de datos Biblio.mdb. Pero recuerden que al bajar el ejercicio
deben actualizar los Path con la ubicación de la base de datos de su disco rígido. El formulario se ve de
la siguiente manera:
Tenemos 6 controles Text para desplegar los datos y cuatro controles data que conectan con distintas
tablas: El Data1 con en su propiedad RecordSource con Tiles, la Data2 con Publishers, la data3 con Title
Author y la Data4 con Authors.
Y los controles de texto: Text1 (Título) en su propiedad DataSource con la data1, Datafield con Title; el
Text2 (Editor) con la Data2 y el Datafield: Name; el Text3 (Editor) con la Data1 y el datafield: Year
publisher; el Text4 (Autor) con la Data4 y el datafield Author; el Text5 con la Data1 y el datafield:
Subject y el Text6 (Comentarios) con la Data1 y el datafield Comments. El codigo correspondiente es:
Option Explicit
'El RecordType es Table
Private Sub Data1_Reposition()

'Con Seek busca los campos correspondientes.Si estos campos están vaciós aparecerá el
asterisco.
Data2.Recordset.Seek "=", Data1.Recordset.Fields("PubID")
If Data2.Recordset.NoMatch Then Text4.Text = "***"

Data3.Recordset.Seek "=", Data1.Recordset.Fields("ISBN")
If Data3.Recordset.NoMatch Then Text2.Text = "***"
Exit Sub
Data4.Recordset.Seek "=", Data3.Recordset.Fields("AU_ID")
End Sub

'refresca las tablas o sea las actualiza
Data2.Refresh
Data3.Refresh
Data4.Refresh
'establece cuales son las llaves para indexarlas.
Data2.Recordset.Index = "PrimaryKey"
Data3.Recordset.Index = "ISBN"
Data4.Recordset.Index = "PrimaryKey"
End Sub
Ejercicio 49 – BD Suma con SQL
Este ejercicio usa un control DBGrid y dos Control Data uno que abre la tabla que se muestra en la grilla
y otro que ejecuta la suma. El control DBGrid, como vimos en el ejemplo anterior debe estar
relacionado a la tabla que usamos. El código en el evento Load es el siguiente:
'La grilla debe estar conectada a la data 1 Data1.DatabaseName = App.Path & "\DBase.mdb"
Data1.RecordSource = "Select * from DBorder " Data2.DatabaseName = App.Path & "\DBase.mdb"
Data2.RecordSource = "SELECT sum(OrderAmt) As total from DBOrder "
Data2.Refresh Text1.Text = Data2.Recordset!total
End Sub
Una vez cargado el programa ejecuta las consultas SQL y nos muestra la suma total del precio de los
productos. Suma todos los campos de la tabla DBOrder y los carga en total, luego le damos salida a
este valor en un control TextBox.

Ejercicio 50 – BD Funciones con SQL
Este ejercicio nos muestra el uso de tres funciones: Mínima, Máxima y Media. El formulario tiene
cuatro controles de Texto donde muestra: en el primero la cantidad de registros (Count ofAuthor) en el
segundo la fecha menor de nacimiento de los Autores (MinofYear Born), el tercero la fecha mayor de
nacimiento de los Autores (Maxofyear Born) y el cuarto la media de los años de nacimiento de los
Aurores (AvgofYear Born).
Cada caja de texto de comunica con el control Data1 y cada Datafield se refiere a : CountofAutor,
MinofYear, Maxofyear y AvgofYear. Y la consulta SQL esta hecha directamente en la propiedad
RecordSource del control Data1, cuya sintáxis es:
SELECT Count(*) AS CountofAuthor, Avg([Year Born]) AS [AvgogYear Born], Min ([Year Born])AS
[MinofYear], Max ([Year Born]) AS [Maxofyear] FROM Authors
Esto selecciona todos los registros, volcando el valor a CountofAuthor, luego la media de los años de
nacimiento de los autores, guardándola en el alias AvgogAuthor como variable y así con los otros
valores.
No olviden cambiar el camino o Path del ejercicio original al cargarlo en sus máquinas. La base usada es
Biblio.mdb.
Ejercicio 51 – BD Visor de SQL
El siguiente ejercicio nos permite crear un Visor de conusltas SQL, esto es de mucha utilidad para
probra el código de las consultas y practicar este lenguaje de consultas estructuradas de información
contenida en tablas de Base de Datos. La explicación esta hecha en Visual basic 6, pero también la
pueden hacer en el 5 cambiando el control MsFlex Grid por el Data Bound Grid de la versión 5.

Como vemos este formulario está compuesto por: dos controles Text, un MSFlexGid, dos botones, uno
que busca y selecciona la base de datos y otro para ejecutar el código SQL de la caja de texto2, un
control data que vincula a una base de datos y un commonddialog que nos permite seleccionar la base
a consultar, el camino de la base seleccionada se muestra en el Text1.
El código es el siguiente:
Option Explicit

On Error GoTo nobase
CommonDialog1.CancelError = True
CommonDialog1.Filter = "Database|*.mdb"
Data1.DatabaseName = CommonDialog1.FileNameaqui se enlaza a una 'Base de Datos.
Data1.Refresh
If Err = 0 Then
Text1.Text = CommonDialog1.FileName 'aqui se muestra el camino de la 'base de datos.
Else
MsgBox Err.Description
End If
nobase: On Error GoTo 0
End Sub

On Error GoTo sqlerror
Data1.RecordSource = Text2 'aqui se vuelca la consulta SQL
Data1.Refresh
Exit Sub
sqlerror: MsgBox Err.Description
End Sub
Como vemos se incluyen alguna rutinas para controlar posibles erroes.

Ejercicio 52 – BD Consultas SQL
Para ejecutar estas consultas SQL, pueden usar el visor del ejercicio anterior, o el Administrador Visual
de datos de Visual basic, abrir la Base Books6.mdb y tipear las consultas en la ventana de código SQL y
ejecutarlas.
El SQL del JetDataManager soporta el uso de operadores como: BETWEEN, IN y LIKE. Ejemplos:
SELECT PubID, Name, StateProv, City FROM Publishers WHERE PubID BETWEEN 10 AND 15
Con IN puedo hacer una lista de condiciones:
SELECT PubID, Name, City, StateProv FROM Publishers WHERE StateProv IN ('NY' , 'CA' , 'RI')
Puedo usar LIKE para obtener una vista cuyos registros cumplan con un patrón específico. Ejemplo:
aquellos registros cuya columna StateProv tenga una letra I en su comienzo, o el PubID sea un valor
determinado.
SELECT PubID, Name, City, StateProvFROM Publichers WHERE StateProv LIKE ' I '
SELECT PubID, Name, City, StateProv FROM Publichers WHERE PubID LIKE 10
Puedo usar WHERE para vincular tablas en un solo conjunto de Datos. la instrucción crea una vista que
muestra el título de un libro y el nombre de la editorial. esto se logra con WHERE al solicitar que
genere una vista donde los valores de la columna PubID de ambas confluyen.
SELECT Titles.Title, Publishers.Name FROM Publishers.Title WHERE Publishers.PubID = Titles.PubID
Se pueden combinar las versiones de WHERE para combinar tablas y limitar registros seleccionados en
una sola instrucción SELECT.
SELECT Titles.PubID, Titles.Title, Publishers.Name FROM Titles, Publishers WHERE Titles.PubID =

Publishers.PubID AND Publishers.PubID BETWEEN 5 AND 10
Podemos modificar el nombre que SQL le asigna a las columnas con la claúsula AS.
SELECT Titles.PubID AS CodigoPub, Titles.Title AS TituloLibro, Publishers.Name AS NombrePub,

Authors.Name AS NombreAutor FROM Titles, Publishers, Authors WHERE Titles.PubID =
Publishers.PubID AND Titles.AUID = Authors.AUID
Funciones SQL: Es posible usar WHERE y las funciones agregadas en un mismo SELECT, para limitar los
registros a incluir en los cálculos que realizan las funciones.SELECT COUNT(UNits) AS
RecuentoUnidades, AVG(Units) AS PromedioUnidades, SUM(Units) AS SumatoriaUnidades, MIN(Units)
AS UnidadMinima, MAX(Units) AS UnidadMaxima FROM BookSales WHERE Qtr = 1

Uso de las funciones de Visual basic en una instrucción SELECT: Al cargar cualquier base de datos
mediante el Jet en un aaplicación Visual Basic, es posible utilizar cualquier función propia del entorno
como parte de una instrucción SQL. Ejemplo 1: Vista con una columna que muestra los tres primeros
caracteres de una columna de la tabla base usando la función Left.
SELECT Left(Name,3), Name FROM Authors
Ejemplo 2: Combinar varias columnas en una sola dentro de una vista:
SELECT Name AS Nombre, City & ' , ' & StateProv & ' ' & Zip AS Domicilio FROM Publishers
Ejemplo 3: También pueden usarse las funciones de Visual basic como parte de la claúsula WHERE, este
ejemplo devuelve aquellos registros que tienen como segundo caracter de la columna Name la letra
'a':
SELECT Name FROM Publishers WHERE Mid$(Name,2,1) = "a"
Las desventajas son la incompatibilidad con otras bases de datos como SQL Server, que no ejecuta las
funciones de Visual Basic y que la velocidad del acceso al ejecutarse la consulta disminuye. Si queremos
ganar en Portabilidad y Velocidad mejor no usarlas.
Lección 18:Incorporando proceso de Facturación
Lección 19: Programando proceso de facturación
Lección 20: Consultas simples, con parámetros y detalladas
Ejercicio 53 – BD con DAO
Cualquier programa que accede a tablas utiliza objetos de acceso a datos, aún si lo hace a través de
controles enlazados sin codificación, utiliza estos objetos de acceso a datos. El Modelo de Objetos de
Acceso a datos puede ser:
DAO 3.51 (versión actual de VB6)
DAO 2.5/3.51(compatible con versiones anteriores)
Y otros Modelos como: RDO (Remote data Object) y ADO (Objetos Activos de Acceso a Datos).
El objeto fundamental en los programas basados en DAO es el Recorset. este es el objeto que contiene
la colección de registros que utilizan los programas. Existen tres tipo diferentes de Recordset: Dynaset,
table y Snapshot. Otro objeto es el Database (o base de datos) que convoca a la Base.

Las Bases tradicionales como FoxPro, DBase, Paradox se orientan a Registros, las operaciones que
tienen que ver con la base se realizan registro por registro (bucle). En cambio Access y otras que
soportan SQL están orientadas a conjuntos de datos, se hacen con sonsultas SQL. Las Bases de Datos
que trabajan con SQL pueden ejecutar operaciones en tablas enteras con una sola instrucción.
El objeto Recordset de tipo Table es adecuado para ejecutar procesamientos orientados a registros.
Los tipos Dynaset y Snapshot lo son para procesamientos orientados a conjuntos de datos. El primero
es dinámico, permite lectura y escritura, el segundo sólo lectura.
Al crear el Dynaset por código en lugar de un control data debemos crear dos objetos: el DataBase y el
RecordSet. Para esto nada mejor que un ejercicio.
En este ejercicio vamos a ver como creamos la DataBase y el RecordSet y contamos los registros que
contiene una de las Tablas. También vamos a usar la propiedad Filter para crear un nuevo RecordSet. El
código es:
Option Explicit Private Sub Form_Load()
'Lo primero que debo hacer es incorporar la referencia Microsoft DAO 3.51.
'creación de los objetos Database y recordset para manejar
'un conjunto de datos de tipo Dynaset
Dim db As Database 'este es el objeto Database
Dim rs As Recordset ' este es el objeto recordset
'creamos dos variables locales

Dim strNombreDB As String
Dim strNombreRS As String
'creamos una variable para contar los registros

Dim intRegs As Integer
'inicializamos las variables

strNombreDB = App.Path & "\books6.mdb"
strNombreRS = "Titles"
'crea los objetos

'abre la base de datos y hace que el objeto db apunte a ella
Set db = DBEngine.OpenDatabase(strNombreDB)
'genera el Dynaset a partir de la tabla Titles
Set rs = db.OpenRecordset(strNombreRS, dbOpenDynaset)
'cuenta los registros en el conjunto de datos
With rs

.MoveLast ' se mueve al final del registro
intRegs = .RecordCount ' obtiene la cantidad de registros
End With
'los vuelca en un msgbox

MsgBox strNombreRS & ": " & intRegs, vbInformation, "Total de Registros en el conjunto de Datos"
'los imprimo en el formulario
Print strNombreRS & ": " & intRegs & " Registros"
Print "____________________________________"
'Uso de la propiedad Filter y el Método OpenRecordset

'para obtener un segundo conjunto de datos.
Dim strFiltro As String
Dim rs2 As Recordset
strFiltro = "YearPub > 1990" 'crea el conjunto filtrado.
'Pruebe a cambiar el año a 1980 o 1993.

rs.Filter = strFiltro
Set rs2 = rs.OpenRecordset
With rs2 .MoveLast ' moverse al final del conjunto de datos

intRegs = .RecordCount 'obtenga el total
End With
MsgBox strFiltro & ": " & intRegs, vbInformation, "Total de registros en el segundo conjunto de datos"
'lo imprime en el formulario
Print strNombreRS & ": " & strFiltro & ": " & intRegs & " Registros"
End Sub
Ejercicio 54 – BD con DAO validacion de campos
En esta ejercitación vamos a trabajar con algunos ejemplos de validación de campos. en este primer
ejercicio vamos a validar filtrando el teclado. O sea podrán ingresar sólo números del 0 al 9, en el
primer cuadro de texto. Y letras en el segundo cuadro de texto. Y ambos en el tercero. El código es:
Private Sub Text1_KeyPress(KeyAscii As Integer)

Dim strvalido As String
strvalido = "0123456789" 'habilita solo números

If InStr(strvalido, Chr(KeyAscii)) = 0 Then
KeyAscii = 0 ' sino es válido lo vuelve nulo
End If
End Sub

KeyAscii = Asc(UCase(Chr(KeyAscii))) ' cambia a mayúsculas.
End Sub

strvalido = "0123456789ABCDEFGHIJKLMNÑOPQRSTUVWXYZÁÉÍÓÚ"
KeyAscii = Asc(UCase(Chr(KeyAscii)))
If KeyAscii > 26 Then ' si no es un codigo de control
KeyAscii = 0
End If
End If
End Sub
En este ejercicio vamos a agregar el uso de un control nuevo que nos facilita la validación de campos.
El MaskedEdit, que debemos traer desde componentes. Este control funciona como el cuadro de texto
pero con algunas propiedades extras. ¡Importante! Debe establecer la propiedad PromptIncluede
como False cuando lo utilice como control enlazado. De lo contrario puede dar Error.
En la propiedad Mask: le determinamos un formato para número telefónico: (##) ### - ####. Y en la
propiedad Format seleccionamos para Importe: $#,##0.00;($#.##0.00).
El código es:
Private Sub Form_Load() 'Carga la lista desplegable

With Combo1

.AddItem "Minorista"
.AddItem "Mayorista"
.AddItem "Distribuidor"
.AddItem "Otro"
.ListIndex = 0 ' estalece de forma predeterminada el primer elemento.
End With
End Sub
Aquí vamos a validar por código un campo requerido y un rango de mayor y menor, pero vamos a
hacer la validación a través de el Click de un Botón.O sea vamos a hacer la validación a nivel de
formulario y no de campos. Para esto vamos a crear una función validoform que cuando chequee que
está todo correcto devuelva un valor adecuado, aceptando la información del formulario, de lo
contrario devuelva un mensaje de error.
El código es:
Option Explicit

Dim strMsj As String
strMsj = validoform()
If strMsj = "" Then
Unload Me
Else
MsgBox strMsj, vbExclamation, "Error de validación"
End If
End Sub
Private Sub Form_Load() 'Carga la lista desplegable

With Combocliente
.AddItem "Minorista"
.AddItem "Mayorista"

.AddItem "Distribuidor"
.AddItem "Otro"
.ListIndex = 0 ' estalece de forma predeterminada el primer elemento.
End With
End Sub
Public Function validoform() As String 'valida el formulario y devuelve un mensaje de error si no es válido
'variables para la validación del rango
Dim intSup As Integer
Dim intInf As Integer
Dim strMsjSupInf As String 'variables para la validación de la longitud
Dim intMinLong As Integer
Dim intMaxLong As Integer
Dim strMsjMinMax As String
Dim strEnviarMsj As String 'valores del rango
intSup = 100 intInf = 0
strMsjSupInf = "El campo Superior/Inferior debe contener un valor entre " & CStr(intInf) & " y " &
CStr(intSup) & "." 'valores de la longitud
intMinLong = 3
intMaxLong = 10
strMsjMinMax = "El campo Mayúsculas debe tener entre " & CStr(intMinLong) & " y " &
CStr(intMaxLong) & " caracteres."
strEnviarMsj = "" 'verifique el campo Superior/Inferior
With txtsupeinf
If Val(.Text) < intInf Or Val(.Text) > intSup Then
strEnviarMsj = strEnviarMsj & vbCrLf & strMsjSupInf & vbCrLf
.SetFocus
End If
End With
'verifique el campo mayúsculas
With txtletrasmayusculas
If Len(.Text) < intMinLong Or Len(.Text) > intMaxLong Then
strEnviarMsj = strEnviarMsj & vbCrLf & strMsjMinMax & vbCrLf
.SetFocus
End If
End With
validoform = strEnviarMsj 'valido el campo dinero
If MaskEddinero.Text <> "" Then 'Tiene datos?
If Not IsNumeric(MaskEddinero.Text) Then ' son numericos?
strEnviarMsj = strEnviarMsj & vbCrLf & "El campo dinero debe tener un valor
numérico." & vbCrLf MaskEddinero
.SetFocus
End If
End If 'verifico el campo combinado
With txtcombinado
If Len(Trim(.Text)) = 0 Then
strEnviarMsj = strEnviarMsj & vbCrLf & "El campo combinado es requerido." &
vbCrLf
.SetFocus
End If
End With
validoform = strEnviarMsj
End Function
Private Sub txtcombinado_KeyPress(KeyAscii As Integer)


strvalido = "0123456789ABCDEFGHIJKLMNÑOPQRSTUVWXYZÁÉÍÓÚ"
KeyAscii = Asc(UCase(Chr(KeyAscii)))
If KeyAscii > 26 Then ' si no es un codigo de control
KeyAscii = 0
End If
End If
End Sub
Private Sub txtletrasmayusculas_KeyPress(KeyAscii As Integer)

KeyAscii = Asc(UCase(Chr(KeyAscii))) ' cambia a mayúsculas.
End Sub
Private Sub txtnumeros_KeyPress(KeyAscii As Integer)

strvalido = "0123456789" 'habilita solo números
KeyAscii = 0 ' sino es válido lo vuelve nulo
End If
End Sub
Ejercicio 55 - Crear un reporte simple utilizando el DataReport

http://www.recursosvisualbasic.com.ar/htm/tutoriales/datareport.htm
Ejercicio 56 - Ejemplo para cargar un Datareport sin estar enlazado a un

DataEnvironment
http://www.recursosvisualbasic.com.ar/htm/trucos-codigofuente-visual-basic/132-datareport-sin-
dataenvironment.htm
Ejercicio 57 - Genera informe de un ListView para imprimir

http://www.recursosvisualbasic.com.ar/htm/trucos-codigofuente-visual-basic/485-generar-informe-de-listview-
para-imprimir.htm
Ejercicio 58 - Refrescar Dataenvironment con parametros

http://www.recursosvisualbasic.com.ar/htm/trucos-codigofuente-visual-basic/487-refrescar-dataenvironment-
con-parametros.htm
Ejercicio 59 - Datareport - Imprimir ficha del cliente

http://www.recursosvisualbasic.com.ar/htm/trucos-codigofuente-visual-basic/481-imprimir-ficha-de-cliente-
con-datareport.htm
Ejercicio 60 - Crystal Reports

http://www.recursosvisualbasic.com.ar/htm/tutoriales/manual-crystal-reports.htm

Ejercicio 61 – BD Crystal Report
Esta es una aplicación generadora de Informes. Estos informes se diseñan a partir de una Base de datos
y la aplicación nos permite añadir un encabezado, fechas, textos, pie de páginas. etc. O hacer en
tiempo de ejecución a partir de un programa de Visual Basic una consulta SQL y luego usando el
control Crystal Report crear un Informe y darle salida por pantalla o impresora. Como vemos son dos
cosas distintas aunque en el fondo cumplen la misma función que es generar un Informe. tenemos la
aplicación Crystal Reports y el control Crystal Report que debemos traer de componentes, para
incluirlo en la Caja de herramientas.
Primero veremos la aplicación Crystal Reports, vamos a Inicio, programas y dentro de Microsoft Visual
Basic selecionamos Crystal reports, una vez dentro de la aplicación, elegimos File o Archivo, nuevo
report o nuevo Informe y cuando nos pregunte qué Base de datos vamos a utilizar le decimos
Biblio.mdb. Entonces veremos una pantalla similar a esta:
La pantalla en tiempo de diseño la tenemos dividida en el encabezado, los detalles donde insertamos
los campos de la tabla con la que vamos a trabajar y el pie de página. Investiguen y prueben las
distintas opciones haciendo uso de la Ayuda. Luego que seleccionamos los campos Au_ID y Author
grabamos el archivo y cerramos la aplicación.
Luego abrimos Visual Basic y creamos la siguiente aplicación:

El formulario contiene un Control data cuya propiedad DatabaseName es Biblio.mdb y la propiedad
RecordSource: la tabla Authors. Luego tenemos una DBGrid traída de componentes cuya propiedad
DataSource es :DataControl.
Un Crystal Report, también traído de componentes, cuya propiedad ReportFileName es el informe que
creamos recientemente,, en la aplicación Crystal Reports: aut.rpt. Luego agregamos una caja de texto
para ingresar la identificación del Autor y actualizar el informe y dos botones, uno que muestra la grilla
actualizada y otro que genera el Informe activando el Control crystal report.
El programa en ejecución al generar el informe de uno de los Autores se ve así:
El código para actualizar la grilla es :

Data1.RecordSource = "Select * from authors Where Au_ID = " & Text1.Text
Data1.Refresh
DBGrid1.Refresh
End Sub
Y para generar el Informe:

CrystalReport1.Action = 1
End Sub
El valor 1 de Action le da salida por pantalla luego, haciendo click en el icono de la impresora podemos
darle salida por la misma.
7. Crystal Reports
http://www.vb6.us/tutorials/using-crystal-reports-vb6-tutorial
Leccion 62 - VideoLección 21: Reportes simples y con parámetros
Leccion 63 - VideoLección 22: Reporte de Factura

Leccion 64 - VideoLección 23: Reportes Avanzandos usando dos o más tablas
Leccion 65 - VideoLección 24: Últimos Arreglos, Empaquetado y distribución

Cuaderno de Trabajo Visual Basic Con BD PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cuaderno de Trabajo Visual Basic Con BD PDF

Uploaded by

Copyright:

Available Formats

CUADERNO DE TRATRABAJO

Cuaderno de Trabajo Visual Basic se encu

Cuaderno de Trabajo Visual Basic con Base de Datos Página 2

Cuaderno de Trabajo Visual Basic con Base de Datos Página 3

Cuaderno de Trabajo Visual Basic con Base de Datos Página 4

Cuaderno de Trabajo Visual Basic con Base de Datos Página 5

Option Explicit 'Esta expresión nos fuerza a declarar las variables.

Private Sub Command1_Click() 'Este boton es el que carga el 'archivo TXT

Cuaderno de Trabajo Visual Basic con Base de Datos Página 6

Private Sub Command2_Click()

Ejercicio 07 – Leer datos desde un archivo

Ahora he aquí el codigo a teclear:

Cuaderno de Trabajo Visual Basic con Base de Datos Página 7

' Borramos el contenido de text1

Y en el boton de Cargar Archivo:

Dim Archivo As String

' Linea almacenará los datos del archivo "Historia.txt"

Dim Linea As String

' Asignamos a la variable Archivo la ruta correcta. El objeto _

App.Path nos devuelve el directorio donde se encuentra nuesta _

aplicación. Luego le agregamos la barra invertida y el nombre _

Archivo = App.Path & "\" & "Historia.txt"

utilizamos el modo Input seguido del número de archivo "#1"

Open Archivo For Input As #1

la sentencia Input, no continue leyendo y se produzca un error en tiempo de eje _

Cuaderno de Trabajo Visual Basic con Base de Datos Página 8

solo mostraría el último contenido de la variable "Linea"

While Not EOF(1)

Line Input #1, Linea

Text1.Text = Text1.Text & Linea

' Cerramos el archivo

Ejercicio 08 – Usar output para grabar un archivo

Los controles que lleva son:

Cuaderno de Trabajo Visual Basic con Base de Datos Página 9

Print #1, Text1

Private Sub Timer1_Timer()

Cuaderno de Trabajo Visual Basic con Base de Datos Página 10

Private Sub Command1_Click()

' Definimos las variables

' Asignamos a texto el contenido de text1

' Abrimos el archivo en modo aPPend para agregar datos al _

Cuaderno de Trabajo Visual Basic con Base de Datos Página 11

' Cerramos el archivo

' Evaluamos la condicion. Si es verdadera abrimos el archivo para leerlo _

Private Sub Command2_Click()

Private Sub Command3_Click()

Cuaderno de Trabajo Visual Basic con Base de Datos Página 12

CONTROLES PARA FORM1

Cuaderno de Trabajo Visual Basic con Base de Datos Página 13

CODIGO PARA FORM1

' Esta variable almacena el path del archivo "Config.dat"

Private Sub Command1_Click()

' Comprobamos si está presionado el control check1. Si lo está _

If Check1.Value = Checked Then

Private Sub Form_Load()

Dim archivo As String

archivo = App.Path & "\" & "Config.dat"

Line Input #1, MiVAriable ' Almacenamos el valor

Cuaderno de Trabajo Visual Basic con Base de Datos Página 14

Cuaderno de Trabajo Visual Basic con Base de Datos Página 15

' Procedimiento para agregar datos separados por comas con la _

Private Sub agregarEntrada(apellido As String, nombre As String, telefono As String, direccion As

Private Sub mostrarDatos()