Mostrando las entradas con la etiqueta ADO.Net. Mostrar todas las entradas
Mostrando las entradas con la etiqueta ADO.Net. Mostrar todas las entradas

domingo, 23 de enero de 2011

ADO.Net - Insertar, actualizar y eliminar datos utilizando Sql Server 2008

El objetivo de este articulo es aprender y conocer más sobre la importancia de usar ADO.Net (recordemos que ADO.Net, es una parte de la biblioteca de clases base que están incluidas en el Microsoft .NET Framework); sobre este misma aplicación iremos agregando nuevas cosas, como por ejemplo mostrar los datos en forma de una lista utilizando SAP Crystal Reports for Visual Studio 2010, exporta a Microsoft Excel 2010 entre otras cosas que se me ocurre.

Comencemos con los requisitos:

Requisitos para el Desarrollos
  1. IDE (Visual Studio 2010).
  2. SGBD (SQL Server 2008).
  3. LP (C#).
  • Crear la solución con nombre de [ADO.Net Mantenimiento] así mismo creamos el proyecto que se llamara como el mismo nombre que tiene la solución.
  • Diseñamos nuestro formulario que esta compuesto por los controles de etiqueta (label), texto (textbox), grillas (datagridview) y botones (button).

  • Breves Explicaciones

    Cadena de conexión (app.config).
    Crear nuestra cadena de conexión (código XML), con nombre "cndb"
    
      
        
      
        
      
    
    Entidades (clsClienteEntity).
    Creamos la clase de entidad, donde creamos las propiedades (columna) de la entidad (tabla cliente). 

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ADO.Net_Mantenimiento
    {
        public class ClsClienteEntity
        {
            public int IdCliente {get; set;}
    
            public string NomCliente {get; set;}
            public string ApeCliente{get; set;}
            public string DirCliente {get; set;}
            public string TelCliente {get;set;}
            public string CelCliente { get; set;}
        }
    }
    Capa de acceso a datos (clsClienteDal).
    Creamos nuestro método privado cargarCliente, en la cual creamos nuestra estructura de solo lectura y hacemos referencia a nuestra clase de entidades ClsClienteEntity.
    //Invocamos o importamos estas referencias
    using System.Data;
    using System.Data.SqlClient; // Proveedor de base de datos
    using System.Configuration; // para poder acceder a nuestra archivo de configuraciones (App.config)
    
    //Sobre esta evento ya se hablo en el anterior articulo
        public class ClsClienteDAL
        {
            private static ClsClienteEntity CargaCliente(IDataReader Reader)
            {
                ClsClienteEntity cliente = new ClsClienteEntity();
    
                cliente.IdCliente = Convert.ToInt32(Reader["IdCliente"]);
    
                cliente.NomCliente = Convert.ToString(Reader["NomCliente"]);
                cliente.ApeCliente = Convert.ToString(Reader["ApeCliente"]);
                cliente.DirCliente = Convert.ToString(Reader["DirCliente"]);
                cliente.TelCliente = Convert.ToString(Reader["TelCliente"]);
                cliente.CelCliente = Convert.ToString(Reader["CelCliente"]);
    
                return cliente;
            }
    Creamos nuestro evento público de tipo  lista para capturar todos los registro de nuestra entidad (tabla) Cliente.

    //Filtrar todos los registros de la entidad cliente
            public static List<clsclienteentity> ClienteAll()
            {
                string strsql = @"SELECT [IdCliente]
                                          ,[NomCliente]
                                          ,[ApeCliente]
                                          ,[DirCliente]
                                          ,[TelCliente]
                                          ,[CelCliente]
                                      FROM [dbAdoNet].[dbo].[Cliente]";
    
                List<clsclienteentity> listar = new List<clsclienteentity>();
    
                using (SqlConnection sqlcn = new SqlConnection(ConfigurationManager.ConnectionStrings["cndb"].ToString()))
                {
                    SqlCommand sqlcmd = new SqlCommand(strsql, sqlcn);
                    sqlcn.Open();
                    SqlDataReader sqlReader = sqlcmd.ExecuteReader();
    
                    while (sqlReader.Read())
                    {
                        listar.Add(CargaCliente(sqlReader));
                    }
                    return listar;
                }
            }

Creamos nuestro evento público para filtrar los registro de acuerdo al IdCliente (filtrar por código de cliente) de nuestra entidad (tabla) Cliente.
//Filtrar registro por ID de la entidad cliente
        public static ClsClienteEntity ClienteID(int ID)
        {
            string strsql = @"SELECT [IdCliente]
                                      ,[NomCliente]
                                      ,[ApeCliente]
                                      ,[DirCliente]
                                      ,[TelCliente]
                                      ,[CelCliente]
                                  FROM [dbAdoNet].[dbo].[Cliente]
                                  WHERE [IdCliente]=@ID";

            ClsClienteEntity cliente = null;
            using (SqlConnection sqlcn = new SqlConnection(ConfigurationManager.ConnectionStrings["cndb"].ToString()))
            {
                SqlCommand sqlcmd = new SqlCommand(strsql, sqlcn);

                sqlcmd.Parameters.AddWithValue("Id", ID);
                sqlcn.Open();

                SqlDataReader sqlReader = sqlcmd.ExecuteReader();

                if (sqlReader.Read())
                {
                    cliente = CargaCliente(sqlReader);
                }
                return cliente;
            }
        }

Creamos nuestro evento privado para generar nuevo IdCliente (código de cliente) de nuestra entidad (tabla) Cliente.
//Capturar el máximo ID de la entidad cliente (tabla)
        private static int idmax()
        {
            string strsql = @"SELECT MAX(IdCliente) FROM CLIENTE";

            using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cndb"].ToString()))
            {
                SqlCommand cmdsql = new SqlCommand(strsql, cn);
                cn.Open();

                return Convert.ToInt32(cmdsql.ExecuteScalar());
            }
        }
Creamos nuestro evento público para la inserción de un nuevo registro e invocamos  nuestro evento privado que genera un nuevo código (int nuevoid = idmax() + 1).
//Método Insertar nuevo registro
        public static ClsClienteEntity InsertarRegistro(ClsClienteEntity cliente)
        {
            string strsql = @"INSERT INTO dbAdoNet.dbo.Cliente
                                           (IdCliente
                                           ,NomCliente
                                           ,ApeCliente
                                           ,DirCliente
                                           ,TelCliente
                                           ,CelCliente)
                                     VALUES
                                           (@IdCliente
                                           ,@NomCliente
                                           ,@ApeCliente
                                           ,@DirCliente
                                           ,@TelCliente
                                           ,@CelCliente)";
            using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cndb"].ToString()))
            {
                //Incrementamos nuevo id
                int nuevoid = idmax() + 1;
                SqlCommand cmdsql = new SqlCommand(strsql, cn);

                cmdsql.Parameters.AddWithValue("IdCliente", nuevoid);
                cmdsql.Parameters.AddWithValue("NomCliente", cliente.NomCliente);
                cmdsql.Parameters.AddWithValue("ApeCliente", cliente.ApeCliente);
                cmdsql.Parameters.AddWithValue("DirCliente", string.IsNullOrEmpty(cliente.DirCliente) ? (object)DBNull.Value : cliente.DirCliente);
                cmdsql.Parameters.AddWithValue("TelCliente", cliente.TelCliente);
                cmdsql.Parameters.AddWithValue("CelCliente", string.IsNullOrEmpty(cliente.CelCliente) ? (object)DBNull.Value : cliente.CelCliente);

                cn.Open();

                cmdsql.ExecuteNonQuery();
                cliente.IdCliente = nuevoid;
                return cliente;
            }
        }

Creamos nuestro evento público para la actualización de los registros de acuerdo al IdCliente (código cliente) seleccionado.
//Método Actualizar registro
        public static ClsClienteEntity ActualizarRegistro(ClsClienteEntity cliente, int id)
        {
            //int idcli = Convert.ToInt32(cliente.IdCliente);

            string strsql = @"UPDATE dbAdoNet.dbo.Cliente
                           SET NomCliente = @NomCliente
                              ,ApeCliente = @ApeCliente
                              ,DirCliente = @DirCliente
                              ,TelCliente = @TelCliente
                              ,CelCliente = @CelCliente
                         WHERE IdCliente = @IdCliente";
            
            
            using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cndb"].ToString()))
            {
                
                SqlCommand cmdsql = new SqlCommand(strsql, cn);
                
                cmdsql.Parameters.AddWithValue("NomCliente", cliente.NomCliente);
                cmdsql.Parameters.AddWithValue("ApeCliente", cliente.ApeCliente);
                cmdsql.Parameters.AddWithValue("DirCliente", string.IsNullOrEmpty(cliente.DirCliente)?(object)DBNull.Value:cliente.DirCliente);
                cmdsql.Parameters.AddWithValue("TelCliente", cliente.TelCliente);
                cmdsql.Parameters.AddWithValue("CelCliente", string.IsNullOrEmpty(cliente.CelCliente) ? (object)DBNull.Value : cliente.CelCliente);
                cmdsql.Parameters.AddWithValue("IdCliente", id);

                cn.Open();
                cmdsql.ExecuteNonQuery();

                return cliente;
            }
        }

Creamos nuestro evento público para la eliminación del registro seleccionado.
public static void ElimarRegistro(int id)
        {
            string strsql = @"DELETE FROM Cliente WHERE IdCliente = @IdCliente";

            using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cndb"].ToString()))
            {
                SqlCommand cmdsql = new SqlCommand(strsql, cn);
                cmdsql.Parameters.AddWithValue("IdCliente", id);

                cn.Open();
                cmdsql.ExecuteNonQuery();
            }
        }
En el formulario invocaremos nuestros eventos que se crearon en la clsClienteDal.

Iniciamos controlando nuestro formulario en el evento cargar (load);  controlamos nuestra caja de texto de solo lectura (este valor es el código autogenerado) y a su vez cargamos nuestra grilla invocando nuestra clase ClsClienteDAL y evento ClienteAll().
//Evento Load
        private void Form1_Load(object sender, EventArgs e)
        {
            //Bloquear campo id (sera autogenerado)
            txtID.ReadOnly = true;
           
            //Cargamos el datagridview
            dgv_cliente.DataSource = ClsClienteDAL.ClienteAll();                        
        }

En el evento doble clic de la grilla validamos si es que existe if (row != nullregistros y capturamos el registro “ID” (int id = Convert.ToInt32(row.Cells["ID"].Value); que se encuentra en la grilla; si es que todo marcha bien seleccionamos las entidades   (if (this.ClienteSelected != null) para setear los valores en los controles, que en te caso todos son cajas de textos.
//Cargar los textbox desde el datagridview
        private void dgv_cliente_DoubleClick(object sender, EventArgs e)
        {
            DataGridViewRow row = dgv_cliente.CurrentRow as DataGridViewRow;

            if (row != null)
            {
                //Obtenemos la columna ID del datagridview
                int id = Convert.ToInt32(row.Cells["ID"].Value);

                this.ClienteSelected = ClsClienteDAL.ClienteID(id);

                if (this.ClienteSelected != null)
                {
                    ClsClienteEntity cliente = this.ClienteSelected;
                    
                    txtID.Text = Convert.ToString(cliente.IdCliente);

                    txtNombres.Text = cliente.NomCliente;
                    txtApellidos.Text = cliente.ApeCliente;
                    txtDireccion.Text = cliente.DirCliente;
                    txtTelefono.Text = cliente.TelCliente;
                    txtCelular.Text = cliente.CelCliente;

                }
              }
        }

Evento para realizar el limpiado de las cajas texto y enviar el foco a la caja de texto (txtNombres.Focus()).
//Metodo Limpiar controles
        private void LimpiarCtrl()
        {
            txtID.Text = "";
            txtNombres.Text = "";
            txtApellidos.Text = "";
            txtDireccion.Text = "";
            txtTelefono.Text = "";
            txtCelular.Text = "";

            txtNombres.Focus();
        }

Evento clic de botón guardar, recuperamos y validamos los valores obligatorios a ingresar en la caja de texto e invocamos los eventos de Inserción y actualización que se encuentra en la clase  ClsClienteDAL, limpiamos los controles ingresados y por último invocamos al evento ClienteAll que se encuentra en la clase ClsClienteDAL.
private void btnGuardar_Click(object sender, EventArgs e)
        {
            try
            {
                ClsClienteEntity cliente = new ClsClienteEntity();

                //Recuperar los valores ingresados de la caja de texto
                cliente.NomCliente = txtNombres.Text;
                cliente.ApeCliente = txtApellidos.Text;
                cliente.DirCliente = txtDireccion.Text;
                cliente.TelCliente = txtTelefono.Text;
                cliente.CelCliente = txtCelular.Text;

                //Validación - Datos obligaatorios a ingresar
                if (txtNombres.Text == "")
                {
                    MessageBox.Show("Falta Ingresar Nombre", "Aviso del Sistema", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    txtNombres.Focus();
                    return;
                }

                if (txtApellidos.Text == "")
                {
                    MessageBox.Show("Falta Ingresar Apellidos", "Aviso del Sistema", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    txtApellidos.Focus();
                    return;
                }

                if (txtTelefono.Text == "")
                {
                    MessageBox.Show("Falta Ingresar Telefono", "Aviso del Sistema", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    txtTelefono.Focus();
                    return;
                }

                // Si es que la caja de texto se encuentra vacio se hace referencia al evento InsertarRegistro(cliente) que se encuentra en la clase ClsClienteDAL
                if (txtID.Text == "")
                {
                    ClsClienteDAL.InsertarRegistro(cliente);
                    MessageBox.Show("Registro guardado correctamente", "Aviso del Sistema", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }

                // Si es que la caja de texto se encuentra distinto a vacio se hace referencia al evento ActualizarRegistro(cliente, Convert.ToInt32(txtID.Text)) que se encuentra en la clase ClsClienteDAL
                if (txtID.Text != "")
                {
                    ClsClienteDAL.ActualizarRegistro(cliente, Convert.ToInt32(txtID.Text));
                    MessageBox.Show("Registro Actualizado correctamente","Aviso del Sitema", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }

                //Invoco al evento LimpiarCtrl(), y vuelvo a cargar la grilla
                LimpiarCtrl();
                dgv_cliente.DataSource = ClsClienteDAL.ClienteAll();

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }            
        }

Evento clic de botón eliminar, capturamos el id e invocamos el evento ElimarRegistro(id).
private void btnEliminar_Click(object sender, EventArgs e)
        {
            DataGridViewRow row = dgv_cliente.CurrentRow as DataGridViewRow;
            //Validación
            if (row != null)
            {
                //Capturamos id de la grilla
                int id = Convert.ToInt32(row.Cells["id"].Value);
                //Invocamos el evento para la eliminación
                ClsClienteDAL.ElimarRegistro(id);
                //(Refrescar) Vuelvo a cargar la grilla
                dgv_cliente.DataSource = ClsClienteDAL.ClienteAll();
            }
        }

viernes, 24 de diciembre de 2010

ADO.Net - Recuperar datos con DataReader

DataReader:
Se utiliza solo para recuperar información de SOLO LECTURA de la base de datos, considerando que no se puede realizar modificaciones alguna. Mejora en rendimiento y reduce la sobrecarga del sistemas (lo recomendable es recupera datos puntuales que no serán modificadas).

Implica crear una instancia del objeto Command y de un DataReader a continuación, para lo cual se llama a Command.ExecuteReader a fin de recuperar filas de un origen de datos.

Requisitos
  1. IDE (Visual Studio 2010).
  2. SGBD (SQL Server 2008.
  3. LP (C#)
  • Crear la solución con nombre de [ADO.Net DataReader].
  • Crear la base de datos (se creará desde el IDE de Visual Studio 2010); publico los pasos  de como crear una base de datos desde el propio IDE  (en ocasiones nos es útil crealo desde el propio IDE de Visual Studio).
Clic derecho en data connection / create new sql server database.

Autentificacion, server name / user name / password / new database name, clic en OK.
  • Creando la tabla Cliente


Clic derecho en table / add new table

Creando campos y primary key (seleccionar el campo IdCliente y clic en set primary key).

Guardando la tabla cliente 
  • Paso opcional, si deseas modificar la tabla cliente


Clic derecho en table / open table definition

Modificaremos los not null a null y clic en save all
  • Insertar datos a la tabla cliente.
Clic derecho en la tabla cliente / show table date

Insertamos los datos necesarios y clic en save all
  • Diseñar nuestro formulario (Form1.cs).
Controles datagridview, botton
  • Crear el app.config para nuestra cadena de conexión con la  base de datos.
  • Crear las clases clsClienteDal y clsClienteEntity.
Explicaciones:

Cadena de conexión (app.config).
Crear nuestra cadena de conexión (código XML), con nombre "cndb"

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>   
  </configSections>
  <connectionStrings>
    <add name="cndb"
         connectionString ="Data Source=HADSON-PC;Initial Catalog=dbAdoNet;User ID=sa; Password=aquitupassword;Pooling=False"
         providerName="System.Data.SqlCliente"/>
  </connectionStrings>
</configuration>

Entidades (clsClienteEntity).
Creamos la clase de entidad, donde creamos las propiedades (columna) de la entidad (tabla cliente). 

public class ClsClienteEntity
    {
        public int IdCliente { getset; }
        public string NomCliente { getset; }
        public string ApeCliente { getset; }
        public string DirCliente { getset; }
        public string TelCliente { getset; }
        public string CelCliente { getset; }
    }

Capa de acceso a datos (clsClienteDal).
Creamos nuestro método privado cargarCliente, en la cual creamos nuestra estructura de solo lectura y aremos referencia a nuestra clase de entidades ClsClienteEntity.

private static ClsClienteEntity cargarCliente(IDataReader Rdr)
        {
           ClsClienteEntity cliente = new ClsClienteEntity();

            cliente.IdCliente =  Convert.ToInt32(Rdr["IdCliente"]);
            cliente.NomCliente = Convert.ToString(Rdr["NomCliente"]);
            cliente.ApeCliente = Convert.ToString(Rdr["ApeCliente"]);
            cliente.DirCliente = Convert.ToString(Rdr["DirCliente"]);
            cliente.TelCliente = Convert.ToString(Rdr["TelCliente"]);
            cliente.CelCliente = Convert.ToString(Rdr["CelCliente"]);

           return cliente;
        }

Creamos nuestro método publico CargarAll; y recuperamos nuestra cadena de conexión "using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cndb"].ToString()))" y con el SqlCommand recuperamos nuestra sentencia select "sql" y la variable de la cadena de conexión "cn". Recordemos que nuestro método es un List por tal motivo retornará un "return listar"

public static List<ClsClienteEntity> CargarAll()
        {           
            string sql = @"SELECT IdCliente, NomCliente, ApeCliente, DirCliente, TelCliente, CelCliente FROM Cliente";

            List<ClsClienteEntity> listar = new List<ClsClienteEntity>();

            using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["cndb"].ToString()))
            {
                SqlCommand cmd = new SqlCommand(sql, cn);
                cn.Open();
                SqlDataReader Rdr = cmd.ExecuteReader();

                while (Rdr.Read())
                {
                    listar.Add(cargarCliente(Rdr));
                }
                Rdr.Close();
                cn.Close();
            }
            return listar;          
        }


Botón Cargar Data (btncargar).
Por último en el evento click del botón Cargar Data de nuestro formulario Form1.cs se hace referencia al datagridview e invocamos nuestro evento CargarAll() que se encuentra en la clase ClsClienteDal.


private void btnCargar_Click(object sender, EventArgs e)
        {
            dataGridView1.DataSource = ClsClienteDal.CargarAll();
        }


Esto es el inicio para una nueva publicación sobre "ADO.Net - Mantenimiento".

La intenciones es brindarte un ejemplo práctico, aquí les dejo el código (C#) de esta pequeña publicación.