0% encontró este documento útil (0 votos)
94 vistas95 páginas

Ing. Wiler Arturo Ponce Benites 2017

Descargar como pdf o txt
Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1/ 95

Ing.

Wiler Arturo Ponce Benites


2017
ADO.NET 4.6
CONTENIDO
Script de la base de datos de origen
Diagrama de base de datos: Contrato
Introducción a ADO.NET 4.6
Novedades de ADO.NET 4.6
Arquitectura de ADO.NET 4.6
Componente de ADO.NET
Proveedores de datos
Objetos principales de los proveedores de datos
Espacio de nombres System.Data.SqlClient
Espacio de nombre System.Data
Clase SqlConnection
Definición de la cadena de conexión
Clase SqlAdapter
Configuration Manager
Clase DataSet
Clase DataTable
Clase DataView
Instrucción Using
Clase SqlCommand
Casos desarrollados
Problema:
Implementar una aplicación Windows Forms que permita el mantenimiento de la tabla
Equipo.
Se debe tener en cuenta lo siguiente:
Implementar en SQL Server procedimientos almacenados que permitan listar, insertar,
modificar y eliminar registros de la tabla Equipo, además de implementar
procedimientos almacenados que permitan listar los datos de los tipos y estados de los
equipos.
Configurar la cadena de conexión en el archivo App.config.
Crear la clase Conexión e implementar el método getConecta, el cual permita asociarse
a la cadena de conexión especificada en app.config.
Crear la clase LogicaNegocio e implementar los métodos necesarios para asociarse a
todos los procedimientos almacenados necesarios para el mantenimiento de registros
de la tabla Equipo.
Usar un control ToolStrip para las opciones que permita el mantenimiento de registro
de equipos.
frmMantenimientoEquipo.cs[Design]
Script de la base de datos de origen

/* CREACION DE LA BASE DE DATOS */


USE master
GO

CREATE DATABASE CONTRATO


ON PRIMARY (
NAME=CONTRATO,
FILENAME='H:\BaseDatos\Contrato\BDatos\CONTRATO.mdf',
SIZE=3MB,
MAXSIZE=unlimited,
FILEGROWTH=3% )
LOG ON (
NAME=CONTRATO_log,
FILENAME='H:\BaseDatos\Contrato\BDatos\CONTRATO_log.ldf',
SIZE=3MB,
MAXSIZE=unlimited,
FILEGROWTH=1% )
GO
/* CREACION DE TABLAS */

USE CONTRATO
CREATE TABLE ESTADO_EQUIPO
GO
(
COD_EST CHAR(6) NOT NULL,
CREATE TABLE EQUIPO DES_EST VARCHAR(100)
( )
IDE_EQU CHAR(6) NOT NULL, GO
COD_TIP_EQU CHAR(6) NOT NULL,
DESC_EQU VARCHAR(50) NOT NULL,
CREATE TABLE TIPO_EQUIPO
PRE_EQU MONEY NULL,
(
COD_EST CHAR(6) NULL
COD_TIP_EQU CHAR(6) NOT NULL,
)
DES_TIP VARCHAR(100) NOT NULL
GO
)
GO
Script de creación de la Primary Key de las tablas: EQUIPO, TIPO_EQUIPO y ESTADO_EQUIPO
ALTER TABLE EQUIPO ADD PRIMARY KEY (IDE_EQU)
GO

ALTER TABLE ESTADO_EQUIPO ADD PRIMARY KEY (COD_EST)


GO

ALTER TABLE TIPO_EQUIPO ADD PRIMARY KEY (COD_TIP_EQU)


GO

Script de creación de la Foreign Key de las tablas: EQUIPO, TIPO_EQUIPO y ESTADO_EQUIPO y


establecer las relaciones entre ellas
ALTER TABLE EQUIPO
ADD FOREIGN KEY (COD_TIP_EQU)
REFERENCES TIPO_EQUIPO

ALTER TABLE EQUIPO


ADD FOREIGN KEY (COD_EST)
REFERENCES ESTADO_EQUIPO

GO
Diagrama de base de datos: Contrato
Script ingreso de datos en las tablas:
EQUIPO, TIPO_EQUIPO y ESTADO_EQUIPO

-- REGISTROS DE LA TABLA: TIPO DE EQUIPO


INSERT INTO TIPO_EQUIPO VALUES
('TIP001','MONITOR'),
('TIP002','MOUSE'),
('TIP003','PARLANTES'),
('TIP004','TECLADO'),
('TIP005','CPU'), -- REGISTROS DE LA TABLA: ESTADO EQUIPO
('TIP006','LAPTOP'), INSERT INTO ESTADO_EQUIPO VALUES
('TIP007','AUDIFONOS'), ('0','DISPONIBLE'),
('TIP008','PROYECTOR'), ('1','OCUPADO')
('TIP009','IMPRESORA'), GO
('TIP010','FOTOCOPIADORA')
GO
-- REGISTROS DE LA TABLA: EQUIPO
INSERT INTO EQUIPO VALUES
('EQ0001','TIP001','MONITOR DELL 1717F',200,'0'),
('EQ0002','TIP002','MOUSE HP', 15, '0'),
('EQ0003','TIP003','PARLANTES', 50, '1'),
('EQ0004','TIP004','TECLADO GENIUS', 40, '0'),
('EQ0005','TIP005','CPU ASUS', 250,'0'),
('EQ0006','TIP006','LAPTOP TOSHIBA', 800,'1'),
('EQ0007','TIP007','AUDIFONOS SONNY', 30, '0'),
('EQ0008','TIP008','PROYECTOR CANON', 500,'1'),
('EQ0009','TIP009','IMPRESORA EPSON', 200,'0'),
('EQ0010','TIP010','FOTOCOPIADORA RICOH',750,'0')
GO
Procedimientos almacenados
2.6.- Script para los procedimientos almacenados
-- Procedimiento: Lista EQUIPOS
IF OBJECT_ID('SP_LISTAEQUIPOS') IS NOT NULL
DROP PROC SP_LISTAEQUIPOS
PRINT 'PROC SP_LISTAEQUIPOS, HA SIDO PROCESADO'
GO
CREATE PROC SP_LISTAEQUIPOS
AS
SELECT
E.IDE_EQU AS CODIGO,
E.DESC_EQU AS DESCRIPCION,
T.DES_TIP AS TIPO,
E.PRE_EQU AS PRECIO,
ES.DES_EST AS ESTADO
FROM EQUIPO E
JOIN TIPO_EQUIPO T ON E.COD_TIP_EQU = T.COD_TIP_EQU
JOIN ESTADO_EQUIPO ES ON E.COD_EST=ES.COD_EST
GO
-- Procedimiento: Lista tipo EQUIPOS
IF OBJECT_ID('SP_LISTATIPOEQUIPOS') IS NOT NULL
DROP PROC SP_LISTATIPOEQUIPOS
PRINT 'PROC SP_LISTATIPOEQUIPOS, HA SIDO PROCESADO'
GO

CREATE PROC SP_LISTATIPOEQUIPOS


AS
SELECT
T.COD_TIP_EQU AS CODIGO,
T.DES_TIP AS TIPO
FROM TIPO_EQUIPO T
GO
-- Procedimiento: Lista ESTADOS
IF OBJECT_ID('SP_LISTAESTADOS') IS NOT NULL
DROP PROC SP_LISTAESTADOS
PRINT 'PROC SP_LISTAESTADOS, HA SIDO
PROCESADO'
GO

CREATE PROC SP_LISTAESTADOS


AS
SELECT
ES.COD_EST AS CODIGO,
ES.DES_EST AS ESTADO
FROM ESTADO_EQUIPO ES
GO
-- Procedimiento: Obtención del Código del último registro
-- de la tabla EQUIPO

IF OBJECT_ID('SP_ULTIMOEQUIPO') IS NOT NULL


DROP PROC SP_ULTIMOEQUIPO
PRINT 'PROC SP_ULTIMOEQUIPO, HA SIDO PROCESADO'
GO
CREATE PROC SP_ULTIMOEQUIPO
AS
SELECT TOP 1
E.IDE_EQU AS CODIGO
FROM EQUIPO E
ORDER BY 1 DESC
GO
-- Procedimiento: Ingreso de registros en la tabla EQUIPO

IF OBJECT_ID('SP_NUEVOEQUIPO') IS NOT NULL


DROP PROC SP_NUEVOEQUIPO
PRINT 'PROC SP_NUEVOEQUIPO, HA SIDO PROCESADO'
GO

CREATE PROC SP_NUEVOEQUIPO


(
@COD CHAR(6), @TIP CHAR(6), @DES VARCHAR(40), @PRE MONEY, @EST INT
)
AS
INSERT INTO EQUIPO VALUES(@COD, @TIP, @DES, @PRE, @EST)
GO
-- Procedimiento: Actualización de campos en registros en la tabla EQUIPO
IF OBJECT_ID('SP_ACTUALIZAEQUIPO') IS NOT NULL
DROP PROC SP_ACTUALIZAEQUIPO
PRINT 'PROC SP_ACTUALIZAEQUIPO, HA SIDO PROCESADO'
GO

CREATE PROC SP_ACTUALIZAEQUIPO


(
@COD CHAR(6), @TIP CHAR(6), @DES VARCHAR(40), @PRE MONEY, @EST INT
)
AS
UPDATE EQUIPO SET
COD_TIP_EQU = @TIP,
DESC_EQU = @DES,
PRE_EQU = @PRE,
COD_EST = @EST
WHERE IDE_EQU = @COD
GO
-- Procedimiento: Eliminación de registros en la tabla EQUIPO

IF OBJECT_ID('SP_ELIMINAEQUIPO') IS NOT NULL


DROP PROC SP_ELIMINAEQUIPO
PRINT 'PROC SP_ELIMINAEQUIPO, HA SIDO PROCESADO'
GO

CREATE PROC SP_ELIMINAEQUIPO


(
@COD CHAR(6)
)
AS
DELETE EQUIPO WHERE IDE_EQU = @COD

GO
frmMantenimientoEquipo.cs[Design]
Introducción a ADO.NET

ADO.NET (ActiveX Data Objets) representa un conjunto de


objetos de acceso a datos, que ofrecen servicios de
conectividad para aplicaciones de desarrollo en Visual C#.
Asimismo, constituye una parte integral del Framework, ya que
proporciona acceso a datos relacionados y de aplicaciones.
ADO.NET permite tener acceso sencillo y confiable a orígenes
de datos como SQL Server, así como a orígenes de datos
expuestos mediante OLE DB y ODBC.
Es a partir de esto que se puede tener acceso a casi todos los
sistemas de gestión de base de datos, como: ORACLE, ACCESS y
EXCEL.
Las aplicaciones de desarrollo que necesitan mostrar
información de dichos gestores pueden utilizar las clases
ADO.NET para conectar estos orígenes y así permitir recuperar,
registrar, modificar o eliminar dicha información.
Observe como se usan las clases para ADO.NET con el fin de
listar información donde un gestor de base de datos como SQL
Server.

Observe como se usan las clases para ADO.NET con el objetivo


de manipular la información (registrar, modificar o eliminar)
desde un gestor de base de datos como SQL Server.
Novedades de ADO.NET 4.6
ADO.NET ahora es compatible con la característica Always Encrypted disponible en SQL
Server 2016. Con Always Encrypted, SQL Server puede realizar operaciones en los datos
cifrados y lo mejor de todo, es que la clave de cifrado reside junto con la aplicación, en el
entorno de confianza del cliente y no en el servidor.

Always Encrypted protege los datos de la máquina cliente para que los administradores de
bases de datos no tengan acceso a los datos de texto sin formato. El cifrado y descifrado da
datos ocurre de forma transparente en el nivel de controlador, lo que minimiza los cambios
que debe realizarse en las aplicaciones existentes.

La característica principal de Always Encrypted está basada en tecnología de Microsoft


Research y ayuda a proteger los datos en reposo y en movimiento. Al utilizar Always
Encrypted, SQL Server puede desempeñar operaciones de datos encriptados y lo principal es
que la llave de encriptación reside en la aplicación en el ambiente de confianza de la
maquina cliente.
Arquitectura de ADO.NET
ADO.NET aprovecha al máximo la eficacia de los archivos
de tipo XML para proporcionar un excelente acceso a
datos sin mantener una conexión a la base de datos
abierta.
Ambas tecnologías convergen en el objeto DataSet, el
cual obtiene información proveniente del archivo XML
dejando de lado el proveedor de datos y concentrado
más en la información que se presenta al cliente.
Así mismo, se debe tener en cuenta que los
componentes de ADO.NET están diseñados para separar
el acceso a datos de la manipulación de la información.
Es decir, existe una clase especializada para la conexión
al servidor y otras para la administración de la
información.
Componentes de ADO.NET
Los componentes de ADO.NET ha sido diseñados para acceder a la base de datos del servidor, así como
manipular la información contenida en dicha base de datos.
Entonces los componentes son:

Proveedores de datos
Los cuales proporcionan clases especializadas para el acceso y manipulación de la información
desde una base de datos.
Se tiene las clases: SqlConnection, SqlCommand, SqlDataAdapter y DataReader.

DataSet
El cual recibe el modelo relacional de la base de datos, desconectándose así de la base de datos y
manteniendo información en memoria.
Proveedores de datos

Los proveedores de datos .NET Framework sirven para Framework Descripción


conectarse a una determinada base de datos, que podría SQL Server Proporciona acceso a datos SQL Server de cualquier versión. Se usa el
espacio de trabajo:
ser SQL Server, Oracle, etc., y permiten ejecutar System.Data.SqlClient
comandos y recuperar resultados. OLE DB Proporciona acceso a datos para orígenes de tipo OLE DB, como un archivo
de texto y un correo electronico. Se usa el espacio de trabajo:
System.Data.OleDb
Asimismo, son considerados ligeros, de manera que ODBC Proporciona acceso a datos que se exponen mediante ODBC como el
crean un nivel mínimo entre el origen de datos y el mismo SQL Server, Oracle, FoxPro y Access. Se usa el espacio de trabajo
System.Data.Odbc
código, con lo que aumenta el rendimiento sin sacrificar ORACLE Proporciona acceso a orígenes de datos Oracle. Se usa el espacio de trabajo
funcionalidad.
System.Data.OracleClient
EntityClient Proporciona acceso a datos para las aplicaciones de Entity Data Model
Los principales proveedores son: (EDM). Se usa el espacio de trabajo
System.Data.EntityClient
SQL Server, OLE DB, ODBC, Oracle y EntityClient
Objetos principales de los proveedores de datos

Existen cuatro clases, las que componen un entorno de desarrollo a nivel cliente-servidor.
Cada una de estas clases, tiene un objetivo especifico dentro de este desarrollo.
➢ Objeto Connection
➢ Objeto DataAdapter
➢ Objeto Command
➢ Objeto DataReader: Transaction, Parameter y Exception.

Objeto Establece una conexión a un origen de datos determinado.


Connection Observe el objeto de la clase SQLConnection, que permita conectarse a una base
de datos en Sql Server

SqlConnection cn =
new SqlConnection(ConfigurationManager.ConnectionStrings["cn"].ConnectionString);
Objeto Llena un DataSet o DataTable y realiza las actualizaciones
necesarias en el origen de datos.
DataAdapter Observe el código que permite llenar un DataSet desde una
conexión activa
SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM CLIENTE", cn);
DataTable dt = new DataTable();
da.Fill(dt);
SqlDataAdapter da = new SqlDataAdapter("SP_LISTAFICHADEVOLUCION", cn);
DataTable dt = new DataTable();
da.Fill(dt);
SqlDataAdapter da = new SqlDataAdapter("Instrucción SQL", cn);
DataTable dt = new DataTable();
da.Fill(dt);
Objeto Ejecuta un comando en un origen de datos. Es a partir de este
Command que se puede obtener resultados escalados, insersiones,
actualizaciones o eliminaciones de registros.

Observe el código para agregar un nuevo registro de cliente


sin especificación de parámetros.
SqlCommand cmd = new SqlCommand("Instrucción SQL", cn);
cmd.ExecuteNonQuery();
Lee un flujo de datos de solo avance y solo lectura desde un
origen de datos.
Esto permitirá llenar controles como cuadros combinados o listas
desde una conexión activa.
Observe el código sobre cómo llenar un cuadro combinado desde
la tabla Cliente.
Objeto
DataReader SqlCommand cmd = new SqlCommand("SELECT * FROM CLIENTE", cn);
cn.Open();
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read());
{
cboCliente.Items.Add(dr[1]);
}
ADO.NET adiciona clases a los cuatro anteriores solo como un control de
datos mucho más especializado, ya que el proveedor de datos así lo permite:
Transaction, Parameter y Exception.
❖Transaction Incluye comandos en las transacciones que se realizan en el origen
de datos. Desde aquí se puede controlar la información que genera
los procesos y así poder asegurar la información, así como anularla.
❖Parameter Define los parámetros de entrada, salida y valores devueltos para los
comandos y los procedimientos almacenados. Desde aquí se puede
enviar los parámetros que se necesitan para el registro, la
actualización o la eliminación de datos
❖Exception Se devuelve cuando se detecta un error en el origen de datos. En caso
de que el error se detecte en el cliente, los proveedores de datos .NET
Framework generan una excepción de .NET framework. La clase base
para todos los objetos Exception es DbException.
Espacio de nombres System.Data.SqlClient
Describe una colección de clases que se utiliza para obtener acceso a una base de datos de SQL Server
en el espacio administrado. Observe las principales clases que componen el espacio de trabajo:

SqlCommand
Representa un procedimiento almacenado o una instrucción de Transact-SQL que se ejecuta en una base de datos SQL
Server como una sentencia escalada: inserción, actualización o eliminación.
SqlCommandBuilder
representa un procedimiento almacenado o una instrucción de Transact-SQL que se ejecuta de forma desconectada al
SQL Server.
SqlConnection
Representa una conexión abierta a una base de datos de SQL Server.
SqlDataAdapter
Representa un conjunto de comando de datos y una conexión de base de datos que se utilizan para rellenar un DataSet.
SqlDataReader
Proporciona una forma de leer una secuencia de filas solo hacia adelante en una base de datos SQL Server.
SqlException
Representa la excepxión que se produce cuando SQL Server devuelve una advertencia o un error.
SqlTransaction
Representa una transacción de Transact-SQL que se realiza en una base de datos de SQL server.
Espacio de nombre System.Data
El espacio de nombres System.Data proporciona acceso a las clases que representan la arquitectura de ADO.NET.
Desde aquí se podrán compilar componentes que administran eficazmente los datos de varios orígenes de datos.
Observe las principales clases que componen el espacio de trabajo

DataColumn
Representa una columna especificada en un DataTable.
DataRow
representa una fila de datos especificada en un DataTable.
DataSet
Representa una caché de memoria interna de datos recuperados de un origen de datos.
DataTable
Representa una tabla almacenada en un espacio de memoria desde un origen de datos.
DataView
Representa una vista personalizada que se puede enlazar a datos de un DataTable para
ordenarlos, buscarlos, etc.
Clase SqlConnection
Contiene métodos y propiedades responsables de la conexión a una base de datos efectiva, además de
representar la interacción entre las sentencias enviadas al servidor, así como las que se reciben,
Un objeto de la clase SqlConnection guarda datos del servidor SQL, al cual se desea conectar.
Luego, podrán ser abiertos para ejecutar sentencias o cerrarlas cuando se termine un proceso.
Método constructor:
Formato Descripción
SqlConnection() Inicializa un objeto de la clase SqlConnection vacía, de tal forma que, mediante propiedades, pueda
configurarse la conexión al servidor de datos.
El siguiente código muestra la configuración vacía.
SqlConnection cn = new SqlConnection();
Y mediante la propiedad ConnectionString se puede configurar la conexión a una base de datos de Sql
Server, por ejemplo:
cn.ConnectionString = "server=USER-PC; database=Contrato; integrated security=SSPI";
SqlConnection Inicializa con una cadena de conexión directamente a un objeto de la clase SqlConnection. El siguiente
(cadena) código muestra la configuración a la base de datos CONTRATO del Sql Server:
SqlConnection cn =
new SqlConnection("server=USER-PC; database=Contrato; integrated security=SSPI");
En ambos formatos se necesita especificar los siguientes parámetros:
Nombre del servidor
Aquí se especifica el nombre del servidor al se desea conectar. Para este caso,
se concentrará en el servidor SQL Server.
Observe una lista de posibles especificaciones:
Especificación Descripción
Data Source = (local);
Data Source = .;
Server = (local);
Especificando un nombre de servidor por defecto
Server = .;
Data Source = 192.168.1.10;
Especificando un nombre del servidor con número de IP.
Server = 192.168.1.10;
Data Source = SOCRATES; Especificando un nombre del servidor configurado a nivel de
Server = SOCRATES; red.
Nombre de la base de datos
Aquí se especifica el nombre de la base de datos de donde provienen los datos. Hay que tener en
cuenta que la base de datos debe encontrarse dentro del servidor especificado en el nombre del
servidor.
Especificación Descripción
Initial Catalog = Contrato; Especificando la base de datos con el catalogo inicial.
Database = Contrato; Especificando la base de datos con Database.

Especificación de seguridad
Aquí se especifica el modo de seguridad que se tiene frente al servidor, ya que desde allí se
obtendrá las credenciales de acceso a la base de datos.
Especificación Descripción
Integrated Security = SSPI; Especificación para el modo de autenticación Windows.
Integrated Security = True;
User Id = sa; Password = 1v3 Especificación para el modo de autenticación Sql Server.
Uid = sa; Pwd = 1v3
Propiedad
Propiedad Descripción

Establece la cadena de conexión usada para abrir una base de datos en Sql Server.

ConnectionString SqlConnection cn = new SqlConnection();

cn.ConnectionString = "server=USER-PC;database = contrato; integrated security = SSPI"


Métodos
Método Descripción
Cierra la conexión mantenida con el servidor de base de datos
SqlConnection cn = new SqlConnection();
Close
cn.ConnectionString = server=USER-PC;database = contrato; integrated security = SSPI"
cn.Close();
Libera los recursos usados en una conexión de base de datos
SqlConnection cn = new SqlConnection();
Dispose
cn.ConnectionString = server=USER-PC;database = contrato; integrated security = SSPI"
cn.dispose();
Abre la conexión especificada en la propiedad ConnectionString.
SqlConnection cn = new SqlConnection();
Open
cn.ConnectionString = server=USER-PC;database = contrato; integrated security = SSPI"
cn.open();
Definición de la cadena de conexión
Observe las diferentes formas de implementar la cadena de conexión en una aplicación.
En todos los casos se deben colocar las siguientes librerías:
using System.Data;
using System.Data.SqlClient;

En la misma aplicación:
SqlConnection cn = new SqlConnection();
cn.ConnectionString = "server=USER-PC;database=contrato;integrated security=SSPI";
SqlCommand cmd = new SqlCommand("select * from Cliente", cn);
cn.Open();

Se inicia creando el objeto de la clase SqlConnection llamado cn.


Luego, se le asigna el parámetro de conexión mediante la propiedad ConnectionString.
En una clase
public class Conexion
{
public SqlConnection getConecta()
{
SqlConnection cn = new
SqlConnection(ConfigurationManager.ConnectionStrings["cn"].ConnectionString);
return cn;
}
}
Se implementa el método getConecta con el tipo de salida SqlConnection, ya
que el método debe devolver la conexión al objeto que lo invoque.
Luego, se debe referenciar mediante el siguiente código:
Conexion objCon = new Conexion();
SqlConnection cn = objcon.getConecta();

SqlCommand cmd = new SqlCommand("select * from Cliente", cn);


cn.Open();

Se inicia declarando el objeto de la clase Conexión. Luego, se crea e inicializa


el objeto de la clase SqlConnection con la invocación al método getConecta
de la clase Conexión.
En un archivo de configuración:
Forma 1.-

<?xml version="1.0" encoding="utf-8" ?>


<configuration>
<configSections>
</configSections>
<connectionStrings>
<add name="pjConexionAsistente.Properties.Settings.CONTRATOConnectionString"
connectionString="Data Source=.;Initial Catalog=CONTRATO;Integrated
Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
</configuration>
Forma 2.-

<?xml version="1.0" encoding="utf-8" ?>


<configuration>
<connectionStrings>
<add name="cn"
connectionString="Data Source=.;Initial Catalog=CONTRATO;Integrated Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
</configuration>
Forma 3.-

<?xml version="1.0" encoding="utf-8" ?>


<configuration>
<connectionStrings>
<add name="cn"
connectionString="Server=USER-PC;database=CONTRATO;Integrated Security=SSPI/>
</connectionStrings>
</configuration>
Clase SQLDataAdapter
Contiene propiedades y métodos que permiten crear un puente
entre las sentencias SQL que necesita una aplicación y SQL Server.
Normalmente, se usa para recuperar información o realizar
inserciones o eliminaciones sobre los registros de una tabla de base
de datos.
Para recuperar información, se usará el método Fill para llenar a un
objeto de la clase DataSet o DataTable.
Mientras que, para grabar, actualizar o eliminar, se debe usar un
objeto de la clase SqlCommand.
Métodos constructores:
Formato Descripción
Inicializa un objeto de la clase SqlDataAdapter en vacío y que mediante sus propiedades se podrá
gestionar la ejecución de sentencias SQL a partir de una conexión activa.

SqlDataAdapter da = new SqlDataAdapter();


Por ejemplo, si se necesita listar los registros de los clientes en un control DataGridView, el
codigo seríe como sigue:
// Creando una cadena de conexión
SqlConnection cn = new SqlConnection();
cn.ConnectionString = "server=USER-PC;database=contrato;integrated security=SSPI";

SqlDataAdapter() // Creando el objeto de la clase SQLDataAdapter


SqlDataAdapter da = new SqlDataAdapter();
da.SelectCommand = new SqlCommand();
da.SelectCommand.Connection = cn;
da.SelectCommand.CommandText = "SP_LISTACLIENTE";

// Enviando la información al DataTable


DataTable dt = new DataTable();
da.Fill(dt);
dgClientes.DataSource = dt;
Inicializa un objeto de la clase SqlDataAdapter tomando como
parámetros la sentencia SQL, la cual puede ser una sentencia
SELECT o un procedimiento almacenado y la cadena de conexión
// Creando la cadena de conexión
SqlConnection cn = new SqlConnection ("server = USER-PC;
database=contrato; integrated security=SSPI");
SqlDataAdapter
(Sentencia, Cadena) // Creando el objeto de la clase SQLDataAdapter
SqlDataAdapter da = new SqlDataAdapter("SP_LISTACLIENTE");

// Enviando la información al DataTable


DataTable dt = new DataTable();
da.Fill(dt);
dgClientes.DataSource = dt;
Inicializa un objeto de la clase SqlDataAdapter tomando como
parámetro un objeto de la clase SQLCommand.
SqlDataAdapter da = new SqlDataAdapter(cmd);
Por ejemplo, si se necesita listar los registros de los clientes en un control DataGridView,
el código sería como sigue:
// Creando la cadena de conexión
SqlConnection cn = new SqlConnection("server=,; database=contrato;integrated
security=SSPI");
SqlDataAdapter
(SqlCommand)
// Creando el objeto de lal clase cmd
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandText = "SP_LISTACLIENTE";

// Creando el objeto de la clase SQLDataAdapter


DataTable dt = new DataTable();
da.Fill(dt);
dgClientes.DataSource = dt;
Principales propiedades:
Propiedades Descripción
Establece una sentencia SQL o procedimiento almacenado para eliminar un registro de
una tabla en SQL Server.
// Creando la cadena de conexión
SqlConnection cn = new SqlConnection("server=.; database=contrato;integrated
security=SSPI");

// Creando el objeto de lal clase cmd


DeleteCommand
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandText = "SP_ELIMINACLIENTE";

// Agregando parámetros
cmd.Parameters.Add("@cod",SqlDbType.Char).Value=codigo;

da.DeleteCommand=cmd;
Establece una sentencia SQL o procedimiento almacenado para agregar un registro de
una tabla en SQL Server.
// Creando la cadena de conexión
SqlConnection cn = new SqlConnection("server=.; database=contrato;integrated
security=SSPI");

// Creando el objeto de la clase cmd


SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
InsertCommand cmd.CommandText = "SP_AGREGACLIENTE";

// Agregando parámetros
cmd.Parameters.Add("@cod", SqlDbType.Char).Value = codigo;
cmd.Parameters.Add("@nom", SqlDbType.Char).Value = nombres;
cmd.Parameters.Add("@dir", SqlDbType.Char).Value = direccion;
cmd.Parameters.Add("@tel", SqlDbType.Char).Value = telefono;

da.InsertCommand = cmd;
Establece una sentencia SQL o procedimiento almacenado para listar uno o más registros
de una tabla en SQL Server.
// Creando la cadena de conexión
SqlConnection cn = new SqlConnection("server=.;database=contrato;integrated
security=SSPI");

// Creando el objeto de la clase cmd


SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
SelectCommand cmd.CommandText = "SP_LISTACLIENTE";

// Creando el objeto de la clase SQLDataAdapter


SqlDataAdapter da = new SqlDataAdapter();
da.SelectCommand(cmd);

// Enviando la información al DataTable


DataTable dt = new DataTable();
da.Fill(dt);
dgClientes.DataSource = dt;
Establece una sentencia SQL o procedimiento almacenado para listar uno o más
registros de una tabla en SQL Server.
// Creando la cadena de conexión
SqlConnection cn = new SqlConnection("server=.;database=contrato;integrated
security=SSPI");

// Creando el objeto de la clase cmd


SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
UpdateCommand
cmd.CommandText = "SP_ACTUALIZACLIENTE";

// Agregando parámetros
cmd.Parameters.Add("@cod", SqlDbType.Char).Value = codigo;
cmd.Parameters.Add("@nom", SqlDbType.Char).Value = nombre;
cmd.Parameters.Add("@dir", SqlDbType.Char).Value = direccion;
cmd.Parameters.Add("@tel", SqlDbType.Char).Value = telefono;
Métodos:
Permite liberar los recursos usados en la implementación del
SqlDataAdapter.
Dispose
La sentencia para liberar el objeto SqlDataAdapter da.dispose();

Permite:
Agregar filas a un objeto datatable o dataset.
Fill
Rellenar un datatable da.Fill(dt);
Rellenar un DataSet da.Fill(ds,"Tabla");
Permite devolver el nombre del objeto de la clase SqlDataAdapter.
ToString
ConfigurationManager
Proporciona acceso a los archivos de configuración para
las aplicaciones cliente. Se debe tener en cuenta que se
debe agregar la librería al proyecto realizando los
siguientes pasos:
1.Clic derecho sobre el proyecto.
2.Seleccione Agregar > Referencia
3.Active el check System.Configuration
Librería:
La librería se especificará solo en la clase donde
System.Configuration
se implementa la cadena de conexión

Propiedad:
Especifica la conexión desde un pool de
ConnectionStrings conexión implementado en el archivo de
configuraciones app.config
Observe una implementación complete hacia la base de datos CONTRATO en SQL Server:
Pasos:
1.- En el archivo de configuración app.config agregue el siguiente código:

<?xml version="1.0" encoding="utf-8" ?>


<configuration>
<configSections>
</configSections>
<connectionStrings>
<add name="pjConexionAsistente.Properties.Settings.CONTRATOConnectionString"
connectionString="Data Source=.;Initial Catalog=CONTRATO;Integrated
Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
</configuration>

Considere que la cadena de conexión se especifica en ConnetionString y que este debe tener un nombre especificado
en <<name>>; es este mismo nombre el cual se hará referencia en el método de conexión.
2.- Luego, prepare el método de conexión con el siguiente código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

// Adicionar la siguiente librería


using System.Threading.Tasks;

// Adicionar librerías ADO NET


using System.Data.SqlClient;
using System.Configuration;
namespace pjConexionClase
{
public class Conexion
{
public SqlConnection getConecta()
{
SqlConnection cn = new
SqlConnection(ConfigurationManager.ConnectionStrings["cn"].ConnectionString);
return cn;
}
}
}

Tener en cuenta que primero debe agregar la referencia System.Configuration al proyecto.


Para esto, presione clic derecho sobre el proyecto y luego Agregar > Referencia.
Después, en la clase donde se implementa el método, agregue las librerías using System.Configuration.
Finalmente, se crea un objeto de la clase SqlConnection, en la cual se especifica en la propiedad connectionString.
Clase DataSet
Un objeto de la clase DataSet representa un conjunto de
datos residente en memoria, el cual proporciona un
modelo de programación relacional totalmente
independiente del origen de datos.
Eso quiere decir que el modo de trabajo sería
desconectado de la data.
Método constructor:
Inicializa el objeto de la clase DataSet en vacío y que a partir de un objeto
SqlDataAdapter permite rellenar el DataSet vacío.
Por ejemplo, si se quiere rellenar el DataSet de clientes, sería de la
siguiente manera:
// Creando la cadena de conexion
SqlConnection cn = new SqlConnection("server=.;database=contrato;integrated
security=SSPI");
DataSet
// Creando el objeto de la clase SQLDataAdapter
SqlDataAdapter da = new SqlDataAdapter("SP_LISTACLIENTE",cn);

// Enviando la información al DataSet


DataSet ds = new DataSet();
da.Fill(ds, "Clientes");
dgClientes.DataSource=ds.Tables.["Clientes"];
Propiedad:
Aquí se especifica el nombre de la tabla del cual necesita mostrar sus registros.
Se debe tener en cuenta que dicho nombre fue asignado por la propiedad Fill del objeto SQLDataAdapter.
Por ejemplo, si se quiere rellenar el DataSet de clientes, sería de la siguiente manera:
// Creando la cadena de conexion:
SqlConnection cn = new SqlConnection("Server=.;database=contrato;integrated security=SSPI");

Tables // Creando el objeto de la clase SQLDataAdapter


SqlDataAdapter da = new SqlDataAdapter("SP_LISTACLIENTES", cn);

// Enviando la informacion al DataSet


DataSet ds = DataSet();
da.Fill(ds,"Clientes");
dgClientes.DataSource=ds.Tables["Clientes"];

Métodos:
Libera todos los recursos asignados al objeto de la clase DataSet.
Dispose El código de liberación es: ds.dispose();
Observe una implementación completa para mostrar los registros de los clientes:
Pasos:
1.- Agregue las siguientes librerías:
using System.Data;
using System.Data.SqlClient;

2.- Implemente un método de conexión:


public SqlConnection getConecta()
{
SqlConnection cn = new SqlConnection(ConfigurationManager.
ConnectionStrings["cn"]ConnectionString);
return cn;
}
3.- Implemente un método que liste los registros de los clientes. Aquí se podría
tener dos posibilidades de listado: la primera sería especificar la consulta
directamente y la otra por medio de un procedimiento almacenado.
Consulta:
DataSet listaClientes()
{
SqlConnection cn = getConecta();
SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM
CLIENTE", cn);
DataSet ds = new DataSet();
da.Fill(ds, "CLIENTES");
return ds;
}
Procedimiento almacenado:
DataSet listaClientes()
{
SqlConnection cn = getConecta();
SqlDataAdapter da = new SqlDataAdapter("SP_LISTACLIENTE", cn);
DataSet ds = new DataSet();
da.Fill(ds, "CLIENTES");
return ds;
}

4.- Finalmente, asigne el resultado al control DataGridView.


dgClientes.DataSource=listaClientes().Tables["CLIENTES"];
Clase DataTable
Un objeto de la clase DataTable representa una
determinada tabla en memoria obtenida desde un relleno
realizado con el objeto de la clase SqlDataAdapter, de
modo que se pueda interactuar con ella y enviarlo a
controles que permitan visualizar sus registros.
La diferencia que tiene con el DataSet es que no necesita
una asignación de nombre.
Método constructor:
Inicializa el objeto de la clase DataTable en vacío y que a partir de un
objeto SqlDataAdapter permite rellenar el DataTable vacío.
Por ejemplo, si se quiere rellenar el DataTable de clientes, sería de la siguiente manera:
// Creando la cadena de conexion
SqlConnection cn = new SqlConnection("server=.;database=contrato;integrated
security=SSPI");
DataTable
// Creando el objeto de la calse SQLDataAdapter
SqlDataAdapter da = new SqlDataAdapter("SP_LISTACLIENTE",cn);

// Enviando la información al DataSet


DataSet dt = new DataTable();
da.Fill(dt);
Métodos:

Libera todos los recursos asignados al objeto


Dispose de la clase DataTable.
El código de liberación es: dt.dispose();

Devuelve el nombre del objeto al cual pertenece el


ToString
DataTable.
Observe una implementación completa para mostrar los
registros de los clientes:
Pasos:
1.- Agregue las siguientes librerías
using System.Data;
using System.Data.SqlClient;

2.- Implemente un método de conexión.


public SqlConnection getConecta()
{
SqlConnection cn = new SqlConnection(ConfigurationManager.
ConnectionStrings["cn"]ConnectionString);
return cn;
}
3.- Implemente un método que liste los registros de los clientes. Aquí se podría tener
dos posibilidades de listado: la primera, sería especificar la consulta directamente y la
otra por medio de un procedimiento almacenado.
Consulta:
DataTable listaClientes()
{
SqlConnection cn = getConecta();
SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM CLIENTE", cn);
DataTable dt = new DataTable();
da.Fill(dt);
return dt;
}
Procedimiento almacenado:
DataTable listaClientes()
{
SqlConnection cn = getConecta();
SqlDataAdapter da = new SqlDataAdapter("SP_LISTACLIENTE", cn);
DataTable dt = new DataTable();
da.Fill(dt);
return dt;
}

4.- Finalmente, asigne el resultado al control DataGridView.


dgClientes.DataSource = listaClientes();
Clase DataView
Un objeto de tipo DataView permite representar a un
subconjunto de datos obtenidos a partir de un DataSet o
DataTable.
Por medio de propiedades y métodos, se puede
administrar la información contenida en un DataView.
Inicializa con valor vacío el objeto de la clase DataView.

DataView dv = new Dataview();

Si se necesita sociar un DataSet con un DataView, se usa el


DataTable siguiente código:
DataSet ds = new DataSet();
da.Fill(ds);
DataView dv = new Dataview();
dv.Table = ds.Tables[0];
dgClientes.DataSource = dv;
Inicializa con un conjunto de datos de tipo DataTable
el objeto de la clase DataView.

DataTable dt = new DataTable();

DataView Si se necesita asociar un DataSet con un DataView, se


(DataTable) usa el siguiente código:
DataTable dt = new DataTable();
da.Fill(dt);
DataView dv = new Dataview(dt);
dgClientes.DataSource = dv;
Propiedades:
Devuelve el número total de registros alacenados en un DataView
solo despues de aplicar la propiedad RowFilter.

Si se quiere mostrar el total de clientes asociados a un objeto


DataView, se podría usar el siguiente código

Por ejemplo, si se quiere rellenar el dataset de clientes, sería de la


Count siguiente manera:
DataTable dt = new DataTable();
da.Fill(dt);
DataView dv = new DataView();
dgClientes.DataSource=dv;
MessageBox.Show("Total de registros: " + dv.Count.ToString());
Establece una expresión que resultará como filtro de registros
contenidos en un DataView.

Por ejemplo, si se quiere mostrar el registro cliente, cuyo código es


CL0002, el código seria como sigue:

DataTable dt = new DataTable();


RowFilter
da.Fill(dt);

DataView dv = new DataView();


dv.RowFilter = "IDE_CLI ="CL0002"";
dgClientes.DataSource = dv;
Permite ordenar los registros contenidos en un objeto DataView.

Este se especificará según las columnas contenidas en el DataView.


Por ejemplo, si se quiere mostrar los registros de los clientes ordenados en
forma ascendente por el apellido paterno del cliente, el codigo es como
sigue:
Sort DataSet ds = new DataSet();
da.Fill(ds);

DataView dv = new DataView();


dv.Table = ds.Tables[0];
dv.Sort = "PAT_CLI";
dgClientes.DataSource = dv;
Instrucción Using
En C#, la palabra clave Using, tiene dos formas de uso: La
primera, es considerada como directiva, ya que permite
definir las librerías en una aplicación y la segunda se
considera como definición de ámbito de un determinado
objeto, el cual lo destruye al finalizar el ámbito de Using.
Observe las siguientes posibilidades de uso de Using:
Es este caso, Using actúa como directiva del compilador, haciendo que
la aplicación use tipos definidos en el espacio de nombre, sin necesidad
de especificarlo directamente en el codigo.
Por ejemplo, para usar las clases ADO.NET, se necesita la siguiente directiva:
Using System.Data.SqlClient;
Importando También se puede usar en la definición de un alias sobre un espacio de
nombre.
espacio de
Por ejemplo, si se necesita usar la librería VisualBasic, se podría definirlo de la
nombres siguiente manera:
Using mv = Microsoft.VisualBasic;
La librería Microsoft.VisualBasic tiene un alias "mv", es es para invocar a sus
métodos de forma directa.
Observe cómo invocar al método InputBox:
string codigo = mv.Interaction.InputBox("Ingrese código: ");
En este caso, Using actúa como un liberador de recursos al finalizar su ámbito.
En un bloque Using se puede usar todo tipo de objetos y estos serán liberados cuando el ámbito
del using finalice.
Using (SqlConnection cn = new SqlConnetion("server=.;database=contrato;integrated security=]SSPI"));
{
// Objeto de la clase SqlCommand
SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
Liberación cmd.CommndText = "SP_LISTACLIENTE";

de // Creando el objeto de la clase SQLDataAdapter


recursos
SqlDataAdapter da = new SqlDataAdapter();
da.SelectedCommand = cmd;

// Enviando la información al DataSet:


DataSet ds = new DataSet();
da.Fill(ds);

DataView ds = new DataView();


dv-Table = ds.Tables[0];
dgClientes.DataSource = dv;
Clase SqlCommand
Representa un procedimiento almacenado o una instrucción de Transact-SQL, que se ejecuta en una
base de datos SQL server.
Métodos constructores:

Inicializa con un valor vacío el objeto de la clase SqlCommand


y a partir de sus propiedades se especifica el tipo de
comando y la conexión.
SqlCommand()
Por ejemplo, si se crea el objeto de la clase SqlCommand vacía,
el codigo sería:
SqlCommand cmd = new SqlCommand();
Inicializa el objeto con una sentencia SQL o
procedimiento almacenado.

Por ejemplo, si se crea el objeto de la clase SqlCommand


SqlCommand en base a una sentencia de SQL:
(String)

String cadena = "SELECT * FROM CLIENTE";

SqlCommand cmd = new SqlCommand(cmd);


Inicializa el objeto con una sentencia SQL o procedimiento
almacenado y especifica la cadena de conexión.

SqlCommand Por ejemplo, si se crea el objeto de la clase SqlCommand en base a


(String, una cadena de conexión y un objeto de transacción
SqlConnection)

SqlCommand cmd = new SqlCommand("SELECT * FROM CLIENTE", cn);


Inicializa el objeto con una sentencia SQL Server, una
conexión y un objeto de transacción.

Por ejemplo, si se crea el objeto de la clase SqlCommand en base a


SqlCommand
una cadena de conexión y un objeto de transacción
(String,
SqlConnection,
SqlTransaction) SqlTransaction te = cn.BeginTransaction(Isolation.Serializable);
String cadena = "SELECT * FROM CLIENTE";
SqlCommand cmd = new SqlCommand(cmd, cn, tr);
Propiedades:

Permite asignar la sentencia SQL o nombre del procedimiento


almacenado al objeto de clase SqlCommand.

Se puede especificar una sentencia SQL de la siguiente manera:

SqlCommand cmd = new SqlCommand();


CommandText
cmd.CommandText = "SELECT * FROM CLIENTE";

O también se puede especificar un procedimiento almacenado de la


siguiente manera

SqlCommand cmd = new SqlCommand();


cmd.CommandText = "SP_LISTACLIENTE";
Permite especificar el tipo de sentencia que debe
interpretar el objeto de la clase SqlCommand

SqlCommand cmd = new SqlCommand();


CommandType
cmd.CommandText = "SP_LISTACLIENTE";

cmd.CommandType = CommandType.StoreProcedure;
Permite especificar de que cadena de conexión proviene la
sentencia asociada al objeto de la clase SqlCommand

SqlConnection cn = new SqlConnetin("servir=.;databse=contrato;


integrated security = SSPI");
Connection SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandText = "SP_LISTACLIENTE";
cmd.CommandType = CommandType.StoreProcedure;
Permite especificar los parámetros de entrada de una o procedimiento
almacenado.
Esta propiedad se usará cuando la consulta presenta uno o mas criterios:

SqlCommand cmd = new SqlCommand("SP_NUEVOCLIENTE", cn);

cmd.CommandType = CommandType.StoreProcedure;

Parameters
cmd.Parameters.Add("@cod",SqlDbType.Char).Value = codigo;

cmd.Parameters.Add("@nom",SqlDbType.Char).Value = nombre;

cmd.Parameters.Add("@dir",SqlDbType.Char).Value = direccion;

cmd.Parameters.Add("@tel",SqlDbType.Char).Value = telefono;
Especifica la transacción que puede tener una sentencia SQL o
procedimiento almacenado.

SqlTransaction tr = cn.BeginTransaction(Isolation.Serializable);
Transaction
string cadena = "SELECT * FROM CLIENTE";
cmd.Command cmd = new Command(cmd, cn);

cmd.Transaction = tr;
Métodos:

Permite liberar los recursos usados al crear el


objeto de la clase SqlCommand
Dispose
cmd.dispose();
Permite especificar que la sentencia SQL o procedimiento almacenado está
ejecutando sentencia del lado servidor como una inserción, actualización o
eliminación.

SqlCommand cmd = new SqlCommand("SP_NUEVOCLIENTE", cn);


cmd.CommandType = CommandType.StoreProcedure;

cmd.Parameters.Add("@cod",SqlDbType.Char).Value = codigo;

ExecuteNonQuery cmd.Parameters.Add("@nom",SqlDbType.Char).Value = nombre


cmd.Parameters.Add("@dir",SqlDbType.Char).Value = direccion
cmd.Parameters.Add("@tel",SqlDbType.Char).Value = telefono

cmd.ExecuteNonQuery();

Se debe tener en cuenta que es obligatorio especificar la apertura de la conexión con


el siguiente código:
Permite especificar que se obtendrá solo el primer elemento de una
sentencia SQL o procedimiento almacenado de tipo consulta.
Esto podrá ayudar al recuperar un solo valor desde el servidor como, por
ejemplo, el ultimo código de cliente o el total de clientes

SqlCommand cmd = new SqlCommand("SP_NUEVOCLIENTE", cn);

ExecuteScalar cmd.CommandType = CommandType.StoreProcedure;

string codigo = cmd.ExcuteScalar();

Se debe tener en cuenta que es obligatorio especificar la apertura de la


conexión con el siguiente código:
cn.Open();
Casos desarrollados

También podría gustarte