Entity Framework
Enhet-ramkod Första migrering

Aktivera migreringar

Använd kommandot för att aktivera Code First Migrations inom enhetsramen

Enable-Migrations

på Package Manager-konsolen .

Du måste ha en giltig DbContext implementering som innehåller dina databasobjekt som hanteras av EF. I det här exemplet kommer databasförhållandet att innehålla föremål BlogPost och Author :

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

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

Efter att kommandot har utförts bör följande utgång visas:

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

Dessutom bör en ny mapp Migrations visas med en enda fil Configuration.cs inuti:

Nästa steg skulle vara att skapa ditt första databasmigrationsskript som skapar den ursprungliga databasen (se nästa exempel).

Lägg till din första migrering

När du har aktiverat migreringar (hänvisa till det här exemplet ) kan du nu skapa din första migrering som innehåller en första skapande av alla databastabeller, index och anslutningar.

En migrering kan skapas med kommandot

Add-Migration <migration-name>

Detta kommando skapar en ny klass som innehåller två metoder Up och Down som används för att tillämpa och ta bort migreringen.

Använd nu kommandot baserat på exemplet ovan för att skapa en migrering som heter 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.

En ny tidsstämpel för fil _Initial.cs skapas (endast de viktiga sakerna visas här):

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

Som du ser, i metoden Up() skapas två tabeller Authors och BlogPosts och fälten skapas i enlighet därmed. Dessutom skapas relationen mellan de två tabellerna genom att lägga till fältet Author_AuthorId . På andra sidan försöker metoden Down() vända migrationsaktiviteterna.

Om du känner dig säker med din migrering kan du tillämpa migreringen till databasen med kommandot:

Update-Database

Alla väntande migrationer (i detta fall den initiala migrationen) tillämpas på databasen och därefter tillämpas frömetoden (lämpligt exempel)

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.

Du kan se resultaten från aktiviteterna i SQL Explorer:

För kommandona Add-Migration och Update-Database flera alternativ tillgängliga som kan användas för att finjustera aktiviteterna. Använd alla för att se alla alternativ

get-help Add-Migration

och

get-help Update-Database

Såddata under migrationer

När du har aktiverat och skapat migreringar kan det vara ett behov att först fylla eller migrera data i din databas. Det finns flera möjligheter men för enkla migreringar kan du använda metoden 'Seed ()' i filen Konfiguration som skapats efter att du har ringt enable-migrations .

Funktionen Seed() hämtar en databassammanhang eftersom den bara är parameter och du kan utföra EF-operationer i den här funktionen:

protected override void Seed(Model.DatabaseContext context);

Du kan utföra alla typer av aktiviteter inom Seed() . I händelse av något fel rullas hela transaktionen (även de tillämpade korrigeringarna) tillbaka.

En exempelfunktion som skapar data endast om en tabell är tom kan se ut så här:

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

En trevlig funktion som tillhandahålls av EF-utvecklarna är förlängningsmetoden AddOrUpdate() . Den här metoden gör det möjligt att uppdatera data baserat på den primära nyckeln eller infoga data om de inte redan finns (exemplet är hämtat från den genererade källkoden för 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" }
    );
}

Observera att Seed() kallas efter att den sista korrigeringen har applicerats. Om du behöver migrera eller utsäda data under korrigeringar måste andra metoder användas.

Använda Sql () under migreringar

Till exempel: Du kommer att migrera en befintlig kolumn från icke-obligatoriskt till obligatoriskt. I det här fallet kan du behöva fylla några standardvärden i din migrering för rader där de ändrade fälten faktiskt är NULL . Om standardvärdet är enkelt (t.ex. "0") kan du använda en default eller defaultSql egenskap i din kolumndefinition. Om det inte är så lätt kan du använda Sql() i Up() eller Down() -funktionerna i dina migrationer.

Här är ett exempel. Om man antar en klass författare som innehåller en e-postadress som en del av datamängden. Nu beslutar vi att ha e-postadressen som ett obligatoriskt fält. För att migrera befintliga kolumner har företaget den smarta idén att skapa dummy-e-postadresser som [email protected] , där fullt namn är författarens fulla namn utan mellanslag. Att lägga till attributet [Required] i fältet Email skulle skapa följande migrering:

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

Detta skulle misslyckas om vissa NULL-fält finns i databasen:

Det går inte att infoga värdet NULL i kolumnen 'E-post', tabellen 'App.Model.DatabaseContext.dbo.Authors'; kolumnen tillåter inte noll. UPDATE misslyckas.

Att lägga till följande som innan AlterColumn kommandot hjälper:

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

update-database lyckas och tabellen ser ut så här (exempel visas data):

Annan användning

Du kan använda Sql() för alla typer av DML- och DDL-aktiviteter i din databas. Det körs som en del av migrationstransaktionen; Om SQL misslyckas misslyckas den fullständiga migreringen och en rollback görs.

Gör "Update-databas" i din kod

Program som körs i miljöer utan utveckling kräver ofta databasuppdateringar. När du har använt kommandot Add-Migration att skapa dina databas-patches finns det behov av att köra uppdateringarna i andra miljöer och sedan testmiljön.

Vanliga utmaningar är:

• ingen Visual Studio installerad i produktionsmiljöer, och
• inga anslutningar tillåtna anslutning / kundmiljöer i verkligheten.

En lösning är följande kodsekvens som kontrollerar om uppdateringar ska utföras och körs i ordning. Se till att transaktioner och undantagshantering fungerar ordentligt för att säkerställa att ingen information går förlorad vid fel.

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

där MyDbConfiguration är din migreringsinställning någonstans i dina källor:

public class MyDbConfiguration : DbMigrationsConfiguration<ApplicationDbContext>

Initial ramverkskod Första migreringen steg för steg

1. Skapa en konsolapplikation.
2. Installera EntityFramework nuget-paket genom att köra Install-Package EntityFramework i "Package Manager Console"
3. Lägg till din anslutningssträng i app.config-filen. Det är viktigt att inkludera providerName="System.Data.SqlClient" i din anslutning.
4. Skapa en allmän klass som du vill, något som " Blog "
5. Skapa ditt ContextClass som ärver från DbContext, något som " BlogContext "
6. Definiera en egenskap i ditt sammanhang av DbSet-typ, något sådant:

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. Det är viktigt att lämna anslutningsnamnet i konstruktören (här Your_Connection_Name)
8. I Package Manager-konsolen kör Enable-Migration kommandot. Detta skapar en migreringsmapp i ditt projekt
9. Kör kommandot Add-Migration Your_Arbitrary_Migraiton_Name , detta skapar en migreringsklass i migrationsmappen med två metod upp () och ned ()
10. Kör Update-Database för att skapa en databas med en bloggtabell