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.

A context object's lifetime, for the sake of our discussion,

is the time from when it's instantiated to when it's disposed.

We don't want to instantiate a context every time that we need to retrieve or

persist data.

But we also don't want a context that lives for too long.

A long living context can,

over time, end up consuming more system memory than we would want.

And have a negative impact on the performance of our application.

So, what are our options?

Let's review how MVC handles requests.

The process begins with a user entering a URL into a browser's address bar,

which causes an HTTP request to be sent to the server.

The server receives the request and hands it off to the MVC Framework.

When processing the request,

MVC uses simple pattern matching against the URL path.

To determine the name of the controller and the action that should be used

to handle the request in the form of controller / action.

So the path ComicBooks / Index

would map to a controller named ComicBooks and an action method named Index.

This process is known as URL routing.

Once the controller and action method have been identified,

MVC then instantiates an instance of the controller class.

And calls the appropriate action method on that instance.

The action method returns an action result which in turn is rendered and

sent back to the user's browser as an HTTP response.

[SOUND] This process is repeated for each request.

Given that, each request is associated with its own instance of the appropriate

controller class.

Aligning the lifetime of our context with the controller's lifetime,

gives us a convenient way of managing the lifetime of the context.

Adding a default constructor to the Comic Book's controller class will allow us to

instantiate an instance to the context when the controller is instantiated.

That takes care of how to manage the start of the context's lifetime.

In the next video, we'll see how we can manage the end of the context's lifetime,

by disposing our context when the controller is disposed.

Let's jump back into the Comic Book's controller, and

make our first set of changes.

We need a private field to hold a reference to the context object instance.

Private Context, then press Ctrl period or

dot to add the using directive for the ComicBookShared.Data name space.

We'll start the private field name with an underscore, so

that it's easy to identify throughout our code.

_context, and initialize the field to null,

and a public default constructor

And initialize the private field to an instance at the context class.

Now that we have our context's instance, let's add our first query.

Starting with the index action method, we need a query that returns

a list of comic books with the related series, entities eagerly loaded.

We can grab the query that we need from the repository class GetComicBooks method.

Select the code for the query starting with the DB set property, and

copy to the clipboard.

Then in the index action method,

replace the comic books collection initialization with the reference

to the context private field followed by the contents in the clipboard.

Moving on to the detail action method, we need a query that returns a single comic

book with the related series and artist entities eagerly loaded.

Again, we can grab the query that we need from the repository class,

this time from the GetComicBook method.

Select the query and copy to the clipboard.

Then, in the detail action method, replace the comic book object initialization

with the reference to the context private field,

followed by the contents of the clipboard.

And change the comic book ID variable to just ID.

Which is the name of the parameter being passed to the action method.

And now the add get action method.

In this action method, we need to pass the context into the viewModel's Init method,

and that's easy to do.

Almost just as soon as we finish typing _context,

Visual Studio will let us know that we have a compilation error.

Now, we need to update the method definition

to accept an instance of the context class.

I'll put my cursor on the method name and

press F12 to browse to the method definition.

Add a parameter of type Context named context, and now we get a new error.

ComicBooksAddViewModel.Init context no suitable method found to override.

The viewModel class inherits from the ComicBooksBaseViewModel class, and

overrides its Init method.

When overriding a method in the base class,

the method signature needs to match the method that you're overriding.

To resolve this error, we need to update the Init method in the base class

to have the same signature as the Init method in the descendant class.

Browse through the base class method,

by placing the cursor on the call to that method, and pressing F12.

And add a parameter of type Context.

Named context.

While we're here, let's replace this new list of series entities

with a query to get the list of series from the context.

context.Series.OrderBy(s =>

s.Title).ToList(),.

We can browse back the ComicBooksAddViewModel class by

pressing Ctrl minus twice.

Now we're getting an error with our call to the base class Init method.

There is no argument given that corresponds to the required formal

parameter context of ComicBooksBaseViewModel.Init(Context).

We need to pass the Context parameter to the Init method call.

And we can replace the new list of artists and

roles entities with queries to get those respective lists.

Context.Artists.OrderBy(a =>

a.Name).ToList(), and for roles.

Context.Roles.OrderBy(r =>

r.Name).ToList(),.

Let's press Ctrl+Shift+B to build our project and check the state of things.

We got three compilation errors,

each with the same description that we saw just a bit ago.

Looks like there are some additional calls to the viewModel.Init

method that we need to update.

Double-click the first error in the list to jump to that line of code, and

update the method to pass the _context private field.

And repeat twice more.

Now that our project is building,

let's test our changes to ensure that the database initializer works as expected.

I'll open the SQL Server Object Explorer window and

delete the ComicBookLibraryManager database.

Then, I'll run the app.

And after a bit of a delay while EF is busy recreating our database,

our list of comic books displays.

Clicking on a Detail button takes us to that comic book's detail page.

Click the Back button to return to the comic books list page,

then click the Add Comic Book button.

And here's the Add Comic Book page with the series.

Artist, and Role select list, populated with their respective available values.

By instantiating an instance of the context class,

in the ComicBooksController class constructor, we've aligned the beginning

of our context's lifetime with the beginning of the controller's lifetime.

But we still need to align the end of the context's lifetime

to the end of the controller's lifetime.

But how do we do that?

How can we dispose our context object instance when the controller is disposed?