At the end of the last video we left the path class in an unusable state.

We set the accessibility of the path field to private

which means no other classes can access it, but

other classes still need to get some information about the path.

For example as an invader comes down the path we need to know

where on the map it is moved to so that we can determine if it's in range of a tower.

Let's add a method to the path class the returns a map location.

We'll call it, get location at.

It will take as a parameter the number of steps down the path they are.

We'll call this parameter path step.

The path step variable can work as an index into the path array.

So if you're at step zero in the path,

you'll be at the map location at index zero in the path array.

Remember, we can get the item at any index of the array.

So we can say, return path at path step, but we have a problem now.

And it's something we need to be aware of, every time we use an array or

a collection of any sort.

What happens if we ask for an index that isn't in the array.

Let's check this out in the C Sharp repl.

So go to the repl by typing C Sharp.

And say for example we have an array that's ten items long.

We'll make this an integer array.

This means that the only valid indexes are zero through nine.

If we ask for the item at index ten or

higher, then we'll cause the array class to throw an index out of range exception.

We can catch this exception though.

Let's see what that looks like.

So wrap the return statement in a try catch block.

And the type of exception we want to catch is

System.IndexOutOfRangeException.

Now, we need to decide what to do when this exception happens.

The return type of this method says we need to return a map location, but

what map location should we return in the event of an exception.

There isn't an obvious answer to this question.

What we can do is return something that tells the call of this method that there

is no map location at the step in the path.

This is a good place to return null.

Remember null represents the absence of a value.

And that's precisely what's going on here.

So let's return null here.

Now if the path array doesn't contain a map location for

the paths that passed in we'll catch the index out of range exception and

return null instead There's something you should know about exceptions though.

It's generally considered bad form to cause an exception to be thrown,

when it could easily be avoided.

The main reason for this, is that exceptions can be expensive.

No I don't mean that your bank account will be charged whenever you use them.

What I mean, is in each second of time a computer can only do so much work.

We should try to avoid making the computer work harder than it needs to,

especially if it can be avoided.

Some operations in programming are more expensive than others.

In terms of the amount of work required to complete them.

For example, multiplication and

division are generally more expensive than addition and subtraction.

When an exception is thrown some amount of work is performed to

construct the exception.

The exception is then communicated all the way back up the stack of method calls,

to find an appropriate catch clause that can handle it.

This means, if we think an exception could be thrown,

then we should consider ways to avoid causing the exception.

In this particular, case we can easily avoid this exception.

We can just check the path array contains the index requested

before we attempt to retrieve it from the array.

Instead of using try catch, we can use an if else statement instead.

So I'll say if Pathstep Is less

than half.length, then return path at path step.

Otherwise, or

else, Return null.

See, now we'll only try to attempt to access the array,

if we know that the path step is a valid index.

If for example the length of the path array was ten and

we passed an integer that's ten or greater,

this method would return null because the array only has indexes zero through nine.

You might be wondering, what will happen if path step is a negative integer?

In that case the index out of range exception will still be thrown.

You see that really would be an exceptional case.

It's conceivable the invaders might attempt to move off the end of the path,

but if they attempted to go to a negative path step

that would mean something is terribly wrong.

That would be a good reason to throw an exception.

That exception would be propagated all the way back to the main method of the program

and we've learned that there is a bug in the code.

Again, knowing when and how to use exceptions can take a bit of thought.

We'll learn more strategies for

dealing with exceptions and other error handling techniques in other courses.