Självstudie: Använda EF-migreringar i en ASP.NET MVC-app och distribuera till Azure
Hittills har Contoso University-exempelwebbappen körts lokalt i IIS Express på utvecklingsdatorn. Om du vill göra ett verkligt program tillgängligt för andra personer att använda via Internet måste du distribuera det till en webbvärdleverantör. I den här självstudien aktiverar du Code First-migreringar och distribuerar programmet till molnet i Azure:
- Aktivera Code First Migrations. Med funktionen Migrering kan du ändra datamodellen och distribuera ändringarna till produktion genom att uppdatera databasschemat utan att behöva släppa och återskapa databasen.
- Distribuera till Azure. Det här steget är valfritt. Du kan fortsätta med de återstående anvisningarna utan att ha distribuerat projektet.
Vi rekommenderar att du använder en kontinuerlig integreringsprocess med källkontroll för distribution, men den här självstudien beskriver inte dessa ämnen. Mer information finns i Distribuera en molnbaserad .NET-mikrotjänst automatiskt med GitHub Actions och Azure Pipelines.
I den här handledningen:
- Aktivera Code First-migreringar
- Distribuera appen i Azure (valfritt)
Förutsättningar
Aktivera Code First-migreringar
När du utvecklar en ny applikation förändras din datamodell ofta, och varje gång modellen förändras tappar den synkroniseringen med databasen. Du har konfigurerat Entity Framework att automatiskt släppa och återskapa databasen varje gång du ändrar datamodellen. När du lägger till, tar bort eller ändrar entitetsklasser eller ändrar din DbContext-klass, tas din befintliga databas automatiskt bort nästa gång du kör programmet. Därefter skapas en ny databas som matchar modellen och fylls med testdata.
Den här metoden för att hålla databasen synkroniserad med datamodellen fungerar bra tills du distribuerar programmet till produktion. När programmet körs i produktion lagrar det vanligtvis data som du vill behålla och du vill inte förlora allt varje gång du gör en ändring, till exempel när du lägger till en ny kolumn. Funktionen Code First Migrations löser det här problemet genom att aktivera Code First för att uppdatera databasschemat i stället för att släppa och återskapa databasen. I den här självstudien distribuerar du programmet och förbereder dig för att aktivera migreringar.
Inaktivera initieraren som du konfigurerade tidigare genom att kommentera ut eller ta bort det
contextselement som du lade till i programmet Web.config filen.<entityFramework> <!--<contexts> <context type="ContosoUniversity.DAL.SchoolContext, ContosoUniversity"> <databaseInitializer type="ContosoUniversity.DAL.SchoolInitializer, ContosoUniversity" /> </context> </contexts>--> <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework"> <parameters> <parameter value="v11.0" /> </parameters> </defaultConnectionFactory> <providers> <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" /> </providers> </entityFramework>I programmet Web.config-filen, ändra även namnet på databasen i anslutningssträngen till ContosoUniversity2.
<connectionStrings> <add name="SchoolContext" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=ContosoUniversity2;Integrated Security=SSPI;" providerName="System.Data.SqlClient" /> </connectionStrings>Den här ändringen konfigurerar projektet så att den första migreringen skapar en ny databas. Detta krävs inte, men du kommer att se senare varför det är en bra idé.
På menyn Verktyg väljer du NuGet Package Manager>Package Manager Console.
Vid
PM>-prompten anger du följande kommandon:enable-migrations add-migration InitialCreateKommandot
enable-migrationsskapar en migreringsmapp i ContosoUniversity-projektet, och i den mappen placeras en Configuration.cs fil som du kan redigera för att konfigurera migreringar.(Om du missade steget ovan som instruerar dig att ändra databasnamnet hittar migreringar den befintliga databasen och gör automatiskt
add-migrationkommandot. Det är okej, det betyder bara att du inte kommer att köra ett test av migreringskoden innan du distribuerar databasen. Senare när du kör kommandotupdate-databasehänder ingenting eftersom databasen redan finns.)Öppna filen ContosoUniversity\Migrations\Configuration.cs. Precis som den initialiserarklass som du såg tidigare innehåller klassen
ConfigurationenSeed-metod.internal sealed class Configuration : DbMigrationsConfiguration<ContosoUniversity.DAL.SchoolContext> { public Configuration() { AutomaticMigrationsEnabled = false; } protected override void Seed(ContosoUniversity.DAL.SchoolContext context) { // This method will be called after migrating to the latest version. // You can use the DbSet<T>.AddOrUpdate() helper extension method // to avoid creating duplicate seed data. E.g. // // context.People.AddOrUpdate( // p => p.FullName, // new Person { FullName = "Andrew Peters" }, // new Person { FullName = "Brice Lambson" }, // new Person { FullName = "Rowan Miller" } // ); // } }Syftet med metoden Seed är att du ska kunna infoga eller uppdatera testdata när Code First har skapat eller uppdaterat databasen. Metoden anropas när databasen skapas och varje gång databasschemat uppdateras efter att en datamodell har ändrats.
Konfigurera Seed-metoden
När du släpper och återskapar databasen för varje ändring av datamodellen använder du initieringsklassens Seed-metod för att infoga testdata, eftersom databasen tas bort efter varje modelländring och alla testdata går förlorade. Med Code First Migrations behålls testdata efter databasändringar, så det är vanligtvis inte nödvändigt att inkludera testdata i metoden Seed. I själva verket vill du inte att Seed-metoden ska infoga testdata om du ska använda migreringar för att distribuera databasen till produktion, eftersom metoden Seed körs i produktion. I så fall vill du att metoden Seed endast ska infoga de data som du behöver i produktionen i databasen. Du kanske till exempel vill att databasen ska innehålla faktiska avdelningsnamn i tabellen Department när programmet blir tillgängligt i produktion.
I den här självstudien kommer du att använda migreringar för distribution, men din Seed-metod infogar testdata ändå för att göra det enklare att se hur programfunktioner fungerar utan att behöva infoga mycket data manuellt.
Ersätt innehållet i Configuration.cs-filen med följande kod, som läser in testdata i den nya databasen.
namespace ContosoUniversity.Migrations { using ContosoUniversity.Models; using System; using System.Collections.Generic; using System.Data.Entity; using System.Data.Entity.Migrations; using System.Linq; internal sealed class Configuration : DbMigrationsConfiguration<ContosoUniversity.DAL.SchoolContext> { public Configuration() { AutomaticMigrationsEnabled = false; } protected override void Seed(ContosoUniversity.DAL.SchoolContext context) { var students = new List<Student> { new Student { FirstMidName = "Carson", LastName = "Alexander", EnrollmentDate = DateTime.Parse("2010-09-01") }, new Student { FirstMidName = "Meredith", LastName = "Alonso", EnrollmentDate = DateTime.Parse("2012-09-01") }, new Student { FirstMidName = "Arturo", LastName = "Anand", EnrollmentDate = DateTime.Parse("2013-09-01") }, new Student { FirstMidName = "Gytis", LastName = "Barzdukas", EnrollmentDate = DateTime.Parse("2012-09-01") }, new Student { FirstMidName = "Yan", LastName = "Li", EnrollmentDate = DateTime.Parse("2012-09-01") }, new Student { FirstMidName = "Peggy", LastName = "Justice", EnrollmentDate = DateTime.Parse("2011-09-01") }, new Student { FirstMidName = "Laura", LastName = "Norman", EnrollmentDate = DateTime.Parse("2013-09-01") }, new Student { FirstMidName = "Nino", LastName = "Olivetto", EnrollmentDate = DateTime.Parse("2005-08-11") } }; students.ForEach(s => context.Students.AddOrUpdate(p => p.LastName, s)); context.SaveChanges(); var courses = new List<Course> { new Course {CourseID = 1050, Title = "Chemistry", Credits = 3, }, new Course {CourseID = 4022, Title = "Microeconomics", Credits = 3, }, new Course {CourseID = 4041, Title = "Macroeconomics", Credits = 3, }, new Course {CourseID = 1045, Title = "Calculus", Credits = 4, }, new Course {CourseID = 3141, Title = "Trigonometry", Credits = 4, }, new Course {CourseID = 2021, Title = "Composition", Credits = 3, }, new Course {CourseID = 2042, Title = "Literature", Credits = 4, } }; courses.ForEach(s => context.Courses.AddOrUpdate(p => p.Title, s)); context.SaveChanges(); var enrollments = new List<Enrollment> { new Enrollment { StudentID = students.Single(s => s.LastName == "Alexander").ID, CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID, Grade = Grade.A }, new Enrollment { StudentID = students.Single(s => s.LastName == "Alexander").ID, CourseID = courses.Single(c => c.Title == "Microeconomics" ).CourseID, Grade = Grade.C }, new Enrollment { StudentID = students.Single(s => s.LastName == "Alexander").ID, CourseID = courses.Single(c => c.Title == "Macroeconomics" ).CourseID, Grade = Grade.B }, new Enrollment { StudentID = students.Single(s => s.LastName == "Alonso").ID, CourseID = courses.Single(c => c.Title == "Calculus" ).CourseID, Grade = Grade.B }, new Enrollment { StudentID = students.Single(s => s.LastName == "Alonso").ID, CourseID = courses.Single(c => c.Title == "Trigonometry" ).CourseID, Grade = Grade.B }, new Enrollment { StudentID = students.Single(s => s.LastName == "Alonso").ID, CourseID = courses.Single(c => c.Title == "Composition" ).CourseID, Grade = Grade.B }, new Enrollment { StudentID = students.Single(s => s.LastName == "Anand").ID, CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID }, new Enrollment { StudentID = students.Single(s => s.LastName == "Anand").ID, CourseID = courses.Single(c => c.Title == "Microeconomics").CourseID, Grade = Grade.B }, new Enrollment { StudentID = students.Single(s => s.LastName == "Barzdukas").ID, CourseID = courses.Single(c => c.Title == "Chemistry").CourseID, Grade = Grade.B }, new Enrollment { StudentID = students.Single(s => s.LastName == "Li").ID, CourseID = courses.Single(c => c.Title == "Composition").CourseID, Grade = Grade.B }, new Enrollment { StudentID = students.Single(s => s.LastName == "Justice").ID, CourseID = courses.Single(c => c.Title == "Literature").CourseID, Grade = Grade.B } }; foreach (Enrollment e in enrollments) { var enrollmentInDataBase = context.Enrollments.Where( s => s.Student.ID == e.StudentID && s.Course.CourseID == e.CourseID).SingleOrDefault(); if (enrollmentInDataBase == null) { context.Enrollments.Add(e); } } context.SaveChanges(); } } }Metoden Seed tar databaskontextobjektet som en indataparameter, och koden i metoden använder objektet för att lägga till nya entiteter i databasen. För varje entitetstyp skapar koden en samling nya entiteter, lägger till dem i lämplig DbSet- egenskap och sparar sedan ändringarna i databasen. Det är inte nödvändigt att anropa metoden SaveChanges efter varje grupp med entiteter, som du gör här, men det hjälper dig att hitta källan till ett problem om ett undantag inträffar när koden skrivs till databasen.
Några av de instruktioner som infogar data använder metoden AddOrUpdate för att utföra en "upsert"-åtgärd. Eftersom
Seed-metoden körs varje gång du kör kommandotupdate-database, vanligtvis efter varje migrering, kan du inte bara infoga data eftersom raderna du försöker lägga till redan finns där efter den första migreringen som skapar databasen. Åtgärden "upsert" förhindrar fel som skulle inträffa om du försöker infoga en rad som redan finns, men den åsidosätter eventuella ändringar av data som du kan ha gjort när du testade programmet. Med testdata i vissa tabeller kanske du inte vill att det ska hända: i vissa fall när du ändrar data när du testar vill du att ändringarna ska finnas kvar efter databasuppdateringarna. I så fall vill du utföra en villkorsstyrd infogningsåtgärd: infoga endast en rad om den inte redan finns. Metoden Seed använder båda metoderna.Den första parametern som skickas till metoden AddOrUpdate anger egenskapen som ska användas för att kontrollera om det redan finns en rad. För teststudentdata som du anger kan egenskapen
LastNameanvändas för detta ändamål eftersom varje efternamn i listan är unikt:context.Students.AddOrUpdate(p => p.LastName, s)Den här koden förutsätter att efternamn är unika. Om du lägger till en elev manuellt med ett duplicerat efternamn får du följande undantag nästa gång du utför en migrering:
Sekvens innehåller mer än ett element
Information om hur du hanterar redundanta data, till exempel två studenter med namnet "Alexander Carson", finns i Seeding and Debugging Entity Framework (EF) DBs på Rick Andersons blogg. Mer information om metoden
AddOrUpdatefinns i Ta hand om EF 4.3 AddOrUpdate-metoden på Julie Lermans blogg.Koden som skapar
Enrollmententiteter förutsätter att du har värdetIDi entiteterna i samlingenstudents, även om du inte angav egenskapen i koden som skapar samlingen.new Enrollment { StudentID = students.Single(s => s.LastName == "Alexander").ID, CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID, Grade = Grade.A },Du kan använda egenskapen
IDhär eftersom värdetIDanges när du anroparSaveChangesför samlingenstudents. EF hämtar automatiskt det primära nyckelvärdet när en entitet infogas i databasen och den uppdaterar egenskapenIDför entiteten i minnet.Koden som lägger till varje
Enrollmententitet iEnrollments-entitetsuppsättningen använder inte metodenAddOrUpdate. Den kontrollerar om en entitet redan finns och infogar entiteten om den inte finns. Den här metoden bevarar ändringar som du gör i ett registreringsbetyg med hjälp av programmets användargränssnitt. Koden loopar igenom varje medlem iEnrollment-listan och om registreringen inte hittas i databasen läggs registreringen till i databasen. Första gången du uppdaterar databasen är databasen tom, så den lägger till varje registrering.foreach (Enrollment e in enrollments) { var enrollmentInDataBase = context.Enrollments.Where( s => s.Student.ID == e.Student.ID && s.Course.CourseID == e.Course.CourseID).SingleOrDefault(); if (enrollmentInDataBase == null) { context.Enrollments.Add(e); } }Skapa projektet.
Kör den första migreringen
När du körde kommandot add-migration genererade migreringar koden som skulle skapa databasen från grunden. Den här koden finns också i mappen Migrations i filen med namnet <tidsstämpel>_InitialCreate.cs. Metoden Up för klassen InitialCreate skapar databastabellerna som motsvarar datamodellentitetsuppsättningarna och metoden Down tar bort dem.
public partial class InitialCreate : DbMigration
{
public override void Up()
{
CreateTable(
"dbo.Course",
c => new
{
CourseID = c.Int(nullable: false),
Title = c.String(),
Credits = c.Int(nullable: false),
})
.PrimaryKey(t => t.CourseID);
CreateTable(
"dbo.Enrollment",
c => new
{
EnrollmentID = c.Int(nullable: false, identity: true),
CourseID = c.Int(nullable: false),
StudentID = c.Int(nullable: false),
Grade = c.Int(),
})
.PrimaryKey(t => t.EnrollmentID)
.ForeignKey("dbo.Course", t => t.CourseID, cascadeDelete: true)
.ForeignKey("dbo.Student", t => t.StudentID, cascadeDelete: true)
.Index(t => t.CourseID)
.Index(t => t.StudentID);
CreateTable(
"dbo.Student",
c => new
{
ID = c.Int(nullable: false, identity: true),
LastName = c.String(),
FirstMidName = c.String(),
EnrollmentDate = c.DateTime(nullable: false),
})
.PrimaryKey(t => t.ID);
}
public override void Down()
{
DropForeignKey("dbo.Enrollment", "StudentID", "dbo.Student");
DropForeignKey("dbo.Enrollment", "CourseID", "dbo.Course");
DropIndex("dbo.Enrollment", new[] { "StudentID" });
DropIndex("dbo.Enrollment", new[] { "CourseID" });
DropTable("dbo.Student");
DropTable("dbo.Enrollment");
DropTable("dbo.Course");
}
}
Migrationer använder metoden Up för att implementera datamodelländringarna för en migrering. När du anger ett kommando för att återställa uppdateringen anropar Migreringar metoden Down.
Det här är den första migreringen som skapades när du angav kommandot add-migration InitialCreate. Parametern (InitialCreate i exemplet) används för filnamnet och kan vara vad du vill. du väljer vanligtvis ett ord eller en fras som sammanfattar vad som görs i migreringen. Du kan till exempel ge en senare migrering namnet "AddDepartmentTable".
Om du skapade den första migreringen när databasen redan finns genereras koden för att skapa databasen, men den behöver inte köras eftersom databasen redan matchar datamodellen. När du distribuerar appen till en annan miljö där databasen inte finns ännu körs den här koden för att skapa databasen, så det är en bra idé att testa den först. Därför ändrade du namnet på databasen i anslutningssträngen tidigare så att migreringar kan skapa en ny från grunden.
I fönstret Package Manager Console anger du följande kommando:
update-databaseKommandot
update-databasekör metodenUpför att skapa databasen och kör sedan metodenSeedför att fylla i databasen. Samma process körs automatiskt i produktion när du har distribuerat programmet, som du ser i följande avsnitt.Använd Server Explorer för att inspektera databasen som du gjorde i den första självstudien och kör programmet för att kontrollera att allt fortfarande fungerar på samma sätt som tidigare.
Distribuera till Azure
Hittills har programmet körts lokalt i IIS Express på utvecklingsdatorn. För att göra den tillgänglig för andra personer att använda via Internet måste du distribuera den till en webbvärdleverantör. I det här avsnittet av självstudien distribuerar du det till Azure. Det här avsnittet är valfritt. Du kan hoppa över detta och fortsätta med följande självstudie, eller så kan du anpassa anvisningarna i det här avsnittet för en annan värdleverantör.
Använda Code First-migreringar för att distribuera databasen
Om du vill distribuera databasen använder du Code First Migrations. När du skapar publiceringsprofilen som du använder för att konfigurera inställningar för distribution från Visual Studio markerar du kryssrutan Uppdatera databas. Den här inställningen gör att distributionsprocessen automatiskt konfigurerar programmet Web.config filen på målservern så att Code First använder klassen MigrateDatabaseToLatestVersion initializer.
Visual Studio gör ingenting med databasen under distributionsprocessen medan projektet kopieras till målservern. När du kör det distribuerade programmet och det kommer åt databasen för första gången efter distributionen kontrollerar Code First om databasen matchar datamodellen. Om det uppstår ett matchningsfel skapar Code First automatiskt databasen (om den inte finns ännu) eller uppdaterar databasschemat till den senaste versionen (om en databas finns men inte matchar modellen). Om programmet implementerar en Seed migreringsmetod körs metoden efter att databasen har skapats eller schemat har uppdaterats.
Din migreringsmetod Seed infogar testdata. Om du distribuerade till en produktionsmiljö skulle du behöva ändra metoden Seed så att den bara infogar data som du vill infoga i produktionsdatabasen. I din aktuella datamodell kanske du till exempel vill ha riktiga kurser men fiktiva studenter i utvecklingsdatabasen. Du kan skriva en Seed metod för att läsa in både de reella och de fiktiva eleverna under utveckling, och sedan kommentera bort de fiktiva eleverna innan du distribuerar till produktion. Eller så kan du skriva en Seed metod för att endast läsa in kurser och ange fiktiva studenter i testdatabasen manuellt med hjälp av programmets användargränssnitt.
Hämta ett Azure-konto
Du behöver ett Azure-konto. Om du inte redan har en, men du har en Visual Studio-prenumeration, kan du aktivera dina prenumerationsförmåner. Annars kan du skapa ett kostnadsfritt utvärderingskonto på bara några minuter. Mer information finns i kostnadsfri utvärderingsversion av Azure.
Skapa en webbplats och en SQL-databas i Azure
Din webbapp i Azure körs i en delad värdmiljö, vilket innebär att den körs på virtuella datorer som delas med andra Azure-klienter. En delad värdmiljö är ett billigt sätt att komma igång i molnet. Senare, om webbtrafiken ökar, kan programmet skalas för att uppfylla behovet genom att köras på dedikerade virtuella datorer. Mer information om prisalternativ för Azure App Service finns i Prissättning för App Service.
Du distribuerar databasen till Azure SQL-databasen. SQL Database är en molnbaserad relationsdatabastjänst som bygger på SQL Server-tekniker. Verktyg och program som fungerar med SQL Server fungerar också med SQL Database.
I Azure Management Portalväljer du Skapa en resurs på den vänstra fliken och väljer sedan Visa alla i fönstret Ny (eller blad) för att se alla tillgängliga resurser. Välj Web App + SQL i avsnittet Web på bladet Allt. Välj slutligen Skapa.
Formuläret för att skapa en ny Ny webbapp + SQL resurs öppnas.
Ange en sträng i rutan Appnamn som ska användas som unik URL för ditt program. Den fullständiga URL:en består av det du anger här plus standarddomänen för Azure App Services (.azurewebsites.net). Om Appnamn redan har tagits meddelar guiden dig med ett rött Appnamnet är inte tillgängligt meddelande. Om Appnamn är tillgängligt visas en grön bockmarkering.
I rutan Prenumeration väljer du den Azure-prenumeration där du vill att App Service- ska finnas.
I textrutan resursgrupp väljer du en resursgrupp eller skapar en ny. Den här inställningen anger vilket datacenter som webbplatsen ska köras i. Mer information om resursgrupper finns i Resursgrupper.
Skapa en ny App Service-plan genom att klicka på avsnittet App Service, Skapa nyoch fyll i App Service-plan (kan vara samma namn som App Service), Platsoch Prisnivå (det finns ett kostnadsfritt alternativ).
Klicka på SQL Databaseoch välj sedan Skapa en ny databas eller välj en befintlig databas.
I rutan Namn anger du ett namn för databasen.
Klicka på rutan målserver och välj sedan Skapa en ny server. Om du tidigare har skapat en server kan du också välja den servern i listan över tillgängliga servrar.
Välj avsnittet Prisnivå , välj sedan Kostnadsfri. Om ytterligare resurser behövs kan databasen skalas upp när som helst. Mer information om Priser för Azure SQL finns i Prissättning för Azure SQL Database.
Ändra sorteringsordning efter behov.
Ange ett administratörsnamn SQL-administratörsanvändarnamn och SQL-administratörslösenord.
- Om du har valt Ny SQL Database-serverdefinierar du ett nytt namn och lösenord som du ska använda senare när du kommer åt databasen.
- Om du valde en server som du skapade tidigare anger du autentiseringsuppgifter för servern.
Telemetrisamling kan aktiveras för App Service med Application Insights. Med lite konfiguration samlar Application Insights in värdefull information om händelser, undantag, beroenden, begäranden och spårning. Mer information om Application Insights finns i Azure Monitor.
Klicka på Skapa längst ned för att visa att du är klar.
Hanteringsportalen återgår till sidan Instrumentpanel och området Meddelanden överst på sidan visar att webbplatsen skapas. Efter en stund (vanligtvis mindre än en minut) visas ett meddelande om att distributionen lyckades. I navigeringsfältet till vänster visas den nya App Service i avsnittet App Services och den nya SQL-databasen visas i avsnittet SQL-databaser.
Distribuera appen till Azure
I Visual Studio högerklickar du på projektet i Solution Explorer och väljer Publicera på snabbmenyn.
På sidan Välj ett publiceringsmål väljer du App Service och sedan Välj befintlig, och väljer sedan Publicera.
Om du inte tidigare har lagt till din Azure-prenumeration i Visual Studio utför du stegen på skärmen. Med de här stegen kan Visual Studio ansluta till din Azure-prenumeration så att listan över App Services- innehåller din webbplats.
På sidan App Service väljer du Prenumeration du har lagt till App Service i. Under Visaväljer du resursgrupp. Expandera resursgruppen som du lade till App Service i och välj sedan App Service. Välj OK för att publicera appen.
Fönstret Utdata visar vilka distributionsåtgärder som har vidtagits och rapporterar att distributionen har slutförts.
När distributionen är klar öppnas standardwebbläsaren automatiskt till URL:en för den distribuerade webbplatsen.
Din app körs nu i molnet.
Nu har SchoolContext--databasen skapats i Azure SQL-databasen eftersom du valde Kör kod första migreringar (körs vid appstart). Den Web.config filen på den distribuerade webbplatsen har ändrats så att MigrateDatabaseToLatestVersion-initieraren körs första gången koden läser eller skriver data i databasen (som inträffade när du valde fliken Students):
Distribueringsprocessen skapade också en ny anslutningssträng (SchoolContext_DatabasePublish) för Code First-migreringar, som ska användas för att uppdatera databasschemat och fylla databasen med data.
Du hittar den distribuerade versionen av filen Web.config på din egen dator i ContosoUniversity\obj\Release\Package\PackageTmp\Web.config. Du kan komma åt den distribuerade Web.config själva filen med hjälp av FTP. Anvisningar finns i ASP.NET webbdistribution med Visual Studio: Distribuera en koduppdatering. Följ anvisningarna som börjar med "Om du vill använda ett FTP-verktyg behöver du tre saker: FTP-URL:en, användarnamnet och lösenordet."
Not
Webbappen implementerar inte säkerhet, så alla som hittar URL:en kan ändra data. Anvisningar om hur du skyddar webbplatsen finns i Distribuera en säker ASP.NET MVC-app med medlemskap, OAuth och SQL-databas till Azure. Du kan förhindra att andra personer använder webbplatsen genom att stoppa tjänsten med hjälp av Azure Management Portal eller Server Explorer i Visual Studio.
Avancerade migreringsscenarier
Om du distribuerar en databas genom att köra migreringar automatiskt enligt den här självstudien och distribuerar till en webbplats som körs på flera servrar, kan du få flera servrar att försöka köra migreringar samtidigt. Migreringar är atomiska, så om två servrar försöker köra samma migrering lyckas den ena och den andra misslyckas (förutsatt att åtgärderna inte kan utföras två gånger). I det scenariot om du vill undvika dessa problem kan du anropa migreringar manuellt och konfigurera din egen kod så att den bara sker en gång. Mer information finns i Köra och skriptmigreringar från kod på Rowan Millers blogg och Migrate.exe (för att köra migreringar från kommandoraden).
Information om andra migreringsscenarier finns i Migreringar Screencast Series.
Uppdatera specifik migrering
update-database -target MigrationName
Kommandot update-database -target MigrationName kör den riktade migreringen.
Ignorera migreringsändringar i databasen
Add-migration MigrationName -ignoreChanges
ignoreChanges skapar en tom migrering med den aktuella modellen som en ögonblicksbild.
Code First-initialiserare
I distributionsavsnittet såg du att MigrateDatabaseToLatestVersion-initieraren används. Code First innehåller även andra initierare, inklusive CreateDatabaseIfNotExists (standard), DropCreateDatabaseIfModelChanges (som du använde tidigare) och DropCreateDatabaseAlways. Den DropCreateAlways initiatorn kan vara användbar för att konfigurera villkor för enhetstester. Du kan också skriva egna initierare och du kan anropa en initialiserare explicit om du inte vill vänta tills programmet läser från eller skriver till databasen.
Mer information om initierare finns i Understanding Database Initializers in Entity Framework Code First och kapitel 6 i boken Programming Entity Framework: Code First av Julie Lerman och Rowan Miller.
Hämta koden
Ladda ned det färdiga projektet
Ytterligare resurser
Länkar till andra Entity Framework-resurser finns i ASP.NET Data Access – Rekommenderade resurser.
Nästa steg
I den här handledningen:
- Aktiverade "Code First"-migreringar
- Distribuerade appen i Azure (valfritt)
Gå vidare till nästa artikel för att lära dig hur du skapar en mer komplex datamodell för ett ASP.NET MVC-program.