Diplomado de

Especialización en .NET
Modulo 2: Tecnologías de acceso a
datos

M.C. Gerardo Beltrán Gutiérrez

Introducción ADO .NET
 Definición

• ADO.NET provee un acceso consistente entre

fuentes de datos, como MSSQL, OLEDB, XML, etc.
• ADO.NET provee mecanismos para ejecutar
comandos y obtener los resultados.

• Cada vez es más común codificar información en

XML para pasarla a trabes de conexiones de red.
Este modelo es muy diferente al modelo de la era
cliente/servidor donde se mantenía una conexión
abierta durante la ejecución de un programa.

• ADO.NET fue diseñado para las solucionar las

necesidades de este nuevo modelo, con una
arquitectura desconectada, integración con XML,
representación común de los datos y la posibilidad de
combinar datos de varias fuentes de datos.
 Proveedores de datos

• Un proveedor de datos de .NET es usado para conectarse a una

base de datos, ejecutar comandos y obtener los resultados.

• NET Provee los siguientes proveedores de datos:

– MSSQL Server 7.0 o superior.
– OLEDB
– ODBC
– ORACLE
• Además de estos hay varios otros proveedores de datos para otros
manejadores de bases de datos, como:
– Npgsql para PostgreSQL
– IBM DB2
– SQL Lite
– Sybase
– Firebird e Interbase
– MySQL
– Db4objects
– Etc.
 Proveedores de datos

• Es recomendable utilizar un proveedor de datos

especifico para el manejador de base de datos a
usar si esta está disponible, ya que este
aprovecha completamente las características de
este, mejorando el rendimiento y la funcionalidad
ofrecida.

• La nomenclatura de las clases de ADO.NET es

sencilla. Dependiendo de el proveedor de datos
el nombre de las clases cambia, la nomenclatura
usada es <Proveedor>Nombre de clase.
ADO .NET Modelo
Desconectado
 Definición

ADO.NET permite el acceso desconectado a datos.

En este modelo se llena un DataSet a través de
un DataAdapter.

Cada proveedor de datos debe de brindar su

DataAdapter, el cual debe de ser el encargado
de llenar un DataSet y actualizar la base de
datos según los cambios en el DataSet.

El DataSet es una colección de DataTable, cada

una de ellas contiene DataRow y DataColumn.
 DataSet

DataSet DataTable

DataColumn

DataTable
DataRow

Relaciones
Esquema XML Restricciones

XML
 Clases del Modelo Desconectado

• DataSet

• DataTable

• DataColumn

• DataRow
 Ejemplo

//Crea Dataset
Datos = new DataSet("CuentaBancaria");

//Crea un DataTable
DataTable tablaClientes = new DataTable("clientes");
DataColumn colNumcta = new DataColumn("numcta", typeof(int));
DataColumn colNombre = new DataColumn("nombre", typeof(string));
DataColumn colApellidos = new DataColumn(“apellidos", typeof(string));
/ DataColumn colSaldo = new DataColumn("saldo", typeof(double));
// Crea las columnas para el DataTable
tablaClientes.Columns.Add(colNumcta);
tablaClientes.Columns.Add(colNombre);
tablaClientes.Columns.Add(colApellidos);
tablaClientes.Columns.Add(colSaldo);
// Agrega la Tabla al DataSet
Datos.Tables.Add(tablaClientes);
 Ejemplo…

// Crea nuevo Cliente

DataRow nuevoCliente = Datos.Tables["clientes"].NewRow();

// Asigna datos al nuevo cliente

nuevoCliente["numcta"] = 123;
nuevoCliente["nombre"] = "Claudia";
nuevoCliente[“apellidos"] = "Lopez";
nuevoCliente["saldo"] = 1500.55;

// Agrega nuevo cliente a tabla de clientes

Datos.Tables["clientes"].Rows.Add(nuevoCliente);
 Ejemplo

//Crea Dataset
Datos = new DataSet("CuentaBancaria");
//Crea un DataTable
DataTable tablaClientes = new DataTable("clientes");
// Crea las columnas para el DataTable
tablaClientes.Columns.Add(new DataColumn("numcta", typeof(int)));
tablaClientes.Columns.Add(new DataColumn("nombre", typeof(string)));
tablaClientes.Columns.Add(new DataColumn(“apellidos”, typeof(string)));
tablaClientes.Columns.Add(new DataColumn("saldo", typeof(double)));
// Agrega la Tabla al DataSet
Datos.Tables.Add(tablaClientes);
// Crea nuevo Cliente
DataRow nuevoCliente = Datos.Tables["clientes"].NewRow();
// Asigna datos al nuevo cliente
nuevoCliente["numcta"] = 123;
nuevoCliente["nombre"] = "Claudia";
nuevoCliente[“apellidos"] = “Lopez";
nuevoCliente["saldo"] = 1500.55;
 Propiedades de Columna

• Datatype. Establece el tipo de dato a almacenar, el valor prestablecido

es string

• Unique . Permite la existencia de valores repetidos, el valor

prestablecido es false

• AllowDBNull. Permite que no tenga información la columna, el valor

prestablecido es true.

• Caption. Es el nombre de la columna por default es el valor establecido

en el constructor.

• AutoIncrement. Establece si el campo es de auto incremento, el valor

prestablecido es n.

• AutoIncrementSeed. Establece el valor inicial de la columna, el valor

prestablecido es 0.

• AutoIncrementStep. Establece el incremento para un campo

incremental, el valor prestablecido es 1.
 Columna como llave primaria

• Generalmente, una tabla de base de datos tiene una columna o

grupo de columnas que identifican de manera exclusiva cada fila
de la tabla. Esta columna o grupo de columnas de identificación
se denomina llave primaria.

• Al identificar una única DataColumn como la PrimaryKey para

una DataTable, la tabla establece automáticamente la
propiedad AllowDBNull de la columna como false y la
propiedad Unique como true. Para las llaves primarias de
varias columnas sólo se establece de forma automática la
propiedad AllowDBNull en false.

• La propiedad PrimaryKey de una DataTable recibe como valor

una matriz de uno o varios objetos DataColumn, como se
muestra en los ejemplos siguientes. En el ejemplo se define una
sola columna como llave primaria.

tablaClientes.PrimaryKey = new DataColumn[] {

tablaClientes.Columns["numcta"] };
 Columnas Calculadas

• En ocasiones es necesario contar con columnas

con información generada a partir de otras
columnas.

tablaClientes.Columns["NombreCompleto"].Expression =
"nombre + ‘ ’ + apellidos";
 Serialización XML

WriteXML
Archivo
XML

Objeto
DataSet

ReadXML
Archivo
XML
 Métodos para Serialización XML

• DataSet ofrece manejo directo de documentos y

esquemas XML

– ReadXml(string ArchXML)

– ReadXmlSchema(string ArchXML)

– WriteXml(string ArchXSD)

– WriteXmlSchema(string ArchXSD)
 Ejemplo

Datos = new DataSet();

…
// Guarda el esquema del DataSet
Datos.WriteXmlSchema(@"c:\users\gerardo\datos.xsd");
// Guarda ls Datos en formato xml
Datos.WriteXml(@"c:\users\gerardo\datos.xml");
…
// Recupera el esquema del DataSet
Datos.ReadXmlSchema(@"c:\users\gerardo\datos.xsd");
// Recupera los Datos en formato xml
Datos.ReadXml(@"c:\users\gerardo\datos.xml");
 Eliminación de DataRow

• Delete (). Elimina un DataRow

• Datos.Tables["clientes"].Rows[0].Delete();
 Cambiar un DataRow

Datos.Tables["clientes"].Rows[0][“cuenta”]=890;

Datos.Tables["clientes"].Rows[0][“nombre”]=“Jose”;

Datos.Tables["clientes"].Rows[0][“apellidos”]=“Lopez”;
 Control de Cambios

• Mientras se están realizando cambios en un

conjunto de datos mediante la actualización,
inserción y eliminación de registros, el conjunto
de datos mantiene las versiones original y actual
de los registros.

• Se puede realiza el seguimiento de la propiedad

RowState de cada fila para indicar si los
registros están en su estado original o si se han
modificado, agregado o eliminado.
 Control de Cambios

• Se puede confirmar los cambios llamando al método

AcceptChanges de DataSet, DataTable o DataRow.

• Cada fila de datos contiene información sobre la

propiedad RowState ( Added, Modified, Deleted,
Unchanged).

• Al llamar a AcceptChanges, cualquier objeto

DataRow que aún esté en el modo de edición finaliza
correctamente el proceso de edición. La propiedad
RowState de cada DataRow también cambia; las
filas en estado Added y Modified se convierten en
Unchanged, y se quitan las filas Deleted.
 Control de Cambios

• Al llamar a AcceptChanges, cualquier objeto

DataRow que aún esté en el modo de edición
finaliza correctamente el proceso de edición. La
propiedad RowState de cada DataRow también
cambia; las filas en estado Added y Modified se
convierten en Unchanged, y se quitan las filas
Deleted.

• Al invocar al método RejectChanges se cancelar

cualquier edición, la fila vuelve a sus valores
anteriores y la propiedad RowState permanece
sin cambios.
 Busquedas en DataTable

• Select(). Obtiene una vector de todos los objetos

DataRow

DataRow []info =null;

info = Datos.Tables["clientes"].Select();
if (info != null)
{
for (int i = 0; i < info.Length;i++ )
Console.WriteLine("{0} {1}",info[i]["numcta"], info[i]["nombre"]);
}
 Busquedas en DataTable

– Select (string criterio). Obtiene una vector de

todos los objetos DataRow que coinciden con los
criterios de filtro por orden de clave principal (o si
ésta no existe, por orden de adición).

info = Datos.Tables["clientes"].Select("nombre = 'claudia‘ ");

if (info != null)
{
for (int i = 0; i < info.Length; i++ )
Console.WriteLine("{0} {1}",info[i]["numcta"], info[i]["nombre"]);

}
 Busquedas en DataTable

• Select(string criterio, string ordenar). Obtiene

una matriz de todos los objetos DataRow que
coinciden con los criterios de filtro, en el criterio
de ordenación especificado.

info = Datos.Tables["clientes"]. Select("numcta< 10020", "nombre ASC");

if (info != null)
{
for (int i = 0; i < info.Length; i++ )
Console.WriteLine("{0} {1}",info[i]["numcta"], info[i]["nombre"]);

}
 Buscar un DataRow

• Find(ClavePrincipal) Obtiene la fila especificada

por el valor de clave principal. Obtiene la fila
especificada por el valor de clave principal.

// Busca numcta (Numero de Cuenta )

DataRow reg = Datos.Tables["clientes"].Rows.Find(10038);
if (reg != null)
{
Console.WriteLine("{0} {1}", reg["numcta"], reg["nombre"]);
}
 Ejercicio

Desarrolle una aplicación para el control del acervo bibliográfico de

una biblioteca, tome en cuenta que se tienen libros con préstamo
a domicilio.

El programa debe contar con lo siguiente:

a) Adquirir nuevo libro.

b) Adquirir mas libros de alguno registrado
c) Prestar un libro (si es posible ya que siempre deberá quedar
uno en la biblioteca)
d) Retornar un Libro.
e) Mostar una lista de libros con la existencia disponible

Agregue al programa la posibilidad de recuperar y guardar la

información de los libros en algún archivo.
 Ejercicio

• Desarrolle una programa que mantenga el control de los

empleados de una empresa tomando en cuenta que se
tienen los datos personales del empleado (código,
nombre, apellidos), una relación de los nombres de los
distintos departamentos, así como otra relación de los
puestos existentes con su respectivo sueldo.

• No olvide que cada empleado pertenece a un

departamento y cuenta con un puesto.

• El programa debe agregar nuevos empleados,

departamentos o puestos, además de emitir un listado de
los empleados registrados y aunado a de los reportes de
los distintos departamentos y puestos.

• Es importante que los datos sean almacenados y

recuperados de un archivo.
 Relaciones en DataSet

padreCol DataRelation
Tabla Padre

hijaCol
Tabla Hija

DataSet
 Relaciones en DataSet

Crea una relación

dsRecursosHumanos.Relations.Add(
"Departamento_Empleados",
dtDepartamentos.Columns["depID"],
dtEmpleados.Columns["empDepto"],
true
);
 Relaciones en DataSet

• Recuperación de datos padre de una relación

for (int i = 0; i < dtEmpleados.Rows.Count; i++) {

dsRecursosHumanos.Relations.Add(
// Recupera datos de la relacion"Departamento_Empleados",
DataRow drDepto = dtDepartamentos.Columns["depID"],
dtEmpleados.Columns["empDepto"]
dtEmpleados.Rows[i].GetParentRow("Departamento_Empleados");
);
Console.WriteLine("{0} {1} {2} {3}", dtEmpleados.Rows[i]["empID"],
dtEmpleados.Rows[i]["empNombre"],
drDepto["depNombre"]
);
}
 Relaciones en DataSet

• Recuperación de datos hijos de una relación

for (int i = 0; i < dtDepartamentos.Rows.Count; i++)
{
// Muestra los departamentos
dsRecursosHumanos.Relations.Add(
Console.WriteLine(" Departamento {0} {1} ",
"Departamento_Empleados",
dtDepartamentos.Rows[i]["depID"],
dtDepartamentos.Columns["depID"],
dtDepartamentos.Rows[i]["depNombre"]);
dtEmpleados.Columns["empDepto"]
// Recupera Datos de empleados del departamento
);
DataRow[] drEmpleados = dtDepartamentos.
Rows[i].GetChildRows("Departamento_Empleados");
// Muestra los empleados del departamento
foreach (DataRow emp in drEmpleados ){
Console.WriteLine("{0} {1} {2}",emp["empID"],
emp["empNombre"],
emp["empApellidos"]);
}
 Actualización y eliminación en cascada

• Al establecer una relación entre tablas se

establece restricciones que al hacer
actualizaciones o eliminaciones en la tabla padre
se aplican en cascada a la tabla hija.
 Ejercicio

• Del Ejercicio anterior emita un reporte de los

empleados por departamento y de los
empleados por puesto, así como eliminar
empleados, departamento o puesto.
 Restricciones en DataSet

• Se pueden utilizar restricciones con el fin de

mantener la integridad de los datos. Una restricción
es una regla automática que se aplica a una columna
relacionada, que determina cómo proceder cuando
se modifica de alguna manera el valor de una fila.

• Existen dos tipos de restricciones en ADO.NET:

ForeignKeyConstraint y UniqueConstraint. De
forma predeterminada, las dos restricciones se crean
automáticamente al crear una relación entre dos o
más tablas agregando DataRelation al DataSet. Sin
embargo, se puede deshabilitar este comportamiento
especificando false en el tercer parámetro al crear la
relación.
 Restricciones en DataSet

ForeignKeyConstraint
• Esta regla establece cómo se propagan las
actualizaciones y eliminaciones a las tablas relacionadas.
Por ejemplo, si se actualiza o elimina el valor de una fila
de una tabla y el mismo valor también se utiliza en una o
varias tablas relacionadas, ForeignKeyConstraint
determinará qué sucede en las tablas relacionadas.

• Las restricciones se aplican cuando la propiedad

System.Data.DataSet.EnforceConstraints del DataSet es
true

• Las propiedades DeleteRule y UpdateRule de

ForeignKeyConstraint definen la acción que se ha de
realizar cuando el usuario intente eliminar o actualizar una
fila en una tabla relacionada.
 Restricciones en DataSet

Establecimiento de reglas Descripción

Elimina o actualiza las filas
Cascade
relacionadas.
Establece los valores de las filas
SetNull
relacionadas en DBNull.
Establece los valores de las filas
SetDefault relacionadas en el valor
predeterminado.
No realiza ninguna acción en las filas
None relacionadas. Este es el valor
predeterminado.

Estos valores se encuentran en la enumeración Rule

 Restricciones en DataSet

• Crear una Restricción

ForeignKeyConstraint fkEmpleadosDeparatamento =
new ForeignKeyConstraint(
“fkEmpleados_Departamentos",
dtDepartamentos.Columns["depID"],
dtEmpleados.Columns["empDepto"]);

fkEmpleadosDeparatamento.DeleteRule = Rule.None;
fkEmpleadosDeparatamento.UpdateRule = Rule.Cascade;

dtEmpleados.Constraints.Add(fkEmpleadosDepartamento);
 Ejercicio

• Complemente el Ejercicio anterior permitiendo

realizar actualizaciones a las claves y nombres
de departamento así como a las claves, nombres
de puesto y sueldo.
 Ejercicio

• Al ejercicio Biblioteca agregue la posibilidad de

mantener un catalogo de usuarios, los cuales
deberán esta relacionados con los prestamos
realizados.

• Debiendo además contar con las opciones de

suspender usuario, activar y eliminar usuario
siempre y cuando no cuente con libros
prestados.
 Fuentes de datos

WriteXML
Archivo
DataAdapter XML

Objeto
Base de
DataSet
datos

SQL Server
MySQL
PostgreSQL
Oracle ReadXML
Access Archivo
XML
 Acceso base de datos de SQL Server

• Utilizar espacios de nombre

– System.Data.SqlClient
– System.Data.SqlTypes
 Crear una conexión con SQL Server

• Uso de SqlConnection

Establecer los parámetros de la cadena de

conexión
– data source
– initial catalog
– uid
– pwd
string strCon = @“Data Source = miservidor.net;
Initial Catalog=inventario; UID=userdb; PWD=123;";
SqlConnection conexion = new SqlConnection(strCon);
conexion.Open();
 Crear una conexión con SQL Server

• Otro uso de SqlConnection

Establecer los parámetros de la cadena de

conexión
– Server
– DataBase
– uid
– pwd
string strCon =
@“Server=miservidor.net;
DataBase=clientes; UID=userdb; PWD=123;";
SqlConnection conexion = new SqlConnection(strCon);
conexion.Open();
 Creación de Base de Datos y tablas en SQL
Server

• CREATE DATABASE clientes;

• USE clientes;

• CREATE TABLE cuentas (numcta INT PRIMARY

KEY IDENTITY(1,1), nombre VARCHAR(40),
saldo DECIMAL);
 DataSet con inserción en SQL Server

//Define cadena de conexión

string cadenaConexion = @"server=db.gerardobeltran.net;
DataBase=clientes;uid=techsoft;
pwd=12AB34cd";
// Establece Objeto de Conexión
SqlConnection conexionSql = new SqlConnection(cadenaConexion);
//Abre Conexión con el servidor
conexionSql .Open();
// Crea objeto de Comando Select
SqlCommand comandoSelect = conexionSql.CreateCommand();
//Define Tipo de Instruccion a ejecutar (SQL)
comandoSelect.CommandType = CommandType.Text;
// Define Cadena Sql de consulta
string cadenaSql = @"SELECT * FROM cuentas";
// Establece cadena Sql para el comando Select
comandoSelect.CommandText = cadenaSql;
 DataSet con inserción en SQL Server

// Crea objeto adaptador de datos

SqlDataAdapter daClientes = new SqlDataAdapter(comandoSelect);
// Crea Comando de construccion de intrucciones SQL
SqlCommandBuilder cbClientes = new SqlCommandBuilder(daClientes);
// Crea Data ser para contener los datos de la consulta
DataSet dsClientes = new DataSet("Clientes");
// Obtiene el esquema de la tabla cuentas desde el servidor
daClientes.FillSchema(dsClientes, SchemaType.Source, "Cuentas");
// Obtiene los datos de la tabla cuentas desde el servidor
daClientes.Fill(dsClientes, "Cuentas");
// Crea una instancia de una nuevo registro
DataRow drCliente = dsClientes.Tables["Cuentas"].NewRow();
// Captura los nuevos datos
Console.Write("Nombre: "); drCliente["nombre"] = Console.ReadLine();
Console.Write("Saldo: ");drCliente["saldo"] =
Convert.ToDouble(Console.ReadLine());
 DataSet insertando en SQL Server

// Agrega el nuevo registro la tabla del DataSet

dsClientes.Tables["Cuentas"].Rows.Add(drCliente);
Console.WriteLine("El numero de cuenta asignado es: {0}",
drCliente["numcta"]);
Envia los datos al servidor SQL
daClientes.Update(dsClientes, "Cuentas");
// Libera el DataSet
daClientes.Dispose();
//Libera el adaptador de datos
daClientes.Dispose();
// Cierra la conexion con el servidor
conexionSql.Close();
 DataSet seleccionando desde SQL Server

//Define cadena de conexión

string cadenaConexion = @"server=db.gerardobeltran.net;
DataBase=clientes;uid=techsoft;
pwd=12AB34cd";
// Establece Objeto de Conexión
SqlConnection conexionSql = new SqlConnection(cadenaConexion);
//Abre Conexión con el servidor
conexionSql .Open();
// Crea objeto de Comando Select
SqlCommand comandoSelect = conexionSql.CreateCommand();
//Define Tipo de Instruccion a ejecutar (SQL)
comandoSelect.CommandType = CommandType.Text;
// Define Cadena Sql de consulta
string cadenaSql = @"SELECT * FROM cuentas";
// Establece cadena Sql para el comando Select
comandoSelect.CommandText = cadenaSql;= cadenaSql;
 DataSet seleccionando desde SQL Server

// Crea objeto adaptador de datos

SqlDataAdapter daClientes = new SqlDataAdapter(comandoSelect);
// Crea Comando de construccion de intrucciones SQL
SqlCommandBuilder cbClientes= new SqlCommandBuilder(daClientes);
// Crea Data ser para contener los datos de la consulta
DataSet dsClientes = new DataSet("Clientes");
// Obtiene el esquema de la tabla cuentas desde el servidor
daClientes.FillSchema(dsClientes, SchemaType.Source, "Cuentas");
// Obtiene los datos de la tabla cuentas desde el servidor
daClientes.Fill(dsClientes, "Cuentas");
// Crea una instancia del DataTable Clientes
DataTable dtClientes = dsClientes.Tables["Cuentas"];
for (int i=0; i<dtClientes.Rows.Count; i++){
Console.WriteLine("{0} {1} {2}", dtClientes.Rows[i]["numcta"],
dtClientes.Rows[i]["nombre"], dtClientes.Rows[i]["saldo"]);
}
 Acceso base de datos de MySql

• Instalar Proveedor de acceso a datos de Mysql.

– Descargar de www.mysql.com

• Agregar referencia a biblioteca de MySql en

Visual Studio desde la pestaña .NET

• Utilizar espacios de nombre

– MySql.Data.MySqlClient
– MySql.Data.Types
– MySql.Data.Common
 Crear una conexión con MySQL

• Uso de MySqlConnection

Establecer los parámetros de la cadena de

conexión
– Server
– DataBase
– uid
– pwd
string strCon =
@"server=miservidor.net;
DataBase=clientes;uid=userdb; pwd=123;";
MySqlConnection conexion = new MySqlConnection(strCon);
conexion.Open();
 Crear una conexión con MySQL

• Otro uso de MySqlConnection

Establecer los parámetros de la cadena de

conexión
– data source
– initial catalog
– uid
– pwd
string strCon = @"data source = miservidor.net;
initial catalog=inventario; uid=userdb; pwd=123;";
MySqlConnection conexion = new MySqlConnection(strCon);
conexion.Open();
 Creación de Base de Datos y tablas en
MySQL

• CREATE DATABASE clientes;

• USE clientes;

• CREATE TABLE cuentas (numcta INT PRIMARY

KEY AUTO_INCREMENT, nombre
VARCHAR(40), saldo DECIMAL);
 Acceso a Productos de Office

• Para el caso de acceso a productos (Access y

Excel) de Office 2007 y 2010, se requiere de
proveedores actualizados por lo que es
necesario descargarlos gratuitos de
http://www.microsoft.com/es-
es/download/details.aspx?id=13255

• El espacio de nombres requerido son:

– System.Data.OleDb;
 Crear una conexión con ACCESS

• Uso de OleDbConnection
Establecer los parámetros de la cadena de
conexión
– data source
– Provider
– Password

string strCon = @"Data Source=

c:\users\gerardo\archdb.accdb;
Provider=Microsoft.ACE.OLEDB.12.0;
Jet OLEDB:Database Password=123;";
OleDbConnection conexion = new OleDbConnection(strCon);
conexion.Open();
 Crear una conexión con EXCEL

• Uso de OleDbConnection
Establecer los parámetros de la cadena de
conexión
– data source
– Provider
– Extended Properties

string strCon = @"Data Source=

c:\basededatos\archdb.xlsx;
Provider=Microsoft.ACE.OLEDB.12.0;
Extended Properties=Excel 12.0;";
OleDbConnection conexion = new OleDbConnection(strCon);
conexion.Open();
 Relaciones entre tablas

En SQL Server
create table cuentas (
numcta int IDENTITY(100,1) PRIMARY KEY,
nombre varchar(40)
);

create table movimientos (

nummov int identity(1000,1) PRIMARY KEY,
tipo int,
cantidad decimal ,
movcta int references cuentas(numcta)
);
 Relaciones entre tablas

string cadenaConexion = @"Data Source=servidordb.net;

Initial catalog=clientes;uid=sa;
pwd=12345678";

SqlConnection conexionSql = new SqlConnection(cadenaConexion);

conexionSql.Open();
// Crea adaptador para cada tabla
SqlDataAdapter daCuentas =
new SqlDataAdapter(@"SELECT * FROM cuentas",conexionSql);
SqlDataAdapter daMovimientos =
new SqlDataAdapter(@"SELECT * FROM movimientos", conexionSql);

// Crea DataSet
DataSet dsClientes = new DataSet("Clientes");
// Recupera información de la tabla cuentas desde la base de datos
daCuentas.FillSchema(dsClientes, SchemaType.Source, "Cuentas");
daCuentas.Fill(dsClientes, "Cuentas");

// Recupera información de la tabla movimientos desde la base de datos

daMovimientos.FillSchema(dsClientes, SchemaType.Source, "Movimientos");
daMovimientos.Fill(dsClientes, "Movimientos");
 Relaciones entre tablas

// Agrega Una relacion Cliente-Movimientos

dsClientes.Relations.Add("Cliente_Movimientos",
dsClientes.Tables["cuentas"].Columns["numcta"],
dsClientes.Tables["movimientos"].Columns["movcta"]
false);
// Crea una instancia para cada tabla
DataTable dtClientes = dsClientes.Tables["Cuentas"];
DataTable dtMovimientos = dsClientes.Tables["Movimientos"];
// Muestra los clientes con sus movimientos
for (int i = 0; i < dtClientes.Rows.Count; i++){

Console.WriteLine("{0} {1} {2}", dtClientes.Rows[i]["numcta"],

dtClientes.Rows[i]["nombre"]);
DataRow[] Movs = dtClientes.Rows[i].GetChildRows("Cliente_Movimientos");

foreach (DataRow reg in Movs){

Console.WriteLine("{0} {1} {2}", reg["nummov"],
Convert.ToInt32(reg["tipo"]) == 1) ? "Deposito" : "Retiro",
reg["cantidad"]);
}
}
 Creando Comandos insert, update y delete
con ComandBuilder
string cadenaConexion = @"Data Source=servidordb.net;
Initial catalog=clientes;uid=sa;
pwd=12345678";

SqlConnection conexionSql = new SqlConnection(cadenaConexion);

conexionSql.Open();

// Crea adaptador para tabla cuentas

SqlDataAdapter daCuentas =
new SqlDataAdapter(@"SELECT * FROM cuentas",conexionSql);

// Crea comandos insert, update y delete

SqlCommandBuilder cbClientes = new SqlCommandBuilder(daCuentas);
 Creando Comandos insert

string cadenaConexion = @"Data Source=servidordb.net;

Initial catalog=clientes;uid=sa;
pwd=12345678";

SqlConnection conexionSql = new SqlConnection(cadenaConexion);

conexionSql.Open();
// Crea adaptador para tabla cuentas
SqlDataAdapter daCuentas =
new SqlDataAdapter(@"SELECT * FROM cuentas",conexionSql);

// Crea comando insert

daCuentas.InsertCommand = new SqlCommand(@"insert into cuentas
(nombre, saldo) values (@nombre, @saldo)",conexionSql);

// Define parametros con el nombre de la columnas

daCuentas.InsertCommand.Parameters.Add(
new SqlParameter("@nombre", SqlDbType.VarChar,40, "nombre"));
daCuentas.InsertCommand.Parameters.Add(
new SqlParameter("@saldo", SqlDbType.Decimal,10, "saldo"));
 Creando Comandos Update

string cadenaConexion = @"Data Source=servidordb.net;

Initial catalog=clientes;uid=sa;
pwd=12345678";

SqlConnection conexionSql = new SqlConnection(cadenaConexion);

conexionSql.Open();
// Crea adaptador para tabla cuentas
SqlDataAdapter daCuentas =
new SqlDataAdapter(@"SELECT * FROM cuentas",conexionSql);

// Crea comando update

daCuentas.InsertCommand = new SqlCommand(@"update cuentas set
nombre=@nombre, saldo=@saldo where numcta=@numcta", conexionSql);

// Define parametros con el nombre de la columnas

daCuentas.UpdateCommand = new SqlCommand(@"update cuentas set
nombre=@nombre, saldo=@saldo where numcta=@numcta", conexionSql);
daCuentas.UpdateCommand.Parameters.Add(
new SqlParameter("@nombre", SqlDbType.VarChar, 40, "nombre"));
daCuentas.UpdateCommand.Parameters.Add(
new SqlParameter("@saldo", SqlDbType.Decimal, 10, "saldo"));
daCuentas.UpdateCommand.Parameters.Add(
new SqlParameter("@numcta", SqlDbType.Int, 10, "numcta"));
 Creando Comandos Delete

string cadenaConexion = @"Data Source=servidordb.net;

Initial catalog=clientes;uid=sa;
pwd=12345678";

SqlConnection conexionSql = new SqlConnection(cadenaConexion);

conexionSql.Open();
// Crea adaptador para tabla cuentas
SqlDataAdapter daCuentas =
new SqlDataAdapter(@"SELECT * FROM cuentas",conexionSql);

// Crea comando update

daCuentas.InsertCommand = new SqlCommand(
@"delete from cuentas where numcta=@numcta", conexionSql);

// Define parametros con el nombre de la columnas

daCuentas.DeleteCommand.Parameters.Add(
new SqlParameter("@numcta", SqlDbType.Int, 10, "numcta"));