Documentos de Académico
Documentos de Profesional
Documentos de Cultura
1
2
Contenido
PRÓLOGO .................................................................................................................................... 6
INTRODUCCIÓN........................................................................................................................... 8
1. MANEJO DE ARCHIVOS........................................................................................................ 11
1.1 Clase File ................................................................................................................... 11
1.1.1 Ejemplo clase File .................................................................................................. 12
1.2 Clases StreamWriter y StreamReader ...................................................................... 17
1.2.1 Ejemplo clases StreamWriter y StreamReader ..................................................... 17
1.3 Controles OpenFileDialog y SaveFileDialog .............................................................. 20
1.3.1 Ejemplo con los controles OpenFileDialog y SaveFileDialog ............................... 20
1.4 Archivos secuenciales ............................................................................................... 24
1.4.1 Ejemplo de archivos secuenciales ........................................................................ 24
1.5 Archivos binarios ........................................................................................................ 29
1.5.1 Ejemplo de archivos binarios ................................................................................. 29
1.6 Importar y exportar datos de una hoja de Excel ........................................................ 32
16.1 Ejemplo importar y exportar datos de Excel .......................................................... 32
1.7 Exportar datos a Word ............................................................................................... 38
1.7.1 Ejemplo de exportar datos de VB.NET a Word ..................................................... 38
1.8 Ejercicios de archivos ................................................................................................ 43
2. BASES DE DATOS ................................................................................................................. 44
2.1 Tipos de bases de datos ............................................................................................ 44
2.1.1 Relacionales .......................................................................................................... 44
2.1.2 Orientada a objetos ............................................................................................... 44
2.2 Lenguaje de Consulta Estructurado (S.Q.L.) ............................................................. 44
2.2.1 Comandos ............................................................................................................. 45
2.2.2 Cláusulas ............................................................................................................... 45
2.2.3 Operadores lógicos................................................................................................ 46
2.2.4 Operadores de Comparación ................................................................................ 46
2.2.5 Funciones de agregado ......................................................................................... 46
2.3 Sentencias Básicas SQL ........................................................................................... 47
2.3.1 CREATE DATABASE ............................................................................................ 47
2.3.2 DROP DATABASE ................................................................................................ 48
2.3.3 CREATE TABLE .................................................................................................... 48
2.3.4 DROP TABLE ........................................................................................................ 48
2.3.5 INSERT .................................................................................................................. 48
2.3.6 ALTER ................................................................................................................... 48
2.3.7 SELECT ................................................................................................................. 49
2.3.8 DELETE ................................................................................................................. 50
2.3.9 UPDATE ................................................................................................................ 50
2.3.10 INNER JOIN ...................................................................................................... 51
2.4 Conexión a bases de datos ....................................................................................... 52
2.5 Ejemplos de conexión a bases de datos ................................................................... 52
2.5.1 Conexión a una base de datos de SQL Server ..................................................... 52
2.5.2 Conexión a una base de datos de ACCESS ......................................................... 56
2.5.3 Conexión a una base de datos de ORACLE con código ...................................... 59
2.6 Conexión a una bases de datos con el Explorador de servidores ............................ 63
2.6.1 Conexión a SQL Server con el Explorador de servidores ..................................... 63
2.7 Ejercicios de conexión a bases de datos ................................................................... 71
3. DESPLAZAMIENTO POR LOS REGISTROS DE UNA TABLA ............................................. 72
3.1 Ejemplos de desplazamiento por los registros de una tabla ..................................... 72
3.1.1 Formulario con campos de texto y botones .......................................................... 72
3.1.2 Formulario con una cuadrícula y botones ............................................................. 82
3.1.2 Formulario con una cuadrícula y un control BindingNavigator .............................. 85
3.2 Ejercicios de desplazamiento por los registros de una tabla ..................................... 92
3
4. OPERACIONES CON TABLAS DE UNA BASE DE DATOS............................................. 93
4.1 Ejemplos de operaciones con tablas de una base de datos ..................................... 93
4.1.1 Insertar registros en una tabla utilizando campos de texto ................................... 93
4.1.2 Insertar registros en una tabla utilizando un DataGridView .................................. 96
4.1.3 Buscar registros por un campo específico .......................................................... 101
4.1.4 Buscar registros por cualquier campo de una tabla ............................................ 104
4.1.5 Buscar registros mientras se escribe .................................................................. 107
4.1.6 Ejecutar instrucciones SQL sobre una base de datos ........................................ 111
4.1.7 Eliminar registros de una tabla ............................................................................ 113
4.1.8 Actualizar registros de una tabla ......................................................................... 117
4.1.9 Generar un reporte de los registros de una tabla ................................................ 120
4.2 Ejercicios de operaciones con tablas de una base de datos ................................... 131
5. MANEJO DE RELACIONES ENTRE TABLAS EN UNA BASE DE DATOS ................... 132
5.1 Ejemplos de relación de tablas de una base de datos ............................................ 132
5.1.1 Visualizar registros de tablas relacionadas ......................................................... 132
5.1.2 Relación de tablas utilizando dos DataGridView ................................................. 135
5.1.3 Relación de tablas utilizando ComboBox ............................................................ 138
5.1.4 Reporte con tablas relacionadas ......................................................................... 147
5.2 Ejercicios de relación de tablas ............................................................................... 162
6. MANEJO DE ARCHIVOS CON ASP.NET ....................................................................... 163
6.1 Manejo de Archivos de texto con ASP.NET. ........................................................... 163
6.2 Ejemplos de manejo de archivos con ASP.NET. ..................................................... 164
6.2.1 Cargar archivo con el control FileUpLoad. .......................................................... 164
6.2.2 Manejo de archivos de texto con StreamWriter y StreamReader. ...................... 168
6.2.3 Guardar /Leer Archivo de texto con FileSystem .................................................. 171
6.3 Ejercicios de archivos de texto con ASP.NET ......................................................... 175
7. BASE DE DATOS CON ASP.NET ................................................................................... 176
7.1 Ejemplos de manipulación de bases de datos con ASP.NET ................................. 176
7.1.1 Pagina Web con los campos de una tabla .......................................................... 176
7.1.2 Conexión a una base de datos desde un Formulario Web ................................. 180
7.1.3 Conexión a SQL Server con el control DetailsView ............................................ 183
7.1.4 Página Web con desplazamiento de registros .................................................... 192
7.1.5 Página Web para insertar registros en una tabla ................................................ 200
7.1.6 Pagina Web para eliminar registros de una tabla ............................................... 210
7.1.7 Página Web para modificar registros .................................................................. 215
7.1.8 Página Web con un informe de los registros de una tabla .................................. 220
7.2 Ejercicios de bases de datos con ASP.NET ............................................................ 231
8. MANEJO DE TABLAS RELACIONADAS CON ASP.NET ............................................... 232
8.1 Ejemplos de relación entre tablas de una base de datos con ASP.NET ................ 232
8.1.1 Relación de dos tablas con DropDownList y GridView ....................................... 232
8.1.2 Relación de tablas utilizando GridView y FormView ........................................... 246
8.1.3 Página Web con tres tablas relacionadas ........................................................... 261
8.2 Ejercicios relación de tablas con ASP.NET ............................................................. 278
ANEXO A CREACIÓN DE APLICACIONES WINDOWS FORMS ........................................... 279
A.1 Crear un nuevo proyecto Visual Basic .NET (Windows Forms) ............................... 279
A.2 Elegir plantilla de aplicaciones ................................................................................... 280
A.3 Crear la interfaz de usuario ........................................................................................ 283
A.4 Establecer las propiedades de los controles ............................................................. 284
A.5 Escribir código ............................................................................................................ 285
A.6 Guardar la aplicación ................................................................................................. 286
A.7 Ejecutar la aplicación Windows Forms ...................................................................... 286
A.8 Cerrar y abrir un proyecto .......................................................................................... 287
ANEXO B CREACIÓN DE APLICACIONES WEB ASP.NET ................................................... 288
B.1 Crear un nuevo Sitio Web (ASP.NET) ...................................................................... 288
4
B.2 Elegir plantilla de aplicaciones ................................................................................... 289
B.3 Crear la interfaz de usuario ........................................................................................ 293
B.4 Establecer las propiedades de los controles. ............................................................ 294
B.5 Escribir código ............................................................................................................ 295
B.6 Ejecutar la aplicación Web ......................................................................................... 298
B.7 Cerrar y abrir un sitio Web ......................................................................................... 300
ANEXO C SQL SERVER .......................................................................................................... 301
C.1. Conectarse a SQL Server. ........................................................................................ 301
C.2 Crear una base de datos ........................................................................................... 302
C.3 Crear tablas en la base de datos ............................................................................... 304
C.4 Crear Diagramas de una base de datos .................................................................... 312
C.5 Crear una vista ........................................................................................................... 316
ANEXO D ORACLE DATABASE 10G EXPRESS .................................................................... 320
D.1 Instalación .................................................................................................................. 320
D.2 Creación de una tabla en la base de datos con usuario system ............................... 325
ÍNDICE ...................................................................................................................................... 332
BIBLIOGRAFÍA.......................................................................................................................... 334
INFOGRAFÍA............................................................................................................................. 334
5
PRÓLOGO
Manejo de datos con Visual Basic y ASP .NET proporciona los elementos necesarios
para el manejo de datos desde el entorno del lenguaje de Programación Visual Basic
.NET con aplicaciones Windows Forms y ASP. Este libro ha sido pensado para todos
aquellos que estén interesados en conocer cómo se puede guardar o recuperar
información desde archivos de texto plano, importar o exportar desde Visual Basic
.NET datos a otros programas como Excel, Word, etc... Además realizar la conexión a
diferentes bases de datos, desplazarse entre los registros de una tabla, realizar
operaciones entre tablas y la relación de éstas. El material didáctico del libro se basa en
el aprendizaje guiado por la conceptualización de cada tema, la realización de ejemplos
prácticos explicados y con gráficos que visualizan el objetivo de los ejercicios.
Todos los ejemplos del libro han sido compilados y ejecutados con el programa
Microsoft Visual Studio 2008 (la mayoría de los ejemplos también los puede compilar y
ejecutar con las versiones Express Edition Visual Basic 2005/2008 y Visual Web
Developer 2005/2008); cada ejemplo es explicado detalladamente, solamente se omiten
explicaciones en aquellos casos en donde se ha realizado con anterioridad.
Manejo de datos con Visual Basic y ASP .NET contiene 8 capítulos y 4 anexos
distribuidos de la siguiente forma:
6
Capítulo 4, Operaciones con tablas de una base de datos: Se manejan
ejemplos de las distintas operaciones que se pueden realizar con los registros
de una tabla como son: insertar, consultar, buscar, eliminar, actualizar y
generar reportes. Cada operación es ilustrada con ejemplos debidamente
explicados.
Capítulo 5, Manejo de las relaciones de tablas en una base de datos:
Aquí se conceptualiza y se crean ejemplos sobre la relación de tablas de una
base de datos utilizando diferentes controles que ofrece Visual Basic .NET,
así como la creación de reportes con tablas relacionadas.
Capítulo 6, Manejo de Archivos con ASP.NET: Se conceptualiza sobre
ASP. NET, como también se crean diversos ejemplos de escritura y lectura
de archivos de texto plano en una aplicación Web.
Capítulo 7, Bases de datos con ASP.NET: Se diseñan ejemplos
ilustrativos sobre la operación y manipulación de los registros de una tabla
utilizando una aplicación Web. Con los ejemplos se puede verificar la
estructura de una tabla, la conexión a una base de datos con distintos
controles, el desplazamiento de registros y las operaciones de inserción,
eliminación, modificación de registros, como también la creación de
reportes.
Capítulo 8, Manejo de tablas relacionadas con ASP.NET: En este
capítulo se diseñaron ejemplos que permiten obtener la relación entre tablas
en aplicaciones Web utilizando diferentes controles de Visual Basic. NET.
Anexo A: Se explica en forma breve cómo se crean proyectos Windows
Forms, el diseño de la interfaz de usuario, la modificación de los controles
del proyecto, la escritura de código, así como guardar y ejecutar un proyecto
Windows Forms. Además, cómo cerrar y/o abrir un proyecto Windows
Forms.
Anexo B: Se explica cómo se crean nuevos sitios Web, el diseño de la
interfaz de usuario, la modificación de los controles del sitio Web, la
escritura de código y la ejecución de un sitio Web. Además, cómo cerrar y/o
abrir un sitio Web.
Anexo C: Se explica cómo se realiza la conexión a SQL Server, así como la
creación de una base de datos, la creación de tablas, diagramas y vistas
dentro de la base de datos.
Anexo D: En este anexo se explica cómo se realiza la instalación de la base
de datos Oracle Database 10g Express Edition; también, cómo se crea e
insertan datos en una tabla de dicha base de datos.
7
INTRODUCCIÓN
Visual Basic .NET (VB.NET) es una versión de Visual Basic enfocada al desarrollo de
aplicaciones .NET, e implementada sobre el Framework.NET (más adelante se explica
este tema). Dicho lenguaje de programación es orientado a objetos, donde es posible la
creación de clases que pueden derivarse de otras mediante herencia, la sobrecarga de
métodos, el control estructurado de excepciones o la creación de aplicaciones con
múltiples hilos de ejecución, además de contar con la extensa librería de .NET, con la
que permite desarrollar tanto aplicaciones Windows Forms y formularios Web, como el
manejo de diversos proveedores de bases de datos, el envío de datos mediante
documentos XML1 y la generación de informes a partir de archivos de texto, bases de
datos, etc.
Microsoft .NET.
8
la específicación CLS (Common Language Specification) que determina las
reglas necesarias para crear el código MSIL compatible con el CLR. Además,
para ejecutarse necesita un compilador JIT3 (Just-In-Time) el cual genera el
código máquina4 real que se ejecuta en la plataforma del cliente. De esta forma
se consigue con .NET independencia de la plataforma de hardware.
.NET Framework
3
Técnica para mejorar el rendimiento de sistemas de programación que compilan a bytecode, consistente
en traducir el bytecode a código máquina nativo en tiempo de ejecución.
4
Sistema de códigos directamente interpretable por un circuito microprogramable, como el
microprocesador de un computador o el microcontrolador de un autómata (un PLC). Este lenguaje está
compuesto por un conjunto de instrucciones que determinan acciones a ser tomadas por la máquina.
9
aplicaciones basadas en las innovacíones más recientes proporcionadas por ASP.NET,
como los formularios Web Forms y los servicios Web XML.
10
1. MANEJO DE ARCHIVOS
Muchos de los programas que se crean con Visual Basic .NET necesitan interactuar con
datos del exterior, procesarlos para luego mostrarlos en un formulario, guardarlos en
archivos de texto, en una hoja de Excel, en un archivo de Word, enviarlos a la red o
simplemente imprimirlos en papel, etc. Se usan archivos para conservar a largo plazo
grandes cantidades de datos. Los datos guardados en archivos se conocen como datos
persistentes. Los computadores guardan los archivos en dispositivos de almacenamiento
secundario como discos magnéticos, ópticos y cintas magnéticas.
Para procesar archivos en Visual Basic .NET se debe hacer uso del espacio de
nombres5 System.IO. El espacio de nombres System.IO contiene enumeraciones para
la apertura de archivos, el acceso a los archivos, el uso compartido de archivos,
además, de clases para las operaciones de rutas de acceso y la manipulación de flujos de
datos.
Se puede utilizar la clase File para operaciones como copiar, mover, cambiar el nombre,
crear, abrir, eliminar y anexar texto a archivos de texto plano. También con la clase File
se puede obtener y definir atributos del archivo o información relacionada con la hora y
fecha de creación, el acceso y la escritura en un archivo.
Stream es la clase base de todas las secuencias de flujos de datos. Una secuencia
es una abstracción de una secuencia de bytes, como un archivo, un dispositivo de
entrada/salida, un canal de comunicación interprocesos o un socket TCP/IP. La clase
Stream y sus clases derivadas proporcionan una visión genérica de diferentes tipos de
entrada y salida, aislando al programador de los detalles específicos del sistema
operativo y sus dispositivos subyacentes.
Método Proceso
CreateText(ruta) Crea o abre un archivo para escribir texto.
Create(ruta) Crea un archivo en la ruta específicada
AppendText Anexa texto a un archivo de texto
existente.
Delete Elimina un archivo existente.
Copy Copia un archivo
Exists Determina si existe un archivo específico.
Open Abre un archivo de texto existente
Move Mueve un archivo a un sitio específico.
GetCreateTime Devuelve la hora y la fecha de la creación
de un archivo.
Replace Reemplaza el contenido de un archivo en
otro.
5
Se usan para agrupar clases y otros tipos de datos que estén relacionados entre sí.
11
1.1.1 Ejemplo clase File
12
Text Guardar en archivo
Button2 Name botonabrir
Text Abrir archivo
Button3 Name botonadicionar
Text Adicionar texto
Form1 Name formulario
Text Guardar, leer y adicionar datos
en archivo de texto.
Escribir código
imports System.IO
Public Class formulario
……
End Class
13
MsgBox("Texto Guardado", MsgBoxStyle.Information)
Catch ex As Exception
MsgBox("Error al guardar el archivo", MsgBoxStyle.Critical)
End Try
14
Dentro del bloque Try primero se coloca el objeto texto en blanco y
luego se crea un objeto llamado adicionartexto de tipo StreamWriter (flujo de
escritura). A dicho objeto se le asigna la propiedad de adición del texto al
archivo “c:\datosentexto.txt” por medio del método AppendText de la clase
File. Utilizando el método WriteLine y enviándole como parámetro el
contenido del control llamado textoadicional, se adiciona la información al final
del archivo específicado. Por otro lado se cierra el archivo utilizando el método
close () y se limpia el objeto textoadicional. En el bloque Catch si se genera
algún error, se mostrará el mensaje “Error al adicionar inf. al archivo”.
Ejecutar el proyecto
15
Pulse el botón Aceptar para cerrar dicha caja. Al pulsar el botón Leer Archivo,
se visualizará nuevamente la figura 1.3. Si se adiciona el texto “adicionando texto al
archivo que previamente había guardado” en el objeto textoadicional. El formulario
deberá ser semejante a la siguiente figura:
16
1.2 Clases StreamWriter y StreamReader
17
Tabla 1.3 Propiedades de los controles del proyecto GuardarábrirArchivoTexto.
Escribir código
a) Seleccione el objeto botonguardar, dé doble clic para abrir el editor de código y
escriba el siguiente código:
Try
Dim archivo As New System.IO.StreamWriter("./archivotexto.txt")
archivo.Write(texto.Text)
archivo.Close()
texto.Text = ""
Catch ex As Exception
MsgBox("No se pudo guardar la informacion", MsgBoxStyle.Critical)
End Try
Ejecutar el proyecto
Al ejecutarse el proyecto en el entorno de desarrollo de Visual Basic.NET/2008, se
visualizará la figura 1.8. Al adicionársele el texto “El amor es el principio de todo, la
razón de todo, el fin de todo” en el objeto llamado texto, el formulario presentaría el
siguiente aspecto:
19
1.3 Controles OpenFileDialog y SaveFileDialog
20
Tabla 1.4 Propiedades de controles proyecto GuardarábrirArchivoConControles.
Escribir código
22
Ejecutar el proyecto
Al ejecutarse el proyecto en el entorno de desarrollo de Visual Basic.NET se visualizará
la figura 1.11. Al pulsar el botón Abrir Archivo de Texto se visualizará el cuadro de
diálogo de Abrir. Se debe seleccionar un archivo de texto y pulsar el botón del cuadro
de diálogo Abrir.
23
Figura 1.14 Cuadro de diálogo control guardar archivo.
24
Figura 1.15 Interfaz de usuario (ArchivosSecuenciales).
25
La interfaz de usuario queda como se muestra en la siguiente figura:
Escribir código
a) Seleccione el objeto botonguardar, dé doble clic para abrir el editor de código y
escriba el siguiente código:
Try
FileOpen(1, "c:\datossecuenciales.txt", OpenMode.Output)
PrintLine(1, textonombre.Text, textoapellido.Text)
textonombre.Text = ""
textoapellido.Text = ""
FileClose(1)
Catch ex As Exception
MsgBox("No se pudo guardar el archivo")
End Try
26
Lo único que cambia con respecto a la opción de Guardar archivo es el
modo de apertura del archivo (OpenMode.Append), se cambia OutPut por
Append (adicionar). Este modo de apertura permite guardar más información al
final del archivo específicado.
Try
FileOpen(1, "c:\datossecuenciales.txt", OpenMode.Input)
Dim linea As String
Do Until EOF(1)
linea = LineInput(1)
textolectura.Text = textolectura.Text & linea & vbCrLf
Loop
FileClose(1)
Catch ex As Exception
MsgBox("No se pudo abrir el archivo")
End Try
Ejecutar el proyecto
Al ejecutarse el proyecto se visualizará la figura 1.16. Al escribir un nombre y un
apellido en las respectivas cajas de texto y pulsar el botón Guardar archivo, se
guardará dicha información en el archivo “c:\datossecuenciales.txt”. El formulario con
la información quedaría de la siguiente forma:
27
Si se desea adicionar más información al archivo de texto, escriba nuevamente
los nombres y apellidos correspondientes y pulse el botón Adicionar texto, se podría
obtener la siguiente pantalla:
Al pulsar el botón Leer Archivo se leerá el contenido del archivo de texto, como
se muestra en la siguiente figura.
28
1.5 Archivos binarios
También es posible guardar o leer información desde un archivo con acceso binario.
Con los archivos de acceso binario se puede almacenar información ya sea numérica, de
cadena o de ambas. Este tipo de archivo no requiere campos de longitud fija. No
obstante, es necesario conocer cómo se escribieron exactamente los datos en el archivo
para poder recuperarlos correctamente. Por ejemplo, si almacena una serie de productos
y unas cantidades, debe tener en cuenta que el primer campo (producto) es texto y el
segundo (cantidades) es numérico.
29
Tabla 1.6 Propiedades de controles proyecto ArchivosBinarios.
Escribir código
Structure Articulo
<VBFixedString(30)> Dim producto As String
<VBFixedString(10)> Dim cantidad As String
End Structure
30
Se define una estructura (Structure) llamada Articulo que contendrá dos
tipos de datos String producto y cantidad. Se utiliza el atributo
VBFixedString () para definir la longitud máxima de los datos.
31
Ejecutar el proyecto
32
Figura 1.23 Interfaz de usuario (ImportarExportarExcel).
33
Figura 1.24 Interfaz de usuario modificada (ImportarExportarExcel).
Escribir código
Antes de escribir código, se deberá crear un archivo en Excel llamado
“importardatos.xls” y en la hoja uno (1) escribir información en el rango A1:D10,
como se muestra en la siguiente figura:
35
Al adaptador de datos adaptadordedatos se le asigna espacio de memoria,
enviándole como parámetro los datos seleccionados (selecciondedatos) y la
cadena de conexión (conexiondedatos), también se asigna espacio de memoria
de tipo DataSet al objeto conjuntodedatos y el adaptador de datos
(adaptadordedatos) se rellena (fill) con el conjunto de datos. Por otro lado se
cierra la conexión de los datos con close (). Además se asigna a la propiedad
DataSource del objeto tabla el conjunto de datos y al adaptador de datos se le
asigna la lista de datos que contiene el archivo de Excel, por último se liberan
todos los objetos utilizando la palabra clave Nothing (liberar). Si la condición es
falsa se mostrará un mensaje donde se informa que no se pudo encontrar el
archivo de Excel.
exportar_Excel(tabla, tabla.Rows.Count)
Ejecutar el proyecto
Al ejecutarse el proyecto en el entorno de desarrollo, se visualizará la figura 1.25. Al
escribir el rango A1:D10 y pulsar el botón Importar de Excel, se visualizará la
siguiente figura:
Si se pulsa el boton “Exportar a Excel”, se exportarán todos los datos del objeto
tabla y se abrirá el archivo de Excel “exportardatos.xls” en c:\. Dicho archivo debe
existir para que no ocurra ningún error.
37
Figura 1.27 Hoja de Excel con datos exportados desde VB.NET.
Con Visual Basic .NET también es posible exportar los datos que existen en un control
de Visual Basic .NET a un archivo de Word. Para esto es necesario agregar una
referencia .NET llamada Microsoft.Office.Interop.Word en el proyecto que se está
trabajando.
Agregar referencia
Desde el submenú proyecto seleccione la opción Agregar referencia… y busque el
nombre del componente Microsoft.Office.Interop.Word, se debería visualizar la
siguiente pantalla:
38
Al estar seleccionado dicho componente, pulse el botón Aceptar para
incorporarlo al proyecto.
39
Figura 1.30 Interfaz de usuario modificada (ExportarWord).
Escribir código
a) Seleccione el objeto botonexportar, dé doble clic para abrir el editor de código
y escriba el siguiente código:
Dim archivo_Word As Microsoft.Office.Interop.Word.Application
Dim Documento As Microsoft.Office.Interop.Word.Document
Dim Parrafo As Microsoft.Office.Interop.Word.Table
Dim filas As Integer
Dim columnas As Integer
Dim dato As Object
archivo_Word = New Microsoft.Office.Interop.Word.Application
archivo_Word.Visible = True
Documento = archivo_Word.Documents.Add
Parrafo = Documento.Tables.Add(Documento.Range(0, 0), tabla.RowCount + 1,
tabla.Columns.Count)
For columnas = 0 To tabla.Columns.Count - 1
arrafo.Cell(1, columnas + 1).Range.InsertAfter(tabla.Columns(columnas).HeaderText)
For filas = 0 To tabla.RowCount - 1
dato = tabla.Item(columnas, filas).Value
Parrafo.Cell(filas + 2, columnas + 1).Range.InsertAfter(dato)
Next
Next
archivo_Word = Nothing
Documento = Nothing
Parrafo = Nothing
40
interno se recorre cada una de las filas del objeto DataGridView y se van
asignando a la variable dato el valor de cada celda(columnas, filas) del objeto
tabla y se coloca en la celda (j, i) de la tabla de Word el valor que tiene el objeto
dato. Por último se liberan todos los objetos utilizando la palabra clave Nothing
(liberar).
With tabla
.Columns.Add("Código", "Código")
.Columns.Add("Producto", "Producto")
.Columns.Add("Precio", "Precio")
.Columns.Add("Inventario", "Inventario actual")
.Columns.Add("Proveedor", "Nombre Proveedor")
.RowCount = 10
For i As Integer = 0 To .RowCount - 1
.Item(0, i).Value = i.ToString
.Item(1, i).Value = "Producto " & i.ToString
.Item(2, i).Value = FormatNumber(225 + i)
.Item(3, i).Value = CInt(Rnd() * 100)
.Item(4, i).Value = "Proveedor: " & i.ToString
Next
End With
Ejecutar el proyecto
Al ejecutarse el proyecto en el entorno de desarrollo de Visual Basic.NET/2008, se
visualizará el formulario con los datos que se asignaron en el procedimiento
formulario_Load, se visualizará la siguiente figura:
Figura 1.31 Formulario con datos cargados desde el load.
41
Al pulsar el botón Exportar a Word, se abrirá un nuevo documento de Word y
se visualizaría lo siguiente:
En este momento puede seleccionar todos los datos y pulsar el icono bordes de
Word y escoger la opción “Todos los bordes” para que el documento presente el
siguiente aspecto:
42
1.8 Ejercicios de archivos
43
2. BASES DE DATOS
Los tipos de bases datos más comunes son las relacionales y en el mercado existen
varios sistemas de administración de bases de datos de ese tipo, algunos son: SQL
Server, Access, Oracle, MySQL, PostgresSQL, etc.
2.1.1 Relacionales
Son las que más se utilizan. Las bases de datos relacionales son un conjunto de tablas
relacionadas entre sí, cada tabla está definida por una serie de campos. Los campos
forman las columnas de las tablas; estos definen el tipo y la variedad de los datos. Las
filas de datos se denominan registros (tuplas), cada tipo definido en un registro se le
denomina atributo. Las tablas pertenecientes a una base de datos pueden relacionarse
entre sí utilizando campos clave comunes entre las tablas.
El esquema de una base de datos por objetos está representado por un conjunto de clases
que definen las características y el comportamiento de los objetos que poblarán la base
de datos. Con una base de datos orientada a objetos, los objetos memorizados en la base
de datos contienen tanto los datos como las operaciones posibles con tales datos. En
cierto sentido, se podrá pensar en los objetos como en datos a los que se les ha puesto
una inyección de inteligencia que les permite saber cómo comportarse, sin tener que
apoyarse en aplicaciones externas.
44
estructura de los mismos. El lenguaje SQL está compuesto por comandos, cláusulas,
operadores y funciones de agregado. Estos elementos se combinan en las instrucciones
para crear, actualizar y manipular las bases de datos.
2.2.1 Comandos
DLL que permiten crear y definir nuevas bases de datos, tablas, campos e índices.
DML que permiten generar consultas para ordenar, filtrar y extraer datos de la base de
datos.
Comandos DLL
Comando Descripción
CREATE Utilizado para crear nuevas bases de datos, tablas, campos e índices.
DROP Empleado para eliminar bases de datos, tablas e índices.
Utilizado para modificar las tablas agregando campos o cambiando la
ALTER
definición de los campos.
Comandos DML
Utilizado para consultar registros de la base de datos que satisfagan un
SELECT
criterio determinado.
Utilizado para cargar lotes de datos en la base de datos en una única
INSERT
operación.
UPDATE Utilizado para modificar los valores de los campos y registros específicados.
DELETE Utilizado para eliminar registros de una tabla de una base de datos.
2.2.2 Cláusulas
Las cláusulas son condiciones de modificación utilizadas para definir los datos que se
desea seleccionar o manipular.
Cláusula Descripción
FROM Para específicar la tabla de la cual se van a seleccionar los registros.
Para específicar las condiciones que deben reunir los registros a
WHERE
seleccionar.
GROUP BY Utilizada para separar los registros seleccionados en grupos específicos.
HAVING Utilizada para expresar la condición que debe satisfacer cada grupo.
ORDER BY Para ordenar los registros seleccionados.
45
2.2.3 Operadores lógicos
Operador Uso
Es el "y" lógico. Evalúa dos condiciones y devuelve un valor de
AND
verdad sólo si ambas son ciertas.
Es el "o" lógico. Evalúa dos condiciones y devuelve un valor de
OR
verdad si alguna de las dos es cierta.
NOT Negación lógica. Devuelve el valor contrario de la expresión.
BETWEEN Utilizado para específicar un intervalo de valores.
LIKE Utilizado en la comparación de un patrón.
IN Utilizado para específicar registros de una base de datos.
ALL Devuelve True si el conjunto de comparaciones en verdad.
Operador Uso
< Menor que
> Mayor que
<> Distinto de
<= Menor o igual que
>= Mayor o igual que
= Igual que
46
Tabla 2.5 Funciones de agregado SQL.
Función Descripción
Utilizada para calcular el promedio de los valores de un campo
AVG
determinado.
COUNT Utilizada para devolver el número de registros de la selección.
Utilizada para devolver la suma de todos los valores de un campo
SUM
determinado.
MAX Utilizada para devolver el valor más alto de un campo específicado.
Utilizada para devolver el valor más bajo de un campo
MIN
específicado.
El comando CREATE DATABASE permite crear una base de datos. Su formato es:
CREATE DATABASE <nombre_base_de_datos)
47
2.3.2 DROP DATABASE
El comando DROP DATABASE permite eliminar una base de datos que previamente
se había creado. Su formato es:
El comando CREATE TABLE permite crear una tabla. Con este comando se
específica el nombre de la tabla, las columnas y sus tipos de datos, las claves primarias
y si es necesario, la clave externa. Su formato es:
El comando DROP TABLE permite eliminar una tabla que previamente se había
creado. Su formato es:
2.3.5 INSERT
2.3.6 ALTER
La sentencia SQL ALTER permite insertar un nuevo campo en una tabla. Su formato
es:
ALTER TABLE nombre_tabla ADD nombre_campo tipo_de_dato ()
48
2.3.7 SELECT
c) Si se desea obtener los registros cuya identificación sea menor o igual a 116, se
debe utilizar la cláusula WHERE que específica las condiciones que deben
reunir los registros que se van a seleccionar.
d) Si se desea obtener los registros cuyos nombres sean Andrés o Cristian, se debe
utilizar el operador IN que específica los registros que se quieren visualizar de
una tabla.
f) Si se desea obtener los registros cuyos nombres empiecen por la letra ‘C’, se
debe utilizar el operador LIKE que utiliza los patrones ‘%’ (todos) y ‘_’
(carácter).
h) Si se desea obtener los registros donde la segunda letra del nombre sea una ‘o’.
49
SELECT * FROM usuarios WHERE nombres LIKE _o%’
i) Si se desea obtener los registros cuya identificación esté entre el intervalo 116 y
140, se debe utilizar la cláusula BETWEEN, que sirve para específicar un
intervalo de valores.
2.3.8 DELETE
b) Para eliminar solamente los registros cuya identificación sea mayor de ‘150’.
2.3.9 UPDATE
b) Para actualizar el campo credito en 200000 para los registros cuyo nombre
empiecen por ‘A’.
c) Para actualizar el campo credito en 50000 para los registros cuya ciudad sea
igual a ‘Bogota’.
50
2.3.10 INNER JOIN
51
2.4 Conexión a bases de datos
Visual Basic .NET utiliza la tecnología ADO.NET que permite el acceso a bases de
datos mediante proveedores para sistemas administradores de bases de datos que
funcionan en el entorno .NET. La plataforma .NET incorpora cuatro proveedores: SQL
SERVER, ORACLE, ODBC (Access), OLEDB.
DataSet: Es el conjunto de datos donde se pueden incluir una o más tablas con
la información acerca de las relaciones entre éstas, y las restricciones que
puedan tener los datos.
DataTable: Permite la manipulación de los datos en la memoria y realiza
operaciones como exploración, ordenación, edición, aplicación de filtros,
creación de vistas, etc.
DataView: Permite representar los datos de la clase DataTable, creando
múltiples vistas de los mismos.
Los proveedores de datos proporcionan el puente entre las bases de datos y las
aplicaciones. Los principales objetos de un proveedor de datos .NET son:
Connection: Sirve para establecer una conexión con una base de datos. Se
utiliza SqlConnection para una conexión a SQL Server, OleDbConnection
para una conexión a Access y OracleConnection para Oracle.
Command: Sirve para ejecutar sentencias SQL y devolver resultados de una
base de datos. Se utiliza SqlCommand para una conexión a SQL Server,
OleDbCommand para una conexión a Access y OracleCommand para Oracle.
DataAdapter: Es el adaptador de datos, el cual es un conjunto de objetos para
intercambiar datos entre una base de datos y un conjunto de datos. Se utiliza
SqlDataAdapter para una conexión a SQL Server, OleDataAdapter para una
conexión a Access y OracleDataAdapter para Oracle.
52
los datos de una tabla en un objeto DataGridView, utilizando código de Visual Basic
.NET.
NOTA: para este ejemplo el usuario debe tener instalado Microsoft SQL SERVER
2005 o posterior y crear una base de datos llamada bdlibrovbnet (Ver anexo C, SQL
Server) y dentro de ella una tabla llamada clientes, con la siguiente estructura:
Dicha tabla debe contener unos registros para poder consultarlos. La siguiente
figura muestra el aspecto de la tabla con los datos:
53
Figura 2.3 Interfaz de usuario (ConexionBDSQLSERVER).
54
Escribir código
b) Seleccione el objeto boton, dé doble clic para abrir el editor de código y escriba
el siguiente código:
Se crea una variable llamada conexion de tipo String que contendrá la cadena
de conexión a la base de datos de SQL Server. La cadena de conexión debe contener
como mínimo los siguientes parámetros:
55
adaptadordedatos, al cual se le envía como parámetros los objetos seleccion (datos
a mostrar) y conexion (cadena de conexión), luego se rellena (fill) el adaptador de
datos con la tabla de datos (tabladedatos) y por último al objeto tabla en su
propiedad DataSource se le establece el conjunto de datos que se van a mostrar al
asignársele la tabla de datos. Por el bloque Catch se establece un mensaje en caso
de que ocurra un error.
Ejecutar el proyecto
NOTA: para este ejemplo el usuario debe tener instalado Microsoft Access y crear una
base de datos llamada bdaccesslibrovbnet y dentro de ella una tabla llamada clientes
(búsque en Internet cómo crear una base de datos y una tabla en Microsoft Access), con
la siguiente estructura:
56
Dicha tabla debe contener unos registros para poder consultarlos. La siguiente
figura muestra el aspecto de la tabla con los datos:
57
La interfaz de usuario queda como se muestra en la siguiente figura:
Escribir código
b) Seleccione el objeto boton, dé doble clic para abrir el editor de código y escriba
el siguiente código:
58
Con relación al código que se realizó para conectarse a la base de datos SQL
Server, se efectuarón dos cambios, a saber:
Ejecutar el proyecto
NOTA: para este ejemplo el usuario debe tener instalada la base de datos Oracle 10g
Express Edition (Ver anexo D, Oracle Database 10g Express), e ingresar con el
59
usuario y clave creados cuando se realiza la instalación del Oracle y crear una tabla
llamada clientes, con la siguiente estructura:
Dicha tabla debe contener unos registros para poder consultarlos. La siguiente
figura muestra el aspecto de la tabla con los datos en Oracle:
60
Figura 2.13 Interfaz de usuario (ConexionBDORACLE).
61
Escribir código
b) Seleccione el objeto boton, dé doble clic para abrir el editor de código y escriba
el siguiente código:
Ejecutar el proyecto
62
Figura 2.15 Formulario con datos de la tabla clientes de Oracle.
También es posible establecer una conexión y realizar operaciones con una base de
datos utilizando la herramienta Explorador de servidores (explorador de bases de
datos – Visual Basic .NET /2005) del menú Ver, el cual tiene asociados las opciones:
Actualizar, Detener Actualización, Conectar con Base de Datos y Conectar con el
Servidor. Esta herramienta mantiene las conexiones definidas y/o permite definir
nuevas. Cada conexión define un nodo con la estructura de la base de datos.
NOTA: para este ejemplo se utilizará la base de datos llamada bdlibrovbnet de SQL
Server (Ver anexo C, conectarse a SQL Server) y la tabla llamada clientes de dicha
base de datos.
63
Figura 2.16 Interfaz de usuario (ConexionConExploradordeServidores).
64
Explorador de servidores..
65
En esta ventana se puede realizar básicamente lo siguiente:
66
Al pulsar en el signo (+) al lado del nombre de la base de datos se visualizará la
estructura definida en la base de datos. Si desea ver las tablas que contiene la base de
datos pulse el signo (+) al lado de Tablas.
67
Ahora seleccione la opción Agregar origen de datos del proyecto, se
visualizará la siguiente ventana:
68
Pulse el botón Sí para copiar el archivo de datos en la carpeta en donde guardó el
proyecto y se visualizará la ventana de guardar cadena de conexión:
Pulse el signo (+) al lado de Tablas para desplegar las tablas de la base de datos
y seleccione la tabla clientes. Por otro lado, cambie el nombre del DataSet que allí
aparece por conjuntodedatos y pulse el botón Finalizar para visualizar la figura:
69
Figura 2.29 DataGridView con los campos de la tabla clientes.
Ejecutar el proyecto
Al ejecutarse el proyecto, se visualizará en el formulario los datos de la tabla clientes en
el objeto DataGridView de la base de datos bdlibrovbnet.mdf de SQL Server:
Figura 2.30 DataGridView con los datos de la tabla clientes de SQL Server.
70
2.7 Ejercicios de conexión a bases de datos
1. Diseñar un programa que permita realizar una conexión a una base de datos y
mostrar datos de una tabla en un control ComboBox.
2. Crear un programa que permita realizar una conexión a una base de datos y
mostrar datos de una tabla en un control ListView.
3. Realizar un programa que permita realizar una conexión a una base de datos y
mostrar datos de una tabla en un control ListBox.
4. Elaborar un programa que permita realizar una conexión a una base de datos y
mostrar los datos de una tabla en un campo de texto.
5. Realizar un programa que permita realizar una conexión a una base de datos y
mostrar los campos de una tabla en un Label.
6. Hacer un programa que permita realizar una conexión a una base de datos
MySQL y mostrar datos de una tabla en una cuadrícula.
7. Diseñar un programa que permita realizar una conexión a una base de datos en
Oracle utilizando la herramienta explorador de servidores y mostrar los datos de
una tabla en campos de texto.
8. Crear un programa que permita realizar una conexión a una base de datos en
Access utilizando la herramienta explorador de servidores y mostrar los datos de
una tabla en Label.
9. Elaborar un programa que permita realizar una conexión a una base de datos en
MySQL y mostrar los datos de una tabla en un ListBox.
10. Realizar un programa que permita hacer una conexión a una base de datos en
MySQL y mostrar los datos de una tabla en un control ListView.
71
3. DESPLAZAMIENTO POR LOS REGISTROS DE UNA TABLA
Hasta el momento con los ejemplos se ha realizado una conexión a una base de datos ya
sea utilizando código o por medio de la herramienta Explorador de servidores y
recurriendo al control DataGridView, visualizándose los registros de una tabla
específica. Ahora lo que se pretende es que el usuario, aparte de visualizar la
información que contenga una tabla, también pueda desplazar o moverse por cada uno
de los registros que contenga dicha tabla. Está operación la podrá realizar en un
formulario utilizando campos de texto (TextBox) o una cuadrícula (DataGridView) y
poder desplazarse por cada uno de los registros por medio de botones (Button) o de un
control BindingNavigator. Para esto es necesario implementar las opciones de
movimiento de registros: ir al primer registro, al siguiente registro, al anterior registro y
al último registro.
72
Establecer las propiedades de los objetos de la interfaz de usuario
Establezca las siguientes modificaciones a los controles:
73
Establecer la conexión
Desde la ficha Datos del cuadro de herramienta arrastre hacia el formulario el adaptador
de datos SQLDataAdapter (Si no aparece el control, dé clic derecho sobre la ficha
Datos y ejecute la orden Elegir elementos, busque el control, selecciónelo en el cuadro
de verificación y pulse el botón Aceptar). Se visualizará la siguiente figura:
74
Figura 3.5 Ventana Microsoft Visual Studio.
75
Figura 3.8 Ventana Generar las instrucciones SQL.
Aquí se puede realizar la selección de los datos que debería cargar el adaptador
de datos. Una forma es escribir en la ventana instrucciones SQL y la otra es pulsar el
botón Generador de consultas. Para el ejemplo se pulsará el botón para visualizar la
siguiente figura:
76
Figura 3.10 Generador de consultas con la tabla clientes.
En esta nueva ventana seleccione la opción * (todas las columnas) o los campos
que desea visualizar (Si desea visualizar la consulta seleccionada pulse el botón
Ejecutar consulta). Se obtendrá la siguiente figura:
Figura 3.11 Generador de consultas con los campos seleccionados (tabla clientes).
77
Figura 3.12 Generador de consultas con la instrucción SQL.
78
Figura 3.14 Ventana Generar conjunto de datos.
Ahora se deben vincular los campos de texto con los campos de la tabla clientes.
Seleccione el objeto campo1, busque la propiedad DataBindings, expanda el nodo (+),
seleccione la propiedad Text y expanda los nodos formulario instancias de lista,
conjuntodedatos, clientes y seleccione el campo nit, como se aprecia en la figura:
79
Figura 3.16 Vinculación del campo nit al objeto campo1.
conjuntodedatos.Clear()
adaptadordedatos.Fill(conjuntodedatos)
80
escriba el siguiente código:
BindingContext(conjuntodedatos, "clientes").Position = 0
81
3.1.2 Formulario con una cuadrícula y botones
82
Figura 3.20 Interfaz de usuario modificada (MovRegDataGridView).
Escribir código
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
de nombres:
Imports System.Data.SqlClient
Public Class Form1
….
……
End Class
83
tabla.dataSource = transaccion
Dim seleccion As String = "Select * From clientes"
Try
adaptador = New SqlDataAdapter(seleccion, conexion)
Dim comando As New SqlCommandBuilder(adaptador)
Dim tabladedatos As New DataTable()
adaptador.Fill(tabladedatos)
transaccion.DataSource = tabladedatos
With tabla
.Refresh()
.FirstDisplayedScrollingRowIndex = transaccion.Position
End With
Catch ex As SqlException
MsgBox(ex.Message.ToString)
Catch ex As Exception
MsgBox(ex.Message.ToString)
End Try
84
Se utiliza el método MovePrevious() del objeto transaccion para
moverse al anterior registro de la tabla.
Ejecutar el proyecto
85
Figura 3.22 Interfaz de usuario (MovRegBindingNavigator).
86
Ahora seleccione el objeto DataGridView llamado tabla y en la flecha que
aparece en el lado superior derecho, dé clic en el mouse para visualizar las Tareas de
DataGridView:
87
Figura 3.26 Asistente para la configuración de orígenes de datos.
88
Figura 3.28 Ventana Agregar conexión.
89
Figura 3.30 Ventana Microsoft Visual Studio.
Cambie el nombre de la conexión que allí aparece por conexion y pulse el botón
Siguiente>, se visualizará la siguiente figura:
90
Pulse el signo (+) al lado de Tablas para desplegar las tablas de la base de datos
y seleccione la tabla clientes. Por otro lado, cambie el nombre del DataSet que allí
aparece por conjuntodedatos y pulse el botón Finalizar, para visualizar la figura 3.33:
Ejecutar el proyecto
91
3.2 Ejercicios de desplazamiento por los registros de una tabla
92
4. OPERACIONES CON TABLAS DE UNA BASE DE DATOS
Cuando se trabaja con bases de datos se pueden realizar operaciones de añadir, eliminar
tablas, vistas, como también insertar, modificar, eliminar o consultar información de
una tabla. Generalmente estas operaciones se realizan ejecutando instrucciones del
lenguaje SQL.
93
Tabla 4.1 Propiedades de controles proyecto InsertarRegCampoTexto.
Control Propiedad Valor
Label1 Name texto
Text Insertar Registros en la tabla
clientes.
Font true
Label2 Name tnit
Text Digite Nit:
Label3 Name tempresa
Text Nombre empresa:
Label4 Name trepresentante
Text Representante:
Label5 Name tdireccion
Text Dirección:
Label6 Name ttelefono
Text Teléfono:
Label7 Name tciudad
Text Ciudad
Textobox1…Textbox6 Name campo1….campo6
Text blanco
Button1 Name botoninsertar
Text Insertar Registro
Form1 Name formulario
Text Insertar registros en una tabla.
Escribir código
94
Imports System.Data.SqlClient
Public Class Form1
….
……
End Class
95
Ejecutar el proyecto
Al ejecutarse el proyecto, se debe digitar la información solicitada en cada campo de
texto y pulsar el botón Insertar Registro, se insertará el registro en la tabla clientes y
se visualizará el mensaje de “Registro Insertado”. Si desea puede ejecutar alguno de
los programas que permiten consultar una base de datos SQL Server para verificar que
el registro efectivamente se ha guardado en la tabla.
96
Figura 4.5 Interfaz de usuario (InsertarRegDataGridView).
97
Escribir código
a) Antes de la apertura de la clase formulario se debe importar el siguiente
espacio de nombres:
Imports System.Data.SqlClient
Public Class Form1
….
……
End Class
imports System.Data.SqlClient
Public class formulario
Private transaccion As New BindingSource
Private adaptador As SqlDataAdapter
Dim conexion As String = "Data Source=(local)\SQLEXPRESS;Database=
bdlibrovbnet; Integrated Security=True"
…….
…….
End Class
c) Dé doble clic sobre el formulario para abrir el editor de código y cree un nuevo
procedimiento llamado cargar_datos:
Public Sub cargar_datos(ByVal sentenciasql As String, ByVal tabla As DataGridView)
Try
adaptador = New SqlDataAdapter(sentenciasql, conexion)
Dim comando As New SqlCommandBuilder(Adaptador)
Dim tabladedatos As New DataTable()
adaptador.Fill(tabladedatos)
transaccion.DataSource = tabladedatos
With tabla
.Refresh()
.FirstDisplayedScrollingRowIndex = transaccion.Position
End With
Catch ex As SqlException
MsgBox(ex.Message.ToString)
Catch ex As Exception
MsgBox(ex.Message.ToString)
End Try
End Sub
98
El procedimiento cargar_datos recibe como parámetros una variable de
tipo String llamada sentenciassql y un objeto tabla de tipo DataGridView. En
un bloque Try se le asigna espacio de memoria al objeto adaptador de tipo
SqlDataAdapter, el cual recibe la sentencia SQL y la cadena de conexión. Por
otro lado, se crea un objeto tabladedatos al cual se le asigna espacio de
memoria DataTable (). Se rellena el adaptador de datos (adaptador) con la
tabla de datos (tabladedatos) y a la propiedad DataSource del objeto
transaccion se le asigna la tabla de datos. Por otro lado, se refresca (Refresh ())
la cuadrícula para cargar los datos y se obtiene la posición del primer registro de
la cuadrícula (FirstDisplayedScrollingRowIndex = transaccion.Position).
Utilizando dos bloques catch se atrapan las excepciones SQLException (por si
existe algún error en la ejecución de las sentencias SQL) y Exception (por si
existe algún problema con el sistema).
Si la fila del objeto tabla no es vacía por medio del método Update del
objeto adaptador se guarda la nueva fila en la tabla clientes, enviándole el
contenido del DataSource del objeto transaccion y un objeto DataTable. Por
otro lado, se llama al procedimiento cargar_datos para mostrar nuevamente los
registros de la tabla clientes. Si la fila es vacía se muestra el mensaje “No se
pudo guardar el registro”.
99
Ejecutar el proyecto
Figura 4.8 Cuadrícula con una nueva fila para insertar datos.
100
Figura 4.9 Cuadrícula con un nuevo registro insertado en la tabla clientes.
101
Tabla 4.3 Propiedades de controles proyecto ConsultaPorCampo.
Control Propiedad Valor
Label1 Name titulo
Text Ciudad a Buscar:
TextBox1 Name campobusqueda
Text blanco
Button1 Name botonbuscar
Text Buscar
DataGridView1 Name tabla
Form1 Name formulario
Text Consultar tabla por campo.
Escribir código
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
de nombres:
Imports System.Data.SqlClient
Public Class Form1
……
End Class
102
adaptador = New SqlDataAdapter(seleccion, conexion)
adaptador.Fill(tabladedatos)
tabla.DataSource = tabladedatos
If Not (tabla.Rows.Count - 1 > 0) Then
MsgBox("Ciudad no existe en la tabla Clientes...", MsgBoxStyle.Information,
"Consulta por ciudad")
End If
Catch ex As Exception
MsgBox("Error: " & ex.Message)
End Try
Ejecutar el proyecto
Figura 4.12 Formulario con los registros cuya ciudad es igual a Cali.
103
4.1.4 Buscar registros por cualquier campo de una tabla
104
Button1 name boton
Text Consultar
ComboBox1 name listacampos
ComboBox2 name listaoperadores
DataGridView1 Name tabla
Form1 Name formulario
Text Búsqueda de registros
en una tabla.
Escribir código
a) Seleccione el control listacampos, busque la propiedad Items, dé clic en los tres
puntos al lado de Colección y en la ventana Editor de la colección Cadena,
escriba por cada línea un campo de la tabla clientes y pulse el botón Aceptar.
Otra forma es dar clic sobre la flecha del control en la parte superior derecha y
seleccionar la opción Editar elementos. La ventana de edición deberá quedar
como se muestra en la figura:
105
b) Seleccione el control listaoperadores, busque la propiedad Items, dé clic en los
tres puntos al lado de Colección y en la ventana Editor de la colección Cadena,
escriba por cada línea los operadores: <, >=, <, >=, =, <>, luego pulse el botón
Aceptar. La ventana de edición deberá quedar como se muestra en la figura:
d) Seleccione el objeto boton, dé doble clic para abrir el editor de código y escriba
el siguiente código:
Se crean las variables: clave que almacenará el valor que esté escrito en
el objeto valorcampo; nombre_campo de tipo String que almacenará el
106
nombre del campo seleccionado por medio de la propiedad SelectedItem del
objeto listacampos; valoroperador de tipo String que almacenará el operador
seleccionado por medio de la propiedad SelectedItem del objeto
listaoperadores; también se crea una variable seleccion de tipo String que
almacenará la instrucción SQL Select. En dicha instrucción se selecciona todos
los campos de la tabla clientes (Select * from clientes), y se utiliza la cláusula
where para mostrar solo aquellos registros cuya nombre_campo corresponda al
criterio de valoroperador concatenado con clave. En un bloque Try se le asigna
espacio de memoria de tipo SqlDataAdapter al objeto adaptador, al cual se le
envía como parámetros los objetos seleccion (sentencia SQL) y conexion
(cadena de conexión), luego se rellena (fill) el adaptador de datos con la tabla de
datos (tabladedatos) y se le asigna al objeto tabla por intermedio de la
propiedad DataSource el objeto tabladedatos.
Ejecutar el proyecto
Figura 4.17 Formulario con los registros cuyo nit es mayor que 300.
107
Figura 4.18 Interfaz de usuario (ConsultaMientrasSeEscribe).
108
Escribir código
Imports System.Data.SqlClient
Public Class formulario
……
End Class
d) Dé doble clic sobre el objeto campobusqueda para abrir el editor de código del
procedimiento campobusqueda_TextChanged y escriba el siguiente código:
109
listaempresas.Items.Add(filascondatos("Empresa").ToString & ", " &
filascondatos("Representante").ToString)
Next
End If
Ejecutar el proyecto
Figura 4.20 Formulario con nombres de empresas que comienzan con “c”.
110
Figura 4.21 Formulario con nombres de empresas que comienzan con “ca”.
111
Tabla 4.6 Propiedades de controles proyecto ConsultarConInstruccionesSQL.
Escribir código
Imports System.Data.SqlClient
Public Class formulario
……
End Class
b) Dé doble clic sobre el objeto boton para abrir el editor de código y escriba el
siguiente código:
112
Integrated Security=True"
Dim seleccion As String = textosql.Text
Dim adaptador As SqlDataAdapter
Dim tabladedatos As New DataTable
Try
adaptador = New SqlDataAdapter(seleccion, conexion)
adaptador.Fill(tabladedatos)
tabla.DataSource = tabladedatos
Catch ex As Exception
MsgBox("Error: " & ex.Message)
End Try
Ejecutar el proyecto
113
Crear la interfaz de usuario
114
Figura 4.26 Interfaz de usuario modificada (EliminarRegistrosTabla).
Escribir código
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
de nombres:
Imports System.Data.SqlClient
Public Class formulario
……
End Class
b) Dé doble clic sobre el objeto boton para abrir el editor de código y escriba el
siguiente código:
115
Se crean las variables: clave que almacenará el valor que esté escrito en
el objeto textoeliminar; seleccion de tipo String almacenará la instrucción SQL
Delete. En dicha instrucción se eliminarán todos los registros de la tabla clientes
(Delete from clientes) cuyo (where) campo nit sea igual al contenido del objeto
clave. Si el valor de la variable respuesta es igual a Sí, se ejecutará la acción de
eliminación y se visualizará en el objeto tabla los registros restantes de la tabla
clientes.
Ejecutar el proyecto
116
4.1.8 Actualizar registros de una tabla
117
Figura 4.30 Interfaz de usuario modificada (ActualizarRegistrosTabla).
Escribir código
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
de nombres:
Imports System.Data.SqlClient
Public Class formulario
……
End Class
b) Dé doble clic sobre el objeto boton para abrir el editor de código y escriba el
siguiente código:
118
Se crean las variables: clave que almacenará el valor que esté escrito en
el objeto textociudad; seleccion de tipo String que almacenará la instrucción
SQL Update. En dicha instrucción se actualizarán todos los registros de la tabla
clientes (Update clientes set ciudad) en el campo ciudad igual al contenido del
objeto clave para aquellas ciudades cuyo nombre sea igual a “Barranquilla”. Si
el valor de la variable respuesta es igual a Sí, se ejecutará la acción de
actualización y se visualizará en el objeto tabla los registros de la tabla clientes.
Ejecutar el proyecto
Al ejecutarse el proyecto, se visualizará la figura 4.30. Si se escribe en el objeto
textociudad el valor de “Cartagena” y se pulsa el botón Actualizar Ciudad, se
visualizará una caja de mensajes con el mensaje “Esta Seguro de Actualizar los
registros”. Si el usuario pulsa el botón Sí se visualizará la figura 4.32, en caso contrario
se mostrará el mensaje “Registros No Actualizados”.
119
4.1.9 Generar un reporte de los registros de una tabla
120
Seleccione la opción “Acoplar en contenedor principal”, se visualizará el
formulario con el control acoplado como se aprecia en la siguiente figura:
121
Diseñar el informe
Para diseñar el informe, pulse la flecha del lado superior derecho del objeto reporte
para ver la ventana Tareas de ReportViewer y escoja la opción Diseñar nuevo
informe.
122
Dé clic en Siguiente> para ver la ventana del Asistente para la configuración
de orígenes de datos.
123
Dé clic en el botón Nueva Conexión. En la ventana que se visualiza elija como
origen de datos Microsoft SQL Server y la base de datos bdlibrovbnet.
124
Figura 4.43 Ventana Microsoft Visual Studio.
Cambie el nombre de la conexión que allí aparece por conexion y pulse el botón
Siguiente>, se visualizará la siguiente figura:
125
Pulse el signo (+) al lado de Tablas para desplegar las tablas de la base de datos
y seleccione la tabla clientes. Por otro lado, cambie el nombre del DataSet que allí
aparece por conjuntodedatos y pulse el botón Finalizar, para visualizar la figura:
Pulse los signos (+) para desplegar la tabla. Dé clic en Siguiente> para
visualizar la ventana de selección de tipo de informe.
126
Seleccione la opción Tabular o Matriz y dé clic en Siguiente> para visualizar
la ventana de diseño de tabla.
127
Dé clic en Siguiente> para visualizar la ventana de elección de diseño de la
tabla.
128
Seleccione la opción con el estilo que desee y dé clic en Siguiente> para
visualizar la ventana de finalización del asistente de informes.
Donde aparece el nombre del informe, cámbielo por Informe Clientes y dé clic
en Finalizar> para visualizar el diseño final del informe.
129
En este momento se podrán modificar los textos de las etiquetas de los campos,
como también la longitud de los campos. Además en el explorador de soluciones se
visualizará el informe agregado al proyecto.
Elija la ficha de diseño del formulario y dé clic sobre la flecha del objeto
reporte y seleccione la opción Elegir informe.
130
Ejecutar el proyecto
Al ejecutarse el proyecto, se visualizará la figura 4.56. Por medio de la barra de
herramientas se podrá desplazar hacia las diferentes hojas del reporte, así como
imprimir el reporte, modificar el diseño del informe, configurar la página, cambiar el
tamaño de visualización del informe y buscar texto dentro del informe.
131
3. Hacer un programa que permita realizar una conexión a SQL Server y aumentar
en 10 días la fecha de entrega de la tabla pedidos.
4. Crear un programa que permita realizar una conexión a una base de datos e
insertar datos. Sólo se deben ingresar datos a la tabla si el nit es mayor que 5000.
5. Realizar un programa que permita conectarse a una base de datos e imprimir en
un formulario un reporte de todos los registros cuya ciudad empiece por B.
6. Crear un programa que permita desplazarse por los registros de una tabla cuya
condición es que la ciudad tenga en su segundo carácter la letra A.
7. Realizar un programa que visualice en un formulario los registros de una tabla
cuyo nit sea mayor que 200 y menor que 900.
8. Hacer un programa que permita a un usuario agregar un nuevo campo a una
tabla.
9. Diseñar un programa que permita visualizar los registros que se van a eliminar
de una tabla en una cuadrícula.
10. Crear un programa que permita visualizar los registros de una tabla en una
cuadrícula. Cada vez que el usuario seleccione un registro se deberán mostrar en
campos de texto los datos de los respectivos campos.
Generalmente una base de datos contiene muchas tablas, algunas de las cuales tienen
campos en común. Dichas tablas se pueden relacionar por el campo común para
manipular la información de los registros de dos o más tablas. Con la relación de tablas
también se puede realizar el desplazamiento y la operación de los registros de dichas
tablas. Como se ha podido observar, en los capítulos anteriores se ha realizado la
conexión a las bases de datos SQL Server, Access y Oracle, como también se han
realizado diferentes ejemplos con SQL Server. En los siguientes ejemplos se seguirá
trabajando con SQL Server y la base de datos bdlibrovbnet.mdf, la cual contiene las
tablas clientes, pedidos, productos, ventas. (Se puede consultar el Anexo C, para ver
la estructura de las tablas y su información).
132
DataGridView.
133
Escribir código
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
de nombres:
Imports System.Data.SqlClient
Public Class formulario
……
End Class
b) Dé doble clic sobre el objeto boton para abrir el editor de código y escriba el
siguiente código:
134
Por último se ejecuta la instrucción SQL y se rellena el objeto tabla con los
registros que cumplan la condición de relación entre las tablas clientes y
pedidos.
Ejecutar el proyecto
Al ejecutarse el proyecto, se visualizará la figura 5.2. Si se pulsa el botón Ejecutar, se
visualizarán todos los registros relacionados de las tablas clientes y pedidos. Solamente
se visualizarán los registros cuyo nit de la tabla pedidos exista en la tabla clientes.
135
Establecer las propiedades de los objetos de la interfaz de usuario
Establezca las siguientes modificaciones a los controles:
136
Escribir código
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
de nombres:
Imports System.Data.SqlClient
Public Class formulario
……
End Class
137
datospedidos con el conjunto de datos y su respectiva tabla. Al objeto
tablaclientes en su propiedad DataMember se le asigna el nombre de la tabla
clientes, a la propiedad DataSource el conjunto de datos y a la propiedad
SelectionMode se le asigna la operación de selección completa de la fila
(DataGridViewSelectionMode.FullRowSelect). Utilizando la propiedad
Relations y la función Add del objeto conjuntodedatos se crea un alias
llamado relacion para definir la relación entre las tablas clientes y pedidos por
el campo común (nit). Al objeto tablapedidos en su propiedad DataMember se
le asigna la relación de las tablas (clientes.relacion), en la propiedad
DataSource el conjunto de datos y en la propiedad SelectionMode se le asigna
la operación de selección completa de la fila
(DataGridViewSelectionMode.FullRowSelect).
Ejecutar el proyecto
139
Establecer la conexión
Desde la ficha Datos del cuadro de herramienta arrastre hacia el formulario el adaptador
de datos SqlDataAdapter (Si no aparece el control, dé clic derecho sobre la ficha
Datos y ejecute la orden Elegir elementos, busque el control, selecciónelo en el cuadro
de verificación y pulse el botón Aceptar.). Se visualizará la siguiente figura:
140
Pulse el botón Aceptar, para visualizar nuevamente la ventana de Elegir la
conexión de datos. Allí pulse Siguiente> para visualizar el siguiente mensaje:
141
Aquí se puede
realizar la selección de los datos que debería cargar el adaptador de datos. Una forma es
escribir en la ventana instrucciones SQL y la otra es pulsar el botón Generador de
consultas. Para el ejemplo se pulsará el botón y se visualiza la siguiente figura:
142
En esta
nueva ventana seleccione la opción * (todas las columnas) o los campos que desea
visualizar (si desea visualizar la consulta seleccionada pulse el botón Ejecutar
consulta). Se obtendrá la siguiente figura:
Figura 5.16 Generador de consultas con los campos seleccionados (tabla clientes).
143
Al pulsar el botón Finalizar, se crearán los objetos: SqlDataAdapter1 y
SqlConnection1. Cambie el nombre de dichos objetos por datosclientes y
conexioncliente respectivamente.
Ahora seleccione nuevamente el control SqlDataAdapter de la ficha Datos y
realice los mismos pasos que se dieron anteriormente, pero esta vez seleccione la tabla
pedidos y cambie los nombres de los objetos SqlDataAdapter1 y sqlConnection1 por
datospedidos y conexionpedidos. Se visualizará la siguiente figura:
144
Figura 5.19 Ventana Generar conjunto de datos.
Escribir código
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
145
de nombres:
Imports System.Data.SqlClient
Public Class formulario
……
End Class
datosclientes.Fill(conjuntodedatos, "clientes")
datospedidos.Fill(conjuntodedatos, "pedidos")
lista.DataSource = conjuntodedatos.Tables("clientes")
lista.DisplayMember = conjuntodedatos.Tables("clientes").Columns(1).ToString
lista.ValueMember = conjuntodedatos.Tables("clientes").Columns(0).ToString
vistapedidos = conjuntodedatos.Tables("pedidos").DefaultView
d) Dé doble clic sobre el objeto boton para abrir el editor de código y escriba el
siguiente código:
e) Dé doble clic sobre el objeto lista para abrir el editor de código del
procedimiento lista_SelectedIndexChanged y escriba el siguiente código:
146
tablapedidos.DataSource = Nothing
Ejecutar el proyecto
Al ejecutarse el proyecto se visualizará la figura 5.8, mostrándose en el objeto lista el
primer nombre de empresa de la tabla clientes (si se desea ver los nombres de empresas
ordenados alfabéticamente, cambie el valor de la propiedad sorted del objeto lista por
true). Si selecciona un nombre de empresa y se pulsa el botón Ver Pedidos, se
visualizará en la cuadrícula todos los registros que estén relacionados con la tabla
pedidos.
147
Establecer las propiedades de los objetos de la interfaz de usuario
Establezca las siguientes modificaciones a los controles:
148
la siguiente figura:
149
Pulse el boton Aceptar, para observar la siguiente figura:
Dé clic en el signo (+) al lado del nombre de la base de datos para visualizar la
estructura definida en la base de datos. Seleccione la carpeta vistas y dé clic derecho
para ver en el menú contextual la opción Agregar nueva vista, selecciónela para
visualizar la ventana Agregar tabla.
150
Agregue las tablas clientes, pedidos y pulse el botón Cerrar. Por otro lado, de
la tabla clientes seleccione los campos nit, empresa, representante y de la tabla
pedidos nropedido, fechaentrega, fechavence, observacíon. Se obtendrá la siguiente
figura:
152
Elija la ficha de diseño del formulario y dé clic sobre la flecha del objeto
reporte y seleccione la opción Diseñar nuevo informe.
Figura 5.33 Seleccionar opción Diseñar nuevo informe del objeto reporte.
153
Dé clic en Siguiente, para ver la ventana de configuración de orígenes de datos.
154
Pulse Siguiente> para visualizar el siguiente mensaje:
Cambie el nombre de la conexión que allí aparece por conexion y pulse el botón
Siguiente>, se visualizará la siguiente figura:
155
Figura 5.39 Ventana de elección de objetos de la base de datos.
Pulse el signo (+) al lado de Vistas para desplegar las vistas actuales de la base
de datos, seleccione la vista tablasrelacionadas. Por otro lado, cambie el nombre del
DataSet que allí aparece por conjuntodedatos y pulse el botón Finalizar, para
visualizar la figura 5.40:
156
Pulse los signos (+) para desplegar la vista. Dé clic en Siguiente> para visualizar
la ventana de selección de tipo de informe.
157
Seleccione los campos nit, empresa, representante y sitúelos en la casilla
Grupo>, el resto de campos en la casilla Detalles>. Se observará la siguiente figura:
158
Seleccione la opción Escalonado o Bloquear y si desea incluir subtotales o
no. Dé clic en Siguiente> para visualizar la ventana de estilo de la tabla.
159
Donde aparece el nombre del informe cámbielo por Informe Clientes - Pedidos
y dé clic en Finalizar> para visualizar el diseño final del informe.
En este momento se podrán modificar los textos de las etiquetas de los campos,
como también la longitud de los campos. Además en el explorador de soluciones se
visualizará el informe agregado al proyecto.
Elija la ficha de diseño del formulario y dé clic sobre la flecha del objeto
reporte y seleccione la opción Elegir informe.
160
Figura 5.49 Formulario con los objetos de manejo de datos.
Ejecutar el proyecto
Al ejecutarse el proyecto, se visualizará la figura 5.50. Por medio de la barra de
herramientas se podrá desplazar hacia las diferentes hojas del reporte, así como
imprimir el reporte, modificar el diseño del informe, configurar la página, cambiar el
tamaño de visualización del informe y buscar texto dentro del informe.
161
5.2 Ejercicios de relación de tablas
1. Realizar un programa que permita hacer una relación entre tres tablas de una
base de datos en SQL Server.
2. Diseñar un programa que permita realizar una relación entre dos tablas con un
filtro por el campo común.
3. Hacer un programa que permita visualizar en un reporte los registros de una
relación de tres tablas.
4. Crear un programa que permita realizar una relación de tres tablas; para la
primera relación se deben seleccionar los datos desde un ListBox y visualizarlos
en un DataGridView. Desde este se debe seleccionar un registro y mostrar los
registros de la segunda relación en un segundo DataGridView.
5. Elaborar un programa que permita realizar una relación de tres tablas y los
registros se deben mostrar en tres DataGridView.
6. Realizar un programa que permita visualizar un reporte de los registros
relacionados cuyos nit sean mayores que 500.
7. Hacer un programa que permita visualizar un reporte de los registros
relacionados cuyas empresas empiecen por la letra C.
8. Diseñar un programa que permita realizar y mostrar en un TreeView los
registros relacionados de tres tablas.
9. Crear un programa que permita mostrar en un TreeView los registros
relacionados de dos tablas cuyo nombre de empresa contenga la letra O.
10. Elaborar un programa que permita realizar un reporte con registros relacionados
utilizando CrystalReportViewer.
162
6. MANEJO DE ARCHIVOS CON ASP.NET
Como se vio en el Capítulo 1, Visual Basic .NET permite interactuar con datos externo
a un proyecto, realizar las diferentes operaciones con archivos de texto plano, como son:
la creación, eliminación, sobreescritura de archivos, así como guardar, leer o adicionar
información a éstos, además importar o exportar información desde y hacia Visual
163
Basic .NET. Con ASP.NET y trabajando en el entorno integrado de desarrollo de Visual
Studio 2008 también es posible desde formularios Web realizar estas operaciones con
archivos de texto plano.
164
Establecer las propiedades de los objetos de la interfaz de usuario.
Establezca las siguientes modificaciones a las propiedades en los controles:
165
Escribir código
166
Figura 6.3 Ejecución del sitio Web FileUpLoadArchivoTexto.
167
6.2.2 Manejo de archivos de texto con StreamWriter y StreamReader.
168
La interfaz de usuario queda como se muestra en la siguiente figura:
Escribir código
a) Seleccione el objeto botonguardar, dé doble clic para abrir el editor de código y
escriba el siguiente código:
Try
Dim miruta As String = Server.MapPath("./miarchivo.txt")
Dim archivo As New System.IO.StreamWriter(miruta)
archivo.Write(texto.Text)
archivo.Close()
texto.Text = ""
MsgBox("Información guardada...", MsgBoxStyle.Information, "Guardar en archivo")
Catch ex As Exception
MsgBox("No se pudo guardar la informacion", MsgBoxStyle.Critical,
"Guardar en archivo")
End Try
Try
Dim miruta As String = Server.MapPath("./miarchivo.txt")
169
Dim archivo As New System.IO.StreamReader(miruta)
texto.Text = archivo.ReadToEnd
archivo.Close()
Catch ex As Exception
MsgBox("No se pudo leer la informacion", MsgBoxStyle.Critical,”Guardar archvo”)
End Try
170
Si se pulsa el botón Guardar información, se limpia el objeto texto y se
mostrará una caja de mensajes reportando que la información ha sido guardada y en la
carpeta donde se guardó el sitio Web ya se debe encontrar el archivo de texto con la
información adicionada. Al pulsar el boton Leer información se mostrará en el objeto
texto la información del archivo de texto.
Crear un sitio Web llamado FileSystem y hacer un programa que permita a un usuario
guardar información en un archivo de texto plano, leer la información de este utilizando
la clase FileSystem.
171
Tabla 6.3 Propiedades de los controles del sitio Web FileSystem.
Escribir código
172
FileSystem.FileClose(archivolibre)
texto.Text = ""
MsgBox("Informacion guardada en archivo", MsgBoxStyle.Information,
"Guardar archivo")
Catch ex As Exception
MsgBox("La Informacion no fue guardada en archivo" & ex.Message,
MsgBoxStyle.Critical, "Guardar archivo")
End Try
Try
Dim archivolibre As Integer = FreeFile()
FileSystem.FileOpen(archivolibre, MapPath("./archivodetexto.txt"),
OpenMode.Input)
Dim linea As String
Do Until EOF(archivolibre)
linea = FileSystem.LineInput(archivolibre)
texto.Text = texto.Text & linea & vbCrLf
Loop
FileSystem.FileClose(archivolibre)
Catch ex As Exception
MsgBox("La Informacion no fue leida" & ex.Message, MsgBoxStyle.Critical,
"Leer archivo")
End Try
173
Figura 6.12 Formulario Web con información para ser guardada.
174
6.3 Ejercicios de archivos de texto con ASP.NET
1. Hacer un sitio Web que permita guardar 10 datos y leerlos en un archivo de texto
plano utilizando la clase FileSystem.
2. Crear un sitio Web que permita guardar 10 datos y leerlos en un archivo de texto
plano utilizando las clases StreamWriter y StreamReader.
3. Diseñar un sitio Web que permita cargar archivos sólo de extensión .doc utilizando
FileUpLoad.
4. Hacer un sitio Web que permita adicionar información a un archivo de texto
previamente creado.
5. Diseñar un sitio Web que permita importar todos los datos que existan en un archivo
de Excel y visualizarlos en un GridView (apóyese en los ejemplos del capítulo 1).
6. Elaborar un sitio Web que permita importar todos los datos que existan en un
archivo de Excel y visualizarlos en un DataList (apóyese en los ejemplos del
capítulo 1).
7. Hacer un sitio Web que permita exportar un rango de datos a una tabla de Word
(apóyese en los ejemplos del capítulo 1).
8. Crear un sitio Web que permita importar los datos de un archivo de texto a un
GridView (apóyese en los ejemplos del capítulo 1).
9. Diseñar un sitio Web que permita exportar los datos de un control DataList a Excel
(apóyese en los ejemplos del capítulo 1).
10. Realizar un sitio Web que permita exportar los datos de un GridView a Word
(apóyese en los ejemplos del capítulo 1).
175
7. BASE DE DATOS CON ASP.NET
Con los proyectos Windows Forms se logró manipular diferentes bases de datos, como
fue realizar la conexión a las bases de datos SQL Server, Access y Oracle, el
desplazamiento entre los registros de una tabla, las operaciones entre una o más tablas,
la creación de reportes de una o más tablas utilizando la tecnología ADO.NET.
176
Establecer las propiedades de los objetos de la interfaz de usuario
Establezca las siguientes modificaciones a los controles:
Escribir código
177
Los espacios de nombres System.Data y System.Data.SqlClient son
necesarios para utilizar las diferentes clases que permitan las operaciones con
bases de datos en una aplicación Web, en este caso SQL Server.
b) Seleccione el objeto boton, dé doble clic para abrir el editor de código y escriba
el siguiente código:
178
datoscolumna y el nombre del tipo de dato de dicho campo (DataType.Name),
por último se muestra en el objeto texto el contenido de la variable consulta.
179
7.1.2 Conexión a una base de datos desde un Formulario Web
180
La interfaz de usuario queda como se muestra en la siguiente figura:
Escribir código
b) Dé doble clic sobre la página para abrir el editor de código del procedimiento
Page_Load y escriba el siguiente código:
Dim conexion As String
conexion = "Data Source=(local)\SQLEXPRESS;Database=bdlibrovbnet;Integrated
Security=True"
Dim seleccion As String = "SELECT * FROM clientes"
Dim adaptadordedatos As SqlDataAdapter
Dim tabladedatos As New DataTable
Try
adaptadordedatos = New SqlDataAdapter(seleccion, conexion)
adaptadordedatos.Fill(tabladedatos)
tabla.DataSource = tabladedatos
181
tabla.DataBind()
etiquetaregistros.text=”Total de Registros:” & talabdedatos.Rows.Count
Catch ex As Exception
MsgBox("Error: " & ex.Message)
End Try
182
7.1.3 Conexión a SQL Server con el control DetailsView
183
Figura 7.9 Interfaz de usuario con controles modificados.
Establecer la conexión
184
Figura 7.11 Ventana tipo origen de datos.
185
Pulse el botón Nueva Conexión, se visualizará la ventana de Agregar
conexión:
186
Pulse el botón Siguiente> para visualizar el siguiente mensaje:
187
En esta ventana se debe seleccionar los datos a mostrar. Una forma es utilizar
instrucciones SQL y la otra es escoger una tabla o vista. Eligiendo la segunda opción
seleccione la tabla cliente y elija * para ver todos los registros de la tabla clientes y
pulse el botón Siguiente para ver la ventana Consulta de prueba.
188
Ejecutar la aplicación Web
Al ejecutarse la aplicación Web, se visualizará en la página Web el primer registro de la
tabla clientes de la base de datos bdlibrovbnet.mdf de SQL Server en el objeto
detalles:
189
Nuevamente ejecute el sitio Web para visualizar la página Web con la
paginación de registros.
190
Si selecciona el esquema Pizarra y se pulse el botón Aceptar, se obtendrá en
modo diseño la siguiente figura:
Figura 7.24 Página Web con el objeto DetailsView con formato Pizarra.
191
7.1.4 Página Web con desplazamiento de registros
192
Establecer las propiedades de los objetos de la interfaz de usuario
Establezca las siguientes modificaciones a los controles:
Establecer la conexión
193
Seleccione el objeto Base de datos y cambie el identificador para el origen de
datos SqlDataSource1 por datos y pulse el botón Aceptar, para ver la siguiente figura:
194
Pulse el botón Nueva Conexión, se visualizará la ventana Agregar conexión:
195
Pulse el botón Siguiente> para visualizar la ventana de configuración de origen
de datos:
196
En esta ventana se debe seleccionar los datos a mostrar. Una forma es utilizar
instrucciones SQL y la otra es escoger una tabla o vista. Eligiendo la segunda opción
seleccione la tabla cliente y elija * para ver todos los registros de la tabla clientes y
pulse el botón Siguiente para ver la ventana Consulta de prueba.
197
Figura 7.34 Ventana de diseño control ListView.
A
l pulsar el botón Aceptar, nuevamente se regresa a modo diseño de la página, como se
muestra en la figura:
198
Figura 7.37 Modo diseño del sitio WebListViewDataPager.
199
Al ejecutarse el sitio Web, se visualizará la página con los cinco primeros registros de la
tabla clientes, como también, los botones de desplazamiento.
200
Establecer las propiedades de los objetos de la interfaz de usuario
201
Figura 7.42 Interfaz de usuario modificada (InsertarDatosWeb).
Establecer la conexión
202
Seleccione la opción Elegir origen de datos y <Nuevo origen de datos…>,
para visualizar la siguiente figura:
203
Pulse el botón Nueva Conexión, se visualizará la ventana Agregar conexión:
204
Pulse el botón Siguiente> para visualizar la ventana de configuración de origen
de datos:
205
Seleccione la tabla clientes y elija * para ver todos los registros de la tabla
clientes. Además pulse el botón Avanzadas para ver la ventana de opciones de
generación de consultas SQL avanzadas.
206
Pulse el botón Finalizar para volver al diseño de la página:
207
Figura 7.54 Objeto tabla con el objeto datos como origen de datos.
208
Al pulsarse el link Nuevo los campos de texto del objeto detalles quedarán en
blanco y se observarán dos nuevos link Insertar y Cancelar, como se aprecia en la
figura.
209
Al pulsarse el link Insertar se guardarán los datos en la tabla clientes y
nuevamente se mostrará el primer registro y el link Nuevo, además se visualizará en el
objeto tabla el nuevo registro.
210
Tabla 7.6 Propiedades de controles del sitio EliminarRegistrosWeb.
Control Propiedad Valor
Label1 ID titulo
Text Eliminar un registro en la tabla Clientes
Font - Bold true
Label2 ID titulotabla
Text Registros de la tabla Clientes.
Font - Bold true
DetailsView1 ID detalles
GridView1 ID tabla
Form1 ID formulario
Document title Eliminar un registro en una tabla.
Default.aspx.vb Nombre de pagina.aspx.vb
archivo.
Establecer la conexión
211
Figura 7.60 Ventana de diseño de sitio Web EliminarRegistrosWeb.
212
Figura 7.62 Objeto tabla con el objeto datos como origen de datos.
213
Figura 7.64 Página Web para eliminar registros.
214
7.1.7 Página Web para modificar registros
215
Establecer la conexión
216
Ahora seleccione la opción Editar campos del objeto detalles para visualizar la
siguiente figura:
217
Figura 7.71 Objeto tabla con el objeto datos como origen de datos.
218
Por ejemplo, si se desea modificar el primer registro de la tabla pulse el botón
Editar para que las cajas de texto queden en modo de edición y se visualicen los
botones Actualizar y Cancelar.
219
7.1.8 Página Web con un informe de los registros de una tabla
220
Figura 7.76 Interfaz de usuario modificada (ReporteTablaWeb).
Para seleccionar la tabla y diseñar el informe, pulse la flecha del lado superior derecho
del objeto reporte para ver la ventana Tareas de ReportViewer y escoger la opción
Elegir informe.
221
Figura 7.78 Elegir informe – Informe servidor.
222
Figura 7.80 Ventana Elegir la conexión de datos.
223
Figura 7.82 Ventana con la base de datos seleccionada.
224
Cambie el nombre de la conexión que allí aparece por conexion y pulse el botón
Siguiente>, se visualizará la siguiente figura:
Pulse el signo (+) al lado de Tablas para desplegar las tablas de la base de datos
y seleccione la tabla clientes. Por otro lado, cambie el nombre del DataSet que allí
aparece por conjuntodedatos y pulse el botón Finalizar, para visualizar la figura:
Pulse los signos (+) para desplegar la tabla. Dé clic en Siguiente> para
225
visualizar la ventana de selección de tipo de informe.
226
Seleccione el campo nit y pulse el boton Grupos, el resto de campos páselos a
la ventana Detalles con el botón Detalles>, se obtiene la siguiente figura:
227
Seleccione la opción Escalonado o Bloquear y dé clic en Siguiente> para
visualizar la ventana de estilo de la tabla.
228
Donde aparece el nombre del informe cámbielo por Reporte Web Tabla
Clientes y dé clic en Finalizar> para visualizar el diseño final del informe.
229
Figura 7.95 Ventana con el informe Reporte Web Tabla Clientes.
Al ejecutarse el sitio Web, se visualizará la página con el informe de los registros que
contiene la tabla clientes. Puede ajustar el tamaño del reporte en la página en modo de
diseño.
Figura 7.96 Pagina Web con el informe de los registros de la tabla clientes.
230
7.2 Ejercicios de bases de datos con ASP.NET
1. Crear un sitio Web que permita eliminar todos los registros de una tabla cuyos
nombres de empresa contengan la letra M.
2. Hacer un sitio Web que permita visualizar los registros de una tabla de una base
de datos de SQL Server en un control DataList.
3. Realizar un sitio Web que permita visualizar los registros de una tabla de una
base de datos de SQL Server en un control Repeater.
4. Elaborar un sitio Web que permita ejecutar instrucciones SQL en un campo de
texto y visualizar los resultados en un objeto GridView.
5. Diseñar un sitio Web que permita actualizar un campo numérico de una tabla de
una base de SQL Server.
6. Crear un sitio Web que permita importar todos los datos que existan en un
archivo de Excel y visualizarlos en un control FormView.
7. Hacer un sitio Web que permita mostrar los registros de una tabla de una base de
datos cuyo nombre de ciudad empiecen con CA.
8. Realizar un sitio web que permita la creación de reporte por un rango
determinado.
9. Hacer un sitio Web que permita visualizar en un control DataList los registros de
una tabla de Access.
10. Diseñar un sitio Web que permita visualizar en un reporte los registros de una
tabla ordenados alfabéticamente.
231
8. MANEJO DE TABLAS RELACIONADAS CON ASP.NET
Como se vio en el Capítulo 5 es posible obtener una relación entre las tablas
pertecenientes a una base de datos. Para que la relación entre tablas se cumpla, como
minimo dos tablas deben tener en común un campo. Una de las tablas tendrá como llave
primaria el campo común y ésta se llamará tabla principal, la otra tabla no necesita que
el campo común sea llave primaria, a ésta se le llamará tabla secundaria.
También con sitios Web ASP.NET se puede realizar el desplazamiento entre los
registros de las tablas relacionadas, como las operaciones de inserción, modificación,
consulta y eliminación, así como la generación de informes.
8.1 Ejemplos de relación entre tablas de una base de datos con ASP.NET
232
Tabla 8.1 Propiedades de controles del sitio Web RelacionDosTablasWeb.
Establecer la conexión
233
Figura 8.3 Ventana de las Tareas del DropDownList.
234
Figura 8.5 Ventana para elegir tipo de origen de datos.
235
Pulse el botón Nueva Conexión, se visualizará la ventana Agregar conexión:
236
Pulse el botón Siguiente> para visualizar la ventana de configuración de origen
de datos – datos:
237
Seleccione la tabla clientes y elija * para ver todos los registros de la tabla
clientes y pulse el botón Siguiente para ver la ventana de Consulta de prueba.
238
Pulse el botón Aceptar para volver a modo diseño.
239
Figura 8.15 Ventana elección tipo de origen de datos (objeto tabla).
240
Dé clic en la flecha y escoja el objeto llamado conexion. Se observará la
siguiente figura:
241
Seleccione la tabla pedidos y elija * para ver todos los registros de la tabla
pedidos. La ventana sería similar a la siguiente figura:
242
Seleccione en la ventana Columna el campo nit, en la ventana Operador el
signo igual (=), en la ventana Origen la opción Control, en la ventana Id. de control
seleccione el objeto listaempresas y pulse el botón Agregar para ver la siguiente
figura:
243
Pulse el botón Siguiente para ver la ventana Consulta de prueba.
Si desea realizar una prueba pulse el botón Consulta de prueba para ver la
ventana de Editor de valores del parámetro.
244
En el campo de texto Valor escriba un valor de un nit que se encuentre en la
tabla clientes (100 para nuestro caso) y pulse el botón Aceptar para ver todos los
registros relacionados con la tabla pedidos. Si existe relación se observaría la siguiente
figura:
Pulse el botón Finalizar para volver a modo diseño del sitio Web.
245
GridView. En el objeto DropDownList se puede seleccionar un nombre de una
empresa de la tabla clientes y en el objeto GridView se visualizarán los registros
relacionados con la tabla pedidos.
246
Establecer las propiedades de los objetos de la interfaz de usuario
Establezca las siguientes modificaciones a los controles:
Establecer la conexión
Seleccione el objeto GridView llamado tabla y en la flecha que aparece en el lado
superior derecho, dé clic en el mouse para visualizar las Tareas de GridView.
247
Figura 8.30 Ventana de las Tareas del GridView.
248
Figura 8.32 Ventana elegir la conexión de datos.
249
Figura 8.34 Ventana con la base de datos seleccionada.
250
Figura 8.36 Ventana para configurar la instrucción Select.
Seleccione la tabla clientes y elija * para ver todos los registros de la tabla
clientes y pulse el botón Siguiente para ver la ventana Consulta de prueba.
251
Figura 8.38 Ventana modo diseño del sitio Web RelacionGridViewFormViewWeb.
252
Figura 8.40 Ventana elección tipo de origen de datos (objeto forma).
253
Dé clic en la flecha y escoja el objeto llamado conexion. Se observará la
siguiente figura:
Seleccione la tabla pedidos y elija * para ver todos los registros de la tabla
pedidos. La ventana sería similar a la siguiente figura:
254
Figura 8.44 Ventana con la tabla pedidos seleccionada.
255
Figura 8.46 Ventana con la cláusula WHERE agregada.
256
Figura 8.48 Ventana Consulta de prueba.
Pulse el botón Finalizar para volver a modo diseño del sitio Web. Habilite la
opción Habilitar paginación en la ventana Tareas de FormView. Se observará la
siguiente figura:
257
Figura 8.50 Ventana de Autoformato.
Si pulsa sobre el link Seleccionar al frente del nit 100, se visualizarán los
registros relacionados con la tabla pedidos en el objeto forma.
258
Figura 8.52 Página Web con registros relacionados clientes - pedidos.
259
Figura 8.54 Objeto forma en modo de edición de plantillas.
Modifique cada una de las etiquetas del objeto forma y pulse la opción
Terminar edición de plantillas. Según los cambios realizados, la página podría quedar
de la siguiente forma:
260
Figura 8.56 Página Web con la relación clientes – pedidos.
261
Establecer las propiedades de los objetos de la interfaz de usuario
Establezca las siguientes modificaciones a los controles:
Establecer la conexión
262
Figura 8.59 Ventana de las Tareas del ListBox.
263
Figura 8.61 Ventana para elegir tipo de origen de datos.
264
Figura 8.63 Ventana Agregar conexión.
265
Figura 8.65 Ventana configuración de origen de datos - datosclientes.
Seleccione la tabla clientes y elija * para ver todos los registros de la tabla
clientes y pulse el botón Siguiente para ver la ventana Consulta de prueba.
266
Figura 8.67 Ventana Consulta de prueba.
267
Figura 8.69 Ventana modo diseño del sitio Web RelacionTresTablasWeb.
268
Figura 8.71 Ventana para elegir tipo de origen de datos.
269
Figura 8.73 Ventana para configurar la instrucción Select.
Seleccione la tabla pedidos y elija * para ver todos los registros de la tabla
pedidos y pulse el botón WHERE para visualizar la ventana Agregar cláusula
WHERE.
270
Figura 8.75 Ventana con la cláusula WHERE agregada.
271
Figura 8.77 Ventana Consulta de prueba.
Pulse el botón Finalizar para volver a modo diseño del sitio Web. Habilite la
opción Habilitar selección en la ventana Tareas de GridView. Se observará la
siguiente figura:
272
Figura 8.79 Objeto tablaventas seleccionado.
273
Figura 8.81 Ventana Elegir la conexión de datos - datosventas.
274
Figura 8.83 Ventana Agregar cláusula WHERE.
275
Figura 8.85 Ventana Configurar origen de datos – datosventas.
Pulse el botón Finalizar para volver a modo diseño del sitio Web. Se observará
la siguiente figura:
276
Figura 8.87 Ventana de diseño de sitio Web RelacionTresTablasWeb.
277
Figura 8.89 Página Web con registros relacionados clientes – pedidos - ventas.
1. Crear un sitio Web que permita realizar una relación entre tres tablas de una base
de datos en SQL Server utilizando controles GridView.
2. Hacer un sitio Web que permita realizar una relación de tres tablas; para la
primera relación se deben seleccionar los datos desde un ListBox y visualizarlos
en un GridView. Desde éste se debe seleccionar un registro y mostrar los
registros de la segunda relación en un DataList.
3. Diseñar un sitio Web que permita visualizar en un reporte los registros
relacionados de dos tablas cuyos nit sean mayores que 500.
4. Elaborar un sitio Web que permita visualizar un reporte de los registros
relacionados cuyas empresas empiecen por las letras PO.
5. Realizar un sitio Web que permita mostrar en un ListBox los registros
relacionados de dos tablas.
6. Crear un sitio Web que permita importar todos los datos relacionados que
existan en un FormView a un archivo de Excel.
7. Hacer un sitio Web que permita mostrar los datos relacionados de dos tablas de
una base de datos por un rango determinado en la tabla principal.
8. Elaborar un sitio Web que permita la creación de un reporte con dos tablas
relacionadas.
9. Hacer un sitio Web que permita visualizar en un control DataList los registros
relacionados de dos tablas de Access.
10. Diseñar un sitio Web que permita visualizar un reporte según un rango
seleccionado.
278
ANEXO A
Este tutorial se trabaja con el entorno de desarrollo de Microsoft Visual Studio .NET
2008, también llamado entorno de desarrollo integrado (Integrated Development
Environment, IDE). Este entorno es personalizable y contiene todas las herramientas
para construir programas para Microsoft Windows.
Crear una aplicación Windows Forms en Visual Basic .NET, requiere unos pasos muy
sencillos como son: iniciar un nuevo proyecto Visual Basic .NET, crear la interfaz del
usuario, establecer las propiedades de los objetos, escribir el código, guardar la
aplicación y ejecutar el proyecto.
Para iniciar un nuevo proyecto desde la página de inicio, se pueden seguir estos
pasos:
Visual Studio .NET ofrece varias plantillas de aplicaciones para soportar el desarrollo
de diferentes tipos de aplicaciones y componentes. Antes de iniciar un nuevo proyecto,
se debe escoger el tipo de plantilla que se va a utilizar. Una plantilla de aplicación
proporciona archivos de inicio y una estructura de proyecto, además contiene los
objetos básicos del proyecto y la configuración del entorno que se necesita para crear el
tipo de aplicación que se desea.
280
Cuando se selecciona una plantilla de aplicaciones aparece el entorno de
desarrollo, donde encontrará:
Menú Principal
Barra de Herramientas
281
Diseñador formulario Windows (Windows Forms): Cuando se inicia un
proyecto en Visual Basic .NET, el Diseñador de formulario de Windows
(Windows Forms) se abre en la vista diseño (un formulario tiene vista diseño
cuando se inicia el proyecto y está en modo de ejecución cuando se ejecuta la
aplicación), mostrándose el formulario Form1 del proyecto. En dicho
formulario se pueden ubicar los controles u objetos necesarios para la aplicación
arrastrándolos desde el cuadro de herramientas para crear la interfaz de usuario.
El formulario predeterminado contiene los elementos mínimos utilizados por la
mayoría de formularios: una barra de título, un cuadro de control y los botones
minimizar, maximizar y cerrar.
282
Ventana de propiedades: muestra una lista de las propiedades que facilitan la
configuración de los valores o propiedades del control seleccionado y se pueden
modificar mientras se crea o se edita la aplicación. Una propiedad describe una
característica de un objeto, como el tamaño, título, color, etc.
Para crear la interfaz de usuario de la aplicación, en primer lugar se deben ubicar los
controles necesarios en un formulario desde el cuadro de herramientas. Como ejemplo
se creará un programa que permita a un usuario digitar un número y al pulsar un botón
se muestre en una cuadrícula la tabla de multiplicación de dicho número. Para este caso
se diseñará la interfaz de usuario utilizando los siguientes controles: 3 Label, 1
TextBox, 1 Button y 1 DataGridView.
Cuando existen varios controles del mismo tipo, éstos se numeran en el mismo
orden en que son colocados (nombre del control más numero del consecutivo). La
interfaz de usuario del ejemplo será como muestra la figura a continuación.
283
Figura A.10 Prepantalla de la interfaz de usuario.
284
Figura A.11 Pantalla final de la interfaz de usuario
Una vez se hayan establecido las propiedades iniciales del formulario y sus objetos, se
puede agregar el código que se ejecutará en respuesta a un evento específico de cada
control. Los eventos ocurren cuando se realizan diferentes acciones sobre un control u
objeto. Por ejemplo, el evento Clic de un botón tiene lugar cuando un usuario hace clic
sobre él con el mouse. Por lo general en las aplicaciones es necesario escribir código
para lograr el objetivo de dar solución al problema planteado por el usuario.
Para el caso del ejemplo, dé doble clic en el objeto Button llamado boton y abra
el editor de código, la figura muestra el editor de código del control.
With tabla
.Columns.Add("Multiplicando", " Multiplicando ")
.Columns.Add("Multiplicador", " Multiplicador ")
.Columns.Add("Producto", "Producto")
.RowCount = 10
For i As Integer = 0 To .RowCount - 1
.Item(0, i).Value = camponumero.Text
.Item(1, i).Value = i + 1
.Item(2, i).Value = (camponumero.Text * (i + 1))
Next
End With
285
Este código sirve para rellenar el objeto tabla con los respectivos datos.
Utilizando el método Add de la propiedad Columns se le adicionan los nombres
Multiplicando, Multiplicador, Producto en la primera fila y la propiedad RowCount
se le asigna un valor de 10 filas. Con un ciclo For que se ejecutará desde una posición i
igual a cero (0) hasta el número de filas -1 del objeto tabla y por cada fila tres ítems. En
la primera columna se imprimirá el valor digitado en el objeto camponumero, en la
segunda columna se imprimirá el valor i+1, en la tercera columna el producto de
multiplicar el valor del objeto camponumero por i+1.
Una vez finalizada la creación de la aplicación, se debe guardar la aplicación dentro del
entorno de desarrollo para asegurar que todos los cambios realizados se almacenen, esto
se puede realizar de la siguiente forma:
286
Las aplicaciones Windows Forms creadas con Visual Basic .NET tienen la
extensión .exe, que podrán ser ejecutadas en cualquier equipo que tenga instalado
Microsoft Windows. Visual Basic .NET instala de manera automática los archivos de
soporte, incluyendo las bibliotecas de vínculos dinámicos y archivos de .NET
framework. Visual Studio puede crear dos tipos de archivos ejecutables:
287
ANEXO B
Este tutorial se trabaja con el entorno de desarrollo de Microsoft Visual Studio .NET
2008.
Como ejemplo se creará un sitio Web que permita a un usuario escoger un tipo
de comida rápida y una bebida en un restaurante y visualizar el valor a pagar por dicho
pedido. Se debe discriminar el valor antes del Impuesto al Valor Agregado ( IVA, 16%)
y el valor total a pagar.
288
Para iniciar un nuevo sitio desde la página de inicio, se pueden seguir estos pasos:
Hacer clic en la opción Archivo del menú y seleccionar Nuevo sitio Web...
Cuando se crea un sitio Web por cualquier de las dos opciones se visualiza la
siguiente ventana:
Una plantilla de aplicación Web proporciona archivos de inicio y una estructura del sitio
Web, además contiene los objetos básicos del sitio y la configuración del entorno que se
necesita para crear el tipo de aplicación que se desea.
289
Figura B.3 Ventana Nuevo sitio Web.
Menú Principal
Barra de Herramientas
290
Figura B.5 Cuadro de Herramientas.
291
Explorador de soluciones: permite visualizar las carpetas y archivos que se
han creado. Si observa en la carpeta en donde guardó el sitio Web se creó la
carpeta App_Data y los archivos Default.aspx, Default.aspx.vb (este archivo
contiene el código fuente que da soporte a la página Default.aspx) y Web.xml
(archivo de configuración xml).
292
Ventana de depuración de errores: muestra una lista de los errores que se
generan al realizar modificaciones a los controles o al ejecutar la aplicación.
Para crear la interfaz de usuario del sitio Web, en primer lugar se deben ubicar los
controles necesarios en el formulario Web desde el cuadro de herramientas. Para el
ejemplo se diseñará la interfaz de usuario utilizando los siguientes controles: 8 Label, 5
TextBox, 1 ListBox y 4 RadioButton.
Cuando existen varios controles del mismo tipo, éstos se numeran en el mismo
orden en que son colocados (nombre del control más número del consecutivo). La
interfaz de usuario del ejemplo será como muestra la figura a continuación.
293
B.4 Establecer las propiedades de los controles.
Después de colocar los controles u objetos a un formulario Web, se puede establecer sus
propiedades en la ventana Propiedades o en el Editor de código.
Para modificar las propiedades se selecciona el control en el formulario Web y
se cambia su configuración en la ventana Propiedades. Para el caso del ejemplo
establezca las siguientes modificaciones a cada uno de los siguientes controles:
294
RadioButton3 ID botonlimonada
Text Limonada
AutoPostBack true
RadioButton4 ID botoncerveza
Text Cerveza
AutoPostBack true
GroupName bebidas
Form1 ID formulario
Document Title Comidas Rápidas
Default.aspx Nombre del archivo Pagina.aspx
Una vez se hayan establecido las propiedades iníciales del formulario Web y sus
objetos, se puede agregar el código que se ejecutará en respuesta a un evento específico
de cada control. Los eventos ocurren cuando se realizan diferentes acciones sobre un
control u objeto. Por ejemplo, el evento Clic de un botón tiene lugar cuando un usuario
hace clic sobre él con el mouse. Por lo general en las aplicaciones es necesario escribir
código para lograr el objetivo de dar solución al problema planteado por el usuario.
295
Figura B.12 Formulario Web con el control ListBox seleccionado.
b) Dé doble clic en el objeto ListBox llamado listacomidas, para abrir el editor del
procedimiento listacomida_SelectedIndexChanged y escriba el siguiente código:
If listacomida.SelectedIndex = 0 Then
valorcomida.Text = "5000"
End If
296
If listacomida.SelectedIndex = 1 Then
valorcomida.Text = "3000"
End If
If listacomida.SelectedIndex = 2 Then
valorcomida.Text = "4000"
End If
If listacomida.SelectedIndex = 3 Then
valorcomida.Text = "3500"
End If
subtotal.Text = Val(valorcomida.Text) + Val(valorbebida.Text)
iva.Text = Val(subtotal.Text) * 0.16
total.Text = Val(subtotal.Text) + Val(iva.Text)
If botongaseosa.Checked Then
valorbebida.Text = "1500"
End If
subtotal.Text = Val(valorcomida.Text) + Val(valorbebida.Text)
iva.Text = Val(subtotal.Text) * 0.16
total.Text = Val(subtotal.Text) + Val(iva.Text)
d) Dé doble clic en el objeto RadioButton llamado botonjugo, para abrir el editor del
procedimiento botonjugo_CheckedChanged y escriba el siguiente código:
If botonjugo.Checked Then
valorbebida.Text = "2000"
End If
subtotal.Text = Val(valorcomida.Text) + Val(valorbebida.Text)
iva.Text = Val(subtotal.Text) * 0.16
total.Text = Val(subtotal.Text) + Val(iva.Text)
If botonlimonada.Checked Then
valorbebida.Text = "1800"
End If
subtotal.Text = Val(valorcomida.Text) + Val(valorbebida.Text)
iva.Text = Val(subtotal.Text) * 0.16
total.Text = Val(subtotal.Text) + Val(iva.Text)
297
If botoncerveza.Checked Then
valorbebida.Text = "2500"
End If
subtotal.Text = Val(valorcomida.Text) + Val(valorbebida.Text)
iva.Text = Val(subtotal.Text) * 0.16
total.Text = Val(subtotal.Text) + Val(iva.Text)
298
Figura B.15 Sitio Web MiProgramaWeb ejecutado.
299
B.7 Cerrar y abrir un sitio Web
Para cerrar el sitio Web MiProgramaWeb o cualquier otro sitio web, estando en modo
diseño se pueden realizar los siguientes pasos:
300
ANEXO C
SQL SERVER
Este tutorial utiliza como base de datos SQL Server 2005 Express.
Dicha base de datos se puede instalar independientemente de la versión de Visual
Studio.
Cuando se instala SQL Server, en los programas existe una opción para conectarse a
dicha base de datos. Seleccione Microsoft SQL Server 2005. Realice los siguientes
pasos:
1. Inicio - > Todos los Programas - > Microsoft SQL Server 2005.
2. SQL Server Management Studio Express.
1. Server Name: Por omisión aparece el nombre del servidor en donde fue
instalado SQL Server.
2. Authenticacion: Por omisión aparece Windows Authentication, la otra opción
es SQL Server Authentication. Si selecciona SQL Server Authentication, se
301
deberá digitar el User Name y el Password creado cuando se realizó la
instalación de SQL Server.
3. Pulsar el botón Connect.
302
Figura C.5 Ventana para crear una nueva base de datos.
303
Figura C.7 Base de datos bdlibrovbnet con sus elementos creados inicialmente.
Para crear tablas en la base de datos seleccione en cualquiera de las dos ventanas la
carpeta Tables y dé clic derecho para visualizar las opciones: New Tables, Filter y
Refresh.
304
Seleccione New Table para ver la ventana de diseño de la tabla, como se aprecia
en la siguiente figura:
Para agregar los campos a la tabla en Column Name escriba nit, en Data Type
seleccione nvarchar(50) (campo alfanumérico).
Realice los mismos pasos para crear los campos: empresa, representante,
direccion, telefono, ciudad (todos con el mismo tipo de datos nvarchar(50)). Por
305
último seleccione el campo nit y pulse el icono para crear la clave primaria ( ), la
figura quedará:
Figura C.11 Ventana con los campos de la tabla y nit como llave primaria.
Pulse el botón Yes para obtener la ventana para escoger el nombre Choose
Name.
306
Figura C.13 Ventana para escribir el nombre de la tabla creada.
Escriba como nombre de la tabla clientes y pulse el botón OK. Para trabajar con
algunos de los ejercicios planteados en el libro, cree las tablas pedidos, productos y
ventas con las estructuras que se muestran a continuación:
307
Figura C.16 Estructura tabla ventas.
Al finalizar de crear las tablas, la estructura de la base de datos con las tablas
quedaría como se aprecia en la siguiente figura:
308
Figura C.18 Opciones para la manipulación de una tabla.
309
En este momento se podrá realizar instrucciones SQL para manipular la tabla
clientes. Al pulsarse el icono (Show SQL Pane) se visualizará un panel para digitar
instrucciones SQL. Por omisión se muestra la siguiente ventana:
310
Figura C.23 Ventana al Aceptar la verificación de sintaxis SQL.
Ahora se deberán llenar con datos las tablas pedidos, productos y ventas de
acuerdo con las siguientes figuras:
311
Figura C.25 Tabla pedidos con datos insertados.
Para crear un diagrama de una base datos seleccione Database Diagrams de la base de
datos bdlibrovbnet, dé clic derecho y seleccione la opción New Database Diagram.
Para ver la ventana de adición de tablas:
312
Figura C.28 Ventana Add Table de la opción New Database Diagram.
Seleccione una tabla y pulse el botón Add. Realice esta misma operación con
cada una de las tablas restantes. Al terminar, pulse el botón Close para observar la
siguiente figura:
Para crear la relaciones entre las tablas seleccione el campo nit de la tabla
cliente, dé clic en el mouse y manténgalo pulsado y arrástrelo hacia el campo nit de la
tabla pedidos, suelte el mouse para ver la ventana Tables and Columns.
313
Figura C.30 Ventana Tables and Columns.
314
Fgura C.32 Ventana de diagramas con las relaciones entre tablas.
Pulse el botón Yes para obtener la ventana para escoger el nombre Choose
Name.
315
Escriba como nombre del diagrama relaciontablas y pulse el botón OK. Se
visualizará la ventana para guardar los cambios realizados.
Figura C.35 Ventana para guardar los cambios realizados en la base de datos.
Una vista es un espejo de cierta información que contiene una base de datos. Para crear
una vista de una base datos seleccione View de la base de datos bdlibrovbnet, dé clic
derecho y seleccione la opción New View. Para ver la ventana de adición de vistas:
316
Figura C.37 Ventana para adicionar tablas a una vista.
Adicione las tablas clientes y pedidos. Al terminar pulse el botón Close para
visualizar la siguiente figura:
317
Figura C.39 Ventana de ejecución de la vista creada.
Pulse el botón Yes para obtener la ventana para escoger el nombre Choose
Name.
318
Escriba como nombre de la vista vista_clientes_pedidos y pulse el botón OK.
Se visualizará la siguiente figura:
319
ANEXO D
D.1 Instalación
De la siguiente dirección:
http://www.oracle.com/technology/software/products/database/xe/index.html
descargue el Oracle Database 10g Express o una versión superior, el cual será un
archivo comprimido llamado OracleXEUniv.rar; una vez hecho esto, dé doble clic en
el siguiente icono:
320
Al dar doble clic sobre éste, se inicializará el asistente de instalación de Oracle
Database 10g Express, como muestra la siguiente figura:
321
Figura D.6 Ventana del acuerdo de licencia Oracle Database 10g Express Edition.
322
Figura D.8 Ventana de contraseñas Oracle Database 10g Express Edition.
En esta ventana digite la contraseña que considere. Para esta instalación se digitó
la contraseña 123456. Pulse el botón Siguiente> para visualizar la ventana Resumen.
Figura D.9 Ventana Resumen de instalación Oracle Database 10g Express Edition.
Revise cada uno de los valores y pulse el botón Instalar, para visualizar la
ventana de Estado de la Instalación.
323
Figura D.10 Ventana Estado de instalación Oracle Database 10g Express Edition.
Figura D.12 Ventana para conectarse a Oracle Database 10g Express Edition.
324
Para realizar la conexión a la base de datos es necesario digitar el usuario y la
contraseña. Por default el nombre de usuario es system, y la contraseña será aquella que
fue digitada en la ventana Específicar contraseñas de Bases de Datos. La siguiente es
la pantalla de inicio de ORACLE.
Para crear una tabla en la base de datos es necesario seleccionar el objeto explorador
de objetos y escoger la opción Crear y allí elegir Tablas.
Figura D.14 Ventana con la opción crear tablas en Oracle Database 10g.
325
Para visualizar la siguiente ventana:
Figura D.15 Ventana inicial para crear una tabla en Oracle Database 10g.
326
Figura D.17 Estructura tabla clientes.
Al terminar pulse el botón Siguiente> para crear la clave primaria, este paso
visualizará la siguiente ventana:
327
Aquí en la opción clave primaria seleccione Sin rellenar, el nombre de la
restricción de la clave primaria es colocada por default este caso será CLIENTES_PK,
la clave primaria será NIT (VARCHAR2) y no se debe seleccionar clave primaria
compuesta. Por último pulse el botón Siguiente> para visualizar la ventana de Clave
Ajena.
Para el ejemplo no se hace necesario crear una clave ajena, por lo tanto pulse el
botón Siguiente> para visualizar la ventana de restricciones.
328
Para el ejemplo tampoco se hace necesario crear restricciones a la tabla, por
consiguiente pulse el botón Terminar para visualizar la ventana de Confirmar.
329
El siguiente paso es insertarle información a la tabla, seleccionando la opción
Datos, se mostrará el mensaje “esta tabla no contiene ningún dato”, ya que hasta el
momento no se le ha ingresado ningún dato.
330
Aquí rellene con información cada uno de los campos de la tabla. Al terminar de
digitar información en el último campo de la tabla puede seleccionar el botón Crear o
Crear y Crear Otro. El botón Crear y Crear Otro le permitirá guardar el registro
digitado y limpiar los campos para ingresar nueva información en otro registro. El botón
Crear guarda el último registro digitado y visualizará la tabla con la información que
contenga dicha tabla.
331
ÍNDICE
332
ORDER, 45 StreamReader, 14, 17
Orientada a objetos, 44 StreamWriter, 14, 17
Output, 24 SUM, 47
Persist Security Info, 62 System.Data.OleDb, 58, 62
Position, 81 System.Data.SqlClient, 55, 177, 180
PostedFile, 165 System.IO, 11, 163
Probar la conexión, 66 Try-Catch, 14
Provider, 59 UPDATE, 45, 50
ReadByte, 165 User, 62
readToEnd, 14 ValueMember, 145
Relacionales, 44 Ventana de depuración de errores, 291
Replace, 11 Ventana de propiedades, 290
RowFilter, 145 Visual Basic .NET, 8
SaveFileDialog, 20 Visual Basic.NET, 8
SELECT, 45, 49 WHERE, 45
SelectedItem, 107 Windows Authentication, 299
SelectedValue, 145 Windows Form, 277
SQL Server, 299 Word.Application, 40
SqlCommand, 52 Word.Documents.Add, 40
SqlConnection, 52 write, 14
SqlDataAdapter, 52 writeLine, 15
Stream, 11
333
BIBLIOGRAFÍA
INFOGRAFÍA
monografias.com/trabajos5/tipbases/tipbases.shtml
monografias.com/trabajos5/basede/basede.shtml
inei.gob.pe/cpi/bancopub/libfree/lib607/cap01.htmet.gob.pe
elizabethpeguero.8m.com/enza.htm
Learnthenet.com/spanish/glossary/database.htmipyme.org/sie/
http://www.elquintero.net/Manuales.aspx?Cat=2&SubCat=6&jscript=true
http://www.willydev.net/descargas/Cursos/vbnet/index.html
http://www.dotnetspider.com/tutorials/AspNet-Tutorials.aspx
http://www.programacionfacil.com/visual_basic_net/start
http://www.programacion.com/asp/articulo/datosaspnet/
http://www.es-asp.net/tutoriales-asp-net/tutorial-61-81/efectuando-acceso-a-
datos.aspx.
http://www.microsoft.com/spanish/MSDN/estudiantes/desarrollo/lenguajes/v
studio.mspx
http://www.programacionfacil.com/java_windows/start
http://www.bitarray.info/2009/02/ado-net-crear-una-conexion-a-una-base-
de-datos-access-usando-el-asistente/
http://www.onglasses.net//default.aspx?articuloid=261
http://www.onglasses.net//default.aspx?articuloid=199
http://www.onglasses.net//default.aspx?articuloid=291
http://www.programar.net/directory/default.aspx?fid=3
http://www.elguille.info/colabora/NET2005/FernandoLuque_MaestroDetalle
Simple.htm
http://support.microsoft.com/default.aspx?scid=http://www.microsoft.com/in
tlkb/spain/E308/0/56.asp
http://www.elguille.info/colabora/puntoNET/yosall_datagrid.htm
334