Let's delete all the breakpoints we have so far and

I'll show you one of my favorite ways to start the debugger.

We can right-click on the line of code that we want to break at and

click Run To Cursor.

The debugger starts and runs to that point.

Another neat but

dangerous trick is to set the next line of code that should be executed.

Let's say we're here and

we want to just skip to the add song method without calling menu dot prompt.

That way we don't have to type in the console.

I can just drag the yellow arrow here down to this line.

This sets the next line of code to be executed.

Unlike using the Step Over button, the code between where we were and

where we are now isn't executed.

So the Menu.Prompt method was never called.

As you can imagine, this can cause some problems.

Let's step into the add song method.

Again, let's say we don't want to have to run these prompt methods.

Another way to set the next line of code to execute is to right click on the line

and click Set Next Statement.

Now, we just jump to past these lines here without executing them.

Hovering over song name and artist shows us that they're both null.

That could be bad.

Never fear, we can just set their values here instead.

Now, if I click the step over button, this song will be added to our list of songs.

Let's jump past the end of the loop and skip this prompt.

Now, I can use the Step Out button to bring us back to the main method.

We can also go backward.

Let's say we want to go back to see this prompt.

We can just drag the yellow arrow up here.

And then, press the Continue button.

We usually want to see how the code runs without us interfering too much.

So using these features can be problematic.

But as you can see, it can also be quite helpful.

You can also use this trick if you're stepping through the code and

you identify what might be causing the bug.

You can experiment with different and variable values and

ways to the code by using these features of the debugger.

In debuggers without these features, you have to stop change the code and

then rerun it.

Some it can take a long time to get back to where the problem is

only to find out that the bug isn't fixed.

Visual Studio has another great debugging feature that allows us to actually make

substantial changes in the code without actually having to stop the debugger and

start all over again.

This feature is called Edit and Continue.

Edit and Continue is a feature that can be enabled or

disabled in Visual Studio's options.

To make sure that it's enabled, go to the Tools menu and click Options.

On the left side of the dialog, scroll down to Debugging, then scroll down to

the Edit and Continue section down here Here we see that it's checked.

We can't change the value of this option while Visual Studio is in debugging mode.

Let's set a breakpoint back here on line 21.

I'll enter an option so that we get to the switch statement.

Let's say that at this point while debugging,

we notice that we accidentally had these two methods swapped.

We can fix this right now without stopping the debugger.

We can move the AddSong method down here.

And we can move the DisplaySongList method up here.

Now, if we step through this code using step into, you'll notice that we now enter

the DisplaySongList method instead of the AddSong method.

This is really handy when we're debugging and

notice things that we can fix right away.