CRUD- Insertar, Editar, Eliminar y Mostrar Datos- C#, SQL Server, SP, POO y Arquitectura en Capas- Nivel Base
por RJ Code Advance
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
o 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.
o 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
o Añadimos un proyecto nuevo de tipo Aplicación de Windows Forms para la Capa de
Presentación.
o Añadimos un proyecto nuevo de tipo Biblioteca de Clases para la Capa de Dominio o Negocio.
o Añadimos un proyecto nuevo de tipo Biblioteca de Clases para la Capa de Acceso a Datos o
Persistencia.
o 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.
o En Capa de Presentación: Referenciamos a la Capa de Negocio.
o 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
o Agregamos una clase para la conexión a SQL Server (CD_Conexion.cs)
o Importamos la librería Data y Data.SqlClient.
using System.Data.SqlClient;
using System.Data;
o 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;
}
}
o 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.
o Importamos la librería Data y Data.SqlClient.
using System.Data;
using System.Data.SqlClient;
o 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
o 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
o En el Formulario, agregamos un datagridview para mostrar los datos, texboxs para los campos del
producto, y botones para editar, eliminar y guardar.
o 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");
}
}
Video Tutorial
Descargas
DESCARGAR PROYECTO + BASE DE DATOS
(GITHUB)
Ver CRUD (Editar, Mostrar) Nivel Intermedio
Login Cap 1- Diseñar Formulario Login Plano Moderno Transaparente y Efecto Placeholder (WaterMark) en TextBox – C# y
WinForm
por RJ Code Advance
INTRODUCCIÓN:
Hola, bienvenido al primer capítulo del tutorial “Login Completo” en C#, SQL Server, WinForms,
Programación Orientada a Objetos (POO) y Arquitectura en Capas, con buenas prácticas y
estrategias (Nivel intermedio).
En muchas ocasiones nos cansamos de los formularios clásicos de Windows, y deseamos realizar una interfaz
gráfica de usuario totalmente personalizado…, pero no sabemos cómo hacerla; déjame decirte que realmente
es muy sencillo, solamente necesitas creatividad y un poco de lógica.
En este tutorial aprenderá como diseñar un formulario de inicio de sesión con aspecto plano,
moderno, transparente y crear el efecto placeholder o watermark en el control TextBox. Puede ver
este tutorial en Youtube.
En los capítulos siguientes, se realizará la validación de usuario y contraseña, seguridad, permisos
de usuario, recuperar contraseña de usuario mediante email y finalmente editar perfil de usuario.
Puede ver todos los capítulos en los siguientes enlaces:
EN LOS ARTÍCULOS DEL BLOG
EN EL CANAL DE YOUTUBE
TUTORIAL:
Paso 1: Crear proyecto de aplicación de Windows Forms
o En Visual Studio, crea un proyecto nuevo de aplicación de Windows Form en Visual C# y asígnele
el nombre que desee. Yo lo nombraré FlatLoginWatermark. Si desea, cambie el nombre de
Form1.cs a FormLogin.cs.
Paso 2: Diseñe el Formulario de Inicio de Sesion.
o Diseñe el Formulario Login de la siguiente manera, la configuración de las propiedades se describen
abajo.
o Descripción de las propiedades del formulario y controles de usuario.
FormLogin:
-FormBorderStyle= None
-Opacity= 90 %
-Size= 780, 330
-BackColor= 39, 57, 80
-StartPosition= Center Screem
TextBox User y Pass
-BackColor= 39, 57, 80
-BorderStyle= None
-Font= Century Gothic 12 pt
-ForeColor= Silver
-Size= 408, 20
-Text (User)= Usuario
-Name=txtuser
-Text (Pass)= Contraseña
-Name=txtpass
Panel 1
-BackColor=0, 100, 182
-Dock=Left
-Name= Panel1
Button Login
-BackColor= 33, 53, 73
-FlatStyle= Flat
-FlatAppearance.BorderColor= 85, 159, 127
-FlatAppearance. MouseDownBackColor = 20, 20, 20
-FlatAppearance.MouseOverBackColor = 70, 118, 126
-ForeColor=LightGray
-Name=btnLogin
Size=408, 40
-Text= ACCEDER
Picture Box Minimize and Close
-Cursor= Hand
-Name(Minimize)= btnMinimizar
-Name(Close)= btnCerrar
Paso 3: Añadir Placeholder/ Marca de agua a TextBoxs
o Creamos el evento Enter y Leave de TextBox Usuario(txtuser) y TextBox Contraseña
(txtpass). Propiedades->eventos->doble click en Enter-> lo mismo para crear el evento Leave, tanto
para txtuser y txtpass.
o Una vez creado los 4 eventos, agregamos los siguientes codigos en los respectivos eventos y
controles.
private void txtuser_Enter(object sender, EventArgs e)
{
if (txtuser.Text == "Usuario")
{
txtuser.Text = "";
txtuser.ForeColor = Color.LightGray;
}
}
private void txtuser_Leave(object sender, EventArgs e)
{
if (txtuser.Text == "")
{
txtuser.Text = "Usuario";
txtuser.ForeColor = Color.Silver;
}
}
private void txtpass_Enter(object sender, EventArgs e)
{
if (txtpass.Text == "Contraseña")
{
txtpass.Text = "";
txtpass.ForeColor = Color.LightGray;
txtpass.UseSystemPasswordChar = true;
}
}
private void txtpass_Leave(object sender, EventArgs e)
{
if (txtpass.Text == "")
{
txtpass.Text = "Contraseña";
txtpass.ForeColor = Color.Silver;
txtpass.UseSystemPasswordChar = false;
}
}
Paso 4: Añadir Función de Minimizar y Cerrar
o Creamos el evento Click de Minimizar (btnMinimizar) y Cerrar (btnCerrar). Agregamos los
siguientes códigos.
private void btncerrar_Click(object sender, EventArgs e)
{
Application.Exit();
}
private void btnminimizar_Click(object sender, EventArgs e)
{
this.WindowState = FormWindowState.Minimized;
}
Paso 5: Añadir Función de Mover / Arrastrar el Formulario
o Importamos la librería Runtime.InteropServices.
using System.Runtime.InteropServices;
o Agregamos el siguiente fragmento de código.
[DllImport("user32.DLL", EntryPoint = "ReleaseCapture")]
private extern static void ReleaseCapture();
[DllImport("user32.DLL", EntryPoint = "SendMessage")]
private extern static void SendMessage(System.IntPtr hwnd, int wmsg, int wparam, int lparam);
o Una vez echo lo anterior, creamos el evento MouseDown de Pânel1 y el propio Formulario
(FormLogin), (Para que el formulario se pueda mover (Redimensionar) de cualquier parte), e
invocamos los métodos anteriores creados.
private void panel1_MouseDown(object sender, MouseEventArgs e)
{
ReleaseCapture();
SendMessage(this.Handle, 0x112, 0xf012, 0);
}
private void FormLogin_MouseDown(object sender, MouseEventArgs e)
{
ReleaseCapture();
SendMessage(this.Handle, 0x112, 0xf012, 0);
}
PD:
<DllImport(«user32.DLL», EntryPoint:=»ReleaseCapture»)>
<DllImport(«user32.DLL», EntryPoint:=»SendMessage»)>
Significa que el método declarado a continuación no está en .NET, sino en un archivo DLL externo (nativo).
En este caso, se encuentra en el archivo User32.dll, que es un componente estándar de Windows. El cual nos
permite utilizar los eventos/método del sistema operativo, en este caso capturar las señales del mouse.
¿Como funciona?
Es un conocido hack (&HF012& no es un syscommand documentado, no es parte del API).
SendMessage notifica al handler de la ventana (en este caso el formulario), mediante un WM_SYSCOMMAND
(&H112&), que comenzará a ser arrastrado (&HF012&), cuando sea haga click sobre el panel1, y se mueva
el ratón sin soltar el botón.
Y eso es todo
Puede ver este tutorial en Youtube:
DESCARGAS:
Descargar Iconos Utilizados
DESCARGAR ICONOS
Descargar Proyecto (Código Fuente)
DESCARGAR PROYECTO
Descargar Proyecto Login Completo + CRUD
La descarga del proyecto (No es gratis) incluye las funciones realizadas en los 6 capítulos del
proyecto LOGIN COMPLETO EN C#, sin embargo, el proyecto tiene un código fuente totalmente
modernizado y optimizado, además de incluir CRUD completo con manejo de imágenes, validación de datos
duplicados, entre otros. Todo ello con SQL Server, WinForm, Programación Orientada a Objetos (POO)
y Arquitectura en Capas, con buenas prácticas y estrategias, tanto de nivel intermedio o
avanzado. Puedes descargar las versiones de demostración y obtener los proyectos desde lo botones
a continuación:
FULL LOGIN NIVEL INTERMEDIO
FULL LOGIN NIVEL AVANZADO
