Creando API con ASP.NET
ANTES DE LEER EL ARTÍCULO, POR FAVOR, LEA AQUÍ
El código disponible en GitHub.
El término API es una abreviatura de Application Programming Interfaces, que en español significa interfaz de programación de aplicaciones. Se trata de un conjunto de definiciones y protocolos que se utiliza para desarrollar e integrar el software de las aplicaciones, permitiendo la comunicación entre dos aplicaciones de software a través de un conjunto de reglas.
Así pues, podemos hablar de una API como una especificación formal que establece cómo un módulo de un software se comunica o interactúa con otro para cumplir una o muchas funciones. Todo dependiendo de las aplicaciones que las vayan a utilizar, y de los permisos que les dé el propietario de la API a los desarrolladores de terceros.
Para crear una API en Visual Studio en la pantalla de inicio seleccionamos Crear un Proyecto
Seleccionamos el tipo de aplicación ASP.NET Web API
Ponemos nombre al proyecto, en este caso ApiEjemplo
Seleccionamos la versión del Framework 7.0, el resto de los parámetros los dejamos como están.
Una vez creado el proyecto, procedemos a agregar Entity Framework.
Primeramente agregamos los paquetes NuGet necesarios:
En la consola de administrador de paquetes escribimos las siguientes líneas:
|
1 2 |
Install-Package Microsoft.EntityFrameworkCore.Tools Install-Package Microsoft.EntityFrameworkCore.SqlServer |
Creamos en la raiz del proyecto una carpeta que le llamamos Datos
Dentro de esa carpeta creamos un modelo que le llamaremos Persona con las siguientes propiedades:
|
1 2 3 4 5 6 7 |
public class Persona { public Guid Id{ get; set;} = Guid.NewGuid(); public string Nombre {get; set;} public string PrimerApellido {get; set;} public string SegundoApellido {get; set;} public string CI {get; set;} } |
También en esa carpeta creamos una clase de nombre ApplicationDbContext con el siguiente contenido:
|
1 2 3 4 5 6 7 |
public class ApplicationDbContext : DbContext { public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options) { } public DbSet<Persona> Personas { get; set; } } |
Nos dirigimos al Program.cs que se encuentra en la raíz de nuestro proyecto y justo después de la línea builder.Services.AddSwaggerGen(); escribimos:
|
1 2 3 4 |
builder.Services.AddDbContext<ApplicationDbContext>(options => { options.UseSqlServer(builder.Configuration.GetConnectionString("Default")); }); |
Donde la cadena de conexión que se hace referencia(Default) la creamos en el fichero appsettings.json quedando de la siguiente forma:
|
1 2 3 |
"ConnectionStrings": { "Default": "Server=<SERVIDOR>;Database=<BASEDATOS>;Trusted_Connection=true;MultipleActiveResultSets=True;Trust Server Certificate=true" }, |
En la consola de administración de paquetes aplicamos la migración para crear la tabla en la base de datos:
|
1 2 |
add-migration Inicial update-database |
Ya estamos listos para desarrollar la API para implementar un CRUD sobre la tabla Persona.
En la carpeta Controllers damos Click Derecho Agregar->Controlador
Seleccionamos Controlador API en blanco:
Es importante que el nombre de los controladores terminen con la palabra Controller
Una vez creado el controlador vamos a declarar el constructor donde inyectaremos el contexto de Entity Framework:
|
1 2 3 4 5 |
private readonly ApplicationDbContext _context; public PersonasController(ApplicationDbContext context) { _context = context; } |
Y 5 métodos para las acciones del CRUD
| API | Descripción | Cuerpo de la solicitud | Cuerpo de la respuesta | |
| 1 | GET /api/persona | Obtener todas las personas | Ninguna | Lista de Personas |
| 2 | GET /api/persona/{id} | Obtener una persona por identificador | Ninguna | Persona |
| 3 | POST /api/ persona | Incorporación de una nueva persona | Persona | Persona |
| 4 | PUT /api/ persona /{id} | Actualizar una persona existente | Persona | Ninguna |
| 5 | DELETE /api/ persona /{id} | Eliminación de una persona | Ninguna | Ninguna |
1- Obtener todas las personas
|
1 2 3 4 5 6 7 8 |
// GET: api/Personas [HttpGet] public async Task<ActionResult<IEnumerable<Persona>>> GetPersonas() { if (_context.Personas == null) return NotFound(); return await _context.Personas.ToListAsync(); } |
2- Obtener una persona por identificador
|
1 2 3 4 5 6 7 8 9 10 11 |
// GET: api/Personas/5 [HttpGet("{id}")] public async Task<ActionResult<Persona>> GetPersona(Guid id) { if (_context.Personas == null) return NotFound(); var persona = await _context.Personas.FindAsync(id); if (persona == null) return NotFound(); return Ok(persona); } |
3- Incorporación de una nueva persona
|
1 2 3 4 5 6 7 8 9 10 |
// POST: api/Personas [HttpPost] public async Task<ActionResult<Persona>> PostPersona(Persona persona) { if (_context.Personas == null) return Problem(); _context.Personas.Add(persona); await _context.SaveChangesAsync(); return Ok(persona); } |
4- Actualizar una persona existente
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// PUT: api/Personas/5 [HttpPut("{id}")] public async Task<IActionResult> PutPersona(Guid id, Persona persona) { if (id != persona.Id) return BadRequest(); _context.Entry(persona).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { throw; } return NoContent(); } |
5- Eliminación de una persona
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// DELETE: api/Personas/5 [HttpDelete("{id}")] public async Task<IActionResult> DeletePersona(Guid id) { if (_context.Personas == null) return NotFound(); var persona = await _context.Personas.FindAsync(id); if (persona == null) return NotFound(); _context.Personas.Remove(persona); await _context.SaveChangesAsync(); return NoContent(); } |
Una ves listos los métodos podemos probarlos, el proyecto ASP.NET WebAPI contiene Swagger, que nos ayudará a probar la APÎ. Corremos la aplicación con F5:
Ahí podemos probar cada uno de las acciones del controlador Persona.
El próximo paso sería proteger el acceso al controlador usando un token de JWT pero eso será en otro artículo.
Simplemente genial. Buena explicación, detallada ,asequible. Buen trabajo