Mostrando las entradas con la etiqueta Web API. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Web API. Mostrar todas las entradas

sábado, 1 de febrero de 2020

ASP.NET Core - Crear Web API con C# y EF

Que tal a todos, hoy quiero compartirles acerca de la creación de Web API con C# y EF, bueno comencemos con algo de teoría. 


API significa interfaz de programación de aplicaciones, es decir es un conjunto de definiciones y protocolos que se utiliza para desarrollar e integrar entre software de distintas aplicaciones, que nos permiten que sus productos y servicios se comuniquen con otros (intermedio), sin necesidad de saber cómo están implementados. Al hacer uso de las API's en el desarrollo de las aplicaciones, nos permite ahorrar tiempo y dinero. Las API nos otorgan flexibilidad; simplifican el diseño e implementación, la administración y el uso de las aplicaciones, y proporcionan oportunidades de innovación e independencia, lo cual es ideal al momento de diseñar nuevos productos.

Características de WEB API
  • Admite acciones CRUD basadas en convenciones, ya que funciona con los verbos HTTP GET, POST, PUT y DELETE.
  • Las respuestas tienen un encabezado de Aceptar y un código de estado HTTP.
  • Las respuestas están formateadas por MediaTypeFormatter de WEB API en JSON, XML o cualquier formato que desee agregar como MediaTypeFormatter.
  • Puede aceptar y generar el contenido que puede no estar orientado a objetos como imágenes, archivos PDF, etc.
  • Tiene soporte automático para OData. Por lo tanto, colocando el nuevo atributo [Queryable] en un método de controlador que devuelve IQueryable, los clientes pueden usar el método para la composición de consulta OData.
  • Puede alojarse en la aplicación o en IIS, JBOSS, WAS u Otros Servidores.
  • También es compatible con las características de MVC, tales como enrutamiento, controladores, resultados de acciones, filtro, carpetas de modelo, contenedor IOC o inyección de dependencia que lo hace más simple y robusto.
¿Por qué elegir WEB API?
  • Si necesitamos un servicio web y no necesitamos SOAP, entonces ASP.Net (u ASP.Net CORE) Web API es la mejor opción.
  • Se utiliza para crear servicios HTTP simples, que no estén basados ​​en SOAP, en la parte superior de la canalización de mensajes de WCF existente.
  • No tiene una configuración tediosa y extensa como el servicio WCF REST.
  • Creación de servicio simple con WEB API. Con WCF REST Services, la creación de servicios es difícil.
  • Solo se basa en HTTP y es fácil de definir, exponer y consumir de manera REST-ful.
  • Es una arquitectura liviana y buena para dispositivos que tienen ancho de banda limitado como teléfonos inteligentes.
  • Es de código abierto.
Sugiero que revisen más conceptos que hay muchísima información al respecto, ahora que conocemos algunos conceptos acerca de las web api iniciemos con nuestro primer demo:

Requisitos para nuestro primer demo:
Microsoft Visual Studio Community 2019
.Net Core 3.1
Microsoft Entity Framework Core
Postman

Crear Solución:
Se puede crear directamente el proyecto y al mismo tiempo se crear la solución, sin embargo para familiarizarnos con la nueva versión del IDE VS2019 crearemos paso a paso la solución y respectivamente el proyecto.

Selecciona solución en blanco y clic en siguiente
Ingresa el nombre de WEB_API_CORE y clic en Crear
Crear Proyecto Web API:
Seguidamente clic derecho en la solución y seleccionar agregar nuevo proyecto, y ubicamos el tipo de proyecto Aplicación web ASP.NET Core.

Seleccionamos Aplicación web ASP.NET Core y clic en Siguiente
Ingresamos el nombre y clic en Crear
Seleccionar ASP.NET Core 3.1 y para finalizar clic en Crear
Crear Modelo:
Para crear nuestro modelo, se agregará la carpeta de nombre Models en la raíz del proyecto creado (clic derecho, agregar carpeta):

Carpeta creado
Luego se agregará una clase de nombre ClsPersona.cs (clic derecho en la carpeta Models y agregar clase)
Seguidamente se agregara los siguiente atributos en la clase (representa el modelo Persona) ClsPersona.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace WEB_API_CORE.Models
{
    public class ClsPersona
    {
        public long id { get; set; }
        public string nombre { get; set; }
        public string apellido { get; set; }
        public string sexo { get; set; }
        public string dni { get; set; }
    }
}

Microsoft Entity Framework Core InMemory:
Qué es Microsoft.EntityFrameworkCore.InMemory: Proveedor de base de datos que permite usar Entity Framework Core con una base de datos en memoria, que sirve especialmente para realizar pruebas.

Instalar EF Core InMemory: Desde la consola de administración de paquetes de NuGet, clic en el menú herramientas, administración de paquetes NuGet y por último clic en consola del administración de paquetes e ingresar las siguiente línea Install-Package Microsoft.EntityFrameworkCore.InMemory -Version 3.1.1

Instalando EF Core InMemory
Microsoft Entity Framework Core SqlServer:
Qué es Microsoft.Entity.Framework.Core.SqlServer: Proveedor de base de datos que permite usar Entity Framework Core con Microsoft SQL Server incluido SQL Azure:

Instalar EF Core SqlServer: Desde el administración de paquetes NuGet para solución, clic en el menú herramientas, administración de paquetes NuGet y por último clic en administración de paquetes NuGet para solución... realiza la búsqueda desde la pestaña examinar e ingresar Microsoft.EntityFrameworkCore.SqlServer, después de ubicar clic en proyecto y clic en instalar.

Instalando EF Core SqlServer
Al concluir la instalación de Microsoft.Entity.Framework.Core.SqlServer automáticamente se creara el ya conocido CRUD, es decir se crearan los siguiente métodos en la clase  Controllers (ClsPersonasController.cs):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using WEB_API_CORE.Models;

namespace WEB_API_CORE.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ClsPersonasController : ControllerBase
    {
        private readonly ClsPersonaContext _context;

        public ClsPersonasController(ClsPersonaContext context)
        {
            _context = context;
        }

        // GET: api/ClsPersonas
        [HttpGet]
        public async Task<ActionResult<IEnumerable<ClsPersona>>> GetClsPersonas()
        {
            return await _context.ClsPersonas.ToListAsync();
        }

        // GET: api/ClsPersonas/5
        [HttpGet("{id}")]
        public async Task<ActionResult<ClsPersona>> GetClsPersona(long id)
        {
            var clsPersona = await _context.ClsPersonas.FindAsync(id);

            if (clsPersona == null)
            {
                return NotFound();
            }

            return clsPersona;
        }

        // PUT: api/ClsPersonas/5
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for
        // more details see https://aka.ms/RazorPagesCRUD.
        [HttpPut("{id}")]
        public async Task<IActionResult> PutClsPersona(long id, ClsPersona clsPersona)
        {
            if (id != clsPersona.id)
            {
                return BadRequest();
            }

            _context.Entry(clsPersona).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ClsPersonaExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return NoContent();
        }

        // POST: api/ClsPersonas
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for
        // more details see https://aka.ms/RazorPagesCRUD.
        [HttpPost]
        public async Task<ActionResult<ClsPersona>> PostClsPersona(ClsPersona clsPersona)
        {
            _context.ClsPersonas.Add(clsPersona);
            await _context.SaveChangesAsync();

            return CreatedAtAction("GetClsPersona"new { id = clsPersona.id }, clsPersona);
        }

        // DELETE: api/ClsPersonas/5
        [HttpDelete("{id}")]
        public async Task<ActionResult<ClsPersona>> DeleteClsPersona(long id)
        {
            var clsPersona = await _context.ClsPersonas.FindAsync(id);
            if (clsPersona == null)
            {
                return NotFound();
            }

            _context.ClsPersonas.Remove(clsPersona);
            await _context.SaveChangesAsync();

            return clsPersona;
        }

        private bool ClsPersonaExists(long id)
        {
            return _context.ClsPersonas.Any(e => e.id == id);
        }
    }
}

Todo esto ocurre porque se esta haciendo uso del ORM (Object-relational mapper) Entity Framework nos olvidamos de estar creando manualmente nuestro código (una buena alternativa para realizar pruebas - en lo personal no uso mucho ORMs prefiero hacer uso de ADO.Net).

Testear con Postman:
Postman permite el envío de peticiones HTTP sin necesidad de desarrollar un cliente, iniciemos  nuestro test:
Ingresamos los datos con e verbs de tipo POST, ingresamos los datos en el Body del application/json y clic en Send
Consultamos los datos con el verbs de tipo GET, e ingresamos 1 en la url ..api/ClsPeronas/1  y clic en Send
Modifica los datos con el verbs de tipo PUT, modifica el nombre en el Body del application/json y clic en Send
Puede seguir implementando y testeando los otros método de petición HTTP verbs y recordemos los métodos más relevantes son:

POST: crear un recurso nuevo.
PUT: modificar un recurso existente.
GET: consultar información de un recurso.
DELETE: eliminar un recurso determinado.
PATCH: modificar solamente un atributo de un recurso.

Conclusión:
En definitivo las Web APIs no es complicado de implementar, y la flexibilidad que nos ofrece es su principal ventaja y uso que reside en la independencia que proporciona frente a cualquier consumidor, sin considerar el lenguaje o plataforma con el que se acceda a ella. Permitiendo que una misma API REST (también se puede resolver de tipo XML) sea consumida por infinidad de clientes sea cual sea la naturaleza de estos y que el cambio a cualquier otro tipo de consumidor no provoque impacto alguno.

Pronto podrás descargar la fuente desde:
Nuevamente agradecer de antemano por la revisión y lectura de este pequeño post, nos vemos en el siguiente tutorial.