Entity Framework
Entidad-marco de código primeras migraciones

Habilitar las migraciones

Para habilitar las Migraciones de Code First en el marco de la entidad, use el comando

Enable-Migrations

en la consola del administrador de paquetes .

DbContext tener una implementación DbContext válida que contenga los objetos de su base de datos administrados por EF. En este ejemplo, el contexto de la base de datos contendrá los objetos BlogPost y Author :

internal class DatabaseContext: DbContext
{
    public DbSet<Author> Authors { get; set; }

    public DbSet<BlogPost> BlogPosts { get; set; }
}

Después de ejecutar el comando, debería aparecer la siguiente salida:

PM> Enable-Migrations
Checking if the context targets an existing database...
Code First Migrations enabled for project <YourProjectName>.
PM>

Además, debe aparecer una nueva carpeta de Migrations con un solo archivo Configuration.cs dentro de:

El siguiente paso sería crear su primer script de migración de base de datos que creará la base de datos inicial (ver el siguiente ejemplo).

Añade tu primera migración

Después de habilitar las migraciones (consulte este ejemplo ), ahora puede crear su primera migración que contenga una creación inicial de todas las tablas de base de datos, índices y conexiones.

Se puede crear una migración usando el comando

Add-Migration <migration-name>

Este comando creará una nueva clase que contiene dos métodos Up y Down que se utilizan para aplicar y eliminar la migración.

Ahora aplique el comando basado en el ejemplo anterior para crear una migración llamada Inicial :

PM> Add-Migration Initial
Scaffolding migration 'Initial'.
The Designer Code for this migration file includes a snapshot of your current Code
First model. This snapshot is used to calculate the changes to your model when you
scaffold the next migration. If you make additional changes to your model that you 
want to include in this migration, then you can re-scaffold it by running 
'Add-Migration Initial' again.

Se crea un nuevo archivo de fecha y hora _Initial.cs (solo se muestran las cosas importantes aquí):

public override void Up()
{
   CreateTable(
       "dbo.Authors",
        c => new
           {
               AuthorId = c.Int(nullable: false, identity: true),
               Name = c.String(maxLength: 128),
           })
        .PrimaryKey(t => t.AuthorId);
        
    CreateTable(
       "dbo.BlogPosts",
       c => new
           {
                Id = c.Int(nullable: false, identity: true),
                Title = c.String(nullable: false, maxLength: 128),
                Message = c.String(),
                Author_AuthorId = c.Int(),
            })
        .PrimaryKey(t => t.Id)
        .ForeignKey("dbo.Authors", t => t.Author_AuthorId)
        .Index(t => t.Author_AuthorId);
}
    
public override void Down()
{
    DropForeignKey("dbo.BlogPosts", "Author_AuthorId", "dbo.Authors");
    DropIndex("dbo.BlogPosts", new[] { "Author_AuthorId" });
    DropTable("dbo.BlogPosts");
    DropTable("dbo.Authors");
}

Como puede ver, en el método Up() se crean dos tablas Authors y BlogPosts y los campos se crean en consecuencia. Además, la relación entre las dos tablas se crea agregando el campo Author_AuthorId . Por otro lado, el método Down() intenta revertir las actividades de migración.

Si se siente seguro con su migración, puede aplicar la migración a la base de datos usando el comando:

Update-Database

Todas las migraciones pendientes (en este caso, la migración inicial ) se aplican a la base de datos y luego se aplica el método de inicialización (el ejemplo apropiado)

PM> update-database
Specify the '-Verbose' flag to view the SQL statements being applied to the target     
database.
Applying explicit migrations: [201609302203541_Initial].
Applying explicit migration: 201609302203541_Initial.
Running Seed method.

Puedes ver los resultados de las actividades en el explorador de SQL:

Para los comandos Add-Migration y Update-Database varias opciones disponibles que se pueden usar para modificar las actividades. Para ver todas las opciones, por favor use

get-help Add-Migration

y

get-help Update-Database

Siembra de datos durante las migraciones

Después de habilitar y crear migraciones, puede ser necesario llenar o migrar inicialmente los datos en su base de datos. Hay varias posibilidades, pero para migraciones simples puede usar el método 'Seed ()' en el archivo Configuración creada después de llamar a enable-migrations .

La función Seed() recupera un contexto de base de datos ya que es solo un parámetro y puede realizar operaciones EF dentro de esta función:

protected override void Seed(Model.DatabaseContext context);

Puedes realizar todo tipo de actividades dentro de Seed() . En caso de cualquier falla, la transacción completa (incluso los parches aplicados) se está revirtiendo.

Una función de ejemplo que crea datos solo si una tabla está vacía podría tener este aspecto:

protected override void Seed(Model.DatabaseContext context)
{
    if (!context.Customers.Any()) {
        Customer c = new Customer{ Id = 1, Name = "Demo" };
        context.Customers.Add(c);
        context.SaveData();
    }
}

Una buena característica proporcionada por los desarrolladores de EF es el método de extensión AddOrUpdate() . Este método permite actualizar los datos en función de la clave principal o insertar datos si aún no existen (el ejemplo se toma del código fuente generado de Configuration.cs):

protected override void Seed(Model.DatabaseContext context)
{
    context.People.AddOrUpdate(
      p => p.FullName,
      new Person { FullName = "Andrew Peters" },
      new Person { FullName = "Brice Lambson" },
      new Person { FullName = "Rowan Miller" }
    );
}

Tenga en cuenta que se llama a Seed() después de que se haya aplicado el último parche. Si necesita migrar o generar datos durante los parches, debe usar otros enfoques.

Usando Sql () durante las migraciones

Por ejemplo: va a migrar una columna existente de no obligatorio a obligatorio. En este caso, es posible que deba completar algunos valores predeterminados en su migración para las filas en las que los campos modificados son realmente NULL . En caso de que el valor predeterminado sea simple (por ejemplo, "0"), puede usar una propiedad default o defaultSql en su definición de columna. En caso de que no sea tan fácil, puede usar la función Sql() en las funciones miembro Up() o Down() de sus migraciones.

Aquí hay un ejemplo. Suponiendo un Autor de clase que contiene una dirección de correo electrónico como parte del conjunto de datos. Ahora decidimos tener la dirección de correo electrónico como un campo obligatorio. Para migrar las columnas existentes, la empresa tiene la idea inteligente de crear direcciones de correo electrónico ficticias como [email protected] , donde el nombre completo es el nombre completo de los autores sin espacios. Al agregar el atributo [Required] al campo Email se crearía la siguiente migración:

public partial class AuthorsEmailRequired : DbMigration
{
    public override void Up()
    {
        AlterColumn("dbo.Authors", "Email", c => c.String(nullable: false, maxLength: 512));
    }
    
    public override void Down()
    {
        AlterColumn("dbo.Authors", "Email", c => c.String(maxLength: 512));
    }
}

Esto fallaría en caso de que algunos campos NULOS estén dentro de la base de datos:

No se puede insertar el valor NULL en la columna 'Correo electrónico', tabla 'App.Model.DatabaseContext.dbo.Authors'; La columna no permite nulos. La actualización falla

Agregar lo siguiente como antes del comando AlterColumn ayudará:

Sql(@"Update dbo.Authors
    set Email = REPLACE(name, ' ', '') + N'@example.com'
    where Email is null");

La llamada de update-database correctamente y la tabla tiene este aspecto (se muestran los datos de ejemplo):

Otro uso

Puede usar la función Sql() para todos los tipos de actividades DML y DDL en su base de datos. Se ejecuta como parte de la transacción de migración; Si el SQL falla, la migración completa falla y se realiza una reversión.

Haciendo "Update-Database" dentro de tu código

Las aplicaciones que se ejecutan en entornos que no son de desarrollo a menudo requieren actualizaciones de la base de datos. Después de usar el comando Add-Migration para crear los parches de la base de datos, existe la necesidad de ejecutar las actualizaciones en otros entornos, y también el entorno de prueba.

Los desafíos comúnmente enfrentados son:

• no se instala Visual Studio en entornos de producción, y
• No se permiten conexiones a entornos de conexión / cliente en la vida real.

Una solución es la siguiente secuencia de código que verifica las actualizaciones que se realizarán y las ejecuta en orden. Asegúrese de que las transacciones y el manejo de excepciones sean correctos para garantizar que no se pierdan datos en caso de errores.

void UpdateDatabase(MyDbConfiguration configuration) {
   DbMigrator dbMigrator = new DbMigrator( configuration);
   if ( dbMigrator.GetPendingMigrations().Any() )
   {
      // there are pending migrations run the migration job
      dbMigrator.Update(); 
   }
}

donde MyDbConfiguration es su configuración de migración en algún lugar de sus fuentes:

public class MyDbConfiguration : DbMigrationsConfiguration<ApplicationDbContext>

Código inicial de Entity Framework, primera migración paso a paso

1. Crear una aplicación de consola.
2. Instale el paquete nuget EntityFramework ejecutando Install-Package EntityFramework en "Package Manager Console"
3. Agregue su cadena de conexión en el archivo app.config. Es importante incluir providerName="System.Data.SqlClient" en su conexión.
4. Crea una clase pública como desees, algo como " Blog "
5. Cree su ContextClass que herede de DbContext, algo como " BlogContext "
6. Defina una propiedad en su contexto de tipo DbSet, algo como esto:

public class Blog 
{
    public int Id { get; set; }

    public string Name { get; set; }
}
public class BlogContext: DbContext
{
    public BlogContext(): base("name=Your_Connection_Name")
    {
    }

    public virtual DbSet<Blog> Blogs{ get; set; }
}

7. Es importante pasar el nombre de la conexión en el constructor (aquí, Your_Connection_Name)
8. En la consola del Administrador de paquetes ejecute el comando Enable-Migration , esto creará una carpeta de migración en su proyecto
9. Ejecute el comando Add-Migration Your_Arbitrary_Migraiton_Name , esto creará una clase de migración en la carpeta de migraciones con dos métodos Up () y Down ()
10. Ejecute el comando Update-Database para crear una base de datos con una tabla de blog