So, how can we check if two different map location objects represent the same

location on the map?

If we go to the documentation for

system.object we'll find a method named Equals.

This is the method that is called to determine if two objects

are practically equal.

By default, it just calls the ReferenceEquals method to see if two

objects refer to the same object but we can override this behavior.

Let's do that in the point class and map location will inherit this new behavior.

So we can overwrite equals to return true

if the coordinates of the two points are equal.

So we'll say public override.

Equals and equals takes a parameter of type Object.

We can type system.object or we can just type object.

System.object is the actual name of the object class.

Object with the lowercase o is just an alias just like int

actually refers to System.int32.

We'll call our parameter obj.

The first thing we need to do is to make sure that the object passed in

is in fact of type point.

So we can say if(!(obj is Point))

then, Will return false.

Because if the object passed in, isn't a point,

they can't possibly equal each other, now can they?

Using the is operator also has the nice effect of checking to make sure

that it isn't null either.

Because if obj is null, then this obj is point will also return false.

Now that we know that they are the same type, we need to cast obj to a point.

We'll call it that.

Now we can return true if this .X.

Equals that .X.

And this .Y.

equals.

That .Y.

Now let's go back to the Is.OnPath method and

change this from using the equality operator to using .Equals.

We do this because we don't want to check if the objects are the exact same object.

We just want to check to see if they are same for all intents and purposes.

That is, they refer to the same coordinates on the map.

Unless we really want to check if two variables refer to the exact same object,

we should always use equals instead of the equality operator.

The caveat to this rule is when dealing with numeric types and strings.

In the case of strings and numeric types like int and double.

The equality operator will always return true

if the objects contain the same value.

So when dealing with strings, ints, and doubles.

We can always use the equality operator.

And it will have the same result as if we called equals.

Let's compile and run our program to see if the Is.OnPath method works as expected.

Now.

Yay! We get our message printed out so

it works as expected, but what does this compiler warning here?

This is telling us that if we override object.equals

we should also override object.GetHashCode.

We'll learn about the GetHashCode method in the next video.