Ir al contenido principal

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 != null) registros 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();
            }
        }
Etiquetas:

Comentarios

Publicar un comentario

Entradas más populares de este blog

Habilitar Usuario HR Oracle

Al realizar la primera instalación del Oracle, el usuario HR por defecto está bloqueado y por ende no podemos loguearnos como dicho usuario, lo que debe hacer son los siguiente pasos, aplicables para Linux o Windows.
1. Conectarse como usuario system o sysdba + contraseña haciendo uso del comando connect.
Usuario: system
Password: xxxx 


2. Hacer uso  del comando alter user hr account unlock desbloqueamos la cuenta.
alter user hr account unlock;

3. Escribimos el comando alter user HR identified by hr; con esto estamos diciendo que la contraseña será hr.

alter user HR identified by hr;

4. Ahora testeamos la conexión con el comando - conn hr/hr@xe. Si deseas después de conectarnos se puede realizar un select a la tabla employees del hr.


Resultado del select realizado
5. Con todos estos pasos realizados ya podemos logearnos desde cualquier IDE como el usuario hr  y la contraseña hr que definimos en el paso 3. 
Para finalizar nos loguearemos con el IDE Oracle SQL Developer.

Espero les sea de utilidad,…
2 comentarios
Leer más

Usuario SYS y SYSTEM - ORACLE

Usuario SYS y SYSTEM
Ambos usuario son creados de forma automática al crear la base de datos ORACLE y se otorga el rol de DBA.

SYS (password por defecto: CHANGE_ON_INSTALL).
SYSTEM (password por defecto: MANAGER).

Lo que se recomienda es cambiar el password de ambos usuarios por el tema de seguridad.

SYS:
Todas las tablas y vistas para el diccionario de datos de la base de datos están almacenados en el esquema SYS. Estas tablas y vistas son críticas para el funcionamiento de la base de datos ORACLE. Para mantener la integridad del diccionario de datos, las tablas del esquema SYS son manipulados solo por la base de datos. Nunca se debería modificar algo o crear tablas en el esquema del usuario SYS.

SYSTEM:
El usuario SYSTEM se utiliza para crear tablas y vistas adicionales que muestran información administrativa, tablas internas y vistas utilizado por varias opciones y herramientas de la base de datos ORACLE. No se recomienda utilizar el esquema SYSTEM para almacenar tablas de interés para usu…
Publicar un comentario
Leer más

Parámetro de entrada y salida – PL/SQL

Parámetro de entrada y salida – PL/SQL:
Los parámetros de entrada y salida no son los parámetros de inicialización de la base de datos ORACLE. Los parámetros de entra y salida son utilizados mayormente en implementaciones de funciones, procedimientos almacenados o bloques de código bajo el lenguaje del PL/SQL, se considera que ambos parámetros (entra y salida) puedan realizar operaciones en el mismo bloque PL/SQL, es decir, si enviamos un parámetro de entrada hará que cumpla cierta operación y retornara los valores de salida de dicha operación procesada de acuerdo al parámetro de ingresado. Es de acuerdo al caso que nos presenta en la implementación.
Algo importante al definir los parámetros, es saber y considerar cuántos tipos de parámetro existe si solo hablamos de entrada y salida, en realidad mi determinación seria 3 tipos:

Parámetros:

IN – entrada
OUT – salida
IN OUT – entrada salida

Parámetro IN – entrada:
El comportamiento común de estés tipos de parámetros es estar siempre pendiente d…
2 comentarios
Leer más