Mencionar que esta arquitectura esta basado para On-Premise (en local), quiere decir que los servidores de aplicación y base de datos estarán dentro de la infraestructura de la organización (no cloud computing).
Revisemos 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 |
 |
| Ingrese 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) |
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:
Puede seguir implementando y testeando los otros método de petición HTTP verbs y recordemos los métodos más relevantes son:
 |
| 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 |
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.
Nuevamente agradecer de antemano por la revisión y lectura de este pequeño post, nos vemos en el siguiente tutorial.
