Now that we have our comic books repository,

we can update our controller to use it.

Let's open the comic books controller class.

We could use the solution explore to find the file that we're looking for, but

let's look at another option.

Pressing control comma will open Visual Studios, navigate to dialog.

Now we can start typing the class, method, or property name that we're looking for.

So in this case, I'll type comic.

Visual Studio will search across the project and show the matching items.

I'll use the down arrow key to select the fifth item in the list,

the comic books controller class, and then press Enter to open the file.

The navigate to dialogue is a great way to open files

without having to take your hands off the keyboard.

Let's add a private field for our repository.

I'll start by typing private ComicBookRepository.

Notice that Visual Studio is already letting us know

that something is wrong with our type name.

The red squiggle is a dead giveaway.

If we leave the cursor right at the end of ComicBookRepository,

we can press control period to open the list of suggested quick actions,

instead of having to use the mouse to click on the light bulb icon.

The first item in the list to add the missing using directive

is what we want to do.

So we can just press Enter to perform this action.

Then, we can continue with adding our field.

Let's name the field _comicBookRepository.

Notice that I'm starting the field name with an underscore and

lower case letter, which is a common naming convention for private fields.

Then set the field value to null.

I'll collapse the solution explorer panel to give us more room.

Now, we need an instance of our repository.

Let's add a constructor and instantiate a repository within it.

Remember, that constructors are special methods

that are called when an instance of our class is being instantiated.

We use constructors to initialize instance members,

which is exactly what we're doing with our repository field.

Constructors can be identified by their lack of a return type.

And their name, which matches the class name.

Next, let's update the detail method.

To start, add an ID parameter of type int.

Then, let's replace the inline instantiation of the comic book model

with a call to the repository's get comic book method.

Be sure to pass the ID argument into the method call.

Ready to preview our changes?

Save the controller and run the website.

I don't know about you, but I'm getting tired of seeing our home page 404.

I promise we'll fix that soon.

But for now, go ahead and browse.

The /comic_books/detail and we got an error.

The parameters dictionary contains a no entry for

parameter ID of non noble type system.in32 for

method system web NVC Action Results detail in 32.

In comic book gallery, controllers, comic books controller.

An optional parameter must be a reference type, a null-able type.

Or be declared as an optional parameter.

Let's break this down.

We can see here and here that this

error message refers to our comic books controller detail action method.

Remember how we added an ID parameter to our detail action method.

Well, this error message is telling us

that the request didn't include a value for the ID parameter.

So in Mvc was unable to call our action method.

Let's take another look at how Mvc URL routing

associates URL's with controller action methods.

In a previous video, we discussed that MVC uses simple

pattern matching against the URL path to determine the name of the Controller and

Action should be used in the form of controller/action.

So, the URL path ComicBooks/Detail would map to a controller

named ComicBooks and an action method named Detail.

As it turns out, the actual pattern that MVC uses is controller/action/id.

The third part of that pattern, the ID segment is optional.

This means that MVC can successfully match the pattern against a URL,

even if the path doesn't include the ID segment.

Unfortunately, MVC is getting confused about what to do with our request for

/ComicBooks/Detail.

The problem is that even though the ID parameter should be optional,

our detail action method only accept an integer which isn't nullable.

So, how do we resolve this issue?

It turns out that C# provides us with an easy solution so

that we can make the necessary changes to our detail action method.

If we update our parameter type to be nullable by placing a question mark

after the keyword int, then MVC can successfully pass null for

the ID parameter if an ID value isn't provided as part of the request.

Nullable types will be covered in more detail in future courses.

Now, we need to do a bit of defensive coding

by checking to see if the ID argument is null.

And if so, we turn a not found error to the client.

We can take advantage of the base controllers http not found method

to return an http not found result object.

Lastly, notice that visual studio is unhappy about passing

the ideal argument to the repositories GetComicBook method.

Argument one cannot convert from question mark to int.

When using a nullable type,

you need to use the value property to get at the underlying value.

You could also use an explicit cast.

Use whichever one feels the most readable or natural to you or

whichever one your development team has decided is their preference and

do that consistently throughout the project.

Restart the website, so that we can retest the /comicbooks/detail route.

Don't forget to manually browse to the correct route, great.

I've never been so happy to see a 404 error.

Let's change our URL, so that it includes the optional ID parameter.

Bomber we just encountered an unhandled exception in our detailView

Click OK to dismiss the exception dialog.

Hm, I wonder what we did wrong.

In the next video, we'll walk through how to use the Visual Studio debugger

to troubleshoot this error.

See you then.