Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
Now that we have EF configured, we're ready to update our first controller to read data from the database. But before we do that, let's talk about the lifetime of our database context object instances.
Follow Along
To follow along committing your changes to this course, you'll need to fork the dotnet-comic-book-library-manager repo. Then you can clone, commit, and push your changes to your fork like this:
git clone <your-fork>
cd dotnet-comic-book-library-manager
git checkout tags/v2.3 -b handling-reads
Keyboard Shortcuts
-
CTRL+PERIODorCTRL+DOT- Quick Actions -
CTRL+MINUS- Navigate Back -
CTRL+SHIFT+B- Build Solution
Now that we have EF configured,
0:00
we're ready to update our first controller
to read data from the database.
0:02
But before we do that,
0:06
let's talk about the lifetime of our
database context object instances.
0:07
A context object's lifetime,
for the sake of our discussion,
0:12
is the time from when it's
instantiated to when it's disposed.
0:15
We don't want to instantiate a context
every time that we need to retrieve or
0:19
persist data.
0:23
But we also don't want a context
that lives for too long.
0:25
A long living context can,
0:28
over time, end up consuming more
system memory than we would want.
0:29
And have a negative impact on
the performance of our application.
0:34
So, what are our options?
0:37
Let's review how MVC handles requests.
0:40
The process begins with a user entering
a URL into a browser's address bar,
0:42
which causes an HTTP request
to be sent to the server.
0:47
The server receives the request and
hands it off to the MVC Framework.
0:50
When processing the request,
0:55
MVC uses simple pattern
matching against the URL path.
0:57
To determine the name of the controller
and the action that should be used
1:00
to handle the request in
the form of controller / action.
1:04
So the path ComicBooks / Index
1:09
would map to a controller named ComicBooks
and an action method named Index.
1:12
This process is known as URL routing.
1:17
Once the controller and
action method have been identified,
1:20
MVC then instantiates an instance
of the controller class.
1:23
And calls the appropriate
action method on that instance.
1:27
The action method returns an action
result which in turn is rendered and
1:30
sent back to the user's
browser as an HTTP response.
1:35
[SOUND] This process is repeated for
each request.
1:39
Given that, each request is associated
with its own instance of the appropriate
1:43
controller class.
1:47
Aligning the lifetime of our context
with the controller's lifetime,
1:49
gives us a convenient way of managing
the lifetime of the context.
1:53
Adding a default constructor to the Comic
Book's controller class will allow us to
1:57
instantiate an instance to the context
when the controller is instantiated.
2:01
That takes care of how to manage
the start of the context's lifetime.
2:06
In the next video, we'll see how we can
manage the end of the context's lifetime,
2:10
by disposing our context when
the controller is disposed.
2:14
Let's jump back into
the Comic Book's controller, and
2:18
make our first set of changes.
2:21
We need a private field to hold a
reference to the context object instance.
2:23
Private Context, then press Ctrl period or
2:27
dot to add the using directive for
the ComicBookShared.Data name space.
2:31
We'll start the private field
name with an underscore, so
2:38
that it's easy to identify
throughout our code.
2:41
_context, and
initialize the field to null,
2:43
and a public default constructor
2:49
And initialize the private field to
an instance at the context class.
2:59
Now that we have our context's instance,
let's add our first query.
3:03
Starting with the index action method,
we need a query that returns
3:07
a list of comic books with the related
series, entities eagerly loaded.
3:11
We can grab the query that we need from
the repository class GetComicBooks method.
3:16
Select the code for the query starting
with the DB set property, and
3:21
copy to the clipboard.
3:25
Then in the index action method,
3:27
replace the comic books collection
initialization with the reference
3:30
to the context private field followed
by the contents in the clipboard.
3:33
Moving on to the detail action method, we
need a query that returns a single comic
3:38
book with the related series and
artist entities eagerly loaded.
3:43
Again, we can grab the query that
we need from the repository class,
3:47
this time from the GetComicBook method.
3:51
Select the query and
copy to the clipboard.
3:55
Then, in the detail action method, replace
the comic book object initialization
3:57
with the reference to
the context private field,
4:02
followed by the contents of the clipboard.
4:05
And change the comic book
ID variable to just ID.
4:07
Which is the name of the parameter
being passed to the action method.
4:17
And now the add get action method.
4:21
In this action method, we need to pass the
context into the viewModel's Init method,
4:30
and that's easy to do.
4:35
Almost just as soon as we
finish typing _context,
4:37
Visual Studio will let us know
that we have a compilation error.
4:41
Now, we need to update
the method definition
4:44
to accept an instance
of the context class.
4:47
I'll put my cursor on the method name and
4:50
press F12 to browse to
the method definition.
4:52
Add a parameter of type Context named
context, and now we get a new error.
4:55
ComicBooksAddViewModel.Init context
no suitable method found to override.
5:01
The viewModel class inherits from
the ComicBooksBaseViewModel class, and
5:07
overrides its Init method.
5:12
When overriding a method
in the base class,
5:14
the method signature needs to match
the method that you're overriding.
5:16
To resolve this error, we need to update
the Init method in the base class
5:20
to have the same signature as the Init
method in the descendant class.
5:25
Browse through the base class method,
5:29
by placing the cursor on the call
to that method, and pressing F12.
5:31
And add a parameter of type Context.
5:36
Named context.
5:41
While we're here, let's replace
this new list of series entities
5:43
with a query to get the list
of series from the context.
5:47
context.Series.OrderBy(s =>
5:50
s.Title).ToList(),.
5:56
We can browse back
the ComicBooksAddViewModel class by
6:02
pressing Ctrl minus twice.
6:06
Now we're getting an error with our
call to the base class Init method.
6:08
There is no argument given that
corresponds to the required formal
6:12
parameter context of
ComicBooksBaseViewModel.Init(Context).
6:16
We need to pass the Context
parameter to the Init method call.
6:21
And we can replace the new
list of artists and
6:25
roles entities with queries to
get those respective lists.
6:28
Context.Artists.OrderBy(a =>
6:31
a.Name).ToList(), and for roles.
6:38
Context.Roles.OrderBy(r =>
6:49
r.Name).ToList(),.
6:54
Let's press Ctrl+Shift+B to build our
project and check the state of things.
6:58
We got three compilation errors,
7:06
each with the same description
that we saw just a bit ago.
7:08
Looks like there are some additional
calls to the viewModel.Init
7:12
method that we need to update.
7:15
Double-click the first error in the list
to jump to that line of code, and
7:16
update the method to pass
the _context private field.
7:20
And repeat twice more.
7:24
Now that our project is building,
7:37
let's test our changes to ensure that the
database initializer works as expected.
7:39
I'll open the SQL Server Object Explorer
window and
7:44
delete the ComicBookLibraryManager
database.
7:47
Then, I'll run the app.
7:54
And after a bit of a delay while EF
is busy recreating our database,
8:01
our list of comic books displays.
8:05
Clicking on a Detail button takes us
to that comic book's detail page.
8:10
Click the Back button to return
to the comic books list page,
8:15
then click the Add Comic Book button.
8:18
And here's the Add Comic Book
page with the series.
8:22
Artist, and Role select list, populated
with their respective available values.
8:29
By instantiating an instance
of the context class,
8:38
in the ComicBooksController class
constructor, we've aligned the beginning
8:40
of our context's lifetime with the
beginning of the controller's lifetime.
8:44
But we still need to align
the end of the context's lifetime
8:48
to the end of the controller's lifetime.
8:51
But how do we do that?
8:53
How can we dispose our context object
instance when the controller is disposed?
8:55
You need to sign up for Treehouse in order to download course files.
Sign up