Migracje Code FirstCode First Migrations

Migracje Code First jest zalecanym sposobem, aby rozwijać schemat bazy danych aplikacji, jeśli jest używany przepływ pracy Code First.Code First Migrations is the recommended way to evolve your application's database schema if you are using the Code First workflow. Migracje udostępniają zestaw narzędzi umożliwiających:Migrations provide a set of tools that allow:

  1. Utwórz początkową bazę danych, która współpracuje z modelem EFCreate an initial database that works with your EF model
  2. Generowanie migracji w celu śledzenia zmian wprowadzonych w modelu EFGenerating migrations to keep track of changes you make to your EF model
  3. Aktualizuj bazę danych o te zmianyKeep your database up to date with those changes

Poniższy przewodnik zawiera omówienie Migracje Code First w Entity Framework.The following walkthrough will provide an overview of Code First Migrations in Entity Framework. Możesz ukończyć cały przewodnik lub przejść do tematu, który Cię interesuje.You can either complete the entire walkthrough or skip to the topic you are interested in. Omówiono następujące tematy:The following topics are covered:

Kompilowanie wstępnego modelu & bazy danychBuilding an Initial Model & Database

Przed rozpoczęciem korzystania z migracji potrzebujemy projektu i modelu Code First do pracy z programem.Before we start using migrations we need a project and a Code First model to work with. W tym instruktażu będziemy używać bloga i modelu post .For this walkthrough we are going to use the canonical Blog and Post model.

  • Utwórz nową aplikację konsolową MigrationsDemoCreate a new MigrationsDemo Console application
  • Dodaj najnowszą wersję pakietu NuGet EntityFramework do projektuAdd the latest version of the EntityFramework NuGet package to the project
    • Tools — > Menedżer pakietów biblioteki — > konsola Menedżera pakietówTools –> Library Package Manager –> Package Manager Console
    • Uruchom polecenie install-package EntityFrameworkRun the Install-Package EntityFramework command
  • Dodaj plik model.cs z kodem pokazanym poniżej.Add a Model.cs file with the code shown below. Ten kod definiuje jedną klasę blogu , która składa się z naszego modelu domeny i klasy BlogContext , która stanowi nasz kontekst Code FirstThis code defines a single Blog class that makes up our domain model and a BlogContext class that is our EF Code First context
    using System.Data.Entity;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.Data.Entity.Infrastructure;

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

        public class Blog
        {
            public int BlogId { get; set; }
            public string Name { get; set; }
        }
    }
  • Teraz, gdy mamy już model, który jest używany do uzyskiwania dostępu do danych.Now that we have a model it’s time to use it to perform data access. Zaktualizuj plik program.cs za pomocą kodu pokazanego poniżej.Update the Program.cs file with the code shown below.
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    namespace MigrationsDemo
    {
        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();
            }
        }
    }
  • Uruchom aplikację i zobaczysz, że została utworzona baza danych MigrationsCodeDemo. BlogContext .Run your application and you will see that a MigrationsCodeDemo.BlogContext database is created for you.

    LocalDB bazy danych

Włączanie migracjiEnabling Migrations

Jest to czas na wprowadzenie kolejnych zmian w modelu.It’s time to make some more changes to our model.

  • Wprowadźmy Właściwość adresu URL do klasy bloga.Let’s introduce a Url property to the Blog class.
    public string Url { get; set; }

Jeśli chcesz uruchomić aplikację ponownie, otrzymasz InvalidOperationException z informacją o tym, że model zapasowy kontekstu "BlogContext" został zmieniony od czasu utworzenia bazy danych. Rozważ użycie Migracje Code First do zaktualizowania bazy danych ( http://go.microsoft.com/fwlink/?LinkId=238269 ).If you were to run the application again you would get an InvalidOperationException stating The model backing the 'BlogContext' context has changed since the database was created. Consider using Code First Migrations to update the database ( http://go.microsoft.com/fwlink/?LinkId=238269).

Z powodu wyjątku sugerujemy czas rozpoczęcia korzystania z Migracje Code First.As the exception suggests, it’s time to start using Code First Migrations. Pierwszym krokiem jest włączenie migracji w naszym kontekście.The first step is to enable migrations for our context.

  • Uruchamianie polecenia enable-migrations w konsoli Menedżera pakietówRun the Enable-Migrations command in Package Manager Console

    To polecenie dodało folder migracji do naszego projektu.This command has added a Migrations folder to our project. Ten nowy folder zawiera dwa pliki:This new folder contains two files:

  • Klasa konfiguracji.The Configuration class. Ta klasa umożliwia skonfigurowanie sposobu zachowania migracji dla kontekstu.This class allows you to configure how Migrations behaves for your context. W tym instruktażu zostanie użyta domyślna konfiguracja.For this walkthrough we will just use the default configuration. Ponieważ istnieje tylko jeden Code First kontekst w projekcie, Enable-Migrations automatycznie wypełnił typ kontekstu, do którego odnosi się ta konfiguracja.Because there is just a single Code First context in your project, Enable-Migrations has automatically filled in the context type this configuration applies to.

  • Migracja InitialCreate.An InitialCreate migration. Ta migracja została wygenerowana, ponieważ Code First utworzyć bazę danych dla nas przed włączeniem migracji.This migration was generated because we already had Code First create a database for us, before we enabled migrations. Kod w tej migracji szkieletowej reprezentuje obiekty, które zostały już utworzone w bazie danych.The code in this scaffolded migration represents the objects that have already been created in the database. W naszym przypadku jest to tabela blogów z BlogId i kolumnami nazw .In our case that is the Blog table with a BlogId and Name columns. Nazwa pliku zawiera sygnaturę czasową ułatwiającą porządkowanie.The filename includes a timestamp to help with ordering. Jeśli baza danych nie została jeszcze utworzona, migracja InitialCreate nie została dodana do projektu. Zamiast tego podczas pierwszego wywołania Add-Migration kod, aby utworzyć te tabele, będzie szkieletem do nowej migracji.If the database had not already been created this InitialCreate migration would not have been added to the project. Instead, the first time we call Add-Migration the code to create these tables would be scaffolded to a new migration.

Wiele modeli przeznaczonych dla tej samej bazy danychMultiple Models Targeting the Same Database

W przypadku korzystania z wersji wcześniejszych niż EF6 tylko jeden model Code First może być używany do generowania schematu bazy danych i zarządzania nią.When using versions prior to EF6, only one Code First model could be used to generate/manage the schema of a database. Jest to wynik pojedynczej tabeli ** _ _ MigrationsHistory** dla jednej bazy danych bez możliwości zidentyfikowania wpisów należących do tego modelu.This is the result of a single __MigrationsHistory table per database with no way to identify which entries belong to which model.

Począwszy od EF6, Klasa konfiguracji zawiera właściwość ContextKey .Starting with EF6, the Configuration class includes a ContextKey property. Działa jako unikatowy identyfikator dla każdego modelu Code First.This acts as a unique identifier for each Code First model. Odpowiadająca kolumna w tabeli ** _ _ MigrationsHistory** umożliwia stosowanie wpisów z wielu modeli w celu udostępnienia tabeli.A corresponding column in the __MigrationsHistory table allows entries from multiple models to share the table. Domyślnie ta właściwość ma ustawioną w pełni kwalifikowaną nazwę kontekstu.By default, this property is set to the fully qualified name of your context.

Generowanie & wykonywania migracjiGenerating & Running Migrations

Migracje Code First ma dwa podstawowe polecenia, z którymi zamierzasz się zapoznać.Code First Migrations has two primary commands that you are going to become familiar with.

  • W ramach migracji do kolejnej migracji w oparciu o zmiany wprowadzone w modelu od momentu utworzenia ostatniej migracjiAdd-Migration will scaffold the next migration based on changes you have made to your model since the last migration was created
  • Aktualizacja — baza danych zastosuje wszystkie oczekujące migracje do bazy danychUpdate-Database will apply any pending migrations to the database

Musimy utworzyć szkielet migracji, aby zachować ostrożność podczas dodawania nowej właściwości adresu URL.We need to scaffold a migration to take care of the new Url property we have added. Polecenie Add-Migration umożliwia nam nadanie nazw migracji nazwy, przywołują nasze AddBlogUrl.The Add-Migration command allows us to give these migrations a name, let’s just call ours AddBlogUrl.

  • Uruchamianie polecenia Add-Migration AddBlogUrl w konsoli Menedżera pakietówRun the Add-Migration AddBlogUrl command in Package Manager Console
  • W folderze migracji mamy teraz nową migrację AddBlogUrl .In the Migrations folder we now have a new AddBlogUrl migration. Nazwa pliku migracji jest wstępnie naprawiona sygnaturą czasową, aby ułatwić porządkowanieThe migration filename is pre-fixed with a timestamp to help with ordering
    namespace MigrationsDemo.Migrations
    {
        using System;
        using System.Data.Entity.Migrations;

        public partial class AddBlogUrl : DbMigration
        {
            public override void Up()
            {
                AddColumn("dbo.Blogs", "Url", c => c.String());
            }

            public override void Down()
            {
                DropColumn("dbo.Blogs", "Url");
            }
        }
    }

Możemy teraz edytować lub dodawać do tej migracji, ale wszystko wygląda dość dobrze.We could now edit or add to this migration but everything looks pretty good. Aby zastosować tę migrację do bazy danych, użyjmy do bazy danych Update-Database .Let’s use Update-Database to apply this migration to the database.

  • Uruchamianie polecenia Update-Database w konsoli Menedżera pakietówRun the Update-Database command in Package Manager Console
  • Migracje Code First będzie porównać migracje w naszym folderze migracji z tymi, które zostały zastosowane do bazy danych programu.Code First Migrations will compare the migrations in our Migrations folder with the ones that have been applied to the database. Zobaczy on, że należy zastosować migrację AddBlogUrl i uruchomić ją.It will see that the AddBlogUrl migration needs to be applied, and run it.

Baza danych MigrationsDemo. BlogContext jest teraz aktualizowana w celu uwzględnienia kolumny adresu URL w tabeli blogów .The MigrationsDemo.BlogContext database is now updated to include the Url column in the Blogs table.

Dostosowywanie migracjiCustomizing Migrations

Do tej pory wygenerowałeś i przeprowadzimy migrację bez wprowadzania żadnych zmian.So far we’ve generated and run a migration without making any changes. Teraz przyjrzyjmy się edycji kodu, który jest generowany domyślnie.Now let’s look at editing the code that gets generated by default.

  • Aby wprowadzić więcej zmian w modelu, dodajmy nową właściwość rankingu do klasy blogaIt’s time to make some more changes to our model, let’s add a new Rating property to the Blog class
    public int Rating { get; set; }
  • Dodajmy również nową klasę postLet's also add a new Post class
    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; }
    }
  • Dodamy również kolekcję ogłoszeń do klasy blog , aby utworzyć drugi koniec relacji między blogiem i wpisemWe'll also add a Posts collection to the Blog class to form the other end of the relationship between Blog and Post
    public virtual List<Post> Posts { get; set; }

Użyjemy polecenia Add-Migration , aby zapewnić, że migracje Code First szkieletem na potrzeby migracji do nas.We'll use the Add-Migration command to let Code First Migrations scaffold its best guess at the migration for us. Będziemy wywoływać to AddPostClassmigracji.We’re going to call this migration AddPostClass.

  • Uruchom polecenie Add-Migration AddPostClass w konsoli Menedżera pakietów.Run the Add-Migration AddPostClass command in Package Manager Console.

Migracje Code First było bardzo dobre zadanie tworzenia szkieletu tych zmian, ale istnieje kilka rzeczy, które warto zmienić:Code First Migrations did a pretty good job of scaffolding these changes, but there are some things we might want to change:

  1. Najpierw Dodaj unikatowy indeks do wpisów. kolumna tytułu (dodanie w wierszu 22 & 29 w poniższym kodzie).First up, let’s add a unique index to Posts.Title column (Adding in line 22 & 29 in the code below).
  2. Dodawana jest również kolumna " Blogi " z nie dopuszczaniem wartości null.We’re also adding a non-nullable Blogs.Rating column. Jeśli w tabeli znajdują się jakieś dane, zostanie do niego przypisana domyślna wartość CLR typu danych dla nowej kolumny (Klasyfikacja jest liczbą całkowitą, tak aby była równa 0).If there is any existing data in the table it will get assigned the CLR default of the data type for new column (Rating is integer, so that would be 0). Ale chcemy określić wartość domyślną równą 3 , aby istniejące wiersze w tabeli blogów miały od znośnego klasyfikację.But we want to specify a default value of 3 so that existing rows in the Blogs table will start with a decent rating. (Można zobaczyć wartość domyślną określoną w wierszu 24 poniższego kodu)(You can see the default value specified on line 24 of the code below)
    namespace MigrationsDemo.Migrations
    {
        using System;
        using System.Data.Entity.Migrations;

        public partial class AddPostClass : DbMigration
        {
            public override void Up()
            {
                CreateTable(
                    "dbo.Posts",
                    c => new
                        {
                            PostId = c.Int(nullable: false, identity: true),
                            Title = c.String(maxLength: 200),
                            Content = c.String(),
                            BlogId = c.Int(nullable: false),
                        })
                    .PrimaryKey(t => t.PostId)
                    .ForeignKey("dbo.Blogs", t => t.BlogId, cascadeDelete: true)
                    .Index(t => t.BlogId)
                    .Index(p => p.Title, unique: true);

                AddColumn("dbo.Blogs", "Rating", c => c.Int(nullable: false, defaultValue: 3));
            }

            public override void Down()
            {
                DropIndex("dbo.Posts", new[] { "Title" });
                DropIndex("dbo.Posts", new[] { "BlogId" });
                DropForeignKey("dbo.Posts", "BlogId", "dbo.Blogs");
                DropColumn("dbo.Blogs", "Rating");
                DropTable("dbo.Posts");
            }
        }
    }

Twoja edytowana migracja jest gotowa do użycia, więc użyjemy aktualizacji bazy danych , aby zapewnić aktualność bazy danych.Our edited migration is ready to go, so let’s use Update-Database to bring the database up-to-date. Ten czas pozwala określić flagę – verbose , aby zobaczyć, że program SQL migracje Code First jest uruchomiony.This time let’s specify the –Verbose flag so that you can see the SQL that Code First Migrations is running.

  • Uruchom polecenie Update-Database – verbose w konsoli Menedżera pakietów.Run the Update-Database –Verbose command in Package Manager Console.

Ruch danych/niestandardowe SQLData Motion / Custom SQL

Do tej pory oglądamy operacje migracji, które nie zmieniają ani nie przechodzą żadnych danych, teraz przyjrzyjmy się coś, co będzie wymagało przeniesienia pewnych danych.So far we have looked at migration operations that don’t change or move any data, now let’s look at something that needs to move some data around. Nie ma jeszcze natywnej obsługi ruchu danych, ale można uruchamiać w dowolnym momencie dowolne polecenia SQL.There is no native support for data motion yet, but we can run some arbitrary SQL commands at any point in our script.

  • Dodajmy do naszego modelu Właściwość post. abstract .Let’s add a Post.Abstract property to our model. Później będziemy wstępnie wypełniać streszczenie istniejących wpisów przy użyciu pewnego tekstu od początku kolumny Content (zawartość ).Later, we’re going to pre-populate the Abstract for existing posts using some text from the start of the Content column.
    public string Abstract { get; set; }

Użyjemy polecenia Add-Migration , aby zapewnić, że migracje Code First szkieletem na potrzeby migracji do nas.We'll use the Add-Migration command to let Code First Migrations scaffold its best guess at the migration for us.

  • Uruchom polecenie Add-Migration AddPostAbstract w konsoli Menedżera pakietów.Run the Add-Migration AddPostAbstract command in Package Manager Console.
  • Wygenerowane migracje uwzględniają zmiany schematu, ale chcemy również wstępnie wypełnić kolumnę abstrakcyjną przy użyciu pierwszych 100 znaków zawartości dla każdego wpisu.The generated migration takes care of the schema changes but we also want to pre-populate the Abstract column using the first 100 characters of content for each post. Możemy to zrobić przez upuszczenie na SQL i uruchomienie instrukcji Update po dodaniu kolumny.We can do this by dropping down to SQL and running an UPDATE statement after the column is added. (Dodawanie w wierszu 12 w poniższym kodzie)(Adding in line 12 in the code below)
    namespace MigrationsDemo.Migrations
    {
        using System;
        using System.Data.Entity.Migrations;

        public partial class AddPostAbstract : DbMigration
        {
            public override void Up()
            {
                AddColumn("dbo.Posts", "Abstract", c => c.String());

                Sql("UPDATE dbo.Posts SET Abstract = LEFT(Content, 100) WHERE Abstract IS NULL");
            }

            public override void Down()
            {
                DropColumn("dbo.Posts", "Abstract");
            }
        }
    }

Twoja edytowana migracja jest dobra, dlatego użyjemy polecenia Update-Database , aby zapewnić aktualność bazy danych.Our edited migration is looking good, so let’s use Update-Database to bring the database up-to-date. Określimy flagę – verbose , aby można było zobaczyć uruchamianie kodu SQL w bazie danych.We’ll specify the –Verbose flag so that we can see the SQL being run against the database.

  • Uruchom polecenie Update-Database – verbose w konsoli Menedżera pakietów.Run the Update-Database –Verbose command in Package Manager Console.

Migrowanie do określonej wersji (w tym obniżanie poziomu)Migrate to a Specific Version (Including Downgrade)

Do tej pory zawsze uaktualniono do najnowszej migracji, ale mogą wystąpić sytuacje, w których uaktualnienie/obniżenie poziomu zostanie przeprowadzone w określonej migracji.So far we have always upgraded to the latest migration, but there may be times when you want upgrade/downgrade to a specific migration.

Załóżmy, że chcemy przeprowadzić migrację bazy danych do stanu, w którym znajdowała się po zakończeniu migracji AddBlogUrl .Let’s say we want to migrate our database to the state it was in after running our AddBlogUrl migration. Do obniżenia poziomu migracji można użyć przełącznika – TargetMigration .We can use the –TargetMigration switch to downgrade to this migration.

  • Uruchom polecenie Update-Database – TargetMigration: AddBlogUrl w konsoli Menedżera pakietów.Run the Update-Database –TargetMigration: AddBlogUrl command in Package Manager Console.

To polecenie spowoduje uruchomienie skryptu w dół dla naszych AddBlogAbstract i migracji AddPostClass .This command will run the Down script for our AddBlogAbstract and AddPostClass migrations.

Jeśli chcesz przywrócić cały sposób do pustej bazy danych, możesz użyć polecenia Update-Database – TargetMigration: $InitialDatabase .If you want to roll all the way back to an empty database then you can use the Update-Database –TargetMigration: $InitialDatabase command.

Pobieranie skryptu SQLGetting a SQL Script

Jeśli inny deweloper chce zmienić te zmiany na komputerze, może po prostu przeprowadzić synchronizację, gdy sprawdzimy nasze zmiany w kontroli źródła.If another developer wants these changes on their machine they can just sync once we check our changes into source control. Po otrzymaniu nowych migracji można po prostu uruchomić polecenie Update-Database, aby zmiany zostały zastosowane lokalnie.Once they have our new migrations they can just run the Update-Database command to have the changes applied locally. Jeśli jednak chcemy wypchnąć te zmiany do serwera testowego i ostatecznie produkcji, prawdopodobnie chcemy, aby skrypt SQL mógł zostać przekazany do naszego DBA.However if we want to push these changes out to a test server, and eventually production, we probably want a SQL script we can hand off to our DBA.

  • Uruchom polecenie Update-Database , ale ten czas należy określić flagę – Script , tak aby zmiany były zapisywane do skryptu, a nie do zastosowania.Run the Update-Database command but this time specify the –Script flag so that changes are written to a script rather than applied. Określimy również migrację źródłową i docelową w celu wygenerowania skryptu.We’ll also specify a source and target migration to generate the script for. Chcemy, aby skrypt przeszedł z pustej bazy danych ($InitialDatabase) do najnowszej wersji ( AddPostAbstractmigracji).We want a script to go from an empty database ($InitialDatabase) to the latest version (migration AddPostAbstract). Jeśli nie określisz docelowej migracji, migracja będzie używać najnowszej migracji jako docelowej. Jeśli nie określisz migracji źródła, migracja będzie używać bieżącego stanu bazy danych.If you don’t specify a target migration, Migrations will use the latest migration as the target. If you don't specify a source migrations, Migrations will use the current state of the database.
  • Uruchom polecenie Update-Database-Script-SourceMigration: $InitialDatabase-TargetMigration: AddPostAbstract w konsoli Menedżera pakietówRun the Update-Database -Script -SourceMigration: $InitialDatabase -TargetMigration: AddPostAbstract command in Package Manager Console

Migracje Code First uruchomi potok migracji, ale zamiast tego rzeczywiście zastosuje zmiany, zapisze je do pliku SQL.Code First Migrations will run the migration pipeline but instead of actually applying the changes it will write them out to a .sql file for you. Po wygenerowaniu skryptu zostanie on otwarty w programie Visual Studio, gotowy do wyświetlenia lub zapisania.Once the script is generated, it is opened for you in Visual Studio, ready for you to view or save.

Generowanie skryptów idempotentneGenerating Idempotent Scripts

Rozpoczynając od EF6, jeśli określono wartość – SourceMigration $InitialDatabase , wygenerowany skrypt będzie "idempotentne".Starting with EF6, if you specify –SourceMigration $InitialDatabase then the generated script will be ‘idempotent’. Skrypty idempotentne mogą uaktualnić bazę danych obecnie w dowolnej wersji do najnowszej wersji (lub określonej wersji, jeśli używasz programu – TargetMigration).Idempotent scripts can upgrade a database currently at any version to the latest version (or the specified version if you use –TargetMigration). Wygenerowany skrypt zawiera logikę, aby sprawdzić tabelę ** _ _ MigrationsHistory** i zastosować tylko zmiany, które nie zostały wcześniej zastosowane.The generated script includes logic to check the __MigrationsHistory table and only apply changes that haven't been previously applied.

Automatyczne uaktualnianie przy uruchamianiu aplikacji (inicjator MigrateDatabaseToLatestVersion)Automatically Upgrading on Application Startup (MigrateDatabaseToLatestVersion Initializer)

W przypadku wdrażania aplikacji może być konieczne automatyczne uaktualnienie bazy danych (przez zastosowanie wszelkich oczekujących migracji) podczas uruchamiania aplikacji.If you are deploying your application you may want it to automatically upgrade the database (by applying any pending migrations) when the application launches. Można to zrobić przez zarejestrowanie inicjatora bazy danych MigrateDatabaseToLatestVersion .You can do this by registering the MigrateDatabaseToLatestVersion database initializer. Inicjator bazy danych po prostu zawiera logikę, która jest używana do poprawnego skonfigurowania bazy danych.A database initializer simply contains some logic that is used to make sure the database is setup correctly. Ta logika jest uruchamiana przy pierwszym użyciu kontekstu w procesie aplikacji (AppDomain).This logic is run the first time the context is used within the application process (AppDomain).

Można zaktualizować plik program.cs , jak pokazano poniżej, aby ustawić inicjator MigrateDatabaseToLatestVersion dla BlogContext przed użyciem kontekstu (wiersz 14).We can update the Program.cs file, as shown below, to set the MigrateDatabaseToLatestVersion initializer for BlogContext before we use the context (Line 14). Należy pamiętać, że należy również dodać instrukcję using dla przestrzeni nazw System. Data. Entity (wiersz 5).Note that you also need to add a using statement for the System.Data.Entity namespace (Line 5).

Gdy utworzymy wystąpienie tego inicjatora, musimy określić typ kontekstu (BlogContext) i konfigurację migracji (konfigurację) — Konfiguracja migracji jest klasą dodaną do folderu migracji po włączeniu migracji.When we create an instance of this initializer we need to specify the context type (BlogContext) and the migrations configuration (Configuration) - the migrations configuration is the class that got added to our Migrations folder when we enabled Migrations.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Data.Entity;
    using MigrationsDemo.Migrations;

    namespace MigrationsDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                Database.SetInitializer(new MigrateDatabaseToLatestVersion<BlogContext, Configuration>());

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

Teraz za każdym razem, gdy aplikacja jest uruchamiana, najpierw sprawdza, czy baza danych, do której jest przeznaczona, jest aktualna, i zastosuje oczekujące migracje, jeśli nie jest.Now whenever our application runs it will first check if the database it is targeting is up-to-date, and apply any pending migrations if it is not.