Tema ADO.

NET

Hay aplicaciones en donde usamos controles DataSource.

En estos controles no es preciso un conocimiento exhaustivo de bases de

datos, pero no podremos realizar acciones más complejas.

Necesitamos entonces, para aplicaciones comerciales, un modelo de objetos

ADO.NET que nos permiten comprender mejor el funcionamiento de datos y
realizar tareas más avanzadas.

Objetos ADO.NET
Objetivo ADO.net = puente entre objetos .net y base de datos

Los objetos ADO.NET encapsulan y ocultan detalles del acceso a la base de

datos (cómo se transportan los datos…)

Clase DataSet
La clase clave es DataSet (en el espacio de nombres System.Data)

El conjunto de datos representa un subconjunto de toda la base de datos,

guardado en el estado de sesión o en memoria caché, sin una conexión
continua con la base de datos.

Se conecta temporalmente con la base de datos para actualizar.

Este conjunto de datos está formado por objetos DataTable y DataRelation
(no solo tablas, tb relaciones, vistas…).

Podemos acceder a ellos con propiedades Tables y Relations del objeto

DataSet. (tb tiene otros métodos y propiedades).

La clase DataTable devuelve una colección DataTableCollection que

contiene todos los objetos DataTable del conjunto de datos.

DataTable tabla1= miDataSet.Tables[0];

Este objeto DataTable también tiene propiedades para devolver las

columnas, vistas… y métodos.

La clase DataRow nos devuelve un conjunto de filas de una determinada

tabla. Con esta colección examinamos el resultado de consultas a la base de
datos.

DbCommand y DbConnection
El objeto DbConeection representa una conexión a un origen de datos.

Esta conexión puede compartirse entre varios objetos comando.

El objeto DbCommand nos permite enviar un comando (instrucción SQL) a la

base de datos.

Objeto DataAdapter
Se utiliza para mediar entre DataSet y la base de datos. Disocia conjunto de
datos de base de datos.

Esto permite que un solo conjunto de datos represente a más de una base
de datos.

.NET ofrece diferentes versiones del objeto DataAdapter para usarlo con
diferentes proveedores de datos (uno para Sql Server, otro para Ole DB
como access…)

Si nos conectamos a una base de datos Sql Server o SqlExpress

incrementamos el rendimiento de nuestra aplicación usando
SqlDataAdapter (de System.Data.SqlClient) junto con SqlCommand y
SqlConnection.

La clase DataAdapter nos da métodos y propiedades para controlar el

comportamiento del objeto de control de datos. (métodos como Fill,
Update…)

Objeto DataReader
Es una alternativa al conjunto de datos.
Ofrece acceso sólo conectado a la base de datos.

Este objeto es ligero, ideal para rellenar una página con datos de lectura.

Tiene propiedades como FieldCount y HasRows para obtener información de

los datos.

Tb nos ofrece métodos para extraer datos a medida que se van recorriendo
como GetBytes, GetData, GetName…

Ejemplo ADO.NET

En una página arrastramos un GridView y NO lo conectamos a un origen de

datos con el asistente.

En el fichero de código oculto:

• Creamos el DataSet

• Asignamos una de sus tablas a la propiedad DataSource del GridView

Los pasos sería:

1. No olvidemos añadir using System.Data.SqlClient

2. Implementamos el método Page_Load para obtener la tabla Cleintes

de la base de datos NorthWindw y vincularla a nuestro GridView.

3. Creamos una cadena de conexión y una cadena de comando

4. Pasamos las cadenas al constructor del SqlDataAdapter

5. Creamos una instancia del DataSet

6. Pedimos al DataAdapter que rellene el DataSet

7. Extraemos la tabla del DataSet

8. Vinculamos el GridView a esa tabla

Solución
protected void Page_Load(object sender, EventArgs e)
{
//Creamos una cadena de conexión y una cadena de comando

string connectionString =
"Data Source=SONY290;Initial
Catalog=Northwind;Persist Security Info=True;User
ID=sa;Password=stersol";

string commandString =
"Select * from Customers";
 //Pasamos las cadenas al constructor del SqlDataAdapter

SqlDataAdapter dataAdapter =
new SqlDataAdapter(commandString,
connectionString);

// Crea la instancia del DataSet

DataSet dataSet = new DataSet();

// Rellena el objeto DataSet

dataAdapter.Fill(dataSet, "Customers");

// Extrae la tabla del DataSet

DataTable dataTable = dataSet.Tables["Customers"];

// Vincula el GridView a la tabla

GridView1.DataSource = dataTable;
GridView1.DataBind();

Usando DataReader
Para recuperar un conjunto de registros y mostrarlos podemos ganar
eficienca con un objeto SqlDataReader

Los DataReaders son limitados comparados con los conjuntos de datos

(dataAdapter) pq solo ofrecen un conjunto de resultados predeterminados.

Hacemos el caso anterior con DataReader.

Solución
protected void Page_Load(object sender, EventArgs e)
{
// crea la cadena de comando y de conexión
string connectionString =
"Data Source=SONY290;Initial
Catalog=Northwind;Persist Security Info=True;User
ID=sa;Password=stersol";

string commandString = "Select * from Customers";

// crea el objeto conexion

SqlConnection conn = new SqlConnection(connectionString);

// crea el ojbeto comando

SqlCommand command = new SqlCommand(commandString);

// abre la conexión
try
{
// open the connection
conn.Open();

// enlaza la conexión al objeto commando

command.Connection = conn;
 // obtiene el lector de datos
SqlDataReader reader =

command.ExecuteReader(CommandBehavior.CloseConnection);

// vincula al lector de datos

GridView1.DataSource = reader;
GridView1.DataBind();

}
finally
{
conn.Close(); // se asegura de cerrar la conexión
}

Las transacciones de base de datos son recursos limitados y es importante

asegurar que cerramos la conexión.

Los data Reader tienen limitaciones como que no se desconectan.

Relaciones de datos en DataSets

DataSet funciona como un modelo desconectado de la base de datos y debe
poder representar tablas y relaciones entre las tablas.

DataSet captura las relaciones en DataRelationCollection y representan las

relaciones entre las tablas con la propiedad Relations.

Cada DataRelation relaciona un par de objetos DataTable entre sí con

objetos DataColumn. En la relación coinciden las columnas de ambas tablas
por su clave principal.

Podemos ver un ejemplo en donde capturamos relaciones de nuestra base

de datos.

Creamos un primer objeto DataRelation que define la relación entre la tabla

Orders y Orders Details con el campo OrderID.

La segunda relación será entre la tabla Order Details y Products mediante

ProductID.

Necesitaremos tres GridView.

La primera representará los pedidos y mostrará cinco pedidos cada vez con
un botón para seleccionar un pedido determinado.

(autogenerateColumns en false, allowPaging true en pagesize 5, y en

columns

buttonField de type button y command select y orderid, order date,

companyname, contacttitle y phone.

Creamos las columnas con editar columnas.

Segunda rejilla.

Estará en un Panel para poder ocultar y mostrar a nuestro gusto.

Tampoco se autogeneran las columnas y ponemos orderdate, productname,

unitprice y quantity de la tabla.

Tercera rejilla

Muestra las relaciones del conjunto de datos

Por ahora sin nada.

El archivo de código oculto será:

Necesitamos

Using System.Text para construir cadenas de texto

Using System.Data.SqlClient para usar dataAdapter…

Fichero código oculto

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text; // necesrio para StringBuilder
using System.Data.SqlClient; // necesario DataAdater

public partial class Default_aspx : System.Web.UI.Page

{
protected void Page_Load(object sender, EventArgs e)
{
DataSet ds = CreateDataSet();

la clave es el método CreateDataSet. Crea un conjunto de datos con

tres tablas y dos conjuntos de relaciones. Se crea y se abre una
conexión a la base de datos Northwind

GridView1.DataSource = ds.Tables[0];
GridView1.DataBind();

// crea la vista de daots y vincula con la rejilla details

DataView detailsView = new DataView(ds.Tables[1]);

DetailsGridView.DataSource = detailsView;
Session["DetailsView"] = detailsView;
DetailsGridView.DataBind();
//vincula la rejilla relations con la conlección relations
OrderRelationsGridView.DataSource = ds.Relations;
OrderRelationsGridView.DataBind();

}
private DataSet CreateDataSet()
{
// connection string to connect to the Orders Database
string connectionString =
"Data Source=SONY290;Initial Catalog=Northwind;Persist
Security Info=True;User ID=sa;Password=stersol";

// Create connection object, initialize with

// connection string and open the connection
System.Data.SqlClient.SqlConnection connection =
new
System.Data.SqlClient.SqlConnection(connectionString);
connection.Open();

// Create a SqlCommand object and assign the connection

System.Data.SqlClient.SqlCommand command =
new System.Data.SqlClient.SqlCommand();
command.Connection = connection;

StringBuilder s = new StringBuilder(

"select OrderID, c.CompanyName,
c.ContactName, ");
s.Append(" c.ContactTitle, c.Phone, orderDate");
s.Append(" from orders o ");
s.Append("join customers c on c.CustomerID =
o.CustomerID");

// set the command text to the select statement

command.CommandText = s.ToString();

// create a data adapter and assign the command object

// and add the table mapping for bugs
SqlDataAdapter dataAdapter = new SqlDataAdapter();
dataAdapter.SelectCommand = command;
dataAdapter.TableMappings.Add("Table", "Orders");

// Create the dataset and use the data adapter to fill it

DataSet dataSet = new DataSet();
dataAdapter.Fill(dataSet);

// create a second command object for the order details

System.Data.SqlClient.SqlCommand command2 =
new System.Data.SqlClient.SqlCommand();
command2.Connection = connection;

// This time be sure to add a column for Severity so that

you can
// create a relation to Products
StringBuilder s2 =
new StringBuilder(
"Select od.OrderID, OrderDate, p.ProductID, ");
s2.Append(" ProductName, od.UnitPrice, Quantity ");
s2.Append("from Orders o ");
s2.Append("join [Order Details] od on o.orderid =
od.orderid ");
 s2.Append("join products p on p.productID = od.productid
");

command2.CommandText = s2.ToString();

// create a second data adapter and

// add the command and map the table
// then fill the dataset from this second adapter
SqlDataAdapter dataAdapter2 = new SqlDataAdapter();
dataAdapter2.SelectCommand = command2;
dataAdapter2.TableMappings.Add("Table", "Order Details");
dataAdapter2.Fill(dataSet);

// create a third command object for the Products table

System.Data.SqlClient.SqlCommand command3 =
new System.Data.SqlClient.SqlCommand();
command3.Connection = connection;

string strCommand3 = "Select ProductID, ProductName from

Products";
command3.CommandText = strCommand3;

// create a third data adapter

// and add the command and map the table
// then fill the dataset from this second adapter
SqlDataAdapter dataAdapter3 = new SqlDataAdapter();
dataAdapter3.SelectCommand = command3;
dataAdapter3.TableMappings.Add("Table", "Products");
dataAdapter3.Fill(dataSet);

// declare the DataRelation and DataColumn objects

System.Data.DataRelation dataRelation;
System.Data.DataColumn dataColumn1;
System.Data.DataColumn dataColumn2;

// set the dataColumns to create the relationship

// between Orders and Order Details on the OrderID key
dataColumn1 =
dataSet.Tables["Orders"].Columns["OrderID"];
dataColumn2 =
dataSet.Tables["Order Details"].Columns["OrderID"];

dataRelation =
new System.Data.DataRelation(
"OrdersToDetails",
dataColumn1,
dataColumn2);

// add the new DataRelation to the dataset

dataSet.Relations.Add(dataRelation);

// reuse the DataColumns and DataRelation objects

// to create the relation between Order Details and
Products
dataColumn1 =
dataSet.Tables["Products"].Columns["ProductID"];
dataColumn2 = dataSet.Tables["Order
Details"].Columns["ProductID"];

dataRelation =
new System.Data.DataRelation(
 "ProductIDToName",
dataColumn1,
dataColumn2);

// add the HistoryToSeverity relationship to the dataset

dataSet.Relations.Add(dataRelation);

return dataSet;
} // end createDataSet

public void OnSelectedIndexChangedHandler(

Object sender, EventArgs e)
{
UpdateDetailsGrid();
}

private void UpdateDetailsGrid()

{

int index = GridView1.SelectedIndex;

if (index != -1)
{
// get the order id from the data grid
DataKey key = GridView1.DataKeys[index];
int orderID = (int)key.Value;
DataView detailsView =
(DataView)Session["detailsView"];
detailsView.RowFilter = "OrderID = " + orderID;
DetailsGridView.DataSource = detailsView;
DetailsGridView.DataBind();
OrderDetailsPanel.Visible = true;
}
else
{
OrderDetailsPanel.Visible = false;
}
}

Añadir datos a mano

Vamos a rellenar un conjunto de datos o una tabla a mano.

Recoger datos de un usuario y guardarlos en una base de datos.

El conjunto de datos es un buen sistema para transportar datos.

Podríamos crear todo, la base de datos, tablas, relaciones con código.

Ejemplo BugTrackerbyhand

Nosotros queremos crear una base de datos con una tabla para guardar los
datos de nuestros clientes interesados.

Diseñamos esta aplicación con validación y comprueba que los datos se

graban correctamente.