[MUSIC]

Our entity data model currently only contains a single entity, ComicBook.

While the ComicBook entity is an important part of our model,

it's not enough on its own to fully describe our data.

As we've previously discussed, each ComicBook belongs to a series.

Our ComicBook entity class currently contains a SeriesTitle property that, as

the name suggests, contains the title of the series that the comic book belongs to.

If we want to also have a description for

the series, we can add another property to the ComicBook entity, SeriesDescription.

This would work, but

now the ComicBook entity has two properties related to a series.

And if we have more than one ComicBook object instance that belongs to the same

series, the series title and series description property string values

would be repeated within each ComicBook instance.

To avoid this unnecessary duplication of values,

we can add a Series entity to our model.

The Series entity will have ID, Title and Description properties.

Then we can replace the ComicBook entity series title

into series description properties with a reference to the series entity.

The relationship between a ComicBook and a series is known as a One-to-Many or

Many-to-One, depending on your point of view.

From the series point of view, a series contains one or more, or many comics.

And from the ComicBook's point of view, a ComicBook belongs to a single or

one series.

So from the series point of view, their relationship is One-to-Many.

And from the ComicBook's point of view, it's Many-to-One.

In addition to the Many-to-One relationship,

we can model Many-to-Many and One-to-One relationships.

We'll implement a Many-to-Many relationship later in the section.

For more information on how to model a One-to-One, or

One-to-Zero or One relationship, see the teacher's notes.

Let's add a series entity to our model and

define the relationship between the ComicBook and series entities.

Right click on the Models folder and select Add > Class.

Name the class Series and click Add.

Add the public access modifier and

the following properties, an int Property named Id.

This property will contain a unique value for each series in our system.

A string property named Title.

This is the title of the series.

A string property named Description.

This is a description of the series.

Now that we have the series entity class,

let's update the ComicBook entity class to make use of it.

I'll replace the series title property with the series property of type series.

By adding this property to the ComicBook entity class,

we've defined a Many-to-One relationship between the ComicBook and series entities.

Each ComicBook instance can be associated with exactly one series instance,

but there's no restriction with how many ComicBook instances

a series instance can be associated with.

In this relationship, the series entity is the principal and the ComicBook entity

is the dependent, meaning that a ComicBook is dependent upon a series.

EF refers to the series property as a navigation property, as it allows

us to navigate the relationship from the ComicBook entity to the series entity.

Including an Id property is important to do, so EF will know

that we intend the data for the series entity to be stored in its own table.

If we didn't include the id property,

EF would treat the series class as a complex type.

And its title and

description properties would be added to the ComicBook's database table.

Complex types give you a way with an EF to group related sets of properties

within an entity or across entities.

For more information about EF complex types, see the teacher's notes.

We can also define an navigation property on the series entity,

though doing so is optional.

Since a series can be associated with more than one ComicBook,

we need to define the navigation property as a collection,

public ICollection of type ComicBooks get; set for the property type.

I prefer to use the ICollection generic interface instead of a concrete type like

list of T, in order to expose the functionality that I want to provide

without tying myself to a specific collection implementation.

We also need to initialize the collection in a default constructor.

public Series, then ComicBooks

= new List.

This ensures that the ComicBooks property is ready to be used immediately after

instantiating a series entity object.

Now that we've updated our entities,

we need to update the program classes main method to get our app compiling again.

After the break, we'll make those changes and

review how our entity relationship has affected our database.