We have our database, but now we need to populate it was some data.

This is commonly referred to as seeding a database.

Seed data can be faked or dummy data to assist us with the development and

testing of our application.

Or it can be data that the application requires in order to operate properly.

Our comic book gallery model requires us to specify the role that an artist has for

a comic book that they are associated with.

To do this, we need the role table to be populated with a set of values

that we can select from.

This kind of data is sometimes referred to as Lookup Data.

In the comic book artist table, we have a role ID column

which provides us with a primary key value for a row in the role table.

With that primary key value in hand, we can query or

look up the associated role name column value.

Let's see how we can use code first migrations to seed our database.

Our configuration class inherits from the code first migrations,

DbMigrationsConfiguration base class,

which provides a seed method that we can override and use to seed our database.

The configuration class that was generated for

us when we enabled migrations has already done this.

The seed method has passed an instance of our context class

which we can use to reference the roles Db set property.

The Db set class contains an outer update method

that can be used to only insert data if it doesn't exist in the database.

If the data is already in the database then an update will be performed.

Developers commonly referred to this operation as an up cert.

This is helpful as the seed method will be called every time after a migration has

been applied to the database using the Update-Database command.

The first parameter that we need to pass to the outer update method

is a lambda expression that specifies the properties, that EF should

use when determining whether an add or update operation should be performed.

Each row should have a unique name.

So, we can use the name property as a natural key, r goes to r.Name.

Then, we can pass one or more row

entity object instances to add or

update, new Role, Name = "Script".

Don't forget to add a using directive for

the ComicBookGalleryModel.Models namespace.

Then, let's add a second role,

new Role, Name = "Pencils".

The context's save changes method is automatically called, so

there's no need to call it directly from the seed method.

Now, let's run our application.

Make sure you have a breakpoint set in the program.cs file

on the query that retrieves the list of comic books.

We're at our breakpoint.

Press F5 and then Enter to continue execution.

Now let's use the SQL Server Object Explorer Window to view the data in

the role table.

Right-click on the role table and select view data.

And the table doesn't contain any data, why is this?

Changes that you make to the seed method won't take effect

until a migration is applied using the update-database command.

We don't have a migration to apply, but that's okay.

We can still run the update-database command, which will determine that there

aren't any pending migrations to apply, and then call the seed method.

Update-database.

We can see here in the console output that the seed method was called.

Right-click on the role table and select view data again.

And now we're seeing our C data.

Let's look at an example of adding some test data

that utilizes our role lookup data.

To save us some time, I already have our C data code here in notepad.

If you're following along, you can find a link to this code in the teacher's notes.

I'll select all, copy to the clipboard, and

then paste into the seed method replacing our previous implementation.

Notice that we've updated our Role C data, to use the roleId property for

the property that EF should use to determine if this should be an add or

update.

And we updated the role entity object instances to have explicit

Id property values, which are set to the constant integer values defined here.

By switching to this approach we now have easy access to the roleId values

when associating an artist with a comic book.

Which we'll see an example of in just a bit.

Here we're adding two artists, Stan Lee and Steve Ditko, and

a little further down we're adding a series, The Amazing Spider-Man.

And finally, here's where we're adding our first comic book.

Notice how we're making use of the available foreign key SeriesId property to

associate the series.

And, here we're calling the comic book entities AddArtist method,

which allows us to pass the artistId to add along with the roleId for their role.

We put our cursor on the AddArtist method and press alt F12 to pick the definition.

We can see that the parameter values flow to the corresponding comic book

artist entity class foreign key properties.

Using the package manager console, let's run the update-database command to update

our database with our new test data.

Update-database and press enter,

and run our app again.

Press F5 to continue execution.

And here's our test data displayed in the console.

Press enter to continue execution.