Visual Basic.net: Acceso a Bases de datos(11) by Lola Cano

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

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 2

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

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.

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 • Data Source • Iser ID • Password • DRIVER • SERVER

(Tipo de BD JET, SQL….. ) (Nombre de Usuario) (Nombre del controlador de la BD) (Nombre de la Red donde se encuentra el Servidor) 6

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.

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() g_conexion.Dispose()

‘Cierra ‘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



Inconvenientes:  Debe existir una conexión de red constante  Escalabilidad limitada

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

¿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 Gestiona la conexión a una base de datos

Base de datos

Ejecuta un comando de consulta en la base de datos

Connection

Intercambia datos entre el conjunto de datos y la base de datos

Command

Almacena datos en un caché distinto de la base de datos

TableAdapter DataSet

Proporciona acceso eficaz a un flujo de datos de sólo lectura

DataReader

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 9

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.

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.

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

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 13

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)

1. Agregar origen de datos

2. Seleccionar las tablas y el tipo de control para cada campo de la Tabla.

3. Arrastrar cada tabla que se desee sobre el Formulario

4. Aparecen los siguientes Objetos:

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

2AĂąadir la opciĂłn de menĂş de Universidad con un elemento por cada tabla: Alumnos, asignaturas y carreras

3. Agregar origen de datos

4. Seleccionar los Objetos de la BD y Finalizar con la conexi贸n.

5. Mostrar el origen de los Datos.

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

8. aparecen los siguientes Objetos: DataSet (1)

TableAdapterManager

TableAdapter (2)

BindingSource (2)

BindingNavigator (1)

8. Podemos arrastrar una consulta de la BD sobre un segundo formulario:

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.

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

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

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 26

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

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:

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 29

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