Entity Framework
Code Entité-cadre Premières migrations

Activer les migrations

Pour activer Code First Migrations dans la structure d'entité, utilisez la commande

Enable-Migrations

sur la console du gestionnaire de packages .

Vous devez avoir une implémentation DbContext valide contenant vos objets de base de données gérés par EF. Dans cet exemple, le contexte de la base de données contiendra les objets BlogPost et Author :

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

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

Après avoir exécuté la commande, la sortie suivante doit apparaître:

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

De plus, un nouveau dossier Migrations devrait apparaître avec un seul fichier Configuration.cs intérieur:

L'étape suivante consisterait à créer votre premier script de migration de base de données qui créera la base de données initiale (voir l'exemple suivant).

Ajoutez votre première migration

Après avoir activé les migrations (veuillez vous reporter à cet exemple ), vous pouvez désormais créer votre première migration contenant une création initiale de toutes les tables, index et connexions de base de données.

Une migration peut être créée en utilisant la commande

Add-Migration <migration-name>

Cette commande créera une nouvelle classe contenant deux méthodes, Up et Down , utilisées pour appliquer et supprimer la migration.

Maintenant, appliquez la commande basée sur l'exemple ci-dessus pour créer une migration appelée Initial :

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.

Un nouveau fichier d' horodatage _Initial.cs est créé (seuls les éléments importants sont affichés ici):

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");
}

Comme vous pouvez le voir, dans la méthode Up() deux tables Authors et BlogPosts sont créées et les champs sont créés en conséquence. De plus, la relation entre les deux tables est créée en ajoutant le champ Author_AuthorId . De l'autre côté, la méthode Down() tente d'inverser les activités de migration.

Si vous êtes sûr de votre migration, vous pouvez appliquer la migration à la base de données en utilisant la commande:

Update-Database

Toutes les migrations en attente (dans ce cas, la migration initiale ) sont appliquées à la base de données et ensuite la méthode d'amorçage est appliquée (l'exemple approprié)

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.

Vous pouvez voir les résultats des activités dans l'explorateur SQL:

Pour les commandes Add-Migration et Update-Database plusieurs options sont disponibles et peuvent être utilisées pour modifier les activités. Pour voir toutes les options, veuillez utiliser

get-help Add-Migration

et

get-help Update-Database

Semis de données lors des migrations

Après avoir activé et créé des migrations, il peut être nécessaire de remplir ou de migrer initialement les données de votre base de données. Il y a plusieurs possibilités mais pour les migrations simples, vous pouvez utiliser la méthode 'Seed ()' dans le fichier Configuration créé après l'appel de enable-migrations .

La fonction Seed() récupère un contexte de base de données uniquement en tant que paramètre et vous pouvez effectuer des opérations EF dans cette fonction:

protected override void Seed(Model.DatabaseContext context);

Vous pouvez effectuer tous les types d'activités à l'intérieur de Seed() . En cas de défaillance, la transaction complète (même les correctifs appliqués) est annulée.

Un exemple de fonction qui crée des données uniquement si une table est vide peut ressembler à ceci:

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();
    }
}

Une fonctionnalité intéressante fournie par les développeurs EF est la méthode d’extension AddOrUpdate() . Cette méthode permet de mettre à jour des données en fonction de la clé primaire ou d'insérer des données si elles n'existent pas déjà (l'exemple est tiré du code source généré 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" }
    );
}

Sachez que Seed() est appelé après l’application du dernier correctif. Si vous avez besoin de migrer ou de générer des données pendant les correctifs, d'autres approches doivent être utilisées.

Utiliser Sql () pendant les migrations

Par exemple: Vous allez migrer une colonne existante de non requise à obligatoire. Dans ce cas, vous devrez peut-être renseigner des valeurs par défaut dans votre migration pour les lignes où les champs modifiés sont réellement NULL . Si la valeur par défaut est simple (par exemple "0"), vous pouvez utiliser une propriété default ou defaultSql dans votre définition de colonne. Si ce n'est pas si facile, vous pouvez utiliser la fonction Sql() dans les fonctions membres Up() ou Down() de vos migrations.

Voici un exemple. En supposant une classe auteur qui contient une adresse e-mail dans le cadre de l'ensemble de données. Nous décidons maintenant d’avoir l’adresse e-mail comme champ obligatoire. Pour migrer des colonnes existantes, l'entreprise a la bonne idée de créer des adresses e-mail factices telles que nom [email protected] , où nom complet est le nom complet des auteurs sans espaces. L'ajout de l'attribut [Required] au champ Email créerait la migration suivante:

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));
    }
}

Cela échouerait si certains champs NULL se trouvaient dans la base de données:

Impossible d'insérer la valeur NULL dans la colonne "Email", table "App.Model.DatabaseContext.dbo.Authors"; colonne n'autorise pas les valeurs NULL. UPDATE échoue.

L'ajout de ce qui suit comme avant la commande AlterColumn aidera:

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

L'appel update-database réussit et la table ressemble à ceci (exemple de données affiché):

Autre usage

Vous pouvez utiliser la fonction Sql() pour tous les types d’activités DML et DDL dans votre base de données. Il est exécuté dans le cadre de la transaction de migration; Si le SQL échoue, la migration complète échoue et une restauration est effectuée.

Faire "Update-Database" dans votre code

Les applications exécutées dans des environnements autres que de développement nécessitent souvent des mises à jour de la base de données. Après avoir utilisé la commande Add-Migration pour créer vos correctifs de base de données, il est nécessaire d'exécuter les mises à jour sur d'autres environnements, puis sur l'environnement de test.

Les défis généralement rencontrés sont les suivants:

• aucun Visual Studio n'est installé sur les environnements de production et
• pas de connexions autorisées aux environnements de connexion / client dans la vie réelle.

Une solution de contournement est la séquence de code suivante qui vérifie les mises à jour à effectuer et les exécute dans l'ordre. Veuillez vous assurer que les transactions et la gestion des exceptions sont correctes pour vous assurer qu'aucune donnée ne soit perdue en cas d'erreur.

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

où MyDbConfiguration est votre configuration de migration quelque part dans vos sources:

public class MyDbConfiguration : DbMigrationsConfiguration<ApplicationDbContext>

Première étape du code-cadre de l'entité

1. Créez une application console.
2. Installez le package nuget EntityFramework en exécutant Install-Package EntityFramework dans "Package Manager Console"
3. Ajoutez votre chaîne de connexion dans le fichier app.config, il est important d'inclure providerName="System.Data.SqlClient" dans votre connexion.
4. Créez une classe publique comme vous le souhaitez, une chose comme " Blog "
5. Créez votre ContextClass qui hérite de DbContext, quelque chose comme " BlogContext "
6. Définissez une propriété dans votre contexte de type DbSet, quelque chose comme ceci:

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. Il est important de passer le nom de la connexion dans le constructeur (ici Your_Connection_Name)
8. Dans la console du gestionnaire de packages, exécutez la commande Enable-Migration , cela créera un dossier de migration dans votre projet.
9. Exécutez la commande Add-Migration Your_Arbitrary_Migraiton_Name , cela créera une classe de migration dans le dossier migrations avec deux méthodes Up () et Down ()
10. Exécuter la commande Update-Database afin de créer une base de données avec une table de blog