Ticker

6/recent/ticker-posts

Crear Web API en ASP.NET con ADO.Net usando Visual Studio 2019 - Fase I


Hola nuevamente espero estén todos bien, en el anterior articulo acerca de la Creación de Web API con C# y EF, inicialmente detallamos acerca de la arquitectura a nivel de despliegue e interacción entre los 4 componente de la infraestructura (On-Premise) que lo conforman. 

En este nuevo articulo veremos la creación e implementación de Web API con C# y ADO.Net, antes de iniciar con el desarrollo o elaboración, mencionar que la arquitectura a implementar será Arquitectura N-Capas Orientada al Dominio.

Las principales bondades de trabajar en capas son las agrupaciones horizontales lógicas de los componentes de tecnología que lo conforman la aplicación o el servicio. Es decir nos ayudan a diferenciar entre los diferentes tipos de tareas a realizar cada componente, todo esto nos ofrece o conlleva a un diseño que maximiza la reutilización y mantenibilidad en el código fuente y despliegue de nuestra aplicación.
Recordemos que la Arquitectura orientado a N-Capas (N-Layer) sólo se concentra en la separación de la lógica de aplicación o programa, no confundamos con la arquitectura 3-Niveles (3-Tiers).
Otras de las bondades es, sin lugar a duda se trata de aplicar el Principio de Separación de Responsabilidad (SoC - Separation of Concerns Principle) dentro de la Arquitectura Orientada al Dominio. 

En esta Fase I veremos acerca de la tabla de base de datos, creación de los proyectos, entidad y atributos e implementaremos el método listar con datos definido en el mismo programa - WEB API. Bueno, sin mayores detalle iniciamos la parte práctica.

Lo que veremos en este articulo:

  • Requisitos para nuestro ejemplo práctico.
  • Paso 1: Detalle de base de datos.
  • Paso 2: Crear el proyecto WebApi.
  • Paso 3: Crear e implementar el proyecto Models.
  • Paso 4: Crear e implementar el proyecto Data.Access.
  • Paso 5: Crear e implementar el proyecto WebApi.Data.Business.
  • Paso 6: Crear e implementar el proyecto WebApi.Domain.
  • Paso 7: Implementar el Proyecto WebApi.
  • Paso 8: Testear el método "ListUsers" desde Postman.
  • Conclusión.

Requisitos para nuestro ejemplo práctico:

  1. Lenguaje de programación C# y T-SQL para manipulación de datos.
  2. Microsoft Visual Studio Community 2019
  3. .Net Framework 4.6
  4. ADO.Net (tecnología para la conexión a datos)
  5. Microsoft SQL Server 2017 Express
  6. Testear con Postman
Para este ejemplo práctico veremos el proceso del ya conocido CRUD, para lo cual haremos uso de la base de datos que se implemento en el articulo "CRUD - Base de Datos con Microsoft SQL Server 2019", ademas crearemos cinco proyectos y finalmente testeamos la API desarrollada desde el Postman.

Paso 1: Detalle de base de datos:

La base de datos es BD_TEST y tabla USUARIO que esta conformado por los siguientes campos:
USE BD_TEST
GO
CREATE TABLE dbo.USUARIO(
       Id int IDENTITY(1,1) NOT NULL,
       usuario varchar(50) NOT NULL,
       contrasena varchar(250) NOT NULL,
       intentos int NOT NULL,
       nivelSeg decimal(18, 0) NOT NULL,
       fechaReg date NOT NULL
)
GO
ALTER TABLE dbo.USUARIO ADD  CONSTRAINT PK_USUARIO PRIMARY KEY (id), CONSTRAINT DF_Usuario_fechaReg  DEFAULT (getdate()) FOR fechaReg

Paso 2: Crear el proyecto WebApi:

Ingresar al Microsoft Visual Studio Community 2019 y crear el proyecto de tipo Aplicación web ASP.Net (.NET Framework) con el nombre de ArquitecturaWebApi  con la versión .NET Framework 4.6:
Buscar y seleccionar el proyecto de tipo Aplicación web ASP.Net (.NET Framework) y clic en siguiente.

Ingresamos el nombre, la ubicación y seleccionar la versión del Framework y clic en Crear

Seleccionar el de tipo API web y clic en Crear

Paso 3: Crear e implementar el proyecto Models:

Luego creamos el proyecto de tipo Biblioteca de clases (.NET Framework) con el nombre de ArquitecturaWebApi.Models con la versión .NET Framework 4.6 (las 2 imágenes siguientes se debe repetir los mismo pasos para los proyectos Data.Access, Data.Business y Domain):
Seleccionar el tipo de proyecto de Biblioteca de clases (.NET Framework) y clic en Siguiente

Asignar nombre, ubicación y seleccionar Framework y clic en Crear

Además agregar la clase de entidad UsuarioModel (para mantener el principio de SoC creamos el directorio Usuario y dentro de ello creamos la clase) con los siguientes atributos:
Clic derecho en el directorio, seleccionar Agregar/Nuevo elemento

Atributos que lo conforman la clase de entidad UsuarioModel:
namespace ArquitecturaWebApi.Models.Usuario
{
    public class UsuarioModel
    {
        public int id { get; set; }
        public string usuario { get; set; }
        public string contrasena { get; set; }
        public int intentos { get; set; }
        public decimal nivelSeg { get; set; }
    }
}
Hasta aquí ya se a creado nuestra entidad de datos, con el fin de hacer la referencia a la tabla USUARIO de nuestra base de datos BD_TEST, por ahora no se está considerando el campo fechaReg (esta por defecto para capturar la fecha actual de servidor de base de datos)

Paso 4: Crear e implementar el proyecto Data.Access:

Ahora creamos el proyecto de tipo Biblioteca de clases (.NET Framework) con el nombre de ArquitecturaWebApi.Data.Access con la versión .NET Framework 4.6 (se considera los pasos de las 2 imágenes iniciales del poryecto Models):

Seguidamente referenciamos al proyecto ArquitecturaWebApi.Models para acceder a los atributos de nuestra entidad UsuarioModel, por ahora sólo implementaremos un método de tipo IEnumerable para devolver una interfaz enumerada de solo de lectura (nombre ListUsers) y listaremos datos definidos en el en mismo programa (aún no se establece la conexión a la base de datos):
//Importar para acceder al poryecto Models y directio Usuario
using ArquitecturaWebApi.Models.Usuario; 
namespace ArquitecturaWebApi.Data.Access.DAL
{
    public class UsuarioDAL
    {
        public static IEnumerable<UsuarioModel> ListUsers()
        {
            //Referanciamos a la entidad UsuarioModel
            UsuarioModel[] resultUsers = new UsuarioModel[]
            {
            new UsuarioModel { id = 1, usuario = "HADSON", contrasena = "tuh0L@1234", intentos = 5, nivelSeg = 5},
            new UsuarioModel { id = 2, usuario = "CESAR01", contrasena = "Ce$ar1234", intentos = 5, nivelSeg = 5}
            }; 
            return resultUsers;
        }
    }
}

Paso 5: Crear e implementar el proyecto WebApi.Data.Business:

Ahora crearemos el proyecto de nombre ArquitecturaWebApi.Data.Business, también de tipo Biblioteca de clases (.NET Framework) con el .NET Framework 4.6 (se considera los pasos de las 2 imágenes iniciales del poryecto Models):

Seguidamente referenciamos los proyectos ArquitecturaWebApi.ModelsArquitecturaWebApi.Data.Access para acceder a la entidad UsuarioModel y creamos el método ListUsers que invoca al método ListUsers del proyecto ArquitecturaWebApi.Data.Access para listar la interfaz enumerada de solo de lectura:
//Importar los poryectos Models y Data.Access, para acceder al directio Usuario y DAL
using ArquitecturaWebApi.Models.Usuario;
using ArquitecturaWebApi.Data.Access.DAL;

namespace ArquitecturaWebApi.Data.Business
{
    public class Usuario
    {       
        public static IEnumerable<UsuarioModel> ListUsers()
        {
            try
            {
                //Retornamos la lista de valores del método ListUsers() que invocamos
                return UsuarioDAL.ListUsers();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
    }
}

Paso 6: Crear e implementar el proyecto WebApi.Domain:

Para ya ir finalizando esta Fase I acerca de la tabla y creación de los proyectos, crearemos el último proyecto de nombre ArquitecturaWebApi.Domain, también de tipo Biblioteca de clases (.NET Framework) con el .NET Framework 4.6 (se considera los pasos de las 2 imágenes iniciales del poryecto Models):

Seguidamente referenciamos los proyectos ArquitecturaWebApi.Models y ArquitecturaWebApi.Data.Business para acceder a la entidad UsuarioModel y creamos el método ListUsers que invoca al método ListUsers del proyecto ArquitecturaWebApi.Data.Business para listar la interfaz enumerada de solo de lectura:
//Importar para acceder al proyecto Models y directio Usuario, adempas importar el proyecto Data.Business
using ArquitecturaWebApi.Models.Usuario;
using ArquitecturaWebApi.Data.Business;

namespace ArquitecturaWebApi.Domain
{
    public class UsuarioDomain
    {
        public IEnumerable<UsuarioModel> ListUsers()
        {
            try
            {//Invocamos al método listar de la capa negocio "Data.Business"
                return Usuario.ListUsers();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
    }
}

Paso 7: Implementar el Proyecto WebApi:

Para finalizar implementaremos en nuestro proyecto ArquitecturaWebApi con 2 métodos con el fin de verificar y testear el correcto funcionamiento de lo desarrollado hasta ahora.

Seguidamente crear el controlador UsuarioController, clic derecho en directorio Controllers y seleccionar agregar\controlador y crear los métodos Get() y Get(int id):
Seleccionar Controlador de Web API 2 con acciones de lectura y escritura y clic en Agregar 

Asignar nombre Usuario.... (la palabra Controller es parte del estándar de MVC) y clic en agregar

Importar los proyectos ArquitecturaWebApi.Models y ArquitecturaWebApi.Domain, luego invocar al método ListUsers, y finalizamos con la implementación de los siguientes métodos Get() y Get(int id):

//Importar los proyectos
using ArquitecturaWebApi.Models.Usuario;
using ArquitecturaWebApi.Domain;

namespace ArquitecturaWebApi.Controllers
{
    public class UsuarioController : ApiController
    {
        UsuarioDomain usuarioDomain = new UsuarioDomain();

        /// <summary>
        /// GET: api/Usuario (retorna toda la lista)
        /// </summary>
        /// <returns></returns>
        [ResponseType(typeof(IEnumerable<UsuarioModel>))]
        public IEnumerable<UsuarioModel> Get()
        {
            return usuarioDomain.ListUsers().ToArray();
            //return users;
        }

        /// <summary>
        /// GET: api/Usuario/5 (retorna los valores de un sólo registro según el valor id)
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public IHttpActionResult Get(int id)
        {
            var usuario = usuarioDomain.ListUsers().ToArray().FirstOrDefault((p) => p.id == id);
            //var usuario = users.FirstOrDefault((p) => p.id == id);
            if (usuario == null)
            {
                return NotFound();
            }
            return Ok(usuario);
        }
    }
}
Recuerden antes de importar los proyecto Models y Domain se debe agregar la referencia

Paso 8: Testear el método "ListUsers" desde Postman:

Para esto debemos establecer como proyecto de inicio al proyecto ArquitecturaWebApi y seguidamente ejecutar la aplicación; desde Postman selecionamos Get y ingresamos la ruta https://localhost:44336/api/Usuario o https://localhost:44336/api/Usuario/1 (pueden lograr el mismo resultado desde el mismo browser):

Resultado https://localhost:44336/api/Usuario

Resultado de https://localhost:44336/api/Usuario/1

Conclusión:

Como mencione en el anterior articulo acerca de las Web Api, en definitivo no es complicado de implementar, y la flexibilidad que nos ofrece y su principal ventaja que reside en la independencia que proporciona frente a cualquier aplicación que la puede consumidor, sin embargo en este articulo quería dar por iniciado acerca de la implementación de Web Api usando una arquitectura en capas e ir dando algunas pinceladas (solo se detallo las características de la tabla) a nivel base datos con el fin de aplicar ADO.Net. 
Como siempre gratitud a Dios por todo, y nuevamente agradecerles de antemano por la revisión y lectura de este nuevo articulo, nos vemos en el Fase II.

Publicar un comentario

0 Comentarios