Entity Framework Core es el ORM de .NET para trabajar con bases de datos usando clases C#.

Llegamos al momento de persistir datos. Hasta ahora nuestra API era “amnésica”: si reiniciabas el servidor, perdías los datos en memoria.

Para guardar la información vamos a usar el ORM por excelencia de .NET: Entity Framework Core (EF Core).

Hoy aprederemos a configurar el motor para que tu API pueda hablar con la base de datos.

Instalación de paquetes

EF Core es modular. No instalamos un monolito, sino las piezas que necesitamos. Para una API típica con SQL Server, necesitamos instalar estos paquetes NuGet:

En tu terminal:

El DbContext

El corazón de EF Core es el DbContext. Es la clase que representa una sesión con la base de datos.

Para integrarlo en ASP.NET, debemos crear una clase que herede de DbContext y, muy importante, tenga un constructor que acepte las opciones de configuración.

using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    // Constructor obligatorio para que funcione la Inyección de Dependencias
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }

    // Tus tablas (DbSets)
    public DbSet<Producto> Productos { get; set; } = null!;
    public DbSet<Usuario> Usuarios { get; set; } = null!;
}

La cadena de conexión

Como vimos en el bloque de configuración, nunca escribimos contraseñas ni direcciones IP en el código C#. La cadena de conexión (Connection String) va al archivo de configuración.

Abre appsettings.json y añade la sección ConnectionStrings:

Configuración en Program.cs

Ahora tenemos que registrar nuestro ApplicationDbContext en el contenedor de Inyección de Dependencias para poder usarlo en los controladores. EF Core nos proporciona el método de extensión AddDbContext.

// Program.cs

var builder = WebApplication.CreateBuilder(args);

// --- CONFIGURACIÓN DE EF CORE ---
// 1. Leemos la cadena de conexión del JSON
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection")
    ?? throw new InvalidOperationException("Falta ConnectionStrings:DefaultConnection");

// 2. Registramos el contexto usando SQL Server
builder.Services.AddDbContext<ApplicationDbContext>(options =>
{
    options.UseSqlServer(connectionString);
});

var app = builder.Build();

Aplicar migraciones

Ahora que ASP.NET sabe dónde está la base de datos y cómo conectarse, necesitamos crear las tablas.

Como tenemos instalado el paquete Microsoft.EntityFrameworkCore.Design, podemos usar la CLI de .NET para generar las migraciones (el código SQL para crear la BBDD).

Ejecuta en tu terminal:

Si todo ha ido bien, verás un mensaje de “Done” y tu base de datos habrá sido creada.

Usar el DbContext en la API

Ya está todo conectado. Ahora, para leer o guardar datos, simplemente inyectamos el contexto en nuestros Endpoints o Controladores.

Ejemplo en Minimal API

app.MapGet("/productos", async (ApplicationDbContext db) =>
{
    // Usamos Entity Framework de forma normal
    return await db.Productos.ToListAsync();
});

app.MapPost("/productos", async (Producto producto, ApplicationDbContext db) =>
{
    db.Productos.Add(producto);
    await db.SaveChangesAsync();
    return Results.Created($"/productos/{producto.Id}", producto);
});

Ejemplo en controlador

public class ProductosController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    // Inyectamos el contexto
    public ProductosController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task<IActionResult> Get()
    {
        var lista = await _context.Productos.ToListAsync();
        return Ok(lista);
    }
}