In the last video we updated the comic book's controller to use our repository.

Unfortunately, we encountered an error when viewing our comic book detail view.

Let's reproduce the error.

Start the website and once the /ComicBooks/detail route

has finished loading, update the URL to /ComicBooks/Detail/1.

Okay, here's our exception.

An exception of type system.NullReferenceException occurred and

under the additional information section,

object reference not set to an instance of an object.

Click OK to dismiss the exception dialog.

Visual Studio is highlighting in yellow the line of

code that the error occurred on.

We can use the Autos window to start debugging this error.

The Autos window displays variables used in the current statement and

the previous statement.

We can see here on this line that the view's model property is null.

In the offending line of code, we're trying to access the display text property

on a null object reference which is why we're getting this error.

So why is the model property null?

Let's keep the website running.

Press F5 to let execution continue,

then switched to the current books controller class.

We're going to use Visual Studio's Debugger, to further analyze this error.

The Debugger is a powerful tool that allows us to observe the runtime behavior

of our website and determine the location of errors.

Breakpoints are used to suspend the execution of our code.

We can set a breakpoint by clicking here in the lefthand margin.

Breakpoints appear as red circles.

Also, notice that the associated line of code is highlighted in red.

By setting a breakpoint on the first line of code in our detail action method,

Visual Studio will suspend execution of our website

when our action method is called.

We can then step through our code.

Now that we have our breakpoint set, refresh the page in the browser.

Switching back to Visual Studio,

we can see that execution has been suspended at our breakpoint.

The yellow arrow indicates which statement is about to be executed.

Just like with our breakpoint,

Visual Studio highlights the associated statement in yellow.

In the Autos window we can see that the ID argument is 1,

which matches the value that we passed via the URL path.

We could also hover the mouse pointer over a parameter or

any variable to see its value.

With execution of our website suspended,

we can now execute one line of code at a time by stepping through our code.

These three toolbar buttons can be used to step through our code,

step into, step over, and step out.

Step into and step over both tell the Debugger to execute the next line of code,

but they handle method calls differently.

Step into will execute the method call and

suspend execution on the first line of code in the method.

Step over will execute the entire method and

suspend execution on the next line of code after the method call.

When you step into a method call,

step out will finish executing that method and return you to the calling method.

If you're like me and want to keep your hands on the keyboard,

you can use the F11 key for the step into command, F10 for

step over, and shift + F11 for step out.

Don't worry if the differences between the step into, step over, and

step out commands don't immediately make sense.

As we step through our code, I'll make it clear which command I'm using and why.

You'll get the hang of it in no time.

I'm going to start by pressing F10 to move execution to the next statement.

Since we have an ID value,

we'd expect this if statement to evaluate to false and not execute.

It's worth noting that since the if statement expression doesn't include any

method calls, the step into and step out commands will both do the same thing.

Now we're ready to call the repository's GetComicBook method.

I'm going to press F10 to step over the call to the GetComicBook method.

Notice here in the Autos window at the comicBook variable is null.

If we were to continue execution we'd end up passing null to our view,

which is causing our error.

Looks like the GetComicBook method is not behaving as we expected it to.

We need to rewind execution in order to step into that method call.

Luckily, the Debugger allows us to do just that.

We can drag the yellow arrow back up to that line of code.

Now we can press F11 to step into the GetComicBook method call.

Now we're debugging the GetComicBook method.

I'm going to press F10 twice to step down to the for each loop.

Okay, so here's where we loop through our available comic books

in order to find the one whose ID matches our ID argument value.

I'll press F10 five times to step down to the if statement inside of our loop.

One, two, three, four, five.

In the Autos window, we can see that our ID argument value is 1, which is correct.

But our comicBook.Id value is currently 0.

That seems odd.

We can expand the comicBook variable to see all of the comicBook model properties.

That's certainly the first comic book in our list,

The Amazing Spider-Man #700, but the ID property is definitely 0.

Let's continue to step through our loop by pressing F10 five more times.

Now we can see in the Autos window that the comicBook variable has been updated

with the second comic book in our list, The Amazing Spider-Man #657.

Its ID property value is also 0.

Again, let's continue to the next iteration of our loop by pressing F10.

Our third comic book, Bone number #50 has the same problem.

Its ID property value is also 0.

If we press F10 until we exit our loop,

we can see that our comic book to return variable is null.

Press F10 three more times and we'll be our controller's

detail methods return statement, which is about to pass null to our view.

All three of our comic books had ID values of 0.

That's definitely a problem.

Go ahead and stop the website.

Let's look at our comic book data in the ComicBookRepository class.

Do you see the problem?

See if you can resolve the issue on your own.

When you're ready, proceed to the next video and

we'll walk through the solution together.