CUADERNO DE TRA TRABAJO BAJO VISUAL BASIC BASIC.

NET con Base ase de Datos

Cuaderno de Trabajo Visual Basic se encu encuentra bajo una Licencia Creative Commons Atribución-No Atribución ComercialLicenciamiento Recíp Recíproco 3.0 Unported. Diciembre – IDSystems

Contenido
INTRODUCCION ..........................................................................................................................................................4 EJERCICIOS Y PRACTICAS SOBRE EL ARCHIVOS ..........................................................................................................5 Ejercicio01a – Editor Sencillo - Guardar (Funciones)..............................................................................................6 Ejercicio01b – Editor Sencillo - Guardar (Stream) ..................................................................................................7 Ejercicio 02a – Editor Sencillo – Leer ......................................................................................................................9 Ejercicio 02b – Editor Sencillo – Leer (Stream).................................................................................................... 11 Ejercicio 03 – Editor Sencillo Lectura de un archivo utilizando un bucle ............................................................ 12 PRACTICA 1 – Editor Sencillo Lectura con Bucle y Stream .................................................................................. 12 Ejercicio 04 - Creación de un editor sencillo ....................................................................................................... 12 PRACTICA 2 – Editor Sencillo con Stream ............................................................................................................ 17 Ejercicio 05 – Archivos con Estructura de Base de Datos .................................................................................... 17 PRACTICA 3 – Agenda .......................................................................................................................................... 17 Ejercicio 06 – Texto y RTF .................................................................................................................................... 18 Ejercicio 07 – Leer datos desde un archivo ......................................................................................................... 19 Ejercicio 08 – Usar output para grabar un archivo .............................................................................................. 21 Ejercicio 09 – Usando APPEND para agregar informacion al archivo.................................................................. 22 Ejercicio 10 – Creando archivos de configuracion para aplicaciones .................................................................. 24 Ejercicio 11 – Usando Write e Input .................................................................................................................... 26 Ejercicio 12 – Usando archivos aleatorios ........................................................................................................... 29 PRACTICA 4 – Convertir Agenda VB6 a VB.NET (con Arch. Aleatorios) ............................................................... 32 Ejercicio 13 – Editor de texto con RTF ................................................................................................................. 39 PRACTICA 5 – Editor de texto con Menus o formularios MDI ............................................................................ 42 PRACTICAS 6-8 ......................................................................................................................................................... 43 EJERCICIOS SOBRE EL BASES DE DATOS .................................................................................................................. 44 Ejercicio 14 – Formulario de Datos...................................................................................................................... 45 Ejercicio 15 – Conectar y Navegar con BD por codigo......................................................................................... 59 Ejercicio 16 – Agregando, Eliminando y Actualizando por Codigo ..................................................................... 63 Ejercicio 17 – Usando DataGrid en modo simple ................................................................................................ 68 Ejercicio 18 – Grid por Codigo ............................................................................................................................. 72 PRACTICA 9 – DataGridView con Color ............................................................................................................... 74 PRACTICA 10 – DataGridView con relaciones ..................................................................................................... 75 PRACTICA 11 – DataGridView Maestro-Detalle en 2 Grids ................................................................................. 76 PRACTICA 12 – DataGridView con Filtro.............................................................................................................. 77 PRACTICA 13 – DataGridView con Ordenacion. .................................................................................................. 78 Cuaderno de Trabajo Visual Basic.NET con Base de Datos Página 2

PRACTICA 14 – Archivos de Excel ........................................................................................................................ 79 PRACTICA 15 – Base de Datos con Imágenes Vinculadas .................................................................................... 81 PRACTICA 16 –BD con Imágenes Vinculadas en campo ...................................................................................... 84 PRACTICA 17 – Base de Datos OLE DB con MySQL.............................................................................................. 85 PRACTICAS 18 – 22 .................................................................................................................................................. 85

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 3

INTRODUCCION
Visual Basic.NET ha mejorado en cuanto al manejo de archivos y bases de datos relacionales externas, tanto locales, cliente/servidor como de aplicaciones web (internet). Para este curso, se han tomado los ejercicios del Cuaderno de Trabajo de Visual Basic 6.0 con Base de Datos y se han adaptado al nuevo entorno del framework .NET que ofrece mas robustez y nuevos modelos de programacion. Se trato de respetar en lo posible la programacion de las versiones anteriores de Visual Basic, pero tambien se incluyen ejercicios y practicas con el nuevo entorno de desarrollo para que este sea el lenguaje base de programacion. No hay que olvidar que este Cuaderno va de la mano con sus lecciones teoricas, tanto en el portal como en clase, asi como es recomendable leer la bibliografia que acompaña al curso. Bienvenido al mundo de la programacion.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 4

EJERCICIOS Y PRACTICAS SOBRE EL ARCHIVOS
A continuacion se presentan algunos ejemplos de manejo de archivos simples con Visual Basic. Algunos archivos de tipo texto, documento o configuracion que son usados por algunas aplicaciones. Se veran algunas de las funciones compatibles con Visual Basic 6.0 y las nuevas sentencias usadas en Visual Basic .NET y su framework.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 5

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 6

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 7

1

- La primera línea: On Error GoTo ErrorDesconocido

Esta línea de código permite controlar cualquier error que ocurra a partir desde donde se escribe. En este caso la 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:
Dim oWrite As System.IO.StreamWriter

Esta línea declara una variable para ser el objeto que tome el metodo de la clase System.IO y pueda grabar en el 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:
oWrite = System.IO.File.CreateText("datos.doc")

Ahora el objeto declarado permitira asociarse a la creacion de un archivo de texto con el metodo CreateText y como parametro el nombre y ubicación del archivo a crear 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 Esta linea es la que permite grabar todo el texto introducido en el control TEXTBOX de nuestro formulario, es decir, lo que el usuario ha introducido Traducida al castellano esta línea quiere decir: GRABAR TODAS LAS LINEA INTRODUCIDAS POR EL USUARIO

4

- La cuarta línea:
oWrite.WriteLine(Text1.Text)

5

- La quinta línea: oWrite.Close()

Finalmente, esta linea indica que el objeto debe cerrarse para proceder con la grabacion final del archivo y que no se quede abierto Traducida al castellano esta linea quiere decir: CIERRA EL ARCHIVO Esta línea muestra una ventana con el mensaje escrito entre los paréntesis y la comilla. En este caso hemos especificado un mensaje que informa al usuario si los datos se han grabado correctamente. 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 ú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

6

- La sexta línea: MsgBox (“Los datos han sido guardado.”)

7

- La séptima línea: Exit Sub

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 8

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: ErrorDesconocido: 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 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: Msgbox(“Ha ocurrido un error al intentar guardar el archivo.”) Muestra un mensaje diciendo que ha ocurrido un error al intentar guardar el archivo en el disco.

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 9

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)

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 10

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

Ejercicio 02b – 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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 11

Ejercicio 03 – 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)

PRACTICA 1 – 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?

Ejercicio 04 - 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…

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 12

▪ Establezca los siguientes valores en las propiedades de los controles utilizados: Control Form1 Propiedad Caption BorderStyle Height Width Text MultiLine ScrollBars Heigth Width Top Left Caption Valor Editor 1- Fixed Single 5460 7635 (Vació) True 2- Vertical 4215 7215 120 120 &Abrir

Text1

cmdAbrir

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 13

cmdGuardar cmdNuevo cmdSalir

Caption Caption Caption

&Guardar &Nuevo &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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 14

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) & Entre comillas se especifica el texto que aparecerá en Tipo de archivo del cuadro de diálogo Abrir. Esta combinación permite obtener el carácter ¦. "*.txt" Extensión de los archivos que se 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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 15

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 16

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.

PRACTICA 2 – 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.

Ejercicio 05 – 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.

PRACTICA 3 – Agenda
Ahora, recrea el ejercicio 05, utilizando la clase System.IO con las caracteristicas de los metodos Stream. Las caracteristicas son similares.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 17

Ejercicio 06 – Texto y RTF
En este Ejercicio vamos a ver como hacemos para directamente desplegar un texto ya copiado y grabado en un archivo con extensión TXT, que podemos tipear en cualquier editor como el NotePad, por ejemplo y otro texto con formato RTF (Rich Text File, o sea archivo de texto enriquecido) . Este formato puede grabarse en el 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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 18

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

Ejercicio 07 – Leer datos desde un archivo
Este ejercicio es para repasar como leemos un archivo de texto usando la instrucción INPUT. Primeramente creamos una interfaz como la siguiente:

La cual contiene una caja de texto, botones de comando y un frame para enmarcar el diseño. La caja de texto tiene la propiedad Multiline = true, y la propiedad Scrollbars como 2 – Vertical. Ahora he aquí el codigo a teclear: En el boton de salir: End En el boton de Borrar TextBox

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 19

' 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)

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 20

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) b) c) d) e) 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

2 Cajas de texto 1 boton de comando Etiquetas Frame Un control de timer para que muestre la hora del sistema actual en tiempo real

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 21

' 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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 22

archivo = My.Application.Info.DirectoryPath + "\" + "Prueba.txt" ' Asignamos a texto el contenido de texto = TextBox1.Text text1

' 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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 23

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) b) c) d) Etiqueta Frame CheckBox Boton de comando
Página 24

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 25

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) 2) 3) 4) 5) 5 cajas de texto Etiquetas Botones de comando Frame 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 '*********************************************************

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 26

' 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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 27

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")

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 28

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

Ejercicio 12 – Usando archivos aleatorios
Este simple programa muestra como grabar datos y recuperar los mismos en un archivo Aleatorio. El programa consta de 2 procedimientos principales. Uno llamado "grabarDatos", que grabará los datos en el archivo "datos.dat". Los parámetros que lleva este procedimiento son los valores de los textBox. Cuando presionemos el botón "grabar", se llamará al procedimiento y grabará los datos en el n° de registro que hayamos seleccionado en el combo1. Este combo está cargado con numeros del 1 al 100. El procedimiento "leerDatos" recuperará los datos del registro que especifiquemos en el combo2.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 29

CONTROLES 1) 2) 3) 4) 5) Cajas de texto Etiquetas Caja combo (combobox) Frame 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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 30

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 31

PRACTICA 4 – 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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 32

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. 2. 3. 4. 5. 6. txtNombre txtApellido txtTelefono txtMail txtNota txtBuscar

Luego agregar 7 CommandButton con los siguientes nombres: 1. CmdAnterior : Botón para ir al anterior registro 2. cmdSiguiente : Botón para ir al siguiente registro 3. cmdGuardar : Botón para guardar los cambios cuando se seleccionó previamente la opción Nuevo Registro 4. cmdEliminar: Elimina el registro actual 5. cmdNuevo : Añade un nuevo reg 6. cmdBuscar : Para buscar 7. Cmdsalir : Descarga el Form Ahora, agregar un control ComboBox llamado Combo1. A este combo, establecerle en la propiedad Style el valor 2 ( DropDownList ) y agregarle los siguientes valores en la propiedad List: Nombre, Apellido, Telefono e Mail en ese orden Nota: Para agregar datos en la propiedad List desde la ventana de propiedades, debes mantener la tecla Ctrl presionada y presionar la tecla Enter para añadir un nuevo dato o Item. Por último, agregar un control Label llamado lblStatus que servirá para poder mostrar cuando nos desplazamos por los registros, con los botones anterior y siguiente, el número del registro actual y la cantidad de registros que hay en el archivo. Este Label lo puedes situar en la parte inferior del formulario o donde quieras. Colocar el código fuente en el formulario:
1. Option Explicit 2. 3. 'Variables 4. '################################################## 5. 6. ' Estructura para los datos de los contactos de la agenda 7. Private Type Contacto 8. Nombre As String * 40 9. Apellido As String * 50 10. Telefono As String * 40

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 33

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)

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 34

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 35

133. 134. 135. 136. 137. 138. 139. 140. 141. 142. 143. 144. 145. 146. 147. 148. 149. 150. 151. 152. 153. 154. 155. 156. 157. 158. 159. 160. 161. 162. 163. 164. 165. 166. 167. 168. 169. 170. 171. 172. 173. 174. 175. 176. 177. 178. 179. 180. 181. 182. 183. 184. 185. 186. 187. 188. 189. 190. 191. 192. 193.

'Escribe en el archivo temporal los datos Put #FileTemp, RegActualTemp, DatosTemp RegActual = RegActual + 1 RegActualTemp = RegActualTemp + 1 Next

Close FileFree 'Elimina el archjivo con los datos Kill "Datos.dat" Close FileTemp 'Renombra el archivo temporal a datos.dat Name "Temporal.tmp" As "Datos.dat"

' Mostramo los datos en los textbox Cargar RegActual = Pos VisualizarDatos End Sub Private Sub cmdGuardar_Click() GuardarDatos End Sub Private Sub Cmdsalir_Click() 'Guarda los cambios en el archivo antes de salir GuardarDatos 'cierra el archivo abierto Close #FileFree End End Sub Private Sub form_load() 'Carga el primer registro del archivo Cargar 'Selecciona en el combo para la búsqueda de datos Combo1 = Combo1.List(0) Cargarcaptions End Sub Private Sub Cargar() FileFree = FreeFile Open "Datos.dat" For Random As FileFree Len = Len(Datos) RegActual = 1 ' Almacenamos la posición del último registro RegUltimo = LOF(FileFree) / Len(Datos) If RegUltimo = 0 Then RegUltimo = 1 End If

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 36

194. 195. 196. 197. 198. 199. 200. 201. 202. 203. 204. 205. 206. 207. 208. 209. 210. 211. 212. 213. 214. 215. 216. 217. _ 218. 219. 220. 221. 222. 223. 224. 225. 226. 227. 228. 229. 230. 231. 232. 233. 234. 235. 236. 237. 238. 239. 240. 241. 242. 243. 244. 245. 246. 247. 248. 249. 250. 251. 252. 253.

'Cargamos los datos en los Textbox VisualizarDatos End Sub 'Botón que agrega un nuevo registro '##################################### Private Sub cmdNuevo_click() RegUltimo = RegUltimo + 1

'Limpia los datos de la estructura para poder agregar un nuevo registro With Datos .Apellido = "" .Nombre = "" .Telefono = "" .Mail = "" .Nota = "" End With ' Graba datos vacios en el nuevo registro hasta que se presione el botón Guardar que graba los verdaderos datos Put #FileFree, RegUltimo, Datos RegActual = RegUltimo

VisualizarDatos txtNombre.SetFocus End Sub

'Botón para posicionar en el siguiente registro '##############################################

Private Sub cmdSiguiente_click() If RegActual = RegUltimo Then MsgBox " Ultimo registro ", vbInformation Else 'Incrementa la posición RegActual = RegActual + 1 'Cargamos los datos en el textbox del siguiente registro VisualizarDatos End If txtNombre.SetFocus End Sub 'Botón para posicionar en el Anterior registro '############################################## Private Sub CmdAnterior_click() If RegActual = 1 Then MsgBox " Primer registro ", vbInformation Else

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 37

254. al 255. 256. 257. 258. 259. 260. 261. 262. 263. 264. 265. 266. 267. 268. 269. 270. 271. 272. 273. 274. 275. r 276. 277. 278. 279. 280. 281. 282. 283. 284. 285. 286. 287. 288. 289. 290. 291. 292. 293. 294. 295. 296. 297. 298. 299. 300. 301. 302. 303. 304. 305. 306. 307. 308. 309. 310. 311. 312.

'Decrementamos la variable que mantiene la posición del registro actu RegActual = RegActual - 1 'Mostramos los datos en las cajas de texto VisualizarDatos End If txtNombre.SetFocus End Sub 'Botón para Buscar datos '############################################## Private Sub cmdBuscar_click() Dim Encontrado As Boolean, PosReg As Long, tmp As Contacto If txtBuscar = "" Then txtNombre.SetFocus: Exit Sub Encontrado = False 'Recorremos desde el primer hasta el último en busca del registro a busca

For PosReg = 1 To RegUltimo 'Leemos el registro Get #FileFree, PosReg, tmp 'Si es el dato es igual salimos del bucle If UCase(txtBuscar) = UCase(Trim(BuscarPor(tmp))) Then Encontrado = True Exit For End If Next If Encontrado Then RegActual = PosReg 'Cargamos los datos en los text VisualizarDatos Else MsgBox "Nombre: " & txtBuscar & " No se ha encontrado el registro" End If txtNombre.SetFocus End Sub 'Función que retorna el valor de la búsqueda '############################################# Private Function BuscarPor(t As Contacto) Select Case Combo1.ListIndex Case 0: BuscarPor = t.Nombre Case 1: BuscarPor = t.Apellido Case 2: BuscarPor = t.Telefono

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 38

313. 314. 315. 316. 317. 318. 319. 320. 321. 322. 323. 324. 325. 326. 327. 328. 329. 330.

Case 3: BuscarPor = t.Mail End Select End Function ' Establece los captions de los controles Command del formulario Private Sub Cargarcaptions() Me.Caption = " Agenda simple utilizando archivos aleatorios " CmdAnterior.Caption = " Anterior " cmdSiguiente.Caption = " Siguiente " cmdGuardar.Caption = " Guardar " cmdEliminar.Caption = " Eliminar " cmdNuevo.Caption = " Nuevo " cmdBuscar.Caption = " Buscar " Cmdsalir.Caption = " Salir " End Sub

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 39

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)

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 40

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,

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 41

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 42

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)

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 43

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 44

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.
Cuaderno de Trabajo Visual Basic.NET con Base de Datos Página 45

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 46

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 47

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 48

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 49

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 50

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 51

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 52

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 53

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 54

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 55

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 56

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 57

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 58

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 59

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()

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 60

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. Cuaderno de Trabajo Visual Basic.NET con Base de Datos Página 61

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: Cuaderno de Trabajo Visual Basic.NET con Base de Datos Página 62

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

Ejercicio 16 – 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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 63

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")

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 64

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 65

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 66

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 67

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 68

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 69

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 70

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 71

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.

Ejercicio 18 – 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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 72

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 73

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 74

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 75

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 76

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 77

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 78

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 79

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 80

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:

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 81

Campo Codigo A100

Nombre de la Imagen A100.jpg

Imagen

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 Codigo Descripcion FechaEnt Cantidad Depto Tipo Text Text Date / Time Integer Text Tamaño 15 50 8 2 50 Página 82

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Foto1 Foto2 Notas

Binary Text Memo

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

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 83

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.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 84

PRACTICA 17 – 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.

PRACTICAS 18 – 22
Estos mas que practicas, son RETOS para cumplir al finalizar el curso. 1.- Hacer una aplicación que permite registrar en una base de datos los datos de los empleados de una empresa. Los campos son: Nombre, Apellido, Edad, Cargo, Sueldo, Dirección, Teléfono y Fecha de contrato. El programa debe permitir al usuario obtener distintos tipos de reporte, como por ejemplo: los empleados que ganen más de 10,000 pesos, los empleados mayores de 50 años de edad, etc. 2.- Hacer una aplicación que permita gestionar un almacén de un supermercado. 3.- Hacer una aplicación que permita gestionar un sistema de inscripción de una universidad o un colegio. 4.- Crear un pequeño punto de venta. Esto es un sistema que permita vender artículos, imprimir facturas y generar reportes de ventas. 5.- Crear una pequeña aplicación que permita gestionar el almacén de una farmacia.

Cuaderno de Trabajo Visual Basic.NET con Base de Datos

Página 85