Minimal API y Entity Framework

Desde .Net 6 tenemos disponible una nueva forma de hacer API más fácilmente. Minimal API fueron diseñadas para crear servicios livianos con dependencias mínimas para la utilización de microservicios o aplicaciones. Veamos cómo utilizarlas.

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)

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
• Postman instalado para realizar pruebas

Proyecto Demo

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

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”.

dotnet new web -o DemoApi
cd DemoApi
code -r ../DemoAPi

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.

dotnet dev-certs https --trust

Ya que 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.

dotnet add package Microsoft.EntityFrameworkCore.InMemory
dotnet add package Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore

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:

dotnet run

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

Este es un demo bastante sencillo de como utilizar Minimal APi con EntityFramework. Si bien hay más métodos como put y delete, lo he dejado para que los pruebes por ti mismo. Si te gusto este post házmelo saber en los comentarios. Próximamente entraremos en más detalle sobre Minimal Api.