- Adding a One-to-Many Entity Relationship 5:48
- Using a One-to-Many Relationship 8:35
- Defining a Foreign Key Property 2:59
- Defining and Using a One-to-Many Relationship 2 objectives
- Adding a Many-to-Many Relationship 10:33
- Defining a Many-to-Many Relationship 2 objectives
- Defining a Many-to-Many Relationship with an Explicit Bridge Entity 10:25
- Defining a Many-to-Many Relationship with an Explicit Bridge Entity 3 objectives
- Using Data Annotations to Refine the Generated Database 5:58
- Refining a Model Using Data Annotations 1 objective
- Overriding the Context's OnModelCreating Method 6:33
- Using the Fluent API 1 objective
- Populating Your Database with Seed Data 5:55
- Section Review 10 questions
Preview
Video Player
00:00
00:00
Using a One-to-Many Relationship
8:35Let's update the Program class' `Main` method to use our new comic-book-to-series entity relationship.
Let's update the Program
class' main method
0:00
to use our new comic book to
series entity relationship.
0:03
First, we need to replace this reference
to the SeriesTitle property with our new
0:07
Series property.
0:12
For now, we can just instantiate
a Series entity object in line and
0:17
set its title property, new Series,
0:23
Title = "The Amazing Spider-Man".
0:29
Now, let's update our query.
0:34
When retrieving the comic book's data,
we need to be explicit and
0:37
tell EF that we also want
to include the series data.
0:40
If we don't do this, each comic book
in the Series property would be null.
0:44
To retrieve the series data, we need
to make a call to the include method.
0:49
.Include, and pass in the string for
0:54
the path to the property that we want
to include, in this case, Series.
0:58
This will work, but having to specify
the path as a string is less than ideal,
1:06
it would be all too easy
to mistype the path.
1:12
Luckily, there's another version
of the include method that we can
1:15
use that accepts a lambda expression,
instead of a string.
1:19
To get access to that method, we need
to add an additional using statement.
1:23
Using System.Data.Entity.
1:32
Now we can replace the string parameter
value with a lambda expression that
1:38
specifies which property to include.
1:43
cb goes to cb.Series.
1:45
Notice that I named this parameter cb,
which are the initials for
1:51
the comicBook class,
which is the parameter's type.
1:55
We have one more change to make, we need
to replace the series title property
1:58
reference in our for
each loop with the series title property.
2:03
Let's test our changes.
2:07
Okay, looks good so far.
2:10
Let's try an experiment.
2:15
What happens if we add
a second comic book?
2:16
I'll copy and paste this code, so
that we're adding a second comic book.
2:21
And I changed the IssueNumber to 2.
2:28
To make it easier to see what is
happening with the data in our database,
2:35
let's configure EF to drop and
create the database on every app start.
2:39
We can accomplish this by changing
our database initializer to
2:43
use the DropCreateDatabaseAlways class.
2:47
Let's also add a display text property
to the ComicBook entity class
2:52
that includes both the series title and
the Issue Number.
2:55
That will make it easier to identify
comic books in the console output,
2:59
public string DisplayText { get.
3:04
We can safely add read only or get our
only properties to our entity class,
3:12
as EF will ignore when generating the in
memory representation of the model
3:17
any properties that don't define a setter.
3:23
Let's use an interpolated string for
our return value.
3:26
Interpolated strings are string
literals that begin with a dollar sign.
3:29
Interpolated strings allow us to mix code
expressions along with literal text.
3:38
Let's start with the Series.Title property
value within a set of curly braces.
3:44
Then follow that with a number sign
in the IssueNumber property value,
3:52
also within a set of curly braces.
3:57
To prevent a null reference exception,
4:02
if the series property is null,
we can include a null conditional operator
4:04
just before attempting to
access the title property.
4:09
Using this operator will cause the series
property to be checked if it's null.
4:12
And if it is, return null.
4:16
Otherwise, it will return
the value of the title property.
4:19
Now, let's update the console write line
method call to use our new display text
4:23
property.
4:27
Press F5 to run the app again.
4:36
And here's the display text for
our two comic books.
4:41
Let's review the data in the database.
4:48
Using the SQL Server Object Explorer
window,
4:58
right click on the ComicBooks table and
select View Data.
5:00
Right away, we can see that
the table contains two rows.
5:05
The first row has an issue number column
value of 1 and the second row, 2.
5:09
Here on the right, we can see a column
named Series_Id, which you might recall
5:15
isn't explicitly defined as a property
under comic book entity class.
5:20
Because we defined a one-to-many
relationship between comic books and
5:25
series, EF is automatically
adding this column
5:29
in order to store the Series_Id value for
each comic book.
5:33
In relational database terms, this
column is known as a foreign key column.
5:37
The values contained within the column
represent key values in a foreign table,
5:43
in this case, the series table.
5:49
Unfortunately, there is
a problem with our data.
5:51
Instead of having just
one series record or
5:55
row with the title The Amazing Spider-Man,
we have two.
5:58
Ideally, we should only have a single
record with an Id of 1, and both of our
6:02
comic book records would use that Id
value for their Series_Id column values.
6:07
To resolve this issue,
6:13
we need to make a simple change to
our program class' main method.
6:14
Instead of instantiating two
series entity objects, here and
6:27
here, we need to instantiate
the series entity object once.
6:32
Var series = new Series,
6:39
Title = "The Amazing,
6:44
Spider-Man".
6:52
Then set the comic book series'
properties to the Series variable.
6:55
Just by sharing the same series entity
object between the two comic book entity
7:10
objects, EF will now correctly
understand our intentions,
7:15
that these two comic books
share the same series.
7:18
Run the app again, so
that we can test our changes.
7:22
Hm, the app is just hanging.
7:27
And finally, here's the exception.
7:31
An unhandled exception of type
System.Data.SqlClient.SqlException
7:34
occurred in EntityFramework.dll.
7:39
Additional information: Cannot drop
database ComicBookGallery because
7:42
it is currently in use.
7:47
This exception is occurring because
we left open the comic books
7:50
in series data tabs.
7:55
Let's close those tabs and
run the app again.
7:57
Okay, here's our expected output.
8:04
View the series table data again.
8:11
And now we have a single record for
The Amazing Spider-Man series.
8:20
And both comic books are now using
the same Series_Id column value of 1.
8:28