Dela via

Automatiska Code First-migreringar

Med automatiska migreringar kan du använda Code First Migrations utan att ha en kodfil i projektet för varje ändring du gör. Alla ändringar kan inte tillämpas automatiskt – till exempel kräver kolumnbyten användning av en kodbaserad migrering.

Anmärkning

Den här artikeln förutsätter att du vet hur du använder Code First Migrations i grundläggande scenarier. Om du inte gör det måste du läsa Code First Migrations innan du fortsätter.

Rekommendation för teammiljöer

Du kan varvat automatiska och kodbaserade migreringar, men detta rekommenderas inte i scenarier för teamutveckling. Om du ingår i ett team med utvecklare som använder källkontroll bör du antingen använda rent automatiska migreringar eller rent kodbaserade migreringar. Med tanke på begränsningarna för automatiska migreringar rekommenderar vi att du använder kodbaserade migreringar i teammiljöer.

Skapa en inledande modell och databas

Innan vi börjar använda migreringar behöver vi ett projekt och en Code First-modell att arbeta med. För den här genomgången ska vi använda den kanoniska blogg- och postmodellen.

  • Skapa ett nytt MigreringAutomaticDemo-konsolprogram
  • Lägg till den senaste versionen av EntityFramework NuGet-paketet i projektet
    • Verktyg –> Bibliotekspakethanteraren –> Package Manager-konsolen
    • Kör kommandot Install-Package EntityFramework
  • Lägg till en Model.cs fil med koden som visas nedan. Den här koden definierar en enskild bloggklass som utgör vår domänmodell och en BlogContext-klass som är vår EF Code First-kontext
    using System.Data.Entity;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.Data.Entity.Infrastructure;

    namespace MigrationsAutomaticDemo
    {
        public class BlogContext : DbContext
        {
            public DbSet<Blog> Blogs { get; set; }
        }

        public class Blog
        {
            public int BlogId { get; set; }
            public string Name { get; set; }
        }
    }
  • Nu när vi har en modell är det dags att använda den för att utföra dataåtkomst. Uppdatera Program.cs-filen med koden som visas nedan.
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    namespace MigrationsAutomaticDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                using (var db = new BlogContext())
                {
                    db.Blogs.Add(new Blog { Name = "Another Blog " });
                    db.SaveChanges();

                    foreach (var blog in db.Blogs)
                    {
                        Console.WriteLine(blog.Name);
                    }
                }

                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
        }
    }

  • Kör programmet så ser du att en MigrationsAutomaticCodeDemo.BlogContext-databas har skapats åt dig.

    Database LocalDB

Aktivera migreringar

Det är dags att göra några fler ändringar i vår modell.

  • Nu ska vi introducera en URL-egenskap till klassen Blogg.
    public string Url { get; set; }

Om du skulle köra programmet igen skulle du få en InvalidOperationException som anger att modellen som stöder "BlogContext"-kontexten har ändrats sedan databasen skapades. Överväg att använda Code First Migrations för att uppdatera databasen (http://go.microsoft.com/fwlink/?LinkId=238269).

Som undantaget antyder är det dags att börja använda Code First Migrations. Eftersom vi vill använda automatiska migreringar ska vi ange växeln –EnableAutomaticMigrations .

  • Kör kommandot Enable-Migrations –EnableAutomaticMigrations i Package Manager Console Det här kommandot har lagt till en migreringsmapp i projektet. Den här nya mappen innehåller en fil:

  • Konfigurationsklassen. Med den här klassen kan du konfigurera hur migreringar fungerar för din kontext. För den här genomgången använder vi bara standardkonfigurationen. Eftersom det bara finns en enda Code First-kontext i projektet har Enable-Migrations automatiskt fyllt i den kontexttyp som den här konfigurationen gäller för.

 

Din första automatiska migrering

Code First Migrations har två primära kommandon som du kommer att bekanta dig med.

  • Add-Migration kommer att skapa nästa migrering baserat på ändringar som du har gjort i din modell sedan den senaste migreringen skapades
  • Update-Database tillämpar eventuella väntande migreringar på databasen

Vi kommer att undvika att använda Add-Migration (om vi inte verkligen behöver) och fokusera på att låta Code First Migrations automatiskt beräkna och tillämpa ändringarna. Vi använder Update-Database för att hämta Code First Migrations för att skicka ändringarna till vår modell (den nya egenskapen Blog.Url) till databasen.

  • Kör kommandot Update-Database i Package Manager Console.

Databasen MigrationsAutomaticDemo.BlogContext har nu uppdaterats för att inkludera url-kolumnen i tabellen Bloggar .

 

Din andra automatiska migrering

Nu ska vi göra en ny ändring och låta Code First Migrations automatiskt push-överföra ändringarna till databasen åt oss.

  • Nu ska vi också lägga till en ny Post-klass
    public class Post
    {
        public int PostId { get; set; }
        [MaxLength(200)]
        public string Title { get; set; }
        public string Content { get; set; }

        public int BlogId { get; set; }
        public Blog Blog { get; set; }
    }
  • Vi lägger också till en inläggssamling i klassen Blogg för att bilda den andra änden av relationen mellan Blogg och Inlägg
    public virtual List<Post> Posts { get; set; }

Använd nu Update-Database för att hämta databasen up-to-date. Den här gången ska vi ange flaggan –Verbose så att du kan se SQL:en att Code First Migrations körs.

  • Kör kommandot Update-Database –Verbose i Package Manager Console.

Lägga till en kodbaserad migrering

Nu ska vi titta på något som vi kanske vill använda en kodbaserad migrering för.

  • Nu ska vi lägga till en klassificeringsegenskap i klassen Blogg
    public int Rating { get; set; }

Vi kan bara köra Update-Database för att skicka ändringarna till databasen. Men vi lägger till en kolumn som inte går att nullifiera Blogs.Rating . Om det finns några befintliga data i tabellen tilldelas den CLR-standardvärdet för datatypen för den nya kolumnen (Klassificering är heltal, så det skulle vara 0). Men vi vill ange ett standardvärde på 3 så att befintliga rader i tabellen Bloggar börjar med ett anständigt omdöme. Vi använder kommandot Add-Migration för att skriva den här ändringen till en kodbaserad migrering så att vi kan redigera den. Med kommandot Add-Migration kan vi ge migreringarna ett namn. Vi anropar bara addblograting.

  • Kör kommandot Add-Migration AddBlogRating i Package Manager Console.
  • I mappen Migrering har vi nu en ny AddBlogRating-migrering . Migreringsfilnamnet är förbestämt med en tidsstämpel för att hjälpa till med beställningen. Nu ska vi redigera den genererade koden för att ange standardvärdet 3 för Blog.Rating (rad 10 i koden nedan)

Migreringen har också en kod bakom fil som samlar in vissa metadata. Med dessa metadata kan Code First Migrations replikera de automatiska migreringar som vi utförde före den här kodbaserade migreringen. Detta är viktigt om en annan utvecklare vill köra våra migreringar eller när det är dags att distribuera vårt program.

    namespace MigrationsAutomaticDemo.Migrations
    {
        using System;
        using System.Data.Entity.Migrations;

        public partial class AddBlogRating : DbMigration
        {
            public override void Up()
            {
                AddColumn("Blogs", "Rating", c => c.Int(nullable: false, defaultValue: 3));
            }

            public override void Down()
            {
                DropColumn("Blogs", "Rating");
            }
        }
    }

Vår redigerade migrering ser bra ut, så vi använder Update-Database för att uppdatera databasen till den senaste versionen.

  • Kör kommandot Update-Database i Package Manager Console.

Tillbaka till automatiska migreringar

Nu kan vi växla tillbaka till automatiska migreringar för våra enklare ändringar. Code First Migrations hanterar automatiska och kodbaserade migreringar i rätt ordning baserat på de metadata som lagras i code-behind-filen för varje kodbaserad migrering.

  • Nu ska vi lägga till en Post.Abstract-egenskap i vår modell
    public string Abstract { get; set; }

Nu kan vi använda Update-Database för att hämta Code First Migrations för att skicka den här ändringen till databasen med hjälp av en automatisk migrering.

  • Kör kommandot Update-Database i Package Manager Console.

Sammanfattning

I den här genomgången såg du hur du använder automatiska migreringar för att skicka modelländringar till databasen. Du såg också hur du skapar och kör kodbaserade migreringar mellan automatiska migreringar när du behöver mer kontroll.

  • Last updated on