In the previous video we learned how to make classes more flexible

with properties.

Properties can also be used to perform better encapsulation.

Look at the _location property we just wrote.

We can remove either the getter or the setter portion of the property.

Think about what would happen if we removed the getter.

This means other classes can set the value of the location, but they can't read it.

Methods and other properties within the Invader class

could still read the location by using the private field directly.

What if we remove the setter instead?

Now other classes can get the _location, but they can't set it.

The _location field isn't read only, so methods and other properties

within the Invader class can still set the _location by setting it directly.

Pretty nifty?

Well, sorta.

Once there's a property that gets and

sets a field it's generally bad practice to access the field directly.

You should just ignore the fact that the field is there and

try to just use the property whenever possible.

Otherwise, having two different ways to change the value of a field can be

confusing.

The property is almost always the one you want to use.

We still want to be able to restrict read and write access to the property though.

Instead of deleting the getter and

setter, we can use the private access modifier instead.

If we put the private keyword here on the get,

Then other classes will only be able to set the _location.

Methods and

other properties in the Invader class will still be able to get it though.

It's fairly rare to have a private getter and a public setter.

On the other hand, having a private setter and a public getter is very common.

Now other classes can get the _location but they can't set it.

Methods and properties in the Invader class can still use the setter though.

Most properties do exactly what this code here does.

They just get and set the value of the field.

In these cases, we can further simplify this code.

We can replace what we have here with get set.

We can also delete the field entirely.

And we can put this on a single line.

In C# this is called an auto-property because it doesn't have

a backing field and it automatically implements a getter and a setter.

This is nice because now instead of having both a property and

a field, we just have the property.

It's still used the same.

And we can still set the access to the getter and setter individually.

We want this one private.

If at some time in the future we need the more verbose property,

then we can always expand this back to its original version.

And we won't lose any of the benefits that a property provides.

Now we have a _location property that allows other classes to get the Invader's

location on the map, and allows the Invader class to update its own _location.

It's been a while since we last compiled.

So, let's do that just to make sure we haven't introduce any

errors into the code.

So, let's open up the console and type in our compile commands,

mcs -out:TreehouseDefense.exe *.cs.

Looks like we do have an error here.

Let's see here.

TreehouseDefense.Invader.Location cannot be used in this context

because the set accessor is inaccessible.

I think I know what's going on here.

We made the setter private.

So now, back in the Game class,

we can't set the location any more from the Game class.

We don't need this code anyway, so we'll just clear it out.

Lets compile again, just make sure that fixes it.

There we go.

No compile errors.

In the next video we'll finish coding the Invader class by writing a method for

moving the invader down the path.