Our model allows us to associate artists with comic books, but

our current approach doesn't allow us to specify the role that the artist had.

To do that, we need to move from an implicit bridge table to an explicit one

by adding an entity class to our model for the bridge table.

By defining an explicit bridge entity class, we can include additional

properties beyond the properties that are needed to define the relationship.

Bridge entities or tables that include extra properties or

columns are sometimes said to have payload.

Let's start with adding the role entity class.

Right click on the Model's folder, and select Add, Class.

Name the class Role and click Add.

Add the Public Access modifier in the following properties, and

int property named ID.

Again this property will contain a unique value for each role in our system.

A string property named, Name.

This is the name of the role.

Now let's add the bridge entity class.

I'll name the class ComicBookArtist.

At the public access modifier, and the following properties,

an int property named Id.

This property will contain a unique value for each comic book to artist relationship

in our system An int property named ComicBookId.

This is a foreign key property to the comic book that we're adding artists to.

An int property named ArtistId.

This is a foreign key property to the artist

that we're adding to the comic book.

And an int property named RoleId.

This is a foreign key property to the role that the artist had for this comic book.

Now let's add our navigation properties,

a ComicBook property named ComicBook.

And an ArtistProperty named Artist.

And lastly a Role property named Role.

Now we need to update the comic book and

artist entity classes to use our new bridge entity class.

Starting with the comic book class,

change both references to the artist class to ComicBookArtist.

And do the same for the artist class.

Now let's update our test data.

Just below our artists, let's add

a couple of roles, var role1 = new Role.

Name = "Script".

Var role2 = new Role.

Name = "Pencils".

To help with adding artist to our comic books,

let's add a method to the comic book entity class.

This will be a public method that doesn't return a value.

So a return type of void.

And I'll name the method AddArtist.

It'll accept two parameters, an Artist parameter of type artist

and a Role parameter of type role.

Now let's call the add method on the artist navigation collection property and

pass in an instance of the comic book artist class.

Artists.Add(new ComicBookArtist().

I'll set the Artists and Role properties to their respective parameter values.

Artist = artist.

And Role = role.

Notice that we only had to explicitly set the artist and role navigation properties.

Because we're adding the comic book artist entity to a navigation property

on the comic book entity, EF is able to set the comic book navigation

property value for us implicitly.With that helper method in place,

we can easily replace our comicBook Artists.Add method calls with Add artist,

passing in the appropriate role for each artist.

AddArtist, and then.

Role1.

AddArtist.

And role2.

And again.

AddArtist.

role1.

AddArtist and role2, and

then the last comic book.

AddArtist.

Role1.

And lastly AddArtist.

Role2.

Now, we need to update our comicBooks query to not only include our artist data,

but to include the associated artist and role data for each bridge entity instance.

To do that, we can use the select operator on the artist collection in order to

specify the path to the child property that we want to include on the comic book

artist entity.

So, cb => cb.artist.select.

a => to, a.artist.

And a second call to the include method in order to add the second child property,

the row property.

.Include(cb =>

cb.Artists.Select(a => a.Role.

Notice that we didn't need a third call to the include method in order to populate

the artist's collection.

Every navigation property in the path to the child navigation property that

we're populating will also be populated.

To complete our changes, let's update the collection of artist name strings

to be a collection of artist role names.

We can do that by modifying the select operator to return an interpolated string.

So, .Select (a

=> $"" quotes

{a.Artist.name}-

{a.Role.Name}.

Let's rename the artist names variable by putting the cursor on the variable, and

pressing Ctrl+R, Ctrl+R.

Then change the name to artistRoleNames and press Enter.

Let's also rename artistsDisplayText to artistRolesDisplayText.

Let's test our app And

here's our three comic books along with their respective artists and roles.

Let's review the database.

If you already have the tables folder open be sure to refresh the list of tables.

The artist table remains unchanged, and

the roles table is what we'd expect with ID and name columns.

The comic book artist table contains four columns.

The ID primary key column and three foreign key columns.

ComicBookId, ArtistId and RoleId.

Let's review the tables data.

We can see the ComicBookId 1 is associated with ArtistId 1 and

2, and RoleId 1 and 2, respectively.

The same for ComicBookId 2.

And ComicBookId 3 is associated with ArtistIds 1 and

3, and RoleIds 1 and 2 respectively.

Having the flexibility of an implicit or explicit bridge entity when working with

many-to-many relationships, allows you to start with the implicit approach and

switch to explicitly defining the bridge entity when you need to.

After the break,

we'll see how we can use data annotations to refine the generated database.