Code First Migrations with the Entity Framework in an ASP.

NET MVC Application

The Contoso University sample web application demonstrates how to create ASP.NET MVC 5
applications using the Entity Framework 6 Code First and Visual Studio 2013

The tutorial contains the following sections:

 Enable Code First Migrations. The Migrations feature enables you to change the data
model and deploy your changes to production by updating the database schema
without having to drop and re-create the database.

Enable Code First Migrations

When you develop a new application, your data model changes frequently, and each time the
model changes, it gets out of sync with the database. You have configured the Entity
Framework to automatically drop and re-create the database each time you change the data
model. When you add, remove, or change entity classes or change your DbContext class, the next
time you run the application it automatically deletes your existing database, creates a new one
that matches the model, and seeds it with test data.

This method of keeping the database in sync with the data model works well until you deploy
the application to production. When the application is running in production it is usually storing
data that you want to keep, and you don't want to lose everything each time you make a
change such as adding a new column. The Code First Migrations feature solves this problem by
enabling Code First to update the database schema instead of dropping and re-creating the
database. In this tutorial, you'll deploy the application, and to prepare for that you'll enable
Migrations.  

1. Disable the initializer that you set up earlier by commenting out or deleting the contexts
element that you added to the application Web.config file.

<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>

2. Also in the application Web.config file, change the name of the database in the
connection string to ContosoUniversity2.

<connectionStrings>
<add name="SchoolContext" connectionString="Data Source=(LocalDb)\v11.0;Initial
Catalog=ContosoUniversity2;Integrated Security=SSPI;"
providerName="System.Data.SqlClient" />
</connectionStrings>

This change sets up the project so that the first migration will create a new database.
This isn't required but you'll see later why it's a good idea.

3. From the Tools menu, click Library Package Manager and then Package Manager
Console.
4. At the PM> prompt enter the following commands:

enable-migrations
add-migration InitialCreate

The enable-migrations command creates a Migrations folder in the ContosoUniversity

project, and it puts in that folder a Configuration.cs file that you can edit to configure
Migrations.

(If you missed the step above that directs you to change the database name, Migrations
will find the existing database and automatically do the add-migration command. That's
 OK, it just means you won't run a test of the migrations code before you deploy the
database. Later when you run the update-database command nothing will happen because
the database will already exist.)

Like the initializer class that you saw earlier, the Configuration class includes a Seed
method.

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

The purpose of the Seed method is to enable you to insert or update test data after
Code First creates or updates the database. The method is called when the database is
created and every time the database schema is updated after a data model change.

Set up the Seed Method

When you are dropping and re-creating the database for every data model change, you use the
initializer class's Seed method to insert test data, because after every model change the
database is dropped and all the test data is lost. With Code First Migrations, test data is
retained after database changes, so including test data in the Seed method is typically not
necessary. In fact, you don't want the Seed method to insert test data if you'll be using
Migrations to deploy the database to production, because the Seed method will run in
production. In that case you want the Seed method to insert into the database only the data
that you need in production. For example, you might want the database to include actual
department names in the Department table when the application becomes available in
production.

For this tutorial, you'll be using Migrations for deployment, but your Seed method will insert test
data anyway in order to make it easier to see how application functionality works without
having to manually insert a lot of data.

1. Replace the contents of the Configuration.cs file with the following code, which will load
test data into the new database. 

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

The Seed method takes the database context object as an input parameter, and the
code in the method uses that object to add new entities to the database. For each entity
type, the code creates a collection of new entities, adds them to the appropriate DbSet
property, and then saves the changes to the database. It isn't necessary to call the
SaveChanges method after each group of entities, as is done here, but doing that helps
you locate the source of a problem if an exception occurs while the code is writing to
the database.

Some of the statements that insert data use the AddOrUpdate method to perform an
"upsert" operation. Because the Seed method runs every time you execute the update-
database command, typically after each migration, you can't just insert data, because the
rows you are trying to add will already be there after the first migration that creates the
database. The "upsert" operation prevents errors that would happen if you try to insert
a row that already exists, but it overrides any changes to data that you may have made
while testing the application. With test data in some tables you might not want that to
happen:  in some cases when you change data while testing you want your changes to
remain after database updates. In that case you want to do a conditional insert
operation: insert a row only if it doesn't already exist. The Seed method uses both
approaches.

The first parameter passed to the AddOrUpdate method specifies the property to use to
check if a row already exists. For the test student data that you are providing, the
LastName property can be used for this purpose since each last name in the list is unique:

context.Students.AddOrUpdate(p => p.LastName, s)

This code assumes that last names are unique. If you manually add a student with a
duplicate last name, you'll get the following exception the next time you perform a
migration.

Sequence contains more than one element

For information about how to handle redundant data such as two students named
"Alexander Carson", see Seeding and Debugging Entity Framework (EF) DBs on Rick
 Anderson's blog.  For more information about the AddOrUpdate method, see Take care
with EF 4.3 AddOrUpdate Method on Julie Lerman's blog.

The code that creates Enrollment entities assumes you have the ID value in the entities in
the students collection, although you didn't set that property in the code that creates the
collection.

new Enrollment {
StudentID = students.Single(s => s.LastName == "Alexander").ID,
CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID,
Grade = Grade.A

},

You can use the ID property here because the ID value is set when you call SaveChanges for
the students collection. EF automatically gets the primary key value when it inserts an
entity into the database, and it updates the ID property of the entity in memory. 

The code that adds each Enrollment entity to the Enrollments entity set doesn't use the
AddOrUpdate method. It checks if an entity already exists and inserts the entity if it
doesn't exist. This approach will preserve changes you make to an enrollment grade by
using the application UI. The code loops through each member of the Enrollment List and
if the enrollment is not found in the database, it adds the enrollment to the database.
The first time you update the database, the database will be empty, so it will add each
enrollment.

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

2. Build the project.

Execute the First Migration

When you executed the add-migration command, Migrations generated the code that would
create the database from scratch. This code is also in the Migrations folder, in the file named
<timestamp>_InitialCreate.cs. The Up method of the InitialCreate class creates the database
tables that correspond to the data model entity sets, and the Down method deletes them. 
namespace ContosoUniversity.Migrations
{
using System;
using System.Data.Entity.Migrations;

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),
Secret = c.String(),
})
.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");
 }
}
}

Migrations calls the Up method to implement the data model changes for a migration. When
you enter a command to roll back the update, Migrations calls the Down method.

This is the initial migration that was created when you entered the add-migration InitialCreate
command. The parameter (InitialCreate in the example) is used for the file name and can be
whatever you want; you typically choose a word or phrase that summarizes what is being done
in the migration. For example, you might name a later migration "AddDepartmentTable".

If you created the initial migration when the database already exists, the database creation
code is generated but it doesn't have to run because the database already matches the data
model. When you deploy the app to another environment where the database doesn't exist
yet, this code will run to create your database, so it's a good idea to test it first. That's why you
changed the name of the database in the connection string earlier -- so that migrations can
create a new one from scratch.

1. In the Package Manager Console window, enter the following command:

update-database

The update-database command runs the Up method to create the database and then it
runs the Seed method to populate the database. The same process will run automatically
in production after you deploy the application, as you'll see in the following section.

2. Use Server Explorer to inspect the database as you did in the first tutorial, and run the
application to verify that everything still works the same as before.