1
Bases de Datos : ADO.net
Bases de Datos : ADO.net ............................................................................................................... 1
1. Bases de Datos : ADO.net ........................................................................................................... 1
1.2 Arquitectura de ADO.NET.................................................................................................... 2
2 Conectarse a datos ........................................................................................................................ 4
2.2 Asistente para la Configuración de orígenes de datos. .......................................................... 4
2.2 Crear una conexión por código: ............................................................................................ 6
3. Objetos comunes de ADO.NET .................................................................................................. 9
3.1. Dataset. ................................................................................................................................. 9
3.2. TableAdapter, Bindingsource y BindingNavigator. ........................................................... 11
4. Validar datos ............................................................................................................................. 14
5. Guardar datos ............................................................................................................................ 14
6. Ejercicios resueltos. ................................................................................................................... 14
1. Bases de Datos : ADO.net
La arquitectura de datos subyacente que se utiliza para crear aplicaciones en Visual Studio es
ADO.NET. Independientemente de lo que haga con los datos, hay ciertos conceptos
fundamentales que debe entender. Es posible que nunca utilice ciertos detalles sobre
manipulación de datos, por ejemplo, tal vez nunca cree una base de datos mediante
programación, pero es muy útil comprender los conceptos básicos de ADO.NET, al igual que las
herramientas de datos (asistentes y diseñadores) disponibles en Visual Studio.
La tarea general de trabajar con datos en una aplicación se puede dividir en varios procesos de
nivel superior. Por ejemplo, antes de mostrar los datos a un usuario en un formulario, debe
conectarse a un origen de datos (posiblemente una base de datos) y, a continuación, obtener
los datos que desea mostrar. Una vez incluidos estos datos en la aplicación, necesitará
almacenarlos temporalmente en alguna parte, por ejemplo en un objeto DataSet.
Una aplicación de datos típica utilizará la mayoría de los procesos que se ilustran en el diagrama
siguiente:
El ciclo de datos
2
1.2 Arquitectura de ADO.NET
El concepto más importante que hay que tener claro sobre ADO.NET es su modo de funcionar,
que se revela claramente al analizar su arquitectura:
Figura 1.3.- Arquitectura de ADO.NET
Existen dos capas fundamentales dentro de su arquitectura: la capa conectada y la
desconectada.
Capa conectada
La primera de ellas contiene objetos especializados en la conexión con los orígenes de datos.
Así, la clase genérica Connection se utiliza para establecer conexiones a los orígenes de datos.
La clase Command se encarga de enviar comandos de toda índole al origen de datos. Por fin la
clase DataReader está especializada en leer los resultados de los comandos mientras se
permanece conectado al origen de datos.
La clase DataAdapter hace uso de las tres anteriores para actuar de puente entre la capa
conectada y la desconectada.
Estas clases son abstractas, es decir, no tienen una implementación real de la que se pueda
hacer uso directamente. Es en este punto en donde entran en juego los proveedores de datos.
Cada origen de datos tiene un modo especial de comunicarse con los programas que los utilizan,
además de otras particularidades que se deben contemplar. Un proveedor de datos de ADO.NET
es una implementación concreta de las clases conectadas abstractas que hemos visto, que hereda
de éstas y que tiene en cuenta ya todas las particularidades del origen de datos en cuestión.
Así, por ejemplo, las clases específicas para acceder a SQL Server se llaman SqlConnection,
SqlCommand, SqlDataReader y SqlDataAdapter y se encuentran bajo el espacio de nombres
3
System.Data.SqlClient. Es decir, al contrario que en ADO clásico no hay una única clase
Connection o Command que se use en cada caso, si no que existen clases especializadas para
conectarse y recuperar información de cada tipo de origen de datos.
Nota:
El hecho de utilizar clases concretas para acceso a las fuentes de datos no
significa que no sea posible escribir código independiente del origen de datos.
Todo lo contrario. La plataforma .NET ofrece grandes facilidades de escritura de código genérico basadas en el uso de herencia e implementación de
interfaces. De hecho la versión 2.0 de .NET ofrece grandes novedades
específicamente en este ámbito.
Existen proveedores nativos, que son los que se comunican directamente con el origen de datos
(por ejemplo el de SQL Server o el de Oracle), y proveedores "puente", que se utilizan para
acceder a través de ODBC u OLEDB cuando no existe un proveedor nativo para un determinado
origen de datos.
Nota:
Estos proveedores puente, si bien muy útiles en determinadas circunstancias,
ofrecen un rendimiento menor debido a la capa intermedia que están utilizando (ODBC u OLEDB). Un programador novel puede sentir la tentación
de utilizar siempre el proveedor puente para OLEDB y así escribir código
compatible con diversos gestores de datos de forma muy sencilla. Se trata de
un error y siempre que sea posible es mejor utilizar un proveedor nativo.
Capa desconectada
Una vez que ya se han recuperado los datos desde cualquier origen de datos que requiera una
conexión ésta ya no es necesaria. Sin embargo sigue siendo necesario trabajar con los datos
obtenidos de una manera flexible. Es aquí cuando la capa de datos desconectada entra en juego.
Además, en muchas ocasiones es necesario tratar con datos que no han sido obtenidos desde un
origen de datos relacional con el que se requiera una conexión. A veces únicamente necesitamos
un almacén de datos temporal pero que ofrezca características avanzadas de gestión y acceso a
la información.
Por otra parte las conexiones con las bases de datos son uno de los recursos más escasos con los
que contamos al desarrollar. Su mala utilización es la causa más frecuente de cuellos de botella
en las aplicaciones y de que éstas no escalen como es debido. Esta afirmación es especialmente
importante en las aplicaciones Web en las que se pueden recibir muchas solicitudes simultáneas
de cualquier parte del mundo.
Finalmente otro motivo por el que es importante el uso de los datos desconectado de su origen es
la transferencia de información entre capas de una aplicación. Éstas pueden encontrarse
distribuidas por diferentes equipos, e incluso en diferentes lugares del mundo gracias a Internet.
Por ello es necesario disponer de algún modo genérico y eficiente de poder transportar los datos
entre diferentes lugares, utilizarlos en cualquiera de ellos y posteriormente tener la capacidad
de conciliar los cambios realizados sobre ellos con el origen de datos del que proceden.
Todo esto y mucho más es lo que nos otorga el uso de los objetos DataSet. Es obvio que no se
trata de tareas triviales, pero los objetos DataSet están pensados y diseñados con estos objetivos
en mente. Como podremos comprobar más adelante en este curso es bastante sencillo conseguir
4
estas funcionalidades tan avanzadas y algunas otras simplemente usando de manera adecuada
este tipo de objetos.
Nota:
Otra interesante característica de los DataSet es que permiten gestionar
simultáneamente diversas tablas (relaciones) de datos, cada una de un origen
diferente si es necesario, teniendo en cuenta las restricciones y las relaciones
existentes entre ellas.
Los DataSet, como cualquier otra clase no sellada de .NET, se pueden extender mediante
herencia. Ello facilita una técnica avanzada que consiste en crear tipos nuevos de DataSet
especializados en la gestión de una información concreta (por ejemplo un conjunto de tablas
relacionadas). Estas nuevas tipos clases se denominan genéricamente DataSet Tipados, y
permiten el acceso mucho más cómodo a los datos que representan, verificando reglas de
negocio, y validaciones de tipos de datos más estrictas.
2 Conectarse a datos
Para llevar datos a la aplicación (y devolver los cambios al origen de datos), debe establecerse
algún tipo de comunicación bidireccional. Por lo general, esta comunicación bidireccional es
controlada por un objeto de conexión (por ejemplo, una SqlConnection) que está configurado con
una cadena de conexión, o sea, la información que necesita para conectarse al origen de datos.
2.2 Asistente para la Configuración de orígenes de datos.
Visual Studio proporciona herramientas para conectar la aplicación a datos de muchos orígenes
diferentes, como bases de datos, servicios Web y objetos. Si se utilizan herramientas de diseño de
datos en Visual Studio, a menudo no será necesario crear de forma explícita un objeto de
conexión para el formulario o componente. El objeto de conexión se crea normalmente como
resultado de la finalización de uno de los asistentes de datos o al arrastrar objetos de datos al
formulario. Para conectar la aplicación a los datos de una base de datos, servicio Web u objeto,
ejecute el Asistente para la configuración de orígenes de datos seleccionando Agregar nuevo
origen de datos en la Ventana Orígenes de Datos.
5
6
Seleccionar los Objetos de la BD y Finalizar con la conexión.
2.2 Crear una conexión por código:
OBJETOS Y PROCESOS DE CONEXIÓN :
1.- OBJETOS DE CONEXIÓN:
System.Data.SqlClient.SqlConnection
System.Data.ODBC.ODBCConnection
System.Data.OleDBConnection.OLEDBConnection
System.Data.OracleClient.OracleConnection
2.- Creación de un Objeto de la clase
OleDbConnection:
Dim cnADONetConnection As New OleDb. OleDbConnection()
3.- Creación de una Variable de Módulo para almacenar la conexión:
OleDB: Private g_conexion As New OleDb. OleDbConnection()
Oracle: Dim instance As OracleConnection
4.- Origen de datos a donde queremos acceder.
Tenemos que usar la propiedad ConnectionString del Objeto g_conexion
• Provider (Tipo de BD JET, SQL….. )
• Data Source
• Iser ID (Nombre de Usuario)
• Password
• DRIVER (Nombre del controlador de la BD)
• SERVER (Nombre de la Red donde se encuentra el Servidor)
7
a) Definición de la cadena de conexión:
g_conexion. ConnectionString =
“Provider = Microsoft.Jet.OLDB.4.0;Data Source = c:\...\...\...NombreBD.mdb”
Para oracle: Dim instance As OracleConnection
b) Establecer Conexión a través del Método
Open() : g_conexion.Open()
c) Cerrar una Conexión con una Base de Datos.
Seleccionar el Evento FormClosed y escribir como código:
g_conexion.Close()
g_conexion.Dispose()
PASOS A SEGUIR PARA CONECTAR CON UNA BASE DE DATOS
a) Crear Base de Datos en Access.
b) En el Proyecto de Visual Basic:
1º.- Ejecutar el comando Proyecto / Propiedades Nombre Proyecto.
- Hacer Clic sobre Referencias. En la zona inferior de esta Ficha activar
las casillas:
γ System.Data (suele estar activa)
γ System.XML
2º.- Creación de una Variable de módulo para almacenar la conexión. Public Class frmMain
Private g_conexion As New OleDb.OleDbConnection
3º.- Indicar a qué origen de datos queremos acceder. Esto se hace a través de la
Propiedad ConnectionString que contiene la información de la conexión, como el
nombre del proveedor, el nombre del usuario y la contraseña de acceso. Para
especificar varios parámetros separarlos con punto y coma.
Alguno de los parámetros que acepta ConnectionString son:
• Provider Nombre del Proveedor de datos (JET, SQL…)
• Data Source Origen de la Base de Datos.
• User ID Usuario autorizado a acceder a la B.D.
• Password Contraseña asociada al usuario.
• DRIVER Controlador de la Base de Datos
No es obligatorio si se especifica un DSN.
• SERVER Nombre de la Red donde se encuentra
El Servidor de la Base de Datos.
Private Sub frmMain_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
g_conexion.ConnectionString = _
"Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=C:\Ramon\AdoNet\BDTelefonos.mdb"
End Sub
4º.- Establecer conexión con el Método Open del Objeto de conexión.
8
Private Sub frmMain_Load(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles MyBase.Load
g_conexion.ConnectionString = _
"Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=C:\Ramon\AdoNet\BDTelefonos.mdb"
g_conexion.Open()
End Sub
d) Cerrar conexión con la Base de Datos.
Para cerrar la conexión se utiliza el Método Close(), y si se quiere el Método Dispose()
para dejar disponibles los recursos que ha usado la Base de Datos.
Como ejemplo, una de las opciones donde cerrar una Base de Datos, es cuando se cierra
el Formulario:
Private Sub frmMain_FormClosed(ByVal sender As Object, ByVal e As
System.Windows.Forms.FormClosedEventArgs) Handles Me.FormClosed
g_conexion.Close() ‘Cierra
g_conexion.Dispose() ‘Libera recursos
End Sub
Si trabaja con TableAdapters, DataAdapters o DataCommands, no tendrá que abrir ni cerrar conexiones explícitamente. Cuando se llama a un método de estos objetos (por ejemplo, a los
métodos Fill o Update de un adaptador), el método comprueba si ya está abierta la conexión. Si no es así, el adaptador abre la conexión, ejecuta su lógica y cierra de nuevo la conexión.
Los métodos como Fill sólo abren y cierran automáticamente la conexión si no está ya abierta. Si la conexión está abierta, los métodos la utilizan pero no la cierran. Esto le proporciona la
flexibilidad necesaria para abrir y cerrar comandos de datos. Puede hacer esto si tiene múltiples
adaptadores que compartan una conexión. En este caso, hacer que cada adaptador abra y cierre la
conexión cuando se llame a su método Fill no resulta eficiente. En lugar de hacerlo así, puede
abrir la conexión, llamar al método Fill de cada adaptador y, cuando termine, cerrar la
conexión.
¿Qué es un entorno conectado?
Un entorno conectado es aquel en que los usuarios están conectados continuamente a una fuente de datos
Ventajas:
El entorno es más fácil de mantener
La concurrencia se controla más fácilmente
Es más probable que los datos estén más actualizados que en otros escenarios
Inconvenientes:
Debe existir una conexión de red constante
Escalabilidad limitada
9
¿Qué es un entorno desconectado?
Un entorno desconectado es aquel en el que los datos pueden modificarse de forma independiente y
los cambios se escriben posteriormente en la base de datos
Ventajas:
Las conexiones se utilizan durante el menor tiempo posible, permitiendo que menos conexiones
den servicio a más usuarios
Un entorno desconectado mejora la escalabilidad y el rendimiento de las aplicaciones
Inconvenientes:
Los datos no siempre están actualizados
Pueden producirse conflictos de cambios que deben solucionarse
3. Objetos comunes de ADO.NET
3.1. Dataset.
Diseñado para acceder a datos con independencia de la fuente de datos. En consecuencia, podemos utilizarlo con
varias y diferentes fuentes de datos,. El objeto DataSet contiene una colección de uno o más objetos DataTable
formados por filas y columnas de datos, además de clave principal, clave foránea, restricciones e información de la
relación sobre los datos en los objetos DataTable.
DataSet está compuesto por una colección de objetos DataTable que se pueden relacionar entre
ellos mediante objetos DataRelation. También se puede imponer la integridad de los datos de
DataSet mediante los objetos UniqueConstraint y ForeignKeyConstraint.
Los objetos DataTable contienen los datos, mientras que DataRelationCollection permite
desplazarse por la jerarquía de la tabla. Las tablas están incluidas en un DataTableCollection al
que se obtiene acceso a través de la propiedad Tables. Al obtener acceso a los objetos DataTable,
hay que tener en cuenta que éstos distinguen entre mayúsculas y minúsculas condicionalmente.
Por ejemplo, si un objeto DataTable se denomina "mydatatable" y otro "Mydatatable", la cadena
Base de datos
Connection
Command
DataSet DataReader
TableAdapter
Gestiona la conexión a una base de datos
Ejecuta un comando de consulta en la base de datos
Almacena datos en un caché distinto de la base de datos
Proporciona acceso eficaz a un flujo de datos de sólo lectura
Intercambia datos entre el conjunto de datos y la base de
datos
10
que se utilice para buscar una de las tablas se considerará que distingue entre mayúsculas y
minúsculas. Sin embargo, si existe "mydatatable" pero no existe "Mydatatable", se considerará
que la cadena de búsqueda no distingue entre mayúsculas y minúsculas. Para obtener más
información sobre el trabajo con los objetos DataTable, vea Crear DataTable.
Un DataSet puede leer y escribir datos y esquemas como documentos XML. Los datos y
esquemas pueden transportarse, a continuación, a través de HTTP y cualquier aplicación puede
utilizarlos en cualquier plataforma que sea compatible con XML. Los esquemas se pueden
guardar como esquemas XML mediante el método WriteXmlSchema, y tanto los esquemas como
los datos se pueden guardar mediante el método WriteXml. Hay que utilizar el método ReadXml
para leer un documento XML que incluya esquema y datos.
En una implementación normal de varios niveles, los pasos de creación y actualización de un
DataSet y, a su vez, de actualización de los datos originales, son los siguientes:
1. Construir y llenar cada DataTable de un DataSet con datos desde un origen de datos
mediante TableAdapter.
2. Cambiar los datos de los objetos DataTable individuales mediante la adición,
actualización o eliminación de objetos DataRow.
3. Llamar al método GetChanges para crear un segundo DataSet que sólo incorpore los
cambios realizados en los datos.
4. Llame al método Update de TableAdapter, pasando el segundo DataSet como
argumento.
5. Se invoca el método Merge para combinar los cambios del segundo DataSet con el
primero.
6. Invocar al método AcceptChanges de DataSet. O bien, invocar al método
RejectChanges para cancelar los cambios.
Métodos públicos:
Nombre Descripción
AcceptChanges Confirma todos los cambios realizados en este DataSet desde que se ha
cargado o desde la última vez que se ha llamado a AcceptChanges.
BeginInit Activa la inicialización de un objeto DataSet que se emplea en un
formulario o que utiliza otro componente. La inicialización se produce en
tiempo de ejecución.
Clear Borra cualquier dato de DataSet mediante el procedimiento de quitar
todas las filas de todas las tablas.
Clone Copia la estructura de DataSet, incluidos todos los esquemas, relaciones
y restricciones de DataTable. No copia ningún dato.
Copy Copia la estructura y los datos para este objeto DataSet.
GetChanges Sobrecargado. Obtiene una copia del objeto DataSet que contiene todos
los cambios que se le han realizado desde la última vez que se cargó o
desde que se llamó a AcceptChanges.
11
GetHashCode Sirve como función hash para un tipo concreto. GetHashCode es
apropiado para su utilización en algoritmos de hash y en estructuras de
datos como las tablas hash. (Se hereda de Object).
GetObjectData Rellena un objeto de información de serialización con los datos
necesarios para serializar la clase DataSet.
GetService Obtiene el implementador de IServiceProvider. (Se hereda de
MarshalByValueComponent).
HasChanges Sobrecargado. Obtiene un valor que indica si DataSet presenta cambios,
incluyendo filas nuevas, eliminadas o modificadas.
Load Sobrecargado. Rellena un objeto DataSet con valores de un origen de
datos utilizando la interfaz IDataReader proporcionada.
Merge Sobrecargado. Combina el objeto DataSet, el objeto DataTable o la
matriz de objetos DataRow que se especifique en el objeto DataSet o
DataTable actual.
RejectChanges Deshace todos los cambios realizados en el DataSet desde que se ha
creado o desde que se ha llamado por última vez a
DataSet.AcceptChanges.
Reset Restablece el estado original del objeto DataSet. Las subclases deben
reemplazar a Reset para restaurar el estado original de un DataSet.
ToString Devuelve una String que contiene el nombre de la clase Component si la
hay. Este método no debe reemplazarse. (Se hereda de
MarshalByValueComponent).
3.2. TableAdapter, Bindingsource y BindingNavigator.
El diagrama siguiente muestra el flujo estándar de operaciones al conectarse a datos ejecutando
una consulta TableAdapter para recopilar y mostrar datos en un formulario de una aplicación
para Windows.
12
.BindingSource
El componente BindingSource se utiliza para dos fines. En primer lugar, simplifica el enlace de
datos de los controles de un formulario proporcionando una capa de direccionamiento indirecto,
proporcionando administración de moneda, notificación de cambios y otros servicios. Esto se
consigue adjuntando el componente BindingSource al origen de datos y, a continuación,
enlazando los controles del formulario al componente BindingSource. Toda la interacción
adicional con los datos, incluyendo la exploración, ordenación, filtrado y actualización, se realiza
mediante llamadas al componente BindingSource.
Propiedades:
DataMember Obtiene o establece la lista concreta del origen de datos a la que está enlazado el conector en ese momento.
DataSource Obtiene o establece el origen de datos con el que está enlazado el conector.
Filter Obtiene o establece la expresión utilizada para filtrar las filas que se deben mostrar.
SuspendBinding Suspende el enlace a datos para impedir que los cambios actualicen el origen de datos enlazado.
Eventos:
AddingNew Se produce antes de que se agregue un elemento a la lista subyacente.
BindingComplete Se produce cuando todos los clientes se han enlazado a este BindingSource.
DataError Aparece cuando el BindingSource controla en modo silencioso una excepción
relacionada con la moneda.
DataMemberChanged Se produce cuando cambia el valor de la propiedad DataMember.
13
DataSourceChanged Se produce cuando cambia el valor de la propiedad DataSource.
BimdingNavigator
Representa la interfaz de usuario de exploración y manipulación para los controles de un
formulario que están enlazados a datos.
Propiedades:
BindingContext Obtiene o establece el contexto de enlace para ToolStrip.(Se hereda de ToolStrip).
BindingSource Obtiene o establece el componente System.Windows.Forms.BindingSource que es el origen de datos.
Bottom Obtiene la distancia, en píxeles, que existe entre el borde inferior del control y el borde
superior del área cliente de su contenedor.(Se hereda de Control).
Bounds Obtiene o establece el tamaño y la ubicación del control incluyendo sus elementos no cliente, en píxeles, con respecto al control primario.(Se hereda de Control).
DataBindings Obtiene los enlaces de datos del control.(Se hereda de Control).
Métodos:
AddStandardItems Agrega el conjunto estándar de elementos de desplazamiento al control
BindingNavigator.
BeginInit Deshabilita la actualización de los controles ToolStripItem de BindingNavigator durante la inicialización del componente.
BeginInvoke Sobrecargado. Ejecuta un delegado de forma asincrónica en el subproceso donde se creó el identificador subyacente del control. (Se hereda de Control).
BringToFront Coloca el control al principio del orden Z. (Se hereda de Control).
Contains Obtiene un valor que indica si el control especificado es un control secundario del
control. (Se hereda de Control).
CreateControl Obliga a que se cree el control, incluidos el identificador y los controles secundarios. (Se hereda de Control).
Dispose Sobrecargado. Libera todos los recursos utilizados por BindingNavigator.
BindingNavigator después de que haya finalizado la inicialización del componente.
Tableadapter.
Los TableAdapters comunican la aplicación con una base de datos. Más específicamente, un
TableAdapter se conecta con una base de datos, ejecuta consultas o procedimientos almacenados,
y devuelve una nueva tabla de datos rellena con los datos devueltos o rellena una DataTable
existente con los datos devueltos. Los TableAdapters también se utilizan para devolver los datos
actualizados desde la aplicación a la base de datos.
Los usuarios de versiones anteriores de Visual Studio pueden pensar en un TableAdapter como
un DataAdapter que lleva integrado un objeto de conexión y la capacidad de contener varias
consultas. Cada consulta agregada a un TableAdapter se expone como un método público al que
se llama simplemente como a cualquier otro método o función de un objeto.
Además de la funcionalidad estándar del control DataAdapter, los objetos TableAdapter
proporcionan métodos con tipo adicionales que encapsulan consultas que comparten un esquema
14
común con el control DataTable con tipo asociado. Dicho de otra forma, puede tener tantas
consultas como desee en un TableAdapter, siempre y cuando devuelvan datos que cumplan el
mismo esquema
A continuación se muestran los métodos y propiedades de TableAdapter más utilizados:
Miembro Descripción
TableAdapter.Fill Rellena la tabla de datos asociada del TableAdapter con los
resultados del comando SELECT del TableAdapter..
TableAdapter.Update Devuelve los cambios a la base de datos.
TableAdapter.GetData Devuelve una nueva DataTable rellena con datos.
TableAdapter.Insert Crea una nueva fila en la tabla de datos..
TableAdapter.ClearBeforeFill Determina si se vacía una tabla de datos antes de llamar a
uno de los métodos Fill.
4. Validar datos
Al realizar cambios en los datos, es posible que desee comprobar los cambios antes de permitir
que los valores sean aceptados de regreso en la base de datos o que éstos se escriban en ella.
Validación es el nombre del proceso de comprobar que estos nuevos valores son aceptables para
los requisitos de la aplicación. Puede comprobar los valores de la aplicación a medida que los
modifica.
5. Guardar datos
Después de realizar los cambios en la aplicación (y validarlos), es posible que desee enviar los
cambios a la base de datos. Si está utilizando conjuntos de datos y un modelo de datos
desconectado, debería comprobar si existen infracciones de concurrencia. (Este término se
refiere a una situación en la que los datos de una base de datos se han modificado desde que se
cargaron originalmente en la aplicación y ahora contiene valores más recientes que los de la
aplicación). También es posible que desee actualizar varias tablas al mismo tiempo, en cuyo caso
puede utilizar una transacción.
6. Ejercicios resueltos.
Ejercicio 1: Bases de datos con VB.net 2008 (arrastrando sobre formulario)
15
1. Agregar origen de datos
2. Seleccionar las tablas y el tipo de control para cada campo de la Tabla.
16
3. Arrastrar cada tabla que se desee sobre el Formulario
4. Aparecen los siguientes Objetos:
17
DataSet Diseñado para acceder a datos con independencia de la fuente de
datos. En consecuencia, podemos utilizarlo con varias y diferentes
fuentes de datos,. El objeto DataSet contiene una colección de uno
o más objetos DataTable formados por filas y columnas de datos,
además de clave principal, clave foránea, restricciones e
información de la relación sobre los datos en los objetos DataTable.
TableAdapterManager
Visual Basic 2008 trae un nuevo componente de acceso a datos
llamado TableAdapterManager. En teoría debe simplificarnos el
actualizar una base de datos partiendo de un dataset tipado con
varias tablas relacionadas. El TableAdapterManager tiene un
método, UpdateAll, que guarda los datos de todas las tablas del
dataset (filas añadidas, modificadas y eliminadas) en el orden
correcto, respetando las relaciones y reglas de integridad referencial.
TableAdapter Los TableAdapters proporcionan comunicación entre la aplicación y
una base de datos. Para ser más exactos, un TableAdapter se conecta
a una base de datos, ejecuta consultas o procedimientos
almacenados y devuelve una nueva tabla de datos rellena con los
datos devueltos o con una DataTable con los datos devueltos.
TableAdapters también se utilizan para enviar datos actualizados
desde la aplicación a la base de datos.
BindingSource El componente BindingSource simplifica el enlace de datos de los
controles de un formulario proporcionando una capa de
direccionamiento indirecto, proporcionando administración de
moneda, notificación de cambios y otros servicios. Esto se consigue
adjuntando el componente BindingSource al origen de datos y, a
continuación, enlazando los controles del formulario al componente
BindingSource. Toda la interacción adicional con los datos,
incluyendo la exploración, ordenación, filtrado y actualización, se
realiza mediante llamadas al componente BindingSource.
BindingNavigator
El control BindingNavigator representa una manera normalizada
para desplazarse y manipular los datos en un formulario. En la
mayoría de los casos, se empareja un control BindingNavigator con
un control BindingSource para desplazarse por los registros de
datos de un formulario e interactuar con ellos
2- Ejercicio de bases de Datos con vb.net 2008
Esquema de Relaciones de la BD
1- Añadir un formulario MDIParent
18
2- Añadir la opción de menú de Universidad con un elemento por cada tabla: Alumnos,
asignaturas y carreras
3. Agregar origen de datos
19
4. Seleccionar los Objetos de la BD y Finalizar con la conexión.
5. Mostrar el origen de los Datos.
20
6. Seleccionar las tablas y el tipo de control para cada campo de la Tabla.
7. Arrastrar cada tabla que se desee sobre el Formulario. En este ejemplo Carreras y asig_car
21
8. aparecen los siguientes Objetos:
DataSet (1) Diseñado para acceder a datos con independencia de la fuente de
datos. En consecuencia, podemos utilizarlo con varias y diferentes
fuentes de datos,. El objeto DataSet contiene una colección de uno
o más objetos DataTable formados por filas y columnas de datos,
además de clave principal, clave foránea, restricciones e
información de la relación sobre los datos en los objetos DataTable.
TableAdapterManager
Visual Basic 2008 trae un nuevo componente de acceso a datos
llamado TableAdapterManager. En teoría debe simplificarnos el
actualizar una base de datos partiendo de un dataset tipado con
varias tablas relacionadas. El TableAdapterManager tiene un
método, UpdateAll, que guarda los datos de todas las tablas del
dataset (filas añadidas, modificadas y eliminadas) en el orden
correcto, respetando las relaciones y reglas de integridad referencial.
TableAdapter (2) Los TableAdapters proporcionan comunicación entre la aplicación y
una base de datos. Para ser más exactos, un TableAdapter se conecta
a una base de datos, ejecuta consultas o procedimientos
almacenados y devuelve una nueva tabla de datos rellena con los
datos devueltos o con una DataTable con los datos devueltos.
TableAdapters también se utilizan para enviar datos actualizados
desde la aplicación a la base de datos.
Podemos apreciar en el ejemplo que crea un TableAdapter por cada
tabla.
22
BindingSource (2) El componente BindingSource simplifica el enlace de datos de los
controles de un formulario proporcionando una capa de
direccionamiento indirecto, proporcionando administración de
moneda, notificación de cambios y otros servicios. Esto se consigue
adjuntando el componente BindingSource al origen de datos y, a
continuación, enlazando los controles del formulario al componente
BindingSource. Toda la interacción adicional con los datos,
incluyendo la exploración, ordenación, filtrado y actualización, se
realiza mediante llamadas al componente BindingSource.
Un BindingSource para cada tabla que arrastremos sobre el
formulariocon .
BindingNavigator
(1)
El control BindingNavigator representa una manera normalizada
para desplazarse y manipular los datos en un formulario. En la
mayoría de los casos, se empareja un control BindingNavigator con
un control BindingSource para desplazarse por los registros de
datos de un formulario e interactuar con ellos
8. Podemos arrastrar una consulta de la BD sobre un segundo formulario:
23
3. Bases de Datos con ado.net : Cristal Report
El siguiente ejercicio, programa una BD de Access (utilizaremos una sola tabla: alumno) en
vb.net realizaremos listado. Con el siguiente diseño de pantalla:
Seguiremos los siguientes pasos:
1. Crearemos un nuevo Proyecto .
2. Sobre el proyecto Agregar-> Nuevo elemento ->
Cristal Report
3. Arrastrar de La Caja de herramientas un
CystalReporViewer sobre el formulario.
4. Modificar la propiedad ReportSource del
CrystalViewer con el documento CristalReport
creado.
5. Ejecutar.
6. Se puede modificar el diseño del listado al gusto de
cada uno.
24
4. Bases de Datos con ado.net desconectada
El siguiente ejercicio, programa una BD de Access (utilizaremos una sola tabla) en vb.net y
trabajaremos de forma desconectada. El diseño de pantalla será el siguiente:
Seguiremos los siguientes pasos:
7. Crearemos un nuevo Formulario en la aplicación de base de Datos .
8. Crearemos una conexión con una BD en Access o utilizaremos una ya exixtente
desplegando el explorador de servidores o en Datos-> agregar nuevo origen de
datos..
9. Necesitamos : Un Dataset un TableAdapter y un BindingSource. Arrastraremos
sobre el formulario el dataset y el Bindingsource y automáticamente crea los objetos.
El TableAdapter de crea automáticamente al conectar el BindingSource con las
propiedades DATAsource Y Datamenber. El orden es Dataset, BindingSource y al
enlazar se crea automáticamente el TableAdapter.
10. Las propiedades del BindingSource : Datasource y
Datamenber las modificamos apuntando al dataset
creado y a la tabla Alumno.
Este dataset nos permitirá manipular los datos, y lo podremos utilizar como enlace
entre las cajas de texto y los campos de la tabla que estamos utilizando, también
podremos agregar, eliminar, actualizar registros…etc.
11. Agregar al formulario las cajas de texto (una por cada columna de la tabla Alumno) y
sus etiquetas necesarias.
25
12. Modificar la propiedad DataBIndings de cada caja de texto de la siguiente forma:
(para el campo Interno pondremos un CheckBox, con la propiedad Checkstate enlazada al
BindingSource1-Interno)
Para enlazar las cajas de texto a los campos de la tabla.
13. Crear los botones y Label1.
14. Añadir el siguiente código:
Private Sub Form5_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
'rellenar los datos
AlumnoTableAdapter1.Fill(Me.UniversidaD_SINFOTO2000DataSet1.ALUMN
O)
' etiqueta de información sobre las filas de la tabla
Label1.Text = "Tabla ALUMNO:" &
Me.UniversidaD_SINFOTO2000DataSet1.ALUMNO.Rows.Count
End Sub
26
Private Sub anterior_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles anterior.Click
'Me.BindingSource1.Position = Me.BindingSource1.Position
- 1
Me.BindingSource1.MovePrevious()
Label1.Text = "Tabla ALUMNO:" &
Me.BindingSource1.Position + 1 & " de " & Me.BindingSource1.Count
End Sub
Private Sub primero_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles primero.Click
Me.BindingSource1.Position = 0
'me.BindingSource1.MoveFirst
Label1.Text = "Tabla ALUMNO:" &
Me.BindingSource1.Position + 1 & " de " & Me.BindingSource1.Count
End Sub
Private Sub ultimo_Click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles ultimo.Click
Me.BindingSource1.MoveLast()
' se puede hacer tambien con:
'Me.BindingSource1.Position =
Me.UniversidaD_SINFOTO2000DataSet1.ALUMNO.Rows.Count - 1
'Me.BindingSource1.Position = Me.BindingSource1.Count - 1
Label1.Text = "Tabla ALUMNO:" &
Me.BindingSource1.Position + 1 & " de " & Me.BindingSource1.Count
End Sub
Private Sub siguiente_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles siguiente.Click
'Me.BindingSource1.Position = Me.BindingSource1.Position
+ 1
Me.BindingSource1.MoveNext()
Label1.Text = "Tabla ALUMNO:" &
Me.BindingSource1.Position + 1 & " de " & Me.BindingSource1.Count
End Sub
Private Sub borrar_Click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles borrar.Click
If Me.BindingSource1.Count > 0 Then
'Me.BindingSource1.Remove(Me.BindingSource1.Position)
'Me.BindingSource1.RemoveCurrent()
Me.BindingSource1.RemoveAt(Me.BindingSource1.Position)
Label1.Text = "Tabla ALUMNO:" &
Me.BindingSource1.Position + 1 & " de " & Me.BindingSource1.Count
End If
End Sub
Private Sub agregar_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles agregar.Click
27
' posicionarse en el último registro
Me.BindingSource1.MoveLast()
'otra forma
'Me.BindingSource1.Position = Me.BindingSource1.Count - 1
' añadir un registro en blanco
Me.BindingSource1.AddNew()
' actualizar etiqueta
Label1.Text = "Tabla ALUMNO:" &
Me.BindingSource1.Position + 1 & " de " & Me.BindingSource1.Count
'pasar foco a la caja de texto de la clave principal.
TextBox1.Focus()
'bloquear botones
siguiente.Enabled = False
ultimo.Enabled = False
anterior.Enabled = False
primero.Enabled = False
bcancelar.Enabled = False
actualizar.Enabled = False
End Sub
Private Sub Cancelar_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles Cancelar.Click
Me.BindingSource1.CancelEdit()
Label1.Text = "Tabla ALUMNO:" &
Me.BindingSource1.Position + 1 & " de " & Me.BindingSource1.Count
End Sub
Private Sub actualizar_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles actualizar.Click
Me.Validate()
'detener todas las ediciones
Me.BindingSource1.EndEdit()
'actualizar
Me.AlumnoTableAdapter1.Update(Me.UniversidaD_SINFOTO2000DataSet1.
ALUMNO)
End Sub
Private Sub bcancelar_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles bcancelar.Click
'solo es posible antes de actualizar
Me.UniversidaD_SINFOTO2000DataSet1.ALUMNO.RejectChanges()
End Sub
Private Sub final_Click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles final.Click
Me.Close()
End Sub
Private Sub TextBox1_Leave(ByVal sender As Object, ByVal e As
System.EventArgs) Handles TextBox1.Leave
'cuando el foco de entrada deja la caja de texto
28
clave_principal(TextBox1.Text)
End Sub
Module Module1
Public Sub clave_principal(ByVal clave As String)
If clave = "" Then
MessageBox.Show("el DNI es clave principal y no puede
tener valores nulos")
'bloquear botones
form5.siguiente.Enabled = False
form5.ultimo.Enabled = False
form5.anterior.Enabled = False
form5.primero.Enabled = False
form5.bcancelar.Enabled = False
form5.actualizar.Enabled = False
' foco al caja dni
form5.TextBox1.Focus()
Else
'desbloquear botones
form5.siguiente.Enabled = True
form5.ultimo.Enabled = True
form5.anterior.Enabled = True
form5.primero.Enabled = True
form5.bcancelar.Enabled = True
form5.actualizar.Enabled = True
End If
End Sub
End Module
5. Bases de Datos con ado.net
El siguiente ejercicio, programa una BD de Access (utilizaremos una sola tabla: alumno) en
vb.net realizaremos consultas por apellido. Con el siguiente diseño de pantalla:
29
Seguiremos los siguientes pasos:
15. Crearemos un nuevo Formulario en la aplicación de base de Datos .
16. Crearemos una conexión con una BD en Access o utilizaremos una ya exixtente
desplegando el explorador de servidores.
17. Necesitamos : Un Dataset un TableAdapter y un BindingSource arrastraremos
sobre el formulario y automáticamente crea los objetos . El TableAdapter de crea
automáticamente al conectar el BindingSource con las propiedades DATAsource Y
Datamenber. El orden es Dataset, BindingSource y al enlazar se crea automáticamente
el TableAdapter.
18. Las propiedades del BindingSource : Datasource y
Datamenber las modificamos apuntando al dataset
creado y a la tabla Alumno.
19. Agregar al formulario la caja de texto, un ListBox y un DataGridView.
20. enlazar la propiedad DataSource del DataGridView con el BindingSource1.
21. añadir el siguiente código:
Private Sub Form4_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
TextBox1.Clear() 'limpiar caja de texto
'rellenar los datos
AlumnoTableAdapter1.Fill(Me.UniversidaD_SINFOTO2000DataSet1.ALUMN
O)
End Sub
Private Sub TextBox1_TextChanged(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles TextBox1.TextChanged
' CADENA PARA LA SELECT DE APELLIDOS
Dim CADENA As String
CADENA = "APELLIDOS LIKE '" & TextBox1.Text & "%'"
'Crear una array para guardar las filas del dataSet
Dim filas() As DataRow
'rellenar el array filas con las filas de la tabla alumno
y el select
filas =
Me.UniversidaD_SINFOTO2000DataSet1.ALUMNO.Select(CADENA)
'limpiar el listbox
Me.ListBox1.Items.Clear()
'recorrer array filas y añadir al listBox
If filas.Length > 0 Then
30
For Each i As DataRow In filas
' en el listbox pongo el apellido,nombre de cada
fila
Me.ListBox1.Items.Add(i("apellidos").ToString &
"," & i("nombre".ToString))
Next
End If
End Sub
Private Sub ListBox1_SelectedIndexChanged(ByVal sender As
System.Object, ByVal e As System.EventArgs) Handles
ListBox1.SelectedIndexChanged
'c_apell es un string donde guardaré el apellido solo
Dim c_apell As String
'coma es un entero con la posición de la caja de texto
donde esta la coma
'que separa el apellido del nombre
Dim coma As Integer
'busco la posición de la coma
coma = InStr(Me.ListBox1.SelectedItem.ToString, ",")
'separo el apellido
c_apell = Mid(Me.ListBox1.SelectedItem.ToString, 1, coma
- 1)
'pasar a la caja de texto el seleccionado
Me.TextBox1.Text = Me.ListBox1.SelectedItem.ToString
' eliminar selecciones anteriores
Me.DataGridView1.ClearSelection()
'buscar la fila del DataGridview que coincide
For Each i As DataGridViewRow In Me.DataGridView1.Rows
If c_apell = i.Cells(2).Value.ToString Then
'seleccionarla
Me.DataGridView1.Rows(i.Index).Selected = True
'ponerla visible
Me.DataGridView1.FirstDisplayedScrollingRowIndex
= i.Index
Exit For
End If
Next
End Sub