Cómo agregar datos iniciales a una base de datos con Entity Framework Core

En este post vamos a ver otro elemento muy importante dentro del enfoque Code First, la importación de datos, o data seed en inglés. 

1 - Qué es Data seed en entity framework core?

Data seed, o importación de datos es la capacidad de importar datos iniciales en una base de datos al principio de la aplicación. Es una práctica muy útil cuando tenemos que precargar datos de referencia o estáticos a nuestro sistema.

Un ejemplo muy claro son las monedas con el símbolo y código, ya que no suelen cambiar, suelen ser un ejemplo (si se utilizan, claro) de precarga de datos. 

2 - Implementar data seed con Entity Framework core

Para implementar Data seed lo hacemos a través de las migraciones que vimos en el post anterior-; Si no estás familiarizado con las migraciones, dale un vistazo antes de continuar. 

Para añadir los datos, lo debemos hacer dentro del método OnModelCreating dentro de nuestro DbContext; Sabemos que el dbcontext contiene la configuración de la base de datos, las tablas, etc. y por supuesto también contiene las migraciones de datos. 

Y aquí podemos ver un ejemplo de cómo importamos un usuario por defecto:

public class CursoEfContext : DbContext
{
    public virtual DbSet<User> Users { get; set; }

    public virtual DbSet<Wokringexperience> Wokringexperiences { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. You can avoid scaffolding the connection string by using the Name= syntax to read it from configuration - see https: //go.microsoft.com/fwlink/?linkid=2131148. For more guidance on storing connection strings, see http://go.microsoft.com/fwlink/?LinkId=723263.
        => optionsBuilder.UseMySQL("server=127.0.0.1;port=4306;database=cursoEF;user=root;password=cursoEFpass");


    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>().HasData(
            new User { Email = "[email protected]", Id = 1, UserName = "user1" },
            new User { Email = "[email protected]", Id = 2, UserName = "user2" }
        );
    }
}

Como puedes imaginar, para evitar que este método crezca hasta el infinito hay mejores formas de implementar la precarga de datos.

Anteriormente, simplemente crearemos una clase aparte y la podemos instanciar y ejecutar desde el método. Pero desde .net core tenemos mejores opciones, para ello utilizamos clases que implementan la interfaz IEntityTypeConfiguration.

Esta interfaz contiene un único método, el cual es el que vamos a implementar, y aquí, es donde vamos a indicar la precarga de datos:

public class UserSeed : IEntityTypeConfiguration<User>
{
    public void Configure(EntityTypeBuilder<User> builder)
    {
        builder.HasData(
            new User { Email = "[email protected]", Id = 1, UserName = "user1" },
            new User { Email = "[email protected]", Id = 2, UserName = "user2" }
        );
    }
}

 Ahora, únicamente nos falta invocar dicha clase, y como en la primera versión, lo hacemos en el método OnModelCreating:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.ApplyConfiguration(new UserSeed());
}

• Nota: desde la version 2.2 puedes utilizar modelBuilder.ApplyConfigurationsFromAssembly junto al assembly donde tienes las interfaces y se implemenan automáticamente, pero yo sinceramente prefiero la forma “normal” ya que es más clara (en mi opinión).

Ahora simplemente nos queda crear una migración, como vimos en el post anterior. Podemos ver que nos crea el fichero con el Up and Down correspondiente:

namespace CursoEFCore.Codefirst.API.Migrations
{
    /// <inheritdoc />
    public partial class AddSeedUsers : Migration
    {
        /// <inheritdoc />
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.InsertData(
                table: "Users",
                columns: new[] { "Id", "Email", "UserName" },
                values: new object[,]
                {
                    { 1, "[email protected]", "user1" },
                    { 2, "[email protected]", "user2" }
                });
        }

        /// <inheritdoc />
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DeleteData(
                table: "Users",
                keyColumn: "Id",
                keyValue: 1);

            migrationBuilder.DeleteData(
                table: "Users",
                keyColumn: "Id",
                keyValue: 2);
        }
    }
}

• Nota: También modifica el snapshot. 

Finalmente, ejecutamos el código, y podemos observar cómo se crea la base de datos con los nuevos datos en las tablas:

Conclusión

En este post hemos visto que es Data seed o la precarga de datos en Entity Framework Core.

Cómo implementar Data Seed en Entity framework core.