Minimal API y Entity Framework

Con la llegada de .NET 6, se introduce una nueva y más sencilla forma de crear APIs: las Minimal APIs. Estas fueron diseñadas con el propósito de desarrollar servicios livianos con dependencias mínimas, ideales para la implementación de microservicios o aplicaciones de naturaleza similar. A continuación, explicaremos cómo utilizar esta nueva funcionalidad y aprovechar sus beneficios en el desarrollo de servicios web en .NET 6 o superior.

Diferencias con Web API.

Poseen algunas diferencias con las API Rest o proyectos web APIS que veamos utilizando hasta hoy, las minimal api pueden:

• Manejo de filtros de forma diferente.
• No es posible usar IModelBinderProvider o ImodelBinder.
• No posee validación integrada como IModelValidator.
• No posee un motor de vistas integrado.
• No se puede utilizar JsonPath. (por el momento)
• No se puede utilizar Odata.(por el momento)

Es importante destacar que la elección entre Web API y Minimal API dependerá de los requisitos específicos del proyecto y de la preferencia por la simplicidad frente a la flexibilidad. Las Minimal APIs son ideales para proyectos más pequeños y escenarios simples, mientras que las Web APIs son más adecuadas para proyectos más grandes y complejos.

Requisitos para el demo

Para realizar este demo necesitaremos tener instalado:

• Visual Studio Code
• El plugin de C# para VSCode. Click aquí
• SDK .Net 7.0 o superior
• Postman instalado para realizar pruebas

Proyecto Demo

Lo primero que debes hacer es abrir una aplicación de consola. En mi caso yo uso windows terminal con el add “Oh My Posh”.

Ejecutaremos desde la línea de comando los comandos para crear nuestro proyecto.

Luego abriremos nuestro proyecto con el VSCode y nos dirigimos al archivo program.cs. Veremos algo parecido a este código:

Lo siguiente será agregar la confianza al certificado de desarrollo. Deberemos ejecutar la siguiente línea de comando desde la terminal y aceptaremos el Warning que nos saldrá en pantalla.

Como nos encontramos en la consola, agregamos las librerías necesarias de Entity Framework para nuestro demo. Utilizaremos EntityFramework para crear nuestra base de datos en memoria.

Lo siguiente será crear en la raíz de nuestro proyecto un modelo. Nuestro modelo será perro y tendrá las propiedades: Id, Nombre, raza y edad.

class Perro
{
    public int Id { get; set; }
    public string? Nombre{ get; set; }
    public string Raza { get; set; }
    public int Edad{ get; set; }
}

Ahora crearemos nuestro contexto para la base de datos:

using Microsoft.EntityFrameworkCore;

class PerroDb : DbContext
{
    public PerroDb (DbContextOptions<PerroDb> options)
        : base(options) { }

    public DbSet<Perro> Perros=> Set<Perro>();
}

Vamos a crear nuestras API. Debemos tener presente que las API se crean a nivel de app. Por esta razón la app posee varios métodos MapXXX. Este nos permitirá mapear una url a una petición y a un verbo HTTP. Por ejemplo, si daemon mapear un HttpGet, usaremos MapGet, si deseamos mapear un post, usaremos MapPost, y así sucesivamente.

Abriremos en VS Code nuestro program.cs. Eliminaremos la línea de Hello World.

app.MapGet("/", () => "Hello World!");

Agregaremos los métodos correspondientes de mapeo para nuestra modelo Perro. Nos debería quedar similar a esto:

using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<PerroDb >(opt => opt.UseInMemoryDatabase("Perros"));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();
var app = builder.Build();

app.MapGet("/perro", async (PerroDb  db) =>
    await db.Perros.ToListAsync());

app.MapGet("/perro/{id}", async (int id, PerroDb  db) =>
    await db.Perros.FindAsync(id)
        is Perro perro
            ? Results.Ok(perro)
            : Results.NotFound());

app.MapPost("/perro", async (Perro perro, PerroDb  db) =>
{
    db.Perros.Add(perro);
    await db.SaveChangesAsync();

    return Results.Created($"/perro/{perro.Id}", perro);
});

app.MapPut("/perro/{id}", async (int id, Perro inputPerro, PerroDb  db) =>
{
    var perro = await db.Perros.FindAsync(id);

    if (perro is null) return Results.NotFound();

    perro.Nombre = inputPerro.Nombre;

    await db.SaveChangesAsync();

    return Results.NoContent();
});

app.MapDelete("/perro/{id}", async (int id, PerroDb  db) =>
{
    if (await db.Perros.FindAsync(id) is Perro perro)
    {
        db.Perros.Remove(perro);
        await db.SaveChangesAsync();
        return Results.Ok(perro);
    }

    return Results.NotFound();
});

app.Run();

Antes de invocar nuestras Api con Postman, iniciaremos la aplicación desde la consola:

Bien ahora desde el postman, por medio de un método post, enviaremos un nuevo objeto perro:

Lo siguiente será consultar si, también desde postman, el que hemos insertado.

Conclusiones

En la utilización conjunta de Minimal API y Entity Framework en ASP.NET, se establece un equilibrio entre simplicidad y eficacia. Las Minimal APIs ofrecen una aproximación ligera y directa para la creación de servicios web, simplificando la sintaxis y eliminando redundancias. Al integrar Entity Framework, se facilita la manipulación de datos mediante un ORM robusto.

La combinación de Minimal API y Entity Framework es especialmente ventajosa en escenarios donde la simplicidad de implementación es esencial y se requiere una interacción eficiente con la capa de datos. Este enfoque permite construir rápidamente servicios web funcionales con una mínima cantidad de código, manteniendo al mismo tiempo la capacidad de gestionar operaciones de base de datos de manera efectiva.

Optar por Minimal API y Entity Framework en ASP.NET, favorece un desarrollo ágil y eficiente, proporcionando una solución simple y efectiva para la creación de servicios web respaldados por una sólida capa de acceso a datos.