Está en la página 1de 109

VISUAL BASIC BÁSICO

PASO 4 - IDENTIFICAR Y APLICAR LOS CONCEPTOS BÁSICOS DE MANEJO DE BASES DE


DATOS Y MULTIMEDIA

INDIVIDUAL

WILMER ROMINGUER CORTES CÓDIGO: 1070968240

GRUPO: 201416_8

JAIME RUBIANO LLORENTE

TUTOR

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA (UNAD)

MAYO– 2018
INTRODUCTION
The purpose of this work is to identify the basic structures of Programming, in which is established
graphically through examples of syntax, s, finally, we work INDIVIDUAL to build knowledge, this
work also allows us to generate new unknowns of programming, in that we can ask to meet the
requirements for future computer projects.
Through this activity we can study the basic programming structures and their operation,
developing skills in the use of tools and complying with what is requested in the activity guide.

VALIDACIÓN DE INFORMACIÓN QUE SE INGRESA A UNA BASE DE DATOS Y SUS DIFERENTES


FORMATOS

Puede prohibir o validar datos mediante reglas de validación al escribirlos en bases de datos de
escritorio de Access. Puede usar el generador de expresiones para ayudarle a dar formato a la
regla correctamente. Puede establecer reglas de validación en la vista de diseño de tabla o en la
de hoja de datos de tabla. Hay tres tipos de reglas de reglas de validación en Access:

1. REGLA DE VALIDACIÓN DE CAMPO


Puede usar una regla de validación de campo para especificar un criterio que deben cumplir todos
los valores de campo válidos. No debería tener que especificar el campo actual como parte de la
regla a no ser que use el campo en una función. Las restricciones sobre los tipos de caracteres que
se escriban en un campo pueden aplicarse más fácilmente con una máscara de entrada. Por
ejemplo, un campo de fecha podría tener una regla de validación que no permita valores del
pasado.

EJEMPLOS RÁPIDOS:

Impedir valores de fecha del pasado: >=Fecha()


Por lo general, se acepta este formato de correo electrónico: Is Null OR ((Like "*?@?*.?*") AND
(Not Like "*[ ,;]*"))
Número inferior o igual a cinco: <=5
El campo Divisa no puede ser negativo: >=0
Restringir la longitud de caracteres de una cadena: Len([NombreCampoCadena])<100
2. REGLA DE VALIDACIÓN DE REGISTRO
Puede usar una regla de validación de registro para especificar una condición que necesitan
cumplir todos los registros válidos. Puede comparar valores de distintos campos con una regla de
validación de registro. Por ejemplo, un registro con dos campos de fecha puede necesitar que los
valores de un campo siempre sean anteriores a los del otro (por ejemplo, que FechaDeInicio sea
anterior a FechaDeFinalización).

EJEMPLOS RÁPIDOS:
Asegurarse de que la fecha de finalización no precede a la fecha de inicio: [Fecha de
finalización]>=[Fecha de inicio]
Escribir una fecha obligatoria que esté dentro de un plazo de 30 días a partir de la fecha del
pedido: [FechaObligatoria]<=[FechaPedido]+30

3. Validación en un formulario
Puede usar la propiedad Regla de validación de un control de un formulario para
especificar un criterio que deben cumplir todos los valores indicados para ese control. La
propiedad de control Regla de validación funciona como una regla de validación de campo.
Normalmente, se usa una regla de validación de formulario en lugar de una regla de
validación de campo si se trata de una regla específica del formulario y no de la tabla, sin
importar donde se use.

Tipos de datos Todos los campos de una tabla tienen un tipo de datos que restringe lo
que pueden escribir los usuarios. Por ejemplo, un campo de fecha y hora solo acepta
valores de fecha y hora, un campo de moneda solo acepta datos de moneda, etc.

Propiedades de campo Algunas propiedades de campo restringen la entrada de datos.


Por ejemplo, la propiedad Tamaño del campo de un campo restringe la entrada al limitar la
cantidad de datos.

También puede usar la propiedad Regla de validación para que sea necesario escribir
valores específicos, y la propiedad Texto de validación para informar de errores a los
usuarios. Por ejemplo, si se escribe la regla >100 Y <1000 en la propiedad Regla de
validación, se obliga a los usuarios a especificar valores comprendidos entre 100 y 1000.
Una regla como [FechaFin]>=[FechaInicio] obliga a los usuarios a escribir una fecha de
finalización igual o posterior a una fecha de inicio. Si se escribe el texto “Especifique valores
entre 100 y 1000” o “Especifique una fecha de finalización igual o posterior a la fecha de
inicio” en la propiedad Texto de validación, se indica a los usuarios que cometieron un error
y se explica cómo corregirlo.

Máscaras de entrada Se puede usar una máscara de entrada para validar los datos, lo
que obliga a los usuarios a escribir los valores de una manera específica. Por ejemplo, una
máscara de entrada puede obligar a los usuarios a escribir las fechas en un formato
europeo, como 14/04/2007.
Estos métodos de validación de datos se pueden usar de forma aislada o combinados entre
sí. Los tipos de datos no son opcionales y reportan la validación de tipo de datos más
básica.

Para obtener más información sobre los tipos de datos, tamaños de campo y máscaras de
entrada, vea el artículo Introducción a los tipos de datos y las propiedades de campo.

Tipos de reglas de validación


Se pueden crear dos tipos básicos de reglas de validación:

Reglas de validación de campo Use una regla de validación de campo para comprobar
el valor especificado en un campo al salir de él. Por ejemplo, imagine que tiene un campo
Fecha y escribe >=#01/01/2010# en la propiedad Regla de validación de ese campo. La
regla obligará a los usuarios a escribir fechas que coincidan con el 1 de enero de 2010 o
sean posteriores. Si especifica una fecha anterior a 2010 e intenta colocar el foco en otro
campo, Access no le permitirá abandonar el campo actual hasta que corrija el problema.

Reglas de validación de registro Use una regla de validación de registro para controlar
cuándo puede guardar un registro (una fila de una tabla). A diferencia de una regla de
validación de campo, la regla de validación de registro hace referencia a otros campos de la
misma tabla. Las reglas de validación de registro se crean cuando es necesario comprobar
los valores de un campo en relación con los valores de otro campo. Por ejemplo, imagine
que su empresa le obliga a enviar los productos en un plazo de 30 días y, si no lo hace,
tendrá que reembolsar al cliente parte del precio de compra. Puede definir una regla de
validación de registro como [FechaObligatoria]<=[FechaPedido]+30 para evitar que un
usuario especifique una fecha de envío (el valor del campo FechaObligatoria) demasiado
lejana en el futuro.
Dónde usar las reglas de validación
Se pueden definir reglas de validación para los campos de tabla y los controles de los formularios.
Cuando se definen reglas para tablas, esas reglas se aplican cuando se importan los datos. Para
agregar reglas de validación a una tabla, hay que abrir la tabla y usar los comandos en la pestaña
Campos de la cinta. Para agregar reglas de validación a un formulario, se abre el formulario en la
vista Presentación y se agregan las reglas a las propiedades de los controles individuales.

Los pasos descritos en la sección Agregar una regla de validación a una tabla explican cómo
agregar reglas de validación a los campos de una tabla. Los pasos descritos en la sección Agregar
una regla de validación a un formulario, que aparece más adelante en este artículo, explican cómo
agregar reglas a las propiedades de controles individuales.

Qué se puede incluir en una regla de validación


Las reglas de validación pueden contener expresiones (es decir, funciones que devuelven un solo
valor). Una expresión se puede usar para realizar cálculos, manipular caracteres o comprobar
datos. Una expresión de regla de validación comprueba datos. Por ejemplo, una expresión puede
comprobar un valor de una serie de valores, como “Tokio” o “Moscú” o “París” o “Helsinki”. Las
expresiones también realizan operaciones matemáticas. Por ejemplo, la expresión <100 obliga a
los usuarios a escribir valores inferiores 100. La expresión ([FechaPedido] - [FechaEnvío]) calcula
el número de días transcurrido entre la hora en que se realizó un pedido y la hora en que se envió.

Para obtener más información sobre el uso de las expresiones, consulte el artículo Generar una
expresión.

Principio de página

Agregar una regla de validación a una tabla


Se puede agregar una regla de validación de campo o una regla de validación de registro. La
primera comprueba la entrada en un campo y se aplica cuando el foco deja de ser el campo,
mientras que la segunda comprueba la entrada en uno o más campos y se aplica cuando el foco
deja de ser el registro. Por lo general, una regla de validación de registro compara los valores de
dos o más campos.

Tipo de campo no admiten reglas de validación:


Autonumeración
Objeto OLE
Datos adjuntos
Id. de replicación

Crear una regla de validación de campo


Seleccione el campo que desee validar.

En el grupo Validación de campos de la pestaña Campos, haga clic en Validación y, después, en


Regla de validación de campo.

Use el Generador de expresiones para crear la regla de validación. Para obtener más información
sobre cómo usar el Generador de expresiones, vea el artículo sobre cómo usar el Generador de
expresiones.

Crear un mensaje que se abre cuando la entrada en el campo no es válida


Seleccione el campo donde sea necesario mostrar un mensaje cuando los datos especificados no
sean válidos. Dicho campo debe contar ya con una regla de validación.

En el grupo Validación de campos de la pestaña Campos, haga clic en Validación y, después, en


Mensaje de validación de campo.

Escriba un mensaje adecuado; por ejemplo, si la regla de validación es >10, el mensaje podría ser
“Especifique un valor inferior a 10”.

Puede ver ejemplos de mensajes y reglas de validación de campo en la sección Referencia de


reglas de validación.

Crear una regla de validación de registro


Abra la tabla para la que quiera validar registros.

En el grupo Validación de campos de la pestaña Campos, haga clic en Validación y, después, en


Regla de validación de registro.

Use el Generador de expresiones para crear la regla de validación. Para obtener más información
sobre cómo usar el Generador de expresiones, vea el artículo sobre cómo usar el Generador de
expresiones.
MANEJO DE BASE DE DATOS DESDE EL MISMO VISUAL BASIC

– Editor Sencillo - Guardar (Funciones)

La siguiente aplicación almacena el contenido de una caja de texto en un archivo.

Para crear esta aplicación vamos a utilizar una caja de texto y un dos botones de comando, uno para guardar los datos de la
caja de texto y otro para salir de la aplicación.

▪ Abra un nuevo proyecto.

▪ Diseñe la siguiente pantalla:

▪ Haga clic en la caja de texto y en la ventana propiedades establezca los siguientes valores:

a) En la propiedad MultiLine establezca True.


b) En la propiedad ScrollBars establezca el valor 2 – Vertical.
▪ En el evento Click del botón Guardar escriba:

On Error GoTo ErrorDesconocido

Dim iNumArchivo As Integer

'obtener numero de manipulador de archivo libre


iNumArchivo = FreeFile()

'Abrir archivo para escritura

FileOpen(iNumArchivo, "datos.doc", OpenMode.Output)


PrintLine(iNumArchivo, Text1.Text) FileClose(iNumArchivo)

MsgBox("Los datos han sido guardado.")

Exit Sub
ErrorDesconocido:

MsgBox("Ha ocurrido un error al intentar guardar el archivo.")

▪ En el evento Click del botón Salir escriba:

End

▪ Corra la aplicación.

▪ Después que la aplicación este corriendo escriba algo en la caja de texto.

▪ Cuando halla escrito algo en la caja, haga clic en el botón guardar, y a continuación, aparecerá una ventana
diciendo que “Los datos han sido guardado.”, esto es sino ocurre un error.

▪ Al hacer clic en el botón guardar, automáticamente se creará un archivo llamado DATOS.DOC en el disco “C:”.

PARA VER SI EL ARCHIVO SE HA CREADO REALMENTE EN EL DISCO “C:” HAGA LO SIGUIENTE:

A) Haga doble clic en MY PC.


B) Haga doble clic en Disco C:\
C) Explore todos los archivos que aparecen en el disco “C:\” y verá que entre todos esos archivos se
encuentra el que creamos desde Visual Basic llamado DATOS.DOC.

NOTA: El archivo aparecerá como documento de WORD porque lo hemos creado con la extensión “.DOC” que representan los
archivos de WORD.

Ejercicio01b – Editor Sencillo - Guardar (Stream)


Ahora modificara un poco el ejercicio 01a, para utilizar la clase System.IO y los metodos de lectura y escritura. La interfaz es
la misma, pero cambiara el codigo que va en el boton de guardar:

On Error GoTo ErrorDesconocido

Dim oWrite As System.IO.StreamWriter

oWrite = System.IO.File.CreateText("datos.doc")
oWrite.WriteLine(Text1.Text)

oWrite.Close()

MsgBox("Los datos han sido guardado.")

Exit Sub

ErrorDesconocido:

MsgBox("Ha ocurrido un error al intentar guardar el archivo.")


▪ Corra la aplicación.

▪ Después que la aplicación este corriendo escriba algo en la caja de texto.

Explicación del programa línea por línea:


1 - La primera línea: Esta línea de código permite controlar cualquier error que
ocurra a partir desde donde se escribe. En este caso la
On Error GoTo ErrorDesconocido hemos utilizado para verificar si al grabar los datos ocurre
algún error.

Traducida al castellano esta línea de código quiere decir lo


siguiente:
SI OCURRE UN ERROR SALTA A LA LINEA LLAMADA
ErrorDesconocido

2 - La segunda línea: Esta línea declara una variable para ser el objeto que tome
el metodo de la clase System.IO y pueda grabar en el
Dim oWrite As System.IO.StreamWriter archivo

Traducida al castellano esta línea quiere decir:

DECLARA UNA VARIABLE COMO LA CLASE


STREAMWRITER PARA GRABAR EN UN ARCHIVO

3 - La tercera línea: Ahora el objeto declarado permitira asociarse a la creacion


de un archivo de texto con el metodo CreateText y como
oWrite = parametro el nombre y ubicación del archivo a crear
System.IO.File.CreateText("datos.doc")
Traducida al castellano esta línea quiere decir:

CREA UN ARCHIVO DE TEXTO LLAMADO DATOS.DOC


USANDO LA CLASE SYSTEM.IO.FILE PARA EL OBJETO
OWRITE
4 - La cuarta línea: Esta linea es la que permite grabar todo el texto introducido
en el control TEXTBOX de nuestro formulario, es decir, lo
oWrite.WriteLine(Text1.Text) que el usuario ha introducido

Traducida al castellano esta línea quiere decir:

GRABAR TODAS LAS LINEA INTRODUCIDAS POR EL


USUARIO

5 - La quinta línea: Finalmente, esta linea indica que el objeto debe cerrarse
oWrite.Close() para proceder con la grabacion final del archivo y que no se
quede abierto

Traducida al castellano esta linea quiere decir:

CIERRA EL ARCHIVO
6 - La sexta línea: Esta línea muestra una ventana con el mensaje escrito
entre los paréntesis y la comilla. En este caso hemos
MsgBox (“Los datos han sido guardado.”) especificado un mensaje que informa al usuario si los
datos se han grabado correctamente.

7 - La séptima línea: Esta línea de código permite separar un bloque de código


con otro bloque de código. Se ha utilizado para separar las
Exit Sub últimas dos líneas de código que muestran el mensaje de
error en caso de que este ocurra.

Si esta línea de código no se escribe, entonces el mensaje


de error aparecería aun los datos se hallan guardado
correctamente, esto es, porque no habría nada que separe
el código principal que almacena los datos, del código que
muestra el error en caso de que ocurra.

Es lógico que el error solamente deba aparecer si ocurre


algún error. Y debe de existir algo que separe un bloque de
código de otro código y para esto se utiliza Exit Sub.

8 - La octava línea: Esta línea de código se ha declarado como una etiqueta que
va a permitir desde el punto de vista lógico asignarle un
ErrorDesconocido: nombre a una línea.

Al establecer la etiqueta “ErrorDesconocido:” en una línea,


es posible acceder al bloque de código que se encuentra
después de la etiqueta utilizando la sentencia Goto como se
especifico en la primera línea.

Esto es, porque es la única forma de acceder a la


codificación que reside después de la sexta línea de código
que corresponde a la codificación Exit Sub.

9 - La novena línea: Muestra un mensaje diciendo que ha ocurrido un error al


intentar guardar el archivo en el disco.
Msgbox(“Ha ocurrido un error al intentar
guardar el archivo.”)

Ejercicio 02a – Editor Sencillo – Leer

Ahora, agregaremos la funcion de poder leer un archivo de texto (secuencial) utilizando las funciones de archivo
de VisualBasic.NET. La interfaz es muy similar a la del ejercicio 1, solo que agregaremos un nuevo boton para la
lectura del archivo y el codigo necesario:
En el boton cmdSalir pondremos el codigo:
End

En el boton cmdGuardar pondremos el codigo:


On Error GoTo ErrorDesconocido

Dim iNumArchivo As Integer

'obtener numero de manipulador de archivo libre


iNumArchivo = FreeFile()

'Abrir archivo para escritura

FileOpen(iNumArchivo, "datos.doc", OpenMode.Output)


PrintLine(iNumArchivo, Text1.Text) FileClose(iNumArchivo)

MsgBox("Los datos han sido guardado.")

Exit Sub

ErrorDesconocido:
MsgBox("Ha ocurrido un error al intentar guardar el archivo.")

Y en el boton cmdLeer pondremos el codigo:


Dim Linea1, Linea2, Linea3, Linea4, Linea5, Linea6, Linea7, Linea8 As String Dim
iNumArchivo As Integer

iNumArchivo = FreeFile()
FileOpen(iNumArchivo, "datos.doc", OpenMode.Input) Linea1
= LineInput(iNumArchivo)

Linea2 = LineInput(iNumArchivo)
Linea3 = LineInput(iNumArchivo)
Linea4 = LineInput(iNumArchivo)
Linea5 = LineInput(iNumArchivo)
Linea6 = LineInput(iNumArchivo)
Linea7 = LineInput(iNumArchivo)
Linea8 = LineInput(iNumArchivo)
FileClose(iNumArchivo)

Text1.Text = Linea1 & Chr(10) & Chr(13) & Linea2 & Chr(10) & Chr(13) & Linea3 & Chr(10)

& Chr(13) & Linea4 & Chr(10) & Chr(13) & Linea5 & Chr(10) & Chr(13) & Linea6 & Chr(10) _ & Chr(13)
& Linea7 & Chr(10) & Chr(13) & Linea8

Notemos que el codigo de Guardar es el mismo que en el ejercicio numero 1a. En el caso del boton de leer,
usamos las funciones de FreeFile, FileOpen y FileClose para determinar el numero del manejador disponible,
abrir el archivo según su modo y cerrar el archivo.

Usamos la funcion LineInput para leer linea por linea el archivo de texto. Tome nota que se han declarado solo 8
variables para leer 8 lineas de un archivo. Al finalizar, pondremos lo que hemos leido dentro del control de caja
de texto para mostrarlo en la pantalla.

ADVERTENCIA: Cuando lo ejecute es probable que encuentre algunos errores. Identifiquelos e investigue
porque sucedieron. Comente en clase o con su profesor que fue lo que sucedió.

Editor Sencillo – Leer (Stream)

Ahora modificaremos el ejercicio 2 para utilizar la clase System.IO y los metodos de lectura. La interfaz del
programa es la misma y el codigo para los botones es igual excepto para el de lectura del archivo que queda de
la siguiente manera:

Dim Linea1, Linea2, Linea3, Linea4, Linea5, Linea6, Linea7, Linea8 As String Dim
EntireFile As String

Dim oRead As System.IO.StreamReader

oRead = System.IO.File.OpenText("datos.doc")
'EntireFile = oRead.ReadToEnd()

Linea1 = oRead.ReadLine()
Linea2 = oRead.ReadLine()
Linea3 = oRead.ReadLine()
Linea4 = oRead.ReadLine()
Linea5 = oRead.ReadLine()
Linea6 = oRead.ReadLine()
Linea7 = oRead.ReadLine()
Linea8 = oRead.ReadLine()

EntireFile = Linea1 + Linea2 + Linea3 + Linea4 + Linea5 + Linea6 + Linea7 + Linea8 Text1.Text =
EntireFile

Ahora, sustituye la linea que esta documentada por todas las lineas que leen el archivo linea por linea dejando la
ultima (Text1.text = EntireFile) intacta. Esto es, pon como comentario cada una de las lineas que se leen y quita
el comentario a la que esta marcada. Ve la diferencia.
Discute en clase cual de las opciones es mejor y porque.
Editor Sencillo Lectura de un archivo utilizando un bucle
En ocasiones será muy necesario leer el archivo utilizando un bucle que permitirá leer a totalidad el archivo. Esto es porque
no se conoce de antemano el total de líneas del archivo y aun conociéndola a veces son demasiadas líneas y seria anormal
declarar tantas variables para leer el archivo.

Supóngase un archivo con 1000 mil líneas habría que declarar mil variables para almacenar cada línea del archivo, por tal
razón de ahora en adelante solo utilizaremos bucles para la lectura de nuestros archivos de texto.

En base al ejercicio 02a, crea un nuevo proyecto y redibuja la misma interfaz que este con los mismos controles. Pero en el
boton de Leer Archivo, debemos incluir el ciclo de lectura como sigue:

Dim Linea As String

Dim iNumArchivo As Integer


iNumArchivo = FreeFile()

FileOpen(iNumArchivo, "datos.doc", OpenMode.Input)

Do While Not EOF(iNumArchivo) Linea =


LineInput(iNumArchivo)

Text1.Text = Text1.Text + Linea + Chr(13) + Chr(10)

Loop
FileClose(iNumArchivo)

Editor Sencillo Lectura con Bucle y Stream


Ahora llegamos a nuestra primera practica.
Basados en el Ejercicio 03 y en el ejercicio 02b (Stream), realiza el mismo editor para que lea un archivo de texto utilizando
un ciclo y la clase System.IO con su metodo de StreamReader.

No es dificil, ¿puedes hacerlo verdad?


Creación de un editor sencillo
Vamos a crear una aplicación que permite guardar y abrir un documento escrito en una caja de texto. Utilizaremos para
ello los controles .NET OpenFileDialog y SaveFileDialog para guardar y abrir los archivos.

Para crear nuestra aplicación siga los siguientes pasos:

▪ Inicie un nuevo proyecto en Visual Basic.

▪ Agregue los controles descritos desde la barra de controles a su formulario.

▪ Dibuje una caja de texto y cuatro botones de comando en la parte inferior de la caja. Tal y como se muestra en
la imagen de la siguiente página…
▪ Establezca los siguientes valores en las propiedades de los controles utilizados:

Control Propiedad Valor


Form1 Caption Editor
BorderStyle 1- Fixed Single
Height 5460
Width 7635

Text1 Text (Vació)


MultiLine True
ScrollBars 2- Vertical
Heigth 4215
Width 7215
Top 120
Left 120

cmdAbrir Caption &Abrir


cmdGuardar Caption &Guardar

cmdNuevo Caption &Nuevo

cmdSalir Caption &Salir

▪ En el evento Click del botón Abrir escriba el siguiente bloque de código:

Text1.Text = ""

On Error GoTo NoSeleccionoArchivo

OpenFileDialog1.Filter = "Archivos de texto (TXT)" & Chr(32) & Chr(124) & "*.txt"
OpenFileDialog1.ShowDialog()

Dim Linea As String

Dim iNumArchivo As Integer


iNumArchivo = FreeFile()

FileOpen(iNumArchivo, OpenFileDialog1.FileName, OpenMode.Input)

Do While Not EOF(iNumArchivo) Linea =


LineInput(iNumArchivo)

Text1.Text = Text1.Text + Linea + Chr(13) + Chr(10)

Loop
FileClose(iNumArchivo)

Exit Sub
NoSeleccionoArchivo:

Explicación del código anterior:

- Primera línea:

Text1.Text = “”

Permite limpiar la caja de texto. Esto es en caso de que anteriormente se encontrará algún archivo abierto. Es normal
que si se va a mostrar el contenido de algún archivo el lugar donde se mostrará debe de estar limpio.

- Segunda línea:

On Error GoTo NoSeleccionoArchivo

Esta línea se ha declarado en caso de que ocurra un error al intentar abrir el archivo.
Esto es muy importante porque en ocasiones pueden ocurrir errores desconocidos y estos errores deben ser controlados
desde la aplicación. Esta línea la he declarado principalmente porque siempre que no se selecciona algún archivo en el cuadro
de dialogo abrir ocurrirá un error, es decir, cuando se haga clic en el botón Cancelar del cuadro de dialogo Abrir. No intente
averiguar porque este error ocurre, simplemente especifique siempre esta línea de código cuando intente abrir un archivo.

- Tercera línea:

OpenFileDialog1.Filter = "Archivos de texto (TXT)" & Chr(32) & Chr(124) & "*.txt"

Esta línea es muy importante. Permite especificar el tipo de archivo que permitirá visualizar el cuadro de dialogo abrir.
La propiedad Filter te permite especificar el tipo de archivo que el cuadro de dialogo podrá visualizar a la ahora que este
sea activado.

Estructura de la línea anterior:

OpenFileDialog1.Filter = "Archivos de texto (TXT)" & Chr(32) & Chr(124) & "*.txt"

Entre comillas se especifica el texto que Esta combinación Extensión de los


aparecerá en Tipo de archivo del cuadro de permite obtener el archivos que se
diálogo Abrir. carácter ¦. mostrarán.

En este caso se ha especificado que el cuadro de dialogo Abrir solo visualice los tipos de archivos de texto. Si corre la
aplicación y hace clic en el botón Abrir aparecerá la pantalla de Abrir con la siguiente configuración:

Puede observar que en la caja Files of type (Tipo de archivos) aparece el texto que especificamos en la propiedad Filter de
control Common Dialog. Se pueden especificar más tipos de archivos pero esto lo veremos más adelante.

- Cuarta línea:

OpenFileDialog1.ShowDialog()

Esta línea de código no tiene mucha novedad simplemente muestra el cuadro de dialogo abrir. El
método ShowDialog significar “Mostrar Abrir”, es decir, “Mostrar el cuadro Abrir”.
- Quinta línea:

Dim Linea As String


Esta línea de código declara una variable llamada “Linea” donde se almacenará cada línea de datos del archivo abierto.

- Octava línea:

FileOpen(iNumArchivo, OpenFileDialog1.FileName, OpenMode.Input)

La única novedad que vemos en esta línea de código es “OpenFileDialog1.FileName”. Antes especificábamos el archivo
directamente pero en esta ocasión dejamos que la ventana de diálogo Abrir tome el control del nombre del archivo.

El archivo que se seleccione en la ventana de dialogo Abrir, este será el archivo que se muestre en el Editor. La

propiedad FileName almacena el PATH o la ruta completa del archivo seleccionado.

- Ultimas líneas:

Do While Not EOF(iNumArchivo) Linea =


LineInput(iNumArchivo)

Text1.Text = Text1.Text + Linea + Chr(13) + Chr(10)

Loop
FileClose(iNumArchivo)

Exit Sub
NoSeleccionoArchivo:

Estas ultimas líneas las hemos visto ya anteriormente que se utilizan para la lectura de un archivo completo utilizando un
bucle. Más arriba ya habíamos trabajado con esto. La sentencia de bloqueo Exit Sub también la vimos anteriormente.

▪ En el vento Click del botón Guardar escriba:

On Error GoTo NoSeleccionoArchivo

SaveFileDialog1.Filter = "Archivos de texto (TXT)" & Chr(32) & Chr(124) & "*.txt"

SaveFileDialog1.ShowDialog()
Dim iNumArchivo As Integer
iNumArchivo = FreeFile()

FileOpen(iNumArchivo, SaveFileDialog1.FileName, OpenMode.Output)

Print(iNumArchivo, Text1.Text)
FileClose(iNumArchivo)
MsgBox("Archivo Guardado.")

Exit Sub
NoSeleccionoArchivo:
Explicación del código anterior:

Lo único nuevo que vemos en este bloque de código es el método ShowDialog que permite mostrar el cuadro de dialogo
Guardar.

En esta ocasión utilizamos este método para guardar el archivo en el disco duro. ShowDialog significa “Mostrar Guardar”, es
decir, “Mostrar el cuadro de diálogo Guardar”.
Lo demás lo hemos visto anteriormente. Por ejemplo, utilizamos en esta ocasión el método Output para guardar y
especificamos SaveFileDialog1.FileName en vez de especificar un nombre fijo o un nombre constante. Ya explique eso
anteriormente.

▪ En el evento Click del botón de comando Nuevo escriba:

Text1.Text = ""
Text1.Focus()

Explicación del código anterior:

- Primera línea:

La primera línea quita cualquier texto que se halla mostrado o escrito en la caja de texto.

- Segunda línea:

Hace que la caja de texto reciba el enfoque, es decir, que el cursor se posiciones en la caja.

▪ En el evento Click del botón de comando Salir escriba:

‘Sale de la aplicación.
End

▪ Corra la aplicación y verá que tiene un pequeño Editor. Puede perfeccionarlo agregando negrita, cursiva,
subrayado, tipo de letra, justificaciones de texto, etc.

– Editor Sencillo con Stream


Basados en el Ejercicio 04 y en el ejercicio 02b (Stream), realiza el mismo editor sencillo que tenga las funcionalidades
de abrir, guardar un archivo de texto en donde quiera el usuario utilizando un ciclo y la clase System.IO con su metodo
de StreamReader.

– Archivos con Estructura de Base de Datos

VisualBasic.NET no contiene un manejador de base de datos como algunos otros lenguajes, y se apoya en otros
productos como Access, SQL Server, MySQL, FireBird, Oracle, etc. Sin embargo, para ciertos proyectos se puede
recrear una estructura similar a la base de datos con archivos secuenciales o aleatorios.

Vea la Leccion 3 de su Manual del Curso para una explicacion detallada de cómo crear una Agenda Telefonica
usando archivos secuenciales.
– Agenda

Ahora, recrea el ejercicio 05, utilizando la clase System.IO con las caracteristicas de los metodos Stream. Las
caracteristicas son similares.
– 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 WordPad o 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, 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 TextBox1 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:

Public Class Form1

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


Button1.Click

Dim EntireFile As String


Dim oRead As System.IO.StreamReader

oRead = System.IO.File.OpenText("archivotexto.txt")
EntireFile = oRead.ReadToEnd()

TextBox1.Text = EntireFile

End Sub

Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


Button2.Click

RichTextBox1.LoadFile("archivortf.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
End Class

– 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:

End

En el boton de Borrar TextBox


' Borramos el contenido de text1

Textbox1.text = ""

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 _
' My.Application.Info.DirectoryPath nos devuelve el directorio donde se encuentra
nuesta _
'aplicación. Luego le agregamos la barra invertida y el nombre _
'del archivo.

Archivo = My.Application.Info.DirectoryPath & "\" & "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"
Dim iNumArchivo As Integer
iNumArchivo = FreeFile()
FileOpen(iNumArchivo, Archivo, OpenMode.Input)
'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(iNumArchivo)
'Line Input #1, Linea
Linea = LineInput(iNumArchivo)
TextBox1.Text = TextBox1.Text & Linea
End While

' Cerramos el archivo


'Close #1
FileClose(iNumArchivo)
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

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


Button1.Click
' Archivo que contendrá el path del archivo a usar
Dim archivo As String

archivo = My.Application.Info.DirectoryPath + "\" + "HorayFecha.txt"


' Abrimos el archivo en modo Output
FileOpen(1, archivo, OpenMode.Output)

'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, TextBox1.Text)
Print(1, TextBox2.Text)

'Cerramos el archivo
FileClose(1)

End Sub

Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


Timer1.Tick
' 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

TextBox1.Text = TimeOfDay()
TextBox2.Text = DateValue(Now())

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:

Private Sub cmdGrabar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


cmdGrabar.Click
' Definimos las variables
Dim archivo As String
Dim texto As String
Dim mensaje As String
' asignamos a la variable archivo la ruta correcta
archivo = My.Application.Info.DirectoryPath + "\" + "Prueba.txt"

' Asignamos a texto el contenido de text1


texto = TextBox1.Text

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


'archivo que ya contiene datos
FileOpen(1, archivo, OpenMode.Append)

' Escribimos un salto de carro y el contenido de la variable texto


Print(1, vbCrLf + texto)

' Cerramos el archivo


FileClose(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
FileOpen(1, archivo, OpenMode.Input)

TextBox1.Text = ""
' Borramos el contenido de text1 para que no vuelva
'a imprimir lo que estaba escrito
While Not EOF(1)
texto = LineInput(1)
TextBox1.Text = TextBox1.Text + texto + vbCrLf
End While
Else
Exit Sub
End If
FileClose(1)

End Sub

Private Sub cmdLimpiar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdLimpiar.Click
TextBox1.Text = ""
End Sub

Private Sub cmdSalir_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


cmdSalir.Click
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"


Dim archivo As String

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


Button1.Click

' Establecemos el path


archivo = My.Application.Info.DirectoryPath & "\" & "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 CheckBox1.Checked = True Then


FileOpen(1, archivo, OpenMode.Output)
Print(1, "noAbrir")
FileClose(1) ' Cierra el archivo
End If
Me.Visible = False ' descarga este formulario
Form2.Show() ' muestra el otro form

End Sub

Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load


Dim archivo As String
Dim MiVAriable As String ' Variable para almacenar la cadena que se lea _
'del archivo "config.dat"

archivo = My.Application.Info.DirectoryPath & "\" & "Config.dat"


FileOpen(1, archivo, OpenMode.Input) ' Abre el archivo para leerlo
MiVAriable = LineInput(1) ' Almacenamos el valor
FileClose(1) ' Cerramos el archivo
If MiVAriable = "noAbrir" Then ' Hacemos la comprobación
Me.Visible = False
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

Public Class Form1


' 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
Dim archivo As String

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

Private Sub agregarEntrada(ByVal apellido As String, ByVal nombre As String, ByVal telefono
As String, ByVal direccion As String, ByVal dni As String)
' Las variables que van en los parámetros del procedimiento _
'contienen el valor de los textBox

archivo = My.Application.Info.DirectoryPath + "\" + "datos.dat" ' variable que almacena


el path del archivo datos.dat
FileOpen(1, archivo, OpenMode.Append)
' Abrimos el archivo en modo Append para agregar datos al final del archivo

Write(1, apellido, nombre, telefono, direccion, dni)


'Write #1, apellido, nombre, telefono, direccion, dni
' Grabamos los datos pasandole como parámetro a la sentencia Write las
' variables se paradas por comas
FileClose(1) ' 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 = My.Application.Info.DirectoryPath + "\" + "datos.dat"

FileOpen(1, archivo, OpenMode.Input)


' Abrimos el archivo para leer los datos mediante la sentencia Input

While Not EOF(1) ' Comenzamos a leer el archivo


Input(1, apellido)
Input(1, nombre)
Input(1, telefono)
Input(1, direccion)
Input(1, dni)
'Input #1, apellido, nombre, direccion, telefono, dni

'If contador = ListBox1.ListIndex Then


If contador = ListBox1.SelectedIndex 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

txtApellido.Text = apellido
txtNombre.Text = nombre
txtDireccion.Text = direccion
txtDocumento.Text = dni
txtTelefono.Text = telefono
FileClose(1)
Exit Sub
End If
contador = contador + 1

End While
FileClose(1)
End Sub

Private Sub cargarDatos()


ListBox1.Items.Clear()
' Borramos los datos previos para que no vuelva a duplicar los datos
archivo = My.Application.Info.DirectoryPath + "\" + "datos.dat"

FileOpen(1, archivo, OpenMode.Input)


'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)
Input(1, nombre)
Input(1, direccion)
Input(1, telefono)
Input(1, dni)
'Input #1, apellido, nombre, direccion, telefono, dni
ListBox1.Items.Add(apellido)
End While
FileClose(1)

End Sub

Private Sub cmdSalir_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


cmdSalir.Click
End
End Sub

Private Sub cmdCargar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


cmdCargar.Click
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

Private Sub cmdAgregar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdAgregar.Click
' Esta rutina es para que no se puedan grabar datos si el _
'campo "Apellido" está vacío, mostrando un mensaje y luego saliendo '
de la rutina. Si esta todo bien ignora lo anterior y se ejecuta la
' rutina "agregarEntrada", que lleva como parámetros el conenido de las
' cajas de texto

If txtApellido.Text = "" Then


MsgBox("El campo Apellido no puede estar vacio", vbInformation + vbOKOnly,
"Advertencia")
Exit Sub
End If

agregarEntrada(txtApellido.Text, txtNombre.Text, txtDireccion.Text, txtTelefono.Text,


txtDocumento.Text)

End Sub

Private Sub ListBox1_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles


ListBox1.Click
mostrarDatos()
'Llamamos a la rutina que recupera los datos cada vez que seleccio _
' namos un elemento del control List1

End Sub

– 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

Public Class Form1


'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 Structure T_personas
<VBFixedString(20)> Public Apellido As String
<VBFixedString(20)> Public Nombre As String
<VBFixedString(10)> Public edad As String
End Structure

'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
Private Sub cmdGrabar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
cmdGrabar.Click
' Pasamos los parámetros de los textBox al procedimiento que grabará los(datos)
grabarDatos(txtA_Apellido.Text, txtA_Nombre.Text, txtA_Edad.Text)

End Sub
Private Sub cmdLeer_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
cmdLeer.Click
'Llamamos al procedimiento para leer los datos del archivo
leerDatos()

End Sub
Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
' Aquí cargamos los combos con valores del 1 al 100 cuando inicia el form
Dim x As Integer

For x = 1 To 100
cboA_Seleccion.Items.Add(x)
cboL_Seleccion.Items.Add(x)
Next x

End Sub

' Procedimiento para grabar registros


Private Sub grabarDatos(ByVal Apellido As String, ByVal Nombre As String, ByVal edad As
String)

'Abrimos el archivo en modo aleatorio y le pasamos el tamaño de la _


'estructura()

FileOpen(1, My.Application.Info.DirectoryPath + "\" + "datos.dat", OpenMode.Random, , ,


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 = CLng(cboA_Seleccion.Text)

' Grabamos los datos


FilePut(1, persona, nRegistro)

' Cerramos el archivo


FileClose(1)
End Sub

Private Sub leerDatos()


'Abrimos el archivo en modo aleatorio y le pasamos el tamaño de la
FileOpen(1, My.Application.Info.DirectoryPath + "\datos.dat", OpenMode.Random, , ,
Len(persona))

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


nRegistro = CLng(cboL_Seleccion.Text)

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


FileGet(1, persona, nRegistro)

'Cerramos el archivo
FileClose(1)

' Mostramos en los labels los valores leidos


txtL_Apellido.Text = persona.Apellido
txtL_Nombre.Text = persona.Nombre
txtL_Edad.Text = persona.edad

End Sub

Private Sub cmdCantReg_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdCantReg.Click
Dim tamaño As Integer

tamaño = FileLen(My.Application.Info.DirectoryPath & "\" + "datos.dat") / Len(persona)


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

End Sub
– Convertir Agenda VB6 a VB.NET (con Arch. Aleatorios)

La siguiente Agenda es muy simple creada en Visual basic 6.0 utilizando Ficheros de acceso aleatorio o también
denominados Random , para almacenar los datos de los contactos de la Agenda. La practica (y reto) consiste en
convertir todo el codigo mostrado a continuacion en las sentencias de VB.NET. Para ello puede ayudarte de los
ejemplos dados anteriormente en este cuaderno, y las lecciones 1, 2 y 3 de tu Guia de Curso.

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. 'Variables

3.

4.
' Estructura para los datos de los contactos de la agenda
5. Private Type Contacto

6. Nombre 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.

115. Get #FileFree, RegActual, Datos


116.

117. 'Este es el registro que se elimina


118. If RegActualTemp = Pos Then
119. RegActual = RegActual + 1
120. End If
121.
122. Get #FileFree, RegActual, Datos
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.
137. RegActual = RegActual + 1
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


196. VisualizarDatos
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.

224. VisualizarDatos
225. txtNombre.SetFocus
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
239. RegActual = RegActual + 1
240. 'Cargamos los datos en el textbox del siguiente registro
241. VisualizarDatos
242. End If
243. txtNombre.SetFocus
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
257. VisualizarDatos
258. End If
259.
260. txtNombre.SetFocus
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
294. VisualizarDatos 295.
296. Else
297. MsgBox "Nombre: " & txtBuscar & " No se ha encontrado el registro"
298. End If
299. txtNombre.SetFocus 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. End Select


315. End Function
316.
' Establece los captions de los controles Command del formulario
317.

318.

319. Private Sub Cargarcaptions()

320. Me.Caption = " Agenda simple utilizando archivos aleatorios "


CmdAnterior.Caption = " Anterior "
321.
cmdSiguiente.Caption = " Siguiente "
322. cmdGuardar.Caption = " Guardar "
cmdEliminar.Caption = " Eliminar "
323. cmdNuevo.Caption = " Nuevo "

Ejercicio 13 – 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
 Unos botones de comandos para realizar las acciones.

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


Public Class Form1
Const FILTRO_EXTENSIONES As String = "Archivos de texto (txt)|*.txt|" & _
"Rich Text Formato (RTF)|*.rtf|" & _
"Archivos INI|*.ini|Archivos HTML|" & _
"*.htm|Todos los archivos|*.*"

Private Sub cmdNegrita_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdNegrita.Click
If Not RichTextBox1.SelectionFont Is Nothing Then

Dim currentFont As System.Drawing.Font = RichTextBox1.SelectionFont


Dim newFontStyle As System.Drawing.FontStyle

If RichTextBox1.SelectionFont.Bold = True Then


newFontStyle = FontStyle.Regular
Else
newFontStyle = FontStyle.Bold
End If

RichTextBox1.SelectionFont = New Font(currentFont.FontFamily, currentFont.Size,


newFontStyle)
End If
End Sub

Private Sub cmdNuevo_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdNuevo.Click
RichTextBox1.Text = ""
End Sub

Private Sub cmdGuardar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdGuardar.Click
'Guardar el archivo
Dim res As DialogResult
Dim fname As String
SaveFileDialog1.Filter = FILTRO_EXTENSIONES
'SaveFileDialog1.InitialDirectory = "C:\"
res = SaveFileDialog1.ShowDialog()
If res = Windows.Forms.DialogResult.OK Then
fname = SaveFileDialog1.FileName
If SaveFileDialog1.FilterIndex = 2 Then
RichTextBox1.SaveFile(fname)
Else
RichTextBox1.SaveFile(fname, RichTextBoxStreamType.PlainText)
End If
End If
End Sub

Private Sub cmdAbrir_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdAbrir.Click
Dim res As DialogResult
OpenFileDialog1.Filter = FILTRO_EXTENSIONES
'OpenFileDialog1.InitialDirectory = "C:\"
res = OpenFileDialog1.ShowDialog
If res = Windows.Forms.DialogResult.OK Then
If OpenFileDialog1.FilterIndex = 2 Then
RichTextBox1.LoadFile(OpenFileDialog1.FileName)
Else
RichTextBox1.LoadFile(OpenFileDialog1.FileName,
RichTextBoxStreamType.PlainText)
End If
End If
End Sub

Private Sub cmdCortar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdCortar.Click
RichTextBox1.Cut()
End Sub

Private Sub cmdPegar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdPegar.Click
RichTextBox1.Paste()

End Sub

Private Sub cmdItalica_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdItalica.Click
If Not RichTextBox1.SelectionFont Is Nothing Then

Dim currentFont As System.Drawing.Font = RichTextBox1.SelectionFont


Dim newFontStyle As System.Drawing.FontStyle

If RichTextBox1.SelectionFont.Bold = True Then


newFontStyle = FontStyle.Regular
Else
newFontStyle = FontStyle.Italic
End If

RichTextBox1.SelectionFont = New Font(currentFont.FontFamily, currentFont.Size,


newFontStyle)
End If
End Sub

Private Sub cmdSubrayado_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdSubrayado.Click
If Not RichTextBox1.SelectionFont Is Nothing Then

Dim currentFont As System.Drawing.Font = RichTextBox1.SelectionFont


Dim newFontStyle As System.Drawing.FontStyle

If RichTextBox1.SelectionFont.Bold = True Then


newFontStyle = FontStyle.Regular
Else
newFontStyle = FontStyle.Underline
End If

RichTextBox1.SelectionFont = New Font(currentFont.FontFamily, currentFont.Size,


newFontStyle)
End If
End Sub

Private Sub cmdImprimir_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdImprimir.Click

PrintPreviewDialog1.Document = PrintDocument1
PrintPreviewDialog1.ShowDialog()

End Sub
End Class

PRACTICA 5 – Editor de texto con Menus o formularios MDI

Ahora, el reto es crear el editor de texto de una forma mas completa con menus y ventanas. El
codigo base ya lo tienes según el ejercicio 13. Te daremos unos tips para que consigas crearlo.

Primero que nada toma el concepto del Ejercicio 13.

Ve al portal del curso (idsclassroom.idsystemsmx.com) y en la seccion de biblioteca veras los


recursos que te llevaran a unas paginas web con material complementario y te daran ideas. En caso
de que no puedas accesarlos por ahí, consulta:

En Youtube.

1. http://www.youtube.com/watch?v=9sN434-fiNU
2. http://www.youtube.com/watch?NR=1&v=Xp_vm7G8GXU&feature=endscreen
3. http://www.youtube.com/watch?v=awQayR25K0A

Es un videotutorial en ingles dividio en 3 partes que te indicara como mejorar tu editor.

Paginas Web

1. http://www.hscripts.com/tutorials/vbnet/rich-text-box-properties.html
2. http://www.dotnetheaven.com/article/richtextbox-control-in-vb.net
3. http://www.c-sharpcorner.com/uploadfile/scottlysle/word-processing-with-an-extended-
rich-text-box-control-in-vb/
4. http://braayhaan.blogspot.mx/2010/09/resaltar-contenido-de-richtextbox.html

Esta es una idea de interfaz de cómo podria quedarte al final:


PRACTICAS 6-8

6.- 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.

7.- 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.

8.- 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. (Tip:
Ver Leccion 2 en apartado sobre funciones de archivo)
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 14 – Formulario de Datos

Visual Basic.NET cuenta con una nueva opcion de controles para crear formularios encadenados a las
bases de datos. No encontramos el asistente clasico que veiamos en Visual Basic 6.0, pero la tarea de
que construya un formulario es relativamente sencilla. Vamos a ver paso por paso como hacerlo.

PASO 1.

Como primer paso debe construir una base de datos de Pacientes. Para ello, vamos a comenzar usando
Access 2007. Podemos grabar el archivo en el formato nuevo (.ACCD o en el formato .MDB).

Accesamos Access 2007, y creamos una nueva base de datos, la cual llamaremos CONSULTORIO. Aquí
creamos una tabla que se llame PACIENTES, los cuales tendran los siguientes campos:

Vemos que hemos dado como llave primaria el primer campo de ID (Identificacion) para que nuestros
pacientes sean unicos. A continuacion llenamos con algunos datos de muestra en la Hoja de Datos:

Los datos pueden ser otros ya que necesitamos algunos para poder trabajar en nuestro ejercicio inicial.
Despues de esto, ya podemos cerrar nuestra tabla y nuestra base de datos, asi como salir de Access
2007.

PASO 2

Abrimos Visual Basic.NET 2010 Express (o la version de Visual Studio que tengamos). Y creamos un
nuevo proyecto. Comenzaremos con un formulario en blanco.

Lo primero que debemos de revisar es que tengamos la barra de herramientas de DISEÑO DE DATOS
en la parte superior.

Si esta no apareciese, debemos activarla desde el menu VER y Barra de Herramientas:


Ahora, comenzaremos dando un click en el icono (Crear origenes de datos) para crear nuestra
conexión con la base de datos. A partir de aquí se nos mostrara un asistente que nos indicara desde
donde obtendremos la conexión, el tipo y algunos otros parametros). Comienza mostrandonos una
ventana de ASISTENTE como esta:
Aquí, seleccionamos BASE DE DATOS, como el origen de los datos. Pulsamos SIGUIENTE.

Ahora nos pregunta por el modelo que usaremos, el mas comun es el primero. Pulsamos SIGUIENTE.
Ahora, en esta pantalla nos pregunta por la conexión de datos. Esta seccion es MUY IMPORTANTE
porque le diremos al asistente como se configura la conexión. Al inicio, aparece una caja de lista vacia,
para que indiquemos el nombre de la conexión. Esto es asi, porque es posible que en nuestro sistema
ya tengos una conexión previamente grabada en el sistema Windows y la queramos utilizar. De lo
contrario, tendremos que crear una nueva conexión.

Observamos tambien, que en la parte inferior hay un recuadro con la cadena de conexión (y al
principio esta vacia). Esto es hasta que no se seleccione un nombre de conexión. Ademas, vemos que el
boton de siguiente esta desactivado por la misma razon. Al no tener un nombre de conexión debemos
crear una. Pulsamos en el boton NUEVA CONEXIÓN…

Ahora, nos aparece una ventana de dialogo que nos indica el tipo de conexión a usar. Por defecto,
Visual Basic.NET nos proporciona MS SQL Server (ya sea que lo tengamos instalado en nuestro equipo
o que nos conectemos a un servidor real). Nos indica ademas desde donde viene dicha conexión. Para
nuestro caso utilizaremos ACCESS. Por lo tanto es necesario cambiar la conexión. Pulsamos en el boton
de CAMBIAR.
Ahora se nos presenta otra ventana de dialogo para seleccionar nuestro proveedor de base de datos.
Seleccionamos el primero y pulsamos ACEPTAR.

Vuelve a regresar a nuestra pantalla anterior, pero ligeramente diferente. Nos pregunta por nuestro
archivo y si lo habiamos protegido el nombre del usuario y contraseña. Usamos el boton de
EXAMINAR… para poder seleccionar mas facilmente nuestro archivo de ACCESS y que nos muestre la
ruta completa.
Pulsamos el boton de abrir y veremos que nos mostrara la ubicación y nombre del archivo.
Generalmente los archivos de ACCESS no tiene usuario y contraseña, pero para asegurarnos podemos
usar el boton inferior izquierdo PROBAR CONEXIÓN:
Esto nos indicara que pudo accesar al archivo sin ningun problema. Pulsamos ACEPTAR para cerrar la
ventana de mensaje y ACEPTAR para cerrar la ventana de CONEXIÓN.
Ahora veremos que ya tenemos una conexión o nombre de conexión, asi como la cadena que nos
indica donde esta el archivo, el proveedor de acceso a datos y otros (si hubiera). El boton se ha
activado, asi que pulsamos SIGUIENTE.

En el caso de que el archivo de Access estuviera en alguna otra ubicación en donde no este nuestro
proyecto, Visual Basic.NET nos lo hace saber y nos pregunta si copia este archivo a la ubicación de
resultados o lo dejamos donde mismo.

En algunos casos de desarrollo, no es conveniente copiarlo porque dicho archivo se encuentra por
ejemplo en otra computadora, servidor y desde ahí se utilizara por nuestro programa, ya que el archivo
se encuentra compartido. Para el ejemplo que estamos realizando, le diremos que SI COPIE el archivo
al directorio del proyecto para que su manejo sea mas sencillo.

Ahora nos pregunta si queremos guardar la cadena de conexión que nos ha creado el asistente en un
archivo de configuracion. Este es importante porque de esa manera VB.NET permite ubicar nuestro
archivo de manera facil y rapida, y si hubiera un cambio de ubicación del archivo de manera fisica
(copiarlo a otra carpeta o equipo), editar este archivo seria mucho mas sencillo que realizar todos los
pasos del asistente nuevamente.

Por lo tanto, dejamos la marca en la casilla de verificacion junto con el nombre propuesto y pulsamos
SIGUIENTE.
Ahora, ha que construir el DATASET, para ello necesitamos decirle al asistente cual o cuales seran las
tablas (o vistas) que queremos utilizar. Para nuestro sencillo ejemplo, solo tenemos una tabla (sin
relaciones) asi que seleccionamos PACIENTES.

Ya solo nos queda el boton de FINALIZAR. Pulsamos para terminar la configuracion.

PASO 3

Todavia no tenemos nada en nuestro formulario pero ya tenemos nuestra conexión a la base de datos
como lo podemos ver en la siguiente imagen:
Ahora, necesitamos construir nuestro formulario enlazado a base de datos. Se puede usar un DataGrid
o en su caso, tambien podemos usar los campos de manera directa y VB.NET nos creara las
propiedades y controles necesarios para nuestro formulario.

Comenzamos desplegano la informacion de la tabla de pacientes (izquierda) y seleccionamos el primer


campo ID. Despues, sin dejar de oprimir el boton del raton arrastramos el campo hasta nuestro
formulario.
Y Voila!

Ademas de ponernos el control de caja de texto del campo ID, nos muestra su etiqueta y nos coloca
una barra de navegacion en la parte superior (que es la que se encargar de navegar por los distintos
campos). Tambien, vemos que en la parte inferior nos coloca todos los controles necesarios
relacionados con nuestra conexión de datos como DATASET, BINDINGSOURCE, TABLEADAPTER y el
BINDINGNAVIGATOR.

Todos ellos sin mas esfuerzo que el haber arrastrado el campo. Podemos acomodarlo a nuestra
conveniencia y comenzar a arrastrar el resto de los campos a nuestro formulario.
Listo, hemos arrastrado los campos del panel izquierdo a nuestro formulario para que se adapte a
nuestras necesidades. Ahora grabamos todo el proyecto y lo ejecutamos.

Podemos ver, que ya tenemos la informacion vista en la pantalla de nuestro ejemplo. La barra superior
nos permite navegar entre los registros, agregar nuevos, borrarlos y actualizar la informacion. Todo de
manera sencilla.
Ejercicio 15 – Conectar y Navegar con BD por codigo

En este ejercicio vamos a conectarnos a una base de datos MS Access a traves de codigo ADO.NET utilizando el
nombre de espacio System.Data.OleDb, el cual permite la conexión a bases de datos que no son MS SQL.

Para comenzar tenemos que crear nuestra base de datos en MS ACCESS (2007 para el ejemplo), que se llamara
PERSONDATABASE.MDB. Esta tendra una sola tabla llamada PERSONTABLE con los siguientes campos:

Observamos que no tiene un campo llave definido, pero el primer campo PERSONID es del tipo autonumerico.
De preferencia se recomienda capturar al menos 3 registros dentro de Access a modo de prueba.

Ahora, cerramos nuestra base de datos en Access y vamos MS Visual Basic.NET. Creamos un nuevo proyecto y
en nuestro formulario pondremos los siguientes controles:
Observamos que hemos colocado controles LABEL, TEXTBOX y BOTONES. Quedara mas o menos asi los
nombres:

txtNombre, txtApellido, txtUbicacion.

Para los botones de comando: cmdFill, cmdFirst, cmdPrevious, cmdNext, cmdLast.

Recordemos que son opcionales y podemos darles los nombres que queramos. En este caso no usamos ningun
otro control ni conexión visual ya que utilizaremos codigo. Comenzamos importando el nombre de espacio y
demas. Esto se hace antes de la clase de la forma:

Y tambien, pondremos en la seccion de clase de la forma el codigo mostrado en la imagen anterior:

Dim ds As New DataSet()

Dim intCurrentIndex As Integer

Con esto estamos indicando que crearemos un nuevo conjunto de datos, y tendremos que utilizar una variable
entera como marcador o puntero para saber en que registro estamos dentro de nuestra tabla.

Ahora, tecleamos el siguiente codigo en nuestro primer boton cmdFILL, que es el que se encargara de
conectarse con nuestro archivo de base de datos y obtener los datos de la tabla:
Private Sub cmdFill_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
cmdFill.Click
Try
Dim oConexion As New OleDbConnection()
oConexion.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0; Data Source
=G:\Cys\Cys - Manuales\UM05 - Visual Basic Net con
BD\Ejercicios\ParteII\Ejercicio25_BDNavegarXCodigo\PersonDatabase.mdb; User
Id=admin;Password=;"
oConexion.Open()
'MessageBox.Show("Conectado")
Dim strSQL As String = "Select FirstName, LastName, City From PersonTable"
Dim da As New OleDbDataAdapter(strSQL, oConexion)

da.Fill(ds)

'Checar que la tabla no este vacia


If ds.Tables(0).Rows.Count > 0 Then
txtNombre.Text = ds.Tables(0).Rows(0).Item("FirstName").ToString()
txtApellido.Text = ds.Tables(0).Rows(0).Item("LastName").ToString()
txtUbicacion.Text = ds.Tables(0).Rows(0).Item("City").ToString()

End If

Catch oExcep As OleDbException


'Si se produce algun error
MessageBox.Show("Error arl conectar con datos" & _
ControlChars.CrLf & _
oExcep.Message & ControlChars.CrLf & _
oExcep.Source())

End Try

End Sub

Recordemos que la primer y ultima linea no la tecleamos, ya que VB.NET se encarga de ello segun nuestro
boton. Usamos la instrucción TRY… CATCH, para asegurarnos que no tendremos errores de conexión y que si los
hubiera, nos muestra el codigo de error de dicho problema.

Declaramos una conexión con New OleDbConnection. E indicamos mediante esta conexión una cadena que
contiene el nombre del proveedor de base de datos (en este caso es MS Access, que esta representado como
Microsoft.Jet.OleDB.4.0 –que es el motor que utiliza), la fuente de datos; es decir, la ubicación completa de
donde se encuentra nuestro archivo, es muy importante que el archivo permanezca en esa ruta, de lo contrario
no podremos conectarnos si lo movemos de ahí; el usuario y el password asociado.

MS Access 2007 permite poner un usuario y una contraseña a nuestro archivo, pero regularmente no se utiliza.
Sin embargo , en nuestra declaracion de la cadena debemos incluirlo aunque como vemos con un valor nulo
para la contraseña.

Lo siguiente es abrir la conexión con el metodo OPEN() y declarar una sentencia SQL para que obtenga los datos
que deseamos de dicha tabla (para ello, se utiliza la sintaxis del lenguale SQL estandar).

Finalmente, usando el metodo FILL, obtenemos los datos y se cargan en el “adaptador” (una copia de la base de
datos solamente con los resultados deseados para verse en nuestro programa). Por ultimo, mostramos la primer
fila de dicho “cursor” pasando los valores a nuestros controles de caja de texto.
Ahora pondremos el codigo para navegar y recorrer toda nuestra tabla, comenzando con el boton de inicio o
primero:

Private Sub cmdFirst_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles


cmdFirst.Click
'Como es 0 sera la primera fila
txtNombre.Text = ds.Tables(0).Rows(0).Item("FirstName").ToString()
txtApellido.Text = ds.Tables(0).Rows(0).Item("LastName").ToString()
txtUbicacion.Text = ds.Tables(0).Rows(0).Item("City").ToString()

End Sub

De manera sencilla usamos el objeto ds declarado anteriormente (nuestro DATASET), y obtenemos de la tabla 0,
fila 0, los elementos deseados pasandolos a una cadena.

El boton de PREVIO para navegar hacia atrás en nuestros registros lleva este codigo:

Private Sub cmdPrevious_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdPrevious.Click
'Nos movemos hacia atras si no estamos en la primera fila
If intCurrentIndex > 0 Then
'Substraer uno del indice actual
intCurrentIndex = intCurrentIndex - 1
txtNombre.Text = ds.Tables(0).Rows(intCurrentIndex).Item("FirstName").ToString()
txtApellido.Text = ds.Tables(0).Rows(intCurrentIndex).Item("LastName").ToString()
txtUbicacion.Text = ds.Tables(0).Rows(intCurrentIndex).Item("City").ToString()
Else
MessageBox.Show("Ya esta en el registro inicial")
End If
End Sub

Aquí vemos, porque es importante tener una variable que nos almacene el puntero o posicion en la que nos
encontramos dentro de nuestra tabla para ir recorriendo hacia atrás.

El boton SIGUIENTE tiene este codigo:

Private Sub cmdNext_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdNext.Click
'ds.tables(0).rows.count-1 es el indice de la ultima fila
If intCurrentIndex < ds.Tables(0).Rows.Count - 1 Then
'Agregar uno al indice actual
intCurrentIndex = intCurrentIndex + 1
txtNombre.Text = ds.Tables(0).Rows(intCurrentIndex).Item("FirstName").ToString()
txtApellido.Text = ds.Tables(0).Rows(intCurrentIndex).Item("LastName").ToString()
txtUbicacion.Text = ds.Tables(0).Rows(intCurrentIndex).Item("City").ToString()
Else
MessageBox.Show("Ya esta en el ultimo registro")
End If
End Sub

Y por ultimo el boton FINAL:


Private Sub cmdLast_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
cmdLast.Click
intCurrentIndex = ds.Tables(0).Rows.Count - 1
txtNombre.Text = ds.Tables(0).Rows(intCurrentIndex).Item("FirstName").ToString()
txtApellido.Text = ds.Tables(0).Rows(intCurrentIndex).Item("LastName").ToString()
txtUbicacion.Text = ds.Tables(0).Rows(intCurrentIndex).Item("City").ToString()
End Sub

Ahora podremos ejecutar nuestro programa y veremos que nos mostrara los registros capturados y que
podemos navegar entre los registros

Agregando, Eliminando y Actualizando por Codigo

Vamos a continuar mejorando nuestro formulario para conectarnos con un archivo de base de datos de MS
Access y poder realizar algunas operaciones de adicion, eliminacion y actualizacion de informacion.

Te recomendamos hacer una nueva carpeta donde ira el nuevo proyecto. Tambien, copia el archivo Access
PERSONDATABASE.MDB que hiciste en el ejercicio anterior porque trabajaremos con el.

Ahora, depues de crear un nuevo proyecto, crearas el formulario muy similar al anterior con una ligera variante:

Como podemos observar, hemos agregado 3 botones mas para hacer las operaciones con la tabla y uno para
salir.

Sin embargo, vamos a hacer algunas adecuaciones para que en lugar de que el codigo para mostrar los datos
este en cada boton, esto se haga en una subrutina generica que se mande llamar. De esta forma, el codigo se
reduce y se facilita su compresion. Por lo tanto es necesario tambien, modificar el codigo de los botones de
navegacion: Primero, Atrás, Siguiente, Ultimo. Comencemos primero con el codigo anterior a la clase form, y lo
que necesitamos dentro de la clase para que se vuelva generico.
Imports System.Data.OleDb

Public Class Form1


Dim ds As New DataSet()
Dim intCurrentIndex As Integer = 0
Dim oConexion As New OleDbConnection()
Dim da As New OleDbDataAdapter()

Private Sub FillFields()


txtID.Text = ds.Tables(0).Rows(intCurrentIndex).Item("PersonID").ToString()
txtNombre.Text = ds.Tables(0).Rows(intCurrentIndex).Item("FirstName").ToString()
txtApellido.Text = ds.Tables(0).Rows(intCurrentIndex).Item("LastName").ToString()
txtCiudad.Text = ds.Tables(0).Rows(intCurrentIndex).Item("City").ToString()

End Sub

Observamos que comenzamos de igual manera con la sentencia IMPORTS SYSTEM.DATA.OLEDB,


pero ahora, dentro de nuestra clase Form, tenemos declarada la conexión y el adaptador ademas del
DataSet y nuestra variable de posicion.

Tambien, tenemos una subrutina propia llamada FILLFIELDS en la cual pasaremos los datos de la
tabla a los controles de texto. Vemos que usamos nuestra variable de posicion para tal efecto.

A continuacion, necesitamos cargar los datos en nuestro formulario, y no tenemos un boton para ello,
por lo que usamos el evento LOAD del formulario:

Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load


Try
oConexion.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0; Data Source
=G:\Cys\Cys - Manuales\UM05 - Visual Basic Net con
BD\Ejercicios\ParteII\Ejercicio25_BDNavegarXCodigo\PersonDatabase.mdb; User
Id=admin;Password=;"

da.SelectCommand = New OleDbCommand("Select PersonID, FirstName, LastName, City


From PersonTable")
da.SelectCommand.Connection = oConexion
da.Fill(ds)
FillFields()

Catch oExcep As OleDbException


'Si se produce algun error
MessageBox.Show("Error arl conectar con datos" & _
ControlChars.CrLf & _
oExcep.Message & ControlChars.CrLf & _
oExcep.Source())

End Try

da.UpdateCommand = New OleDbCommand("UPDATE PersonTable SET FirstName = @FirstName,


LastName = @LastName, City = @City WHERE PersonID = @PersonID")
da.UpdateCommand.Connection = oConexion
da.UpdateCommand.Parameters.Add("@FirstName", OleDbType.VarChar, 40, "FirstName")
da.UpdateCommand.Parameters.Add("@LastName", OleDbType.VarChar, 40, "LastName")
da.UpdateCommand.Parameters.Add("@City", OleDbType.VarChar, 40, "City")
da.UpdateCommand.Parameters.Add("@PersonID", OleDbType.Integer, 5, "PersonID")

da.InsertCommand = New OleDbCommand("INSERT INTO PersonTable(PersonID, FirstName,


LastName, City) VALUES(@PersonID, @FirstName, @LastName, @City)")
da.InsertCommand.Connection = oConexion
da.InsertCommand.Parameters.Add("@PersonID", OleDbType.Integer, 5, "PersonID")
da.InsertCommand.Parameters.Add("@FirstName", OleDbType.VarChar, 40, "FirstName")
da.InsertCommand.Parameters.Add("@LastName", OleDbType.VarChar, 40, "LastName")
da.InsertCommand.Parameters.Add("@City", OleDbType.VarChar, 40, "City")

da.DeleteCommand = New OleDbCommand("DELETE FROM PersonTable WHERE PersonID =


@PersonID")
da.DeleteCommand.Connection = oConexion
da.DeleteCommand.Parameters.Add("@PersonID", OleDbType.Integer, 5, "PersonID")

End Sub

Aquí vemos que la primer parte del codigo es semejante al ejercicio anterior en el cual definiamos una cadena
de conexión, un conjunto de datos y llenabamos el adaptardor con los mismos. Tenemos la misma instruccon
TRY…CATCH para detectar los errores.

Pero ademas, tenemos codigo para hacer las operaciones de actualizar, agregar y eliminar. ADO.NET da muchos
objetos (y formas) para hacer esto. Puede usar procedimientos almacenados con el comando OledbCommand, o
puede usar instrucciones SQL directamente con este mismo, o incluso usar el DataAdapter para realizar las
actualizaciones.

Hay diferentes razones para usar cada metodo, pero para el proposito del ejercicio usaremos el DataAdapter.
Asi que la primera parte es para la actualizacion

da.UpdateCommand = New OleDbCommand("UPDATE PersonTable SET FirstName = @FirstName, LastName =


@LastName, City = @City WHERE PersonID = @PersonID")
da.UpdateCommand.Connection = oConexion
da.UpdateCommand.Parameters.Add("@FirstName", OleDbType.VarChar, 40, "FirstName")
da.UpdateCommand.Parameters.Add("@LastName", OleDbType.VarChar, 40, "LastName")
da.UpdateCommand.Parameters.Add("@City", OleDbType.VarChar, 40, "City")
da.UpdateCommand.Parameters.Add("@PersonID", OleDbType.Integer, 5, "PersonID")

Podemos ver, que es basicamente la estructura de nuestra tabla con algunos parametros acerca de los tipos de
campo que se trata.

Dentro del codigo del evento LOAD, vemos tambien para AGREGAR y para eliminar.

Ahora, vemos el resto de los botones. Los pondremos de manera global y hay que poner atencion al inicio de
cada subrutina donde indica el nombre del boton:
Private Sub cmdFirst_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles cmdFirst.Click
FillFields()
End Sub

Private Sub cmdPrevious_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdPrevious.Click
'Nos movemos hacia atras
If intCurrentIndex > 0 Then
intCurrentIndex = intCurrentIndex - 1
FillFields()
Else
MessageBox.Show("Ya esta en el primer registro")
End If
End Sub

Private Sub cmdNext_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdNext.Click
'Nos movemos hacia adelanta
If intCurrentIndex < ds.Tables(0).Rows.Count - 1 Then
intCurrentIndex = intCurrentIndex + 1
FillFields()
Else
MessageBox.Show("Ya esta en el ultimo registro")
End If
End Sub

Private Sub cmdLast_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdLast.Click
intCurrentIndex = ds.Tables(0).Rows.Count - 1
FillFields()
End Sub

Private Sub cmdActualizar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdActualizar.Click
Dim dr As DataRow
'Esta obtiene una referencia de la fila editada
dr = ds.Tables(0).Rows(intCurrentIndex)
dr.BeginEdit()
dr("FirstName") = txtNombre.Text
dr("LastName") = txtApellido.Text
dr("City") = txtCiudad.Text
dr.EndEdit()
'Preguntar al dataadapter y llamar el comando UpdateCommando y actualizar la BD
da.Update(ds)
ds.AcceptChanges()
MessageBox.Show("Datos Actualizados")

End Sub

Private Sub cmdAgregar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdAgregar.Click
Dim dr As DataRow
dr = ds.Tables(0).NewRow()
dr("PersonID") = ds.Tables(0).Rows.Count + 1
dr("FirstName") = txtNombre.Text
dr("LastName") = txtApellido.Text
dr("City") = txtCiudad.Text
ds.Tables(0).Rows.Add(dr)
da.Update(ds)
ds.AcceptChanges()
MessageBox.Show("Datos Agregados")

End Sub

Private Sub cmdEliminar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdEliminar.Click
Dim dr As DataRow
dr = ds.Tables(0).Rows(intCurrentIndex)
dr.Delete()

da.Update(ds)
ds.AcceptChanges()
MessageBox.Show("Datos Eliminados")

End Sub

Private Sub cmdSalir_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles cmdSalir.Click
End
End Sub
End Class

Y ahora solo nos queda ejecutar nuestro programa para poder navegar, y realizar las operciones con los
registros.
Ejercicio 17 – Usando DataGrid en modo simple

Lo primero que tenemos que hacer es una base de datos en Access que usaremos como prueba. Crearemos un
catalogo de Videos o Peliculas. Y tendra mas o menos el siguiente esquema:

Aquí vemos que tenemos varias tablas con sus campos y sus relaciones. Dejamos al alumno la tarea de asignar
los tipos de campos que ve en la imagen, asi como su tamaño; porque se pueden deducir facilmente.
Ahora creamos nuestro proyecto en VB.NET. Y necesitamos, conectar con esta base de datos. Usamos para ello
el asistente de conexión a datos, como vimos en la leccion 14.

Notemos que hemos ocultado varios de los controles del cuadro de herramientas y hemos dejado a la vista la
seccion de DATOS, ya que ahí usaremos el control DATAGRIDVIEW. Simplemente damos click a este control y lo
arrastramos hacia la forma.
Ahora, justo al arrastrarlos nos preguntara sobre el origen de nuestros datos. De la caja combinable,
seleccionamos nuestra tabla que queramos presentar en este control. Seleccionemos PELICULAS.
Ahora vemos que nos muestra los campos de nuestra tabla, y en la parte inferior vemos el resto de los controles
que se usan: DATASET, BINDINGSOURCE, TABLEADAPTER.
Finalmente le damos el tamaño adecuado al control y a nuestra forma, para mostrar las columnas que queremos
y ejecutamos el programa.

Ahora ya podemos presentar la informacion en un formato como Access o Excel.

– Grid por Codigo

Tambien podemos hacer que el GRID nos funcione enteramente con codigo. Utilizaremos la misma base de
datos de PELICULAS del ejercicio anterior (lo podemos copiar a la carpeta del proyecto).

Comenzamos creando la conexión de base de datos en nuestro proyecto de VB.Net y arrastramos nuestro
control GRID. Pero, no seleccionaremos ningun origen de datos.

Nuestra forma ademas del DataGridView, contendra un boton que llamara al codigo para insertar los valores en
el Grid.
Imports System.Data
Imports System.Data.OleDb

Public Class Form1


Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles Button1.Click

Dim cnn As New OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data


Source=peliculas.mdb; User Id=admin;Password=;")
Dim da As New OleDbDataAdapter("SELECT * FROM Peliculas", cnn)
Dim ds As New DataSet

da.Fill(ds)

DataGridView1.DataSource = ds.Tables(0)

End Sub

End Class

Vemos que el codigo del boton, es basicamente:


1. Crear la conexión con el proveedor, el archivo y su usuario
2. Crear un adaptador que contiene la consulta desde la tabla que queremos
3. Crear un DataSet
4. Llenar el Dataset
5. Mostrar en el grid los datos de dicho DataSet
PRACTICA 9 – DataGridView con Color

Ahora que ya conoces las bases del control DataGridView, aplica un poco de formato a este control para que
tenga un aspecto visual diferente.
Deberas investigar por tu cuenta como poner color usando las propiedades del control mediante codigo. El
resultado final debera verse asi:

El Control DataGridView, es un control mas avanzado que el original DataGrid de VB6. Deberas buscar
las propiedades correspondientes a este control para poder manipular el aspecto que presentara. Esto es
ultil cuando tienes muchos datos que deseas visualizar, o para marcar alguna celda en especifica. Por
ejemplo, imagina que tienes un listado de calificaciones en el cual, quieres que las calificaciones por
debajo de 6, se vean en rojo. Es una forma facil de identificar a los alumnos que reprobaron.

El control DataGridView es semejante a Excel, y permite agregarle otro tipo de controles en cada una de
las celdas como combobox, imagenes, calendarios. En esta practica sin embargo solamente queremos
conocer lo basico de su formato.
PRACTICA 10 – DataGridView con relaciones

El DataGridView es un control con muchas funciones, entre ellas, es usado para mostrar relaciones entre 2 o
mas tablas. Muchas de las veces se utiliza un control de caja de texto o un control comboBox para pedir un dato
de una tabla y mostrar registros que concuerden con este criterio. Es la forma de poner una relacion de Uno-A-
Muchos.

Para esta practica deberas tener una base de datos en MS Access que contenga al menos 2 tablas relacionadas,
para que desde VB.NET puedas mostrarlas usando los controles del lenguaje.

Como ejemplo, en la imagen superior estamos usando una base de datos en Access 2007 (pero con una version
en formato 2003, que es .MDB) de peliculas. Esta base de datos tiene una tabla de CATEGORIAS y una tabla de
PELICULAS. En el formulario, vemos que tenemos un boton llamado LLENAR. Lo hacemos asi como demostracion
para cargar los valores de la base de datos iniciales en el DataGridView (lo correcto es ponerlo en el LOAD del
formulario). Ademas, tenemos una caja combo y un boton. En la caja combo, debemos llenar los datos de la
tabla de categorias. En el grid, con la tabla peliculas.

Cuando se selecciona una categoria de la caja combo y se da un click al boton derecho, este hace la relacion
entre las 2 tablas y mostrara solamente las peliculas que corresponden a esta categoria.

En tu practica, puedes utilizar cualquier base de datos que hayas creado, siempre y cuando tenga al menos 2
tablas para ser relacionadas.
PRACTICA 11 – DataGridView Maestro-Detalle en 2 Grids

Veamos como podemos encadenar dos DataGrid y crear un formulario Maestro-Detalle. Crea un
programa en la cual mediante dos datagridview se enlacen 2 tablas de una base de datos de Access.

Al moverse en uno de los DataGridView, automaticamente debera reflejar los registros relacionados o
dependientes en el segundo DataGridView.

El programa debe contener en un Grid los datos de la tabla maestra y al moverse dentro de las filas del primero,
automaticamente cambiar el contenido del segundo Grid.

En el ejemplo de la imagen, tenemos solamente 2 DataGridView y un boton para llenar los datos la
primera vez que se usa el programa. En el primer DataGridView vemos la tabla de categorias de la base
de datos de peliculas que estamos usando desde las practicas anteriores.

Al posicionarnos en una de las filas de la categoria, automaticamente debera desplegar el listado de


peliculas disponibles relacionadas. Aquí, deberas usar las relaciones y algunas propiedades del
DataGridView.
PRACTICA 12 – DataGridView con Filtro

Crea un programa en el cual puedas filtrar los registros deseados, de una tabla de una base de datos de Access.
La diferencia con la practica 10 y 11 es que solamente usas UNA tabla para el filtrado.

En la imagen de ejemplo vemos que tenemos 2 botones. El primero LLENAR, nos permite obtener los datos de
una tabla de peliculas. Despues, tecleamos en la caja de texto la categoria que queremos filtrar y pulsando en el
boton FILTRAR nos mostrara las peliculas de dicha categoria.

Recuerda que puedes utilizar cualquier base de datos de proyectos anteriores.


PRACTICA 13 – DataGridView con Ordenacion.

Para terminar con el uso del control DataGridView, veamos como se puede ordenar los registros que se
muestran en este control.

En la imagen de ejemplo, nuevamente tenemos una tabla desplegada en el DataGridView sobre peliculas.
Primero usamos el boton llenar para obtener todos los datos de la base de datos. Despues, tecleamos el nombre
del CAMPO por el cual queremos que nos ordene la informacion. En la imagen, vemos que seleccionamos el
campo pelicula. Pulsamos el boton ORDENA y vemos todas las peliculas ordenadas de la A a la Z. Debe funcionar
con cualquier campo de la tabla.
PRACTICA 14 – Archivos de Excel

En este ejercicio/practica, 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 en cualquier carpeta que queramos (pero de preferencia donde estes
creando tus practicas), comienza con tu proyecto VB.NET.
En la imagen de ejemplo, vemos que tenemos un control LABEL, TEXTBOX, DATAGRIDVIEW y un boton. Lo
primero que tenemos que hacer es pulsar al boton SELECCIONAR ARCHIVO, para que aparezca una caja de
dialogo (visto en ejercicios anteriores) para que ubiques tu archivos de excel. Una vez hecho esto, la ruta y el
nombre se despliegan en la caja de texto a manera de informacion, y el contenido de tu archivo de excel en el
DATAGRIDVIEW.

Debes investigar cual es el codigo necesario para hacer esto.


PRACTICA 15 – Base de Datos 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.

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. 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.

En el ejemplo, tenemos un boton LLENAR para obtener los datos de nuestra tabla Access, y los botones de
siguiente y anterior para navegar entre los registros. Piensa como seria la mejor forma para que presentes los
datos junto con las imágenes.
PRACTICA 16 –BD con Imágenes Vinculadas en campo

Ahora, como una variacion a la practica 15, crea un programa similar, pero que dentro de la base de datos se
almacene la ruta o ubicación de donde se encuentra la imagen, para que cuando nos desplazemos por los
registros, pueda ir a esa ubicación y muestre la imagen en pantalla.

En el ejemplo de la imagen, vemos una pantalla similar a la practica 15, pero con un campo de texto llamado
ubicación que contiene la ruta de la imagen. Si esta no se encuentra no podra desplegarla.
– Base de Datos OLE DB con MySQL

VB.NET tambien puede conectarse a otro tipo de bases de datos ademas de MS SQL o MS
Access, como lo es MySQL. Para hacer esto, necesita ciertas condiciones primero, y
utilizar un codigo semejante al visto en las practicas anteriores.

En la imagen de ejemplo, vemos un sencillo formulario, que contiene varios botones para
probar la conexión, navegar entre los registros y obtener los datos.

Realiza una practica usando un SERVIDOR LOCAL primeramente para que


hagas las pruebas. Despues, realiza otra practica similar pero con un SERVIDOR
REMOTO. Pide a tu profesor que te de la informacion referente a este servidor
para que puedas conectarte a el, y obtener los datos.
CONCLUSIONS
This article explains how to use validation rules and validation text in table fields
and form controls. A validation rule is a way of limiting the information that is
written in a table field or in a control (such as a text box) of a form. With the
validation text you can include a message to help users who write invalid data.

When data is written, Access checks if a validation rule has been violated and, if
so, the written data is not accepted and Access displays a message.
Access offers several ways to restrict data entry:
Bibliografía
2010, M. d. (Publicado el 4 de jun. de 2011). Como crear una base de datos con visual basic.
Obtenido de https://es.slideshare.net/AlbertoVargas8/como-crear-una-base-de-datos-
con-visual-basic-nx-powerlite

Mejia, R. H. (Publicado el 22 jun. 2012). Como crear una validacion de usuario en visual studio
2010. Obtenido de https://www.youtube.com/watch?v=GgBMvuDS6r8

reglas, T. d. (s.f.). Partes de una base de datos. Obtenido de


https://www.gcfaprendelibre.org/tecnologia/curso/access_2007/explorar_una_base_de_
datos_de_access/4.do