Let's go back to main to test out the GetLocationAt method.

Let's create a new path object here,

say Path path = new Path.

We can actually have the array created and

pass it into the constructor in a single statement.

Like this, so we'll copy this.

Move it into here.

Then we can say new array and

then, indent this like that.

Now the array is being created and

immediately being passed into the constructor of the path class.

See how that works?

Now, we can use our new GetLocationAt method

to find the location of a step on the path.

So, we'll call GetLocationAt and assign it to a MapLocation variable called location.

Now let's print out the x and y values of this step that we know is on the path.

So we'll say,

Console.WriteLine(location.X + ","

+ location.Y).

Let's compile and run this and see what we get.

All right, we get the first location in the path array.

Now, let's see what happens when we pass in a step that isn't on the path.

The path only has indexes 0 through 7.

So if we put 8 here, this should be one step past the end of the path.

Let's compile and run again.

We see unhandled exception printed to the console.

That doesn't tell us much.

Let's get some more information about what happened.

We're catching every exception that could possibly be thrown.

We catch it in one of these three catch clauses.

We saw unhandled exception printed to the console.

So it looks like the one that caught the exception is this final

catch all we have here.

Let's have this print out some more detailed information

about the exception it caught.

First, we'll need to add an exception variable here.

Now we can just append this variable to the end of our message.

Remember, the string concatenation operator here attempts to convert anything

that isn't a string to a string before the concatenation.

It just so happens that the string that exceptions are converted into

have a lot of good information in them.

We'll learn exactly how this works in a later course.

Now let's run our code again to see what we get.

This is what we get when the exception is converted to a string.

As you can see, the name of the exception thrown is System.NullReferenceException.

This exception happens when we try to use null like a normal object.

Look up here.

GetLocationAt is supposed to return null if we ask for

a step that isn't on the path.

That means that the location variable here is now null.

Now when we tried to get the X field from the location object,

it can't do what we asked, because it isn't the location.

This is null, and null is the absence of a location.

This causes the null reference exception to be thrown.

This is a very common exception to deal with.

So, what should we do to make this code work?

One thing we could do is check to see if location is null,

before we try to print out x and y like this.

So we can say, if(location

!= null then print this to the console.

So if location is null, nothing will get printed and

we won't be trying to access location.X or location.Y.

This is a very common pattern when dealing with null.

It's often called a null check.

There are some interesting links in the teacher's notes if you want to dive deeper

into how to handle null values.

We'll learn other ways to deal with null in future courses,

including how to avoid null entirely.

A good practice when working with objects is to always consider what would happen

if an object is null, and take the proper precautions.

We've also just learned about arrays.

Arrays are pretty handy, are they not?

I mentioned before that arrays are just one of the many ways

to store a collection of objects.

We'll learn about those in other courses.

So in the future,

we might want to change our path class to use one of those instead of an array.

We were smart and used encapsulation to hide the fact that we're using an array.

We could change it from an array to any other type of collection.

And it won't break any code that's using the public parts of the path class,

because those parts won't change.

Next we'll learn about properties.

They're an important part of C# that helps with encapsulation.

I can't wait.