Ticker

6/recent/ticker-posts

Windows Forms - CRUD con Visual Studio y SQL Server

Hadsonpar diciembre 05, 2021

En este tutorial práctico, aprenderá a crear una aplicación de Windows Forms (WinForms) haciendo uso del IDE Visual Studio 2019. Una vez que se haya generado la aplicación inicial, desarrollaremos las operaciones básica (CRUD en ingles - Create, Read, Update y Delete) como Insertar, Mostrar Datos (seleccionar), Editar y Eliminar en base al lenguaje de programación C#, con base de datos en SQL Server en base a Store Procedure (procedimientos almacenado) y POO (programación orientado a objetos).

Lo que veremos en este tutorial:

  • Requisitos.
  • Lo que debes saber antes de iniciar con este tutorial práctico.
  • Crear la solución del proyecto según la arquitectura de N-Capas.
  • Implementar el acceso a la base de datos.
  • Implementar las operaciones en la capa de datos.
  • Referenciar e implementar las operaciones en la capa de negocios.
  • Diseñar e implementar la capa interfaz de nuestra aplicación - CRUD.
  • Referencias para el desarrollo de Windows Forms:
  • Conclusiones.

Requisitos:

  1. Microsoft Visual Studio Community 2019
  2. .NET Framework 4.6 con C# como lenguaje de programación
  3. Microsoft SQL Server Management Studio
  4. Transact-SQL como lenguaje de base de datos para SQL Server

Lo que debes saber antes de iniciar con este tutorial práctico:

Con Windows Forms se puede desarrollar y compilar aplicaciones de escritorio de Windows, es decir proporciona una de las formas más productivas de crear aplicaciones de escritorio basadas en el entorno de desarrollo integrado que proporcionado en Visual Studio. Windows Forms admite un amplio conjunto de características de desarrollo de aplicaciones, incluidos controles, gráficos, enlace de datos y entrada del usuario, actualmente existe dos manera para la implementaciones de Windows Forms:

1. La implementación de código abierto: Esta versión se ejecuta en base a .NET Core 5+ (y .NET Core 3.1), soportado con el IDE de Visual Studio 2019 versión 16.8.

La versión más reciente de Windows Forms es para .NET 6 usando la Visual Studio 2022, versión 17.0.

2. La implementación de .NET Framework 4.6: Compatible con Visual Studio 2017, Visual Studio 2019 y Visual Studio 2022.

Para este tutorial práctico en nuestro desarrollo haremos uso de .NET Framework 4.6 con los objetos (tablas y procedimiento almacenados) de la base de datos BD_TEST visto en el articulo de elaboración de CRUD - Base de Datos con Microsoft SQL Server 2019. Sin mayores detalles iniciemos con el desarrollo.

.NET Framework 4 es una versión de .NET solo para Windows y se considera un componente del sistema operativo Windows.

 

Crear la solución del proyecto según la arquitectura de N-Capas:

La arquitectura en N-Capas es la más común para el desarrollo de aplicaciones para Windows Forms, y suelen abreviar como UI (interfaz o presentación de usuario), BLL (capa de lógica de negocios) y DAL (capa de acceso a datos). Con esta arquitectura, los usuarios realizan solicitudes a través de la capa de interfaz de usuario, que interactúa con la capa BLL. BLL, a su vez, puede llamar a DAL para las solicitudes de acceso de datos. La capa de interfaz de usuario no debe realizar solicitudes directamente a DAL, ni debe interactuar con la persistencia de forma directa a través de otros medios. Del mismo modo, BLL solo debe interactuar con la persistencia a través de DAL. De este modo, cada capa tiene su propia responsabilidad.

Arquitectura en 3 Capas, capa UI, BLL y DAL


Implementar el acceso a la base de datos:

A la base de datos BD_TEST visto en el articulo de elaboración de CRUD - Base de Datos con Microsoft SQL Server 2019, se creara un nuevo procedimiento almacenado SP_SELECCIONAR_ALL_USUARIO.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
-- =============================================
-- Author:		<Author - Hadson Paredes>
-- Create date: <Create Date - 21-12-2021>
-- Description:	<Selecionar todos los registros>
-- =============================================
CREATE PROCEDURE [dbo].[SP_SELECCIONAR_ALL_USUARIO] 
AS
BEGIN
	SET NOCOUNT ON;
	SELECT  * FROM	 [dbo].[USUARIO]
END

En esta capa de acceso a la base de datos crearemos 2 clases DALConexion.cs  y DALUsuario.cs. En la clase DALConexion.cs crearemos los métodos de conexión a la base de datos de SQL Server.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
using System.Data;
using System.Data.SqlClient;

namespace CapaDatos
{
    public class DALConexion
    {
        /// <summary>
        /// Cadena de conexión para el acceso a la base de datos SQL Server
        /// </summary>
        private SqlConnection Conexion = new 
            SqlConnection("Server=DESKTOP-CVDA991;DataBase=BD_TEST;User Id=sa; Password=desa1;");

        /// <summary>
        /// Abrir la conexión hacia la base de datos
        /// </summary>
        /// <returns></returns>
        public SqlConnection OpenConnection()
        {
            if (Conexion.State == ConnectionState.Closed)
                Conexion.Open();
            return Conexion;
        }

        /// <summary>
        /// Cerrar la conexión hacia la base de datos
        /// </summary>
        /// <returns></returns>
        public SqlConnection CloseConnection()
        {
            if (Conexion.State == ConnectionState.Open)
                Conexion.Close();
            return Conexion;
        }
    }
}

Implementar las operaciones en la capa de datos:

En la capa DALUsuario.cs implementaremos los métodos de las operaciones como Insertar, Mostrar Datos (seleccionar), Editar y Eliminar.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
using System;
using System.Data.SqlClient;
using System.Data;

namespace CapaDatos
{
    /// <summary>
    /// Clase que conforman los métodos para el acceso a datos a través 
    /// de los procedimientos almacenados "Store Procedure".
    /// </summary>
    public class DALUsuario
    {
        private DALConexion conexion = new DALConexion();

        SqlDataReader dataReader;
        DataTable table = new DataTable();
        SqlCommand comando = new SqlCommand();

        /// <summary>
        /// Método para Insertar "Create" los datos
        /// </summary>
        public void CreateUsuario(string usuario, string contrasena, int intentos, double nivelSeg, DateTime fechaReg)
        {
            comando.Connection = conexion.OpenConnection();
            comando.CommandText = "SP_INSERTAR_USUARIO";
            comando.CommandType = CommandType.StoredProcedure;
            comando.Parameters.AddWithValue("@usuario", usuario);
            comando.Parameters.AddWithValue("@contrasena", contrasena);
            comando.Parameters.AddWithValue("@intentos", intentos);
            comando.Parameters.AddWithValue("@nivelSeg", nivelSeg);
            comando.Parameters.AddWithValue("@fechaReg", fechaReg);

            comando.ExecuteNonQuery();
            comando.Parameters.Clear();
        }

        /// <summary>
        /// Método para Seleccionar "Read" los datos
        /// </summary>
        public DataTable ReadAllUsuario() 
        {        
            comando.Connection = conexion.OpenConnection();
            comando.CommandText = "SP_SELECCIONAR_ALL_USUARIO";
            comando.CommandType = CommandType.StoredProcedure;
            dataReader = comando.ExecuteReader();
            table.Load(dataReader);
            conexion.CloseConnection();
            return table;            
        }

        /// <summary>
        /// Método para Actualizar "Update" los datos
        /// </summary>
        /// <param name="id">parámetro para filtra y actualizar el registro de acurdo al id</param>
        public void UpdateUsuario(string usuario, string contrasena, int intentos, double nivelSeg, DateTime fechaReg, int id)
        {
            
            comando.Connection = conexion.OpenConnection();
            comando.CommandText = "SP_ACTUALIZAR_USUARIO";
            comando.CommandType = CommandType.StoredProcedure;
            comando.Parameters.AddWithValue("@usuario", usuario);
            comando.Parameters.AddWithValue("@contrasena", contrasena);
            comando.Parameters.AddWithValue("@intentos", intentos);
            comando.Parameters.AddWithValue("@nivelSeg", nivelSeg);
            comando.Parameters.AddWithValue("@fechaReg", fechaReg);
            comando.Parameters.AddWithValue("@id",id);

            comando.ExecuteNonQuery();
            comando.Parameters.Clear();
        }

        /// <summary>
        /// Método para Eliminar "Delete" los datos
        /// </summary>
        /// <param name="id">parámetro de entrada para eliminar el registro de acuerdo al filtro id</param>
        public void DeleteUsuario(int id) {
            comando.Connection = conexion.OpenConnection();
            comando.CommandText = "SP_ELIMINAR_USUARIO";
            comando.CommandType = CommandType.StoredProcedure;
            comando.Parameters.AddWithValue("@id", id);

            comando.ExecuteNonQuery();
            comando.Parameters.Clear();
        }

    }
}

Referenciar e implementar las operaciones en la capa de negocios:

Seguidamente referenciaremos las operaciones como Insertar, Mostrar Datos (seleccionar), Editar y Eliminar desde la capa de negocios.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System;
using System.Data;
using CapaDatos;

namespace CapaNegocio
{
    public class BLLUsuario
    {
        private DALUsuario objetoCD = new DALUsuario();

        public DataTable View() {

            DataTable tabla = new DataTable();
            tabla = objetoCD.ReadAllUsuario();
            return tabla;
        }
        public void Create(string usuario, string contrasena, int intentos, double nivelSeg, DateTime fechaReg)
        {

            objetoCD.CreateUsuario(usuario, contrasena, Convert.ToInt32(intentos),Convert.ToDouble(nivelSeg), fechaReg);
    }

        public void Update(string usuario, string contrasena, int intentos, double nivelSeg, DateTime fechaReg, int id)
        {
            objetoCD.UpdateUsuario(usuario, contrasena, Convert.ToInt32(intentos), Convert.ToDouble(nivelSeg), 
                fechaReg, Convert.ToInt32(id));
        }

        public void Delete(int id) {

            objetoCD.DeleteUsuario(id);
        }

    }
}

Diseñar e implementar la capa interfaz de nuestra aplicación - CRUD:

Para el diseño crearemos un From y agregaremos los siguientes controles con TextBox, Button y un DataGridView:

Finalmente implementaremos el code behind c# de nuestro From:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
using System;
using System.Windows.Forms;
using CapaNegocio;

namespace CapaPresentacion
{
    public partial class Form1 : Form
    {
        BLLUsuario objetoCN = new BLLUsuario();
        private int idProducto=0;
        private bool Editar = false;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            ViewAllUsuario();
        }

        private void ViewAllUsuario() {

            BLLUsuario objeto = new BLLUsuario();
            dataGridView1.DataSource = objeto.View();
        }

        private void btnGuardar_Click(object sender, EventArgs e)
        {            
            if (Editar == false)
            {
                try
                {
                    //Validación de controles
                    if (txtUsuario.Text == "")
                    {
                        MessageBox.Show("Falta Ingresar el Usuario", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        txtUsuario.Focus();
                        return;
                    }
                    if (txtContrasena.Text == "")
                    {
                        MessageBox.Show("Falta Ingresar la Contraseña", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        txtContrasena.Focus();
                        return;
                    }
                    if (txtNroIntentos.Text == "")
                    {
                        MessageBox.Show("Falta Ingresar el Nro de Intentos", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        txtNroIntentos.Focus();
                        return;
                    }
                    if (txtNivelSeg.Text == "")
                    {
                        MessageBox.Show("Falta Ingresar el Nivel de Seguridad", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        txtNivelSeg.Focus();
                        return;
                    }
                    if (txtFechaReg.Text == "")
                    {
                        MessageBox.Show("Falta Ingresar la Fecha de Registro", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        txtFechaReg.Focus();
                        return;
                    }

                    objetoCN.Create(txtUsuario.Text, txtContrasena.Text, Convert.ToInt32(txtNroIntentos.Text), Convert.ToDouble(txtNivelSeg.Text), Convert.ToDateTime(txtFechaReg.Text));
                    MessageBox.Show("Se guardo correctamente");
                    ViewAllUsuario();
                    ClearControls();
                }
                catch (Exception ex)
                {
                    MessageBox.Show("No se pudo insertar los datos, se encontro el siguiente error : " + ex);
                }
            }
            
            if (Editar == true) {

                try
                {
                    objetoCN.Update(txtUsuario.Text, txtContrasena.Text, Convert.ToInt32(txtNroIntentos.Text), Convert.ToDouble(txtNivelSeg.Text), Convert.ToDateTime(txtFechaReg.Text), idProducto);
                    MessageBox.Show("Registro actualizado correctamente");
                    ViewAllUsuario();
                    ClearControls();
                    Editar = false;
                }
                catch (Exception ex) {
                    MessageBox.Show("No se pudo insertar los datos, se encontro el siguiente error : " + ex);
                }
            }
        }        

        private void ClearControls() {
            txtContrasena.Clear();
            txtNroIntentos.Clear();
            txtNivelSeg.Clear();
            txtFechaReg.Clear();
            txtUsuario.Clear();
        }

        private void btnEliminar_Click(object sender, EventArgs e)
        {
            if (dataGridView1.SelectedRows.Count > 0)
            {
                idProducto = Convert.ToInt32(dataGridView1.CurrentRow.Cells["Id"].Value);
                objetoCN.Delete(idProducto);
                MessageBox.Show("Registro eliminado correctamente");
                ViewAllUsuario();
            }
            else
                MessageBox.Show("Por favor debe seleccionar una fila");
        }

        private void btnEditar_Click(object sender, EventArgs e)
        {
            if (dataGridView1.SelectedRows.Count > 0)
            {
                Editar = true;
                txtUsuario.Text = dataGridView1.CurrentRow.Cells["usuario"].Value.ToString();
                txtContrasena.Text = dataGridView1.CurrentRow.Cells["contrasena"].Value.ToString();
                txtNroIntentos.Text = dataGridView1.CurrentRow.Cells["intentos"].Value.ToString();
                txtNivelSeg.Text = dataGridView1.CurrentRow.Cells["nivelSeg"].Value.ToString();
                txtFechaReg.Text = dataGridView1.CurrentRow.Cells["fechaReg"].Value.ToString();
                idProducto = Convert.ToInt32(dataGridView1.CurrentRow.Cells["Id"].Value);
            }
            else
                MessageBox.Show("Por favor debe seleccionar una fila");
        }
    }
}

Referencias para el desarrollo de Windows Forms:

Conclusiones:

Se implemento el ejemplo CRUD en Windows Forms haciendo uso del lenguaje C# con base de datos SQL Server.

Asimismo se hace uso de ADO.Net para el uso de los objetos SqlClient, como SqlConnection, SqlDataReader, DataTable y SqlCommand.

Descarga la fuente:

Directorio 01-CRUD

Gratitud a Dios 😊 y gracias a todos ustedes por la acogida de este nuevo articulo, éxitos y bendiciones 🙏 y un gran abrazo a todos ✌...!!!

Hadsonpar

Publicadas por Hadsonpar

Apasionado por las nuevas tecnologías, la investigación, los patrones de diseño y las buenas prácticas; con experiencia y participación en diversos proyectos de banca y seguros desde la etapa de análisis, diseño, desarrollo, implementación, testing y certificación.

Publicar un comentario

0 Comentarios