Base de datos

M.C. Gerardo Beltrán Gutiérrez
Diplomado de
Especialización en .NET
Modulo 2: Tecnologías de acceso a
datos

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.

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
DataTable
DataRow
DataColumn
Relaciones
RestriccionesEsquema XML
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
Archivo
XML
Objeto
DataSet
ReadXML
WriteXML
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:usersgerardodatos.xsd");
// Guarda ls Datos en formato xml
Datos.WriteXml(@"c:usersgerardodatos.xml");
…
// Recupera el esquema del DataSet
Datos.ReadXmlSchema(@"c:usersgerardodatos.xsd");
// Recupera los Datos en formato xml
Datos.ReadXml(@"c:usersgerardodatos.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"]);
}

– 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++ )
}

• 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++ )
}

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
Tabla Hija
Tabla Padre
DataSet
padreCol
hijaCol
DataRelation

Crea una relación
dsRecursosHumanos.Relations.Add(
"Departamento_Empleados",
dtDepartamentos.Columns["depID"],
dtEmpleados.Columns["empDepto"],
true
);

• Recuperación de datos padre de una relación
dtEmpleados.Columns["empDepto"]
);
for (int i = 0; i < dtEmpleados.Rows.Count; i++) {
// Recupera datos de la relacion
DataRow drDepto =
dtEmpleados.Rows[i].GetParentRow("Departamento_Empleados");
Console.WriteLine("{0} {1} {2} {3}", dtEmpleados.Rows[i]["empID"],
dtEmpleados.Rows[i]["empNombre"],
drDepto["depNombre"]
);
}

• Recuperación de datos hijos de una relación
dtEmpleados.Columns["empDepto"]
);
for (int i = 0; i < dtDepartamentos.Rows.Count; i++)
{
// Muestra los departamentos
Console.WriteLine(" Departamento {0} {1} ",
dtDepartamentos.Rows[i]["depID"],
dtDepartamentos.Rows[i]["depNombre"]);
// 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.

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.

Establecimiento de reglas Descripción
Cascade
Elimina o actualiza las filas
relacionadas.
SetNull
Establece los valores de las filas
relacionadas en DBNull.
SetDefault
Establece los valores de las filas
relacionadas en el valor
predeterminado.
None
No realiza ninguna acción en las filas
relacionadas. Este es el valor
predeterminado.
Estos valores se encuentran en la enumeración Rule

• Crear una Restricción
ForeignKeyConstraint fkEmpleadosDeparatamento =
new ForeignKeyConstraint(
“fkEmpleados_Departamentos",
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
Archivo
XML
Objeto
DataSet
ReadXML
WriteXML
Archivo
XML
Base de
datos
DataAdapter
SQL Server
MySQL
PostgreSQL
Oracle
Access

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
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
//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
// 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
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
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
conexión
– data source
– Provider
– Password
string strCon = @"Data Source=
c:usersgerardoarchdb.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
conexión
– data source
– Provider
– Extended Properties
string strCon = @"Data Source=
c:basededatosarchdb.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)
) ;

string cadenaConexion = @"Data Source=servidordb.net;
Initial catalog=clientes;uid=sa;
pwd=12345678";
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
// 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");

// 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
pwd=12345678";
conexionSql.Open();
// Crea adaptador para tabla cuentas
// Crea comandos insert, update y delete
SqlCommandBuilder cbClientes = new SqlCommandBuilder(daCuentas);

Creando Comandos insert
pwd=12345678";
conexionSql.Open();
// 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
pwd=12345678";
conexionSql.Open();
// Crea comando update
daCuentas.InsertCommand = new SqlCommand(@"update cuentas set
nombre=@nombre, saldo=@saldo where numcta=@numcta", conexionSql);
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"));
new SqlParameter("@saldo", SqlDbType.Decimal, 10, "saldo"));
new SqlParameter("@numcta", SqlDbType.Int, 10, "numcta"));

Creando Comandos Delete
pwd=12345678";
conexionSql.Open();
// Crea comando update
daCuentas.InsertCommand = new SqlCommand(
@"delete from cuentas where numcta=@numcta", conexionSql);
daCuentas.DeleteCommand.Parameters.Add(
new SqlParameter("@numcta", SqlDbType.Int, 10, "numcta"));

Base de datos

Más contenido relacionado

La actualidad más candente

Similar a Base de datos

Base de datos