Migraciones en Entity Framework Core y ASP.NET Core

En este artículo, exploraremos en detalle cómo utilizar Entity Framework Core para crear migraciones que nos permitan actualizar o crear una base de datos a partir de modelos de datos y la configuración del DbContext, incluyendo el método OnModelCreating. Utilizaremos el enfoque code-first para definir el modelo de datos en nuestras clases C# y luego generaremos una migración para aplicar estos cambios a la base de datos.

Introducción a las Migraciones en Entity Framework Core

Las migraciones en Entity Framework Core son una herramienta poderosa que nos permite mantener actualizado el esquema de nuestra base de datos a medida que cambia el modelo de datos de nuestra aplicación. En lugar de modificar manualmente la estructura de la base de datos, podemos definir los cambios en el modelo de datos de nuestra aplicación y luego generar migraciones para aplicar estos cambios de forma controlada.

 

Paso 1: Definir Modelos de Datos

En primer lugar, definimos los modelos de datos de nuestra aplicación utilizando clases C#. Estas clases representan las entidades en nuestra base de datos y contienen propiedades que representan las columnas en las tablas de la base de datos.

public class Libro
{
    public int Id { get; set; }
    public string Titulo { get; set; }
    public int AutorId { get; set; }
    public Autor Autor { get; set; }
}

public class Autor
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public ICollection<Libro> Libros { get; set; }
}

 

Paso 2: Configurar el DbContext y el Método OnModelCreating

A continuación, configuramos nuestro DbContext y el método OnModelCreating para establecer la configuración de nuestra base de datos. Esto incluye definir claves primarias, establecer relaciones entre entidades y cualquier otra configuración específica de la base de datos.

using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public DbSet<Libro> Libros { get; set; }
    public DbSet<Autor> Autores { get; set; }

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        modelBuilder.Entity<Libro>()
            .HasKey(l => l.Id);

        modelBuilder.Entity<Autor>()
            .HasKey(a => a.Id);

        modelBuilder.Entity<Libro>()
            .HasOne(l => l.Autor)
            .WithMany(a => a.Libros)
            .HasForeignKey(l => l.AutorId);
    }
}

En este código, configuramos las claves primarias y las relaciones entre las entidades Libro y Autor utilizando el método OnModelCreating.

Nota: Para mas información acerca del método OnModelCreating, visita y lee el siguiente artículo de este blog: OnModelCreating en Entity Framework Core y ASP.NET Core

 

Paso 3: Crear una Migración

Una vez que hemos definido nuestros modelos de datos y configurado el DbContext, es hora de crear una migración para representar los cambios en la base de datos. Las migraciones son archivos de código que describen los cambios en el esquema de la base de datos y se generan utilizando Entity Framework Core Tools.

Generación de una Migración

Para generar una migración, abrimos la consola del Administrador de Paquetes en Visual Studio y ejecutamos el siguiente comando:

Add-Migration InitialCreate

Esto generará una nueva migración con el nombre "InitialCreate" en nuestro proyecto. La migración se crea como una clase dentro de la carpeta "Migrations" y contiene dos métodos principales: Up y Down.

Método Up

El método Up describe los cambios que deben aplicarse a la base de datos para llevarla al estado representado por la migración. Este método normalmente contiene operaciones como la creación de tablas, la adición de columnas y la creación de claves primarias y foráneas.

protected override void Up(MigrationBuilder migrationBuilder)
{
    migrationBuilder.CreateTable(
        name: "Autores",
        columns: table => new
        {
            Id = table.Column<int>(nullable: false)
                .Annotation("SqlServer:Identity", "1, 1"),
            Nombre = table.Column<string>(nullable: true)
        },
        constraints: table =>
        {
            table.PrimaryKey("PK_Autores", x => x.Id);
        });

    migrationBuilder.CreateTable(
        name: "Libros",
        columns: table => new
        {
            Id = table.Column<int>(nullable: false)
                .Annotation("SqlServer:Identity", "1, 1"),
            Titulo = table.Column<string>(nullable: true),
            AutorId = table.Column<int>(nullable: false)
        },
        constraints: table =>
        {
            table.PrimaryKey("PK_Libros", x => x.Id);
            table.ForeignKey(
                name: "FK_Libros_Autores_AutorId",
                column: x => x.AutorId,
                principalTable: "Autores",
                principalColumn: "Id",
                onDelete: ReferentialAction.Cascade);
        });
}

Método Down

El método Down describe cómo deshacer los cambios realizados en el método Up. Este método se utiliza para revertir la migración en caso de ser necesario.

protected override void Down(MigrationBuilder migrationBuilder)
{
    migrationBuilder.DropTable(
        name: "Libros");

    migrationBuilder.DropTable(
        name: "Autores");
}

Ejecución de la Migración

Una vez que hemos generado la migración, podemos aplicarla a la base de datos utilizando el siguiente comando en la consola del Administrador de Paquetes:

Update-Database

Nota: Este comando ejecutará la migración y aplicará los cambios en el esquema de la base de datos.

Detalles Técnicos de la Migración Generada

La migración generada por Entity Framework Core es un archivo de código que describe los cambios necesarios para llevar la base de datos al estado representado por la migración. La migración se crea utilizando un flujo de construcción fluido que permite describir las operaciones de forma clara y concisa.

Flujo de Construcción Fluido

El flujo de construcción fluido utiliza métodos encadenados para definir las operaciones de la migración de forma secuencial. Esto permite una sintaxis limpia y legible que describe los cambios en el esquema de la base de datos de manera efectiva:

migrationBuilder.CreateTable(
    name: "Autores",
    columns: table => new
    {
        Id = table.Column<int>(nullable: false)
            .Annotation("SqlServer:Identity", "1, 1"),
        Nombre = table.Column<string>(nullable: true)
    },
    constraints: table =>
    {
        table.PrimaryKey("PK_Autores", x => x.Id);
    });

Nota: En este ejemplo, estamos utilizando el método CreateTable para crear una nueva tabla llamada "Autores". Utilizamos métodos encadenados para definir las columnas de la tabla y cualquier restricción de clave primaria.

Añadir más operaciones a la migración

Además de las operaciones básicas de creación de tablas y columnas, Entity Framework Core admite una amplia variedad de operaciones de migración que pueden representar cambios más complejos en el esquema de la base de datos. Algunos ejemplos de estas operaciones incluyen:

• Modificación de columnas existentes
• Eliminación de columnas o tablas
• Renombrado de columnas o tablas
• Añadir o eliminar índices
• Añadir o eliminar restricciones de clave externa
• Añadir datos iniciales a la base de datos

Personalizar la Migración

Entity Framework Core permite personalizar la migración generada utilizando anotaciones y Fluent API en nuestras clases de modelo y en el método OnModelCreating. Esto nos da un mayor control sobre cómo se generan las migraciones y nos permite realizar cambios específicos en el esquema de la base de datos.

Por ejemplo, podemos utilizar atributos como [Required], [MaxLength], [Column], etc., para especificar restricciones de columna en nuestras clases de modelo, o podemos utilizar métodos como HasKey(), HasOne(), HasMany(), etc., en el método OnModelCreating para configurar relaciones entre entidades y otras configuraciones avanzadas.

 

Conclusión

En conclusión, la creación de migraciones en Entity Framework Core es un proceso esencial para mantener actualizado el esquema de la base de datos de nuestra aplicación de manera controlada y eficiente. A través del enfoque code-first, podemos definir el modelo de datos en nuestras clases C# y luego generar migraciones que representen los cambios en este modelo. Estas migraciones nos permiten aplicar estos cambios a la base de datos de forma segura, evitando la necesidad de modificar manualmente la estructura de la base de datos.

Además, el proceso de creación de migraciones en Entity Framework Core es altamente personalizable, lo que nos permite adaptar las migraciones generadas a nuestras necesidades específicas utilizando anotaciones, Fluent API y otras técnicas de configuración avanzadas. Esto nos da un mayor control sobre cómo se aplican los cambios en el esquema de la base de datos y nos permite realizar cambios más complejos de manera eficiente.

En resumen, las migraciones en Entity Framework Core son una herramienta poderosa que nos permite mantener la coherencia entre el modelo de datos de nuestra aplicación y la estructura de la base de datos subyacente, facilitando el desarrollo y la evolución de nuestras aplicaciones de manera robusta y escalable.