INTRODUCCIÓN
Hola, en esta oportunidad realizaremos las 4 operaciones CRUD (Create, Read, Update, Delete) en una base de datos SQL Server, desde una aplicación de Windows Form en C#, con procedimientos almacenados, programación orientada a objetos y arquitectura tradicional en capas. Este tutorial está orientada para aquellas personas que empiezan a indagar en programación orientada a objetos y arquitectura en capas, para entender algunos principios de POO y el flujo entre capas (NIVEL BASE). Si ya tienes conocimientos solidos sobre el tema, te recomiendo ver el tutorial de Nivel Intermedio, o CRUD de Nivel Avanzado.
PRE-TUTORIAL
En resumen: Programación en Capas o Arquitectura en Capas, es un estilo de programación que apareció en los años 1980 junto con las aplicaciones empresariales. Bueno, en la arquitectura tradicional en capas, generalmente hay tres capas principales de aplicación: la capa de presentación, la capa de negocio o dominio, la capa de acceso a datos o persistencia, y una capa adicional de soporte, conocida como capa de corte transversal o capa común.
TUTORIAL
Paso 1: Crear base de datos y Procedimientos Almacenados CRUD
- Crearemos una base de datos de nombre Práctica, una tabla Productos y unos cuantos registros, para poder realizar las operaciones CRUD, para ello, también crearemos procedimientos almacenados (Opcional).
create database Practica
go
use Practica
create table Productos
(
Id int identity (1,1) primary key,
Nombre nvarchar (100),
Descripcion nvarchar (100),
Marca nvarchar (100),
Precio float,
Stock int
)
insert into Productos
values
('Gaseosa','3 litros','marcacola',7.5,24),
('Chocolate','Tableta 100 gramos','iberica',12.5,36)
---PROCEDIMIENTOS ALMACENADOS
--------------------------MOSTRAR
create proc MostrarProductos
as
select *from Productos
go
--------------------------INSERTAR
create proc InsetarProductos
@nombre nvarchar (100),
@descrip nvarchar (100),
@marca nvarchar (100),
@precio float,
@stock int
as
insert into Productos values (@nombre,@descrip,@marca,@precio,@stock)
go
------------------------ELIMINAR
create proc EliminarProducto
@idpro int
as
delete from Productos where Id=@idpro
go
------------------EDITAR
create proc EditarProductos
@nombre nvarchar (100),
@descrip nvarchar (100),
@marca nvarchar (100),
@precio float,
@stock int,
@id int
as
update Productos set Nombre=@nombre, Descripcion=@descrip, Marca=@marca, Precio=@precio, Stock=@stock where Id=@id
go
Paso 2: Crear Solución Vacío en Blanco de Visual Studio
Es un error muy común crear las capas en carpetas; las capas de aplicación se deben de crear en proyectos para tener un archivo dll por separado para cada capa, por ello es conocido como capas de aplicación. Por tal razón crearemos una solución en blanco.
- Archivo-> Nuevo-> Proyecto-> Plantillas-> Otros tipos de proyectos -> Soluciones de Visual Studio-> Solución en Blanco) y asígnele el nombre que desee. Aquí lo hemos nombrado CRUD_NCAPAS.
Paso 3: Crear las Capas de Aplicación
- Añadimos un proyecto nuevo de tipo Aplicación de Windows Forms para la Capa de Presentación.
- Añadimos un proyecto nuevo de tipo Biblioteca de Clases para la Capa de Dominio o Negocio.
- Añadimos un proyecto nuevo de tipo Biblioteca de Clases para la Capa de Acceso a Datos o Persistencia.
- No será necesario crear la capa Común de Soporte, ya que no se usará en este tutorial.
Paso 4: Añadir referencias entre capas (Dependecias)
Agregamos las referencias entre capas según la arquitectura tradicional en capas, donde una capa superior sólo conoce la capa inmediatamente debajo de ella, y todas las capas tienen acceso a la Capa Común de Soporte.
- En Capa de Presentación: Referenciamos a la Capa de Negocio.
- En Capa de Negocio: Referenciamos a la Capa de Acceso a Datos.
Una vez esquematizada la solución de nuestro proyecto, es momento de codificarla.
Paso 5: Codificar- Capa de Acceso a Datos
- Agregamos una clase para la conexión a SQL Server (CD_Conexion.cs)
- Importamos la librería Data y Data.SqlClient.
using System.Data.SqlClient; using System.Data;
- Creamos la cadena de conexión, un método para abrir la conexión y otro método para cerrar la conexión.
CD_Conexion.cs
public class CD_Conexion
{
private SqlConnection Conexion = new SqlConnection("Server=DESKTOP-UEPK13H\\RONETJOHN;DataBase= Practica;Integrated Security=true");
public SqlConnection AbrirConexion()
{
if (Conexion.State == ConnectionState.Closed)
Conexion.Open();
return Conexion;
}
public SqlConnection CerrarConexion()
{
if (Conexion.State == ConnectionState.Open)
Conexion.Close();
return Conexion;
}
}
- Agregamos otra clase para el objeto de acceso a datos de Productos (CD_Productos.cs), es decir, esta clase es responsable de las consultas a la base de datos o ejecutar comandos, referentes a la tabla Productos, como realizar las 4 operaciones CRUD.
- Importamos la librería Data y Data.SqlClient.
using System.Data; using System.Data.SqlClient;
- Finalmente creamos métodos para realizar las operaciones CRUD, en ella ejecutamos los procedimientos almacenados creado en la base de datos (Opcional, puedes hacerlo con comandos Transact-SQL en la misma clase).
public class CD_Productos
{
private CD_Conexion conexion = new CD_Conexion();
SqlDataReader leer;
DataTable tabla = new DataTable();
SqlCommand comando = new SqlCommand();
public DataTable Mostrar() {
comando.Connection = conexion.AbrirConexion();
comando.CommandText = "MostrarProductos";
comando.CommandType = CommandType.StoredProcedure;
leer = comando.ExecuteReader();
tabla.Load(leer);
conexion.CerrarConexion();
return tabla;
}
public void Insertar(string nombre,string desc,string marca,double precio, int stock ) {
comando.Connection = conexion.AbrirConexion();
comando.CommandText = "InsetarProductos";
comando.CommandType = CommandType.StoredProcedure;
comando.Parameters.AddWithValue("@nombre",nombre);
comando.Parameters.AddWithValue("@descrip",desc);
comando.Parameters.AddWithValue("@Marca",marca);
comando.Parameters.AddWithValue("@precio",precio);
comando.Parameters.AddWithValue("@stock",precio);
comando.ExecuteNonQuery();
comando.Parameters.Clear();
conexion.CerrarConexion();
}
public void Editar(string nombre, string desc, string marca, double precio, int stock,int id)
{
comando.Connection = conexion.AbrirConexion();
comando.CommandText = "EditarProductos";
comando.CommandType = CommandType.StoredProcedure;
comando.Parameters.AddWithValue("@nombre", nombre);
comando.Parameters.AddWithValue("@descrip", desc);
comando.Parameters.AddWithValue("@Marca", marca);
comando.Parameters.AddWithValue("@precio", precio);
comando.Parameters.AddWithValue("@stock", precio);
comando.Parameters.AddWithValue("@id",id);
comando.ExecuteNonQuery();
comando.Parameters.Clear();
conexion.CerrarConexion();
}
public void Eliminar(int id) {
comando.Connection = conexion.AbrirConexion();
comando.CommandText = "EliminarProducto";
comando.CommandType = CommandType.StoredProcedure;
comando.Parameters.AddWithValue("@idpro",id);
comando.ExecuteNonQuery();
comando.Parameters.Clear();
conexion.CerrarConexion();
}
}
Paso 6: Codificar- Capa de Negocio
- Agregamos una clase para el Objeto de Negocio de Producto (CN_Productos.cs), en esta clase puedes realizar toda la lógica de negocio, validaciones y seguridad. En este caso solo creamos métodos para invocar los métodos creados previamente en la capa de acceso a datos, para ello, necesitamos importar la capa de acceso a datos.
using CapaDatos;
CN_Productos.cs
public class CN_Productos
{
private CD_Productos objetoCD = new CD_Productos();
public DataTable MostrarProd() {
DataTable tabla = new DataTable();
tabla = objetoCD.Mostrar();
return tabla;
}
public void InsertarPRod ( string nombre,string desc,string marca,string precio, string stock){
objetoCD.Insertar(nombre,desc,marca,Convert.ToDouble(precio),Convert.ToInt32(stock));
}
public void EditarProd(string nombre, string desc, string marca, string precio, string stock,string id)
{
objetoCD.Editar(nombre, desc, marca, Convert.ToDouble(precio), Convert.ToInt32(stock),Convert.ToInt32(id));
}
public void EliminarPRod(string id) {
objetoCD.Eliminar(Convert.ToInt32(id));
}
}
Paso 7: Codificar- Capa de Presentación
- En el Formulario, agregamos un datagridview para mostrar los datos, texboxs para los campos del producto, y botones para editar, eliminar y guardar.
- Una vez diseñado el formulario, codificamos de la siguiente manera.
Form1.cs
public partial class Form1 : Form
{
CN_Productos objetoCN = new CN_Productos();
private string idProducto=null;
private bool Editar = false;
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
MostrarProdctos();
}
private void MostrarProdctos() {
CN_Productos objeto = new CN_Productos();
dataGridView1.DataSource = objeto.MostrarProd();
}
private void btnGuardar_Click(object sender, EventArgs e)
{
//INSERTAR
if (Editar == false)
{
try
{
objetoCN.InsertarPRod(txtNombre.Text, txtDesc.Text, txtMarca.Text, txtPrecio.Text, txtStock.Text);
MessageBox.Show("se inserto correctamente");
MostrarProdctos();
limpiarForm();
}
catch (Exception ex)
{
MessageBox.Show("no se pudo insertar los datos por: " + ex);
}
}
//EDITAR
if (Editar == true) {
try
{
objetoCN.EditarProd(txtNombre.Text, txtDesc.Text, txtMarca.Text, txtPrecio.Text, txtStock.Text,idProducto);
MessageBox.Show("se edito correctamente");
MostrarProdctos();
limpiarForm();
Editar = false;
}
catch (Exception ex) {
MessageBox.Show("no se pudo editar los datos por: " + ex);
}
}
}
private void btnEditar_Click(object sender, EventArgs e)
{
if (dataGridView1.SelectedRows.Count > 0)
{
Editar = true;
txtNombre.Text = dataGridView1.CurrentRow.Cells["Nombre"].Value.ToString();
txtMarca.Text = dataGridView1.CurrentRow.Cells["Marca"].Value.ToString();
txtDesc.Text = dataGridView1.CurrentRow.Cells["Descripcion"].Value.ToString();
txtPrecio.Text = dataGridView1.CurrentRow.Cells["Precio"].Value.ToString();
txtStock.Text = dataGridView1.CurrentRow.Cells["Stock"].Value.ToString();
idProducto = dataGridView1.CurrentRow.Cells["Id"].Value.ToString();
}
else
MessageBox.Show("seleccione una fila por favor");
}
private void limpiarForm() {
txtDesc.Clear();
txtMarca.Text = "";
txtPrecio.Clear();
txtStock.Clear();
txtNombre.Clear();
}
private void btnEliminar_Click(object sender, EventArgs e)
{
if (dataGridView1.SelectedRows.Count > 0)
{
idProducto = dataGridView1.CurrentRow.Cells["Id"].Value.ToString();
objetoCN.EliminarPRod(idProducto);
MessageBox.Show("Eliminado correctamente");
MostrarProdctos();
}
else
MessageBox.Show("seleccione una fila por favor");
}
}
Los comentarios están cerrados.