Entity Framework Core: Guía para empezar con Code First

Entity Framework Core se ha convertido en una herramienta indispensable para desarrolladores .NET que trabajan con bases de datos. El enfoque Code First permite definir el modelo de datos directamente en código C#, generando automáticamente la estructura de la base de datos. Esta metodología resulta especialmente útil para proyectos nuevos donde tenemos control total sobre el diseño de la base de datos.

✨ ¿Por qué elegir Code First?

El enfoque Code First ofrece ventajas significativas frente a otras metodologías. Permite mantener el control total sobre el modelo de datos desde el código, facilita el trabajo en equipo mediante migraciones versionadas y proporciona una integración natural con metodologías de desarrollo ágiles.

Además, trabajar con Code First significa que nuestro modelo de datos evoluciona junto con la aplicación, manteniendo siempre la coherencia entre el código y la estructura de la base de datos.

⚙️ Configuración inicial del proyecto

Para comenzar con Entity Framework Core, necesitamos instalar los paquetes NuGet correspondientes. El paquete principal es Microsoft.EntityFrameworkCore, junto con el proveedor específico para nuestra base de datos.

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

⚠️ Importante: La instalación de EntityFrameworkCore.Tools es fundamental para poder ejecutar comandos de migración desde la consola del administrador de paquetes.

🏗️ Creando nuestro primer modelo

Definir entidades en Code First es sorprendentemente directo. Cada clase representa una tabla en la base de datos, y las propiedades de la clase se convierten en columnas.

public class Usuario
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public string Email { get; set; }
    public DateTime FechaRegistro { get; set; }
    public bool EstaActivo { get; set; }

    // Propiedad de navegación
    public List<Pedido> Pedidos { get; set; } = new List<Pedido>();
}

public class Pedido
{
    public int Id { get; set; }
    public string Descripcion { get; set; }
    public decimal Precio { get; set; }
    public DateTime FechaPedido { get; set; }

    // Clave foránea
    public int UsuarioId { get; set; }
    public Usuario Usuario { get; set; }
}

💡 Tip: Entity Framework Core utiliza convenciones para inferir la estructura de la base de datos. Por ejemplo, una propiedad llamada Id se convierte automáticamente en la clave principal de la tabla.

🔧 Configurando el DbContext

El DbContext actúa como el puente entre nuestras entidades y la base de datos. Aquí definimos los conjuntos de datos (DbSet) y configuramos la conexión.

public class ApplicationDbContext : DbContext
{
    public DbSet<Usuario> Usuarios { get; set; }
    public DbSet<Pedido> Pedidos { get; set; }

    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Configuraciones específicas del modelo
        modelBuilder.Entity<Usuario>(entity =>
        {
            entity.Property(e => e.Nombre)
                .IsRequired()
                .HasMaxLength(100);

            entity.Property(e => e.Email)
                .IsRequired()
                .HasMaxLength(255);

            entity.HasIndex(e => e.Email)
                .IsUnique();
        });

        modelBuilder.Entity<Pedido>(entity =>
        {
            entity.Property(e => e.Precio)
                .HasColumnType("decimal(18,2)");

            entity.HasOne(p => p.Usuario)
                .WithMany(u => u.Pedidos)
                .HasForeignKey(p => p.UsuarioId)
                .OnDelete(DeleteBehavior.Cascade);
        });
    }
}

🔗 Configuración de la aplicación

En el archivo Program.cs o Startup.cs, registramos nuestro DbContext en el contenedor de dependencias:

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

📄 La cadena de conexión se define típicamente en appsettings.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=MiAplicacion;Trusted_Connection=true;MultipleActiveResultSets=true"
  }
}

📦 Trabajando con migraciones

Las migraciones son el mecanismo que permite evolucionar la estructura de la base de datos de forma controlada. Cada migración representa un conjunto de cambios que se aplican secuencialmente.

🎯 Para crear la primera migración:

dotnet ef migrations add InitialCreate

Este comando analiza nuestro modelo y genera el código necesario para crear la base de datos inicial. La migración se almacena en la carpeta Migrations del proyecto.

🚀 Para aplicar las migraciones pendientes:

dotnet ef database update

🔄 Cuando modificamos nuestro modelo, simplemente creamos una nueva migración:

dotnet ef migrations add AgregarCampoTelefono

💾 Operaciones básicas con datos

Una vez configurado todo, realizar operaciones CRUD es intuitivo:

public class UsuarioService
{
    private readonly ApplicationDbContext _context;

    public UsuarioService(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<Usuario> CrearUsuarioAsync(string nombre, string email)
    {
        var usuario = new Usuario
        {
            Nombre = nombre,
            Email = email,
            FechaRegistro = DateTime.Now,
            EstaActivo = true
        };

        _context.Usuarios.Add(usuario);
        await _context.SaveChangesAsync();

        return usuario;
    }

    public async Task<List<Usuario>> ObtenerUsuariosActivosAsync()
    {
        return await _context.Usuarios
            .Where(u => u.EstaActivo)
            .Include(u => u.Pedidos)
            .ToListAsync();
    }

    public async Task ActualizarUsuarioAsync(int id, string nuevoNombre)
    {
        var usuario = await _context.Usuarios.FindAsync(id);
        if (usuario != null)
        {
            usuario.Nombre = nuevoNombre;
            await _context.SaveChangesAsync();
        }
    }
}

Mejores prácticas para Code First

Mantener un modelo limpio y bien estructurado es crucial para el éxito a largo plazo. Utilizar Data Annotations o Fluent API para configuraciones específicas ayuda a mantener la claridad del modelo.

Es recomendable crear migraciones frecuentes y con nombres descriptivos. Esto facilita el seguimiento de cambios y la resolución de conflictos en equipos de desarrollo.

Considerar el rendimiento desde el inicio es importante. Configurar índices apropiados y utilizar técnicas como Include() para cargar datos relacionados puede marcar la diferencia en aplicaciones con gran volumen de datos.

Casos de uso comunes

Code First brilla especialmente en escenarios donde desarrollamos aplicaciones desde cero. Proyectos de API REST, aplicaciones web con requisitos de datos específicos, y sistemas donde el modelo de datos evoluciona frecuentemente se benefician enormemente de este enfoque.

También resulta ideal para equipos que prefieren mantener el control total sobre la estructura de la base de datos desde el código, especialmente en metodologías ágiles donde los cambios son constantes.

Consideraciones adicionales

Aunque Code First ofrece gran flexibilidad, es importante considerar sus limitaciones. En proyectos con bases de datos existentes complejas, el enfoque Database First o Model First podría ser más apropiado.

La gestión de migraciones en entornos de producción requiere planificación cuidadosa, especialmente cuando se trabaja con grandes volúmenes de datos o cuando el tiempo de inactividad debe minimizarse.

Entity Framework Core con Code First proporciona una base sólida para el desarrollo de aplicaciones modernas. Su flexibilidad y potencia lo convierten en una herramienta valiosa para cualquier desarrollador .NET que busque un enfoque eficiente y mantenible para el acceso a datos.

La curva de aprendizaje inicial vale la pena cuando consideramos los beneficios a largo plazo en productividad y mantenibilidad del código. Con las bases establecidas en esta guía, estás preparado para aprovechar todo el potencial de Entity Framework Core en tus proyectos.