C# 2.0 - Property Acessor Accessibility

Let's talk about accessor's accessibility introduced in C# 2.0. This is a tiny little feature that can make your life easier in a number of ways. But first, let's define what i am talking about. Normally, a property is composed this way:

	public class TestClass
	{
	private int _myProperty = 0;
	public int MyProperty
	{
	get
	{
	return _myProperty;
	}
	set
	{
	_myProperty = value;
	}
	}
	}

view raw gistfile1.txt hosted with ❤ by GitHub

So, from the example above, we can see that a property has a backfield (called _myProperty) and is composed by a getter and a setter. The getter is called whenever you get the value of that property. The setter is called when you set it's value. If we look carefully, we notice that the getter returns the value of the backfield, and the setter sets it's value, respectively.

If we think about it, a property is nothing more than a wrapper around a private field. This way we can control all the access to that field's value. C#'s properties are nothing more than sintactic sugar for the following structure:

	public class TestClass
	{
	private int _myProperty = 0;
	public int GetMyProperty()
	{
	return _myProperty;
	}
	public void SetMyProperty(int value)
	{
	_myProperty = value;
	}
	}

view raw Old school property hosted with ❤ by GitHub

This is an "old school property". In languages where you don't really have the concept of property, that's the way you control the access to a value from outside sources. Now, we can see that if we do it this way, we can change the accessibility for the get and the set methods independently. Back in C# 1.0, it was not possible to do this with a property sintax. If you defined you property public, you could get and set it's value from anywhere. How would you make a read-only property that you could write to inside your class?  You'd have to use the "old syntax".

Thankfully, C# 2.0 brings us the Accessor Accessibility. This feature let's us vary the getter and setter accessibility independently. So, back to our read-only problem, we would define the property like this:

	public class TestClass
	{
	private int _myProperty = 0;
	public int MyProperty
	{
	get
	{
	return _myProperty;
	}
	private set
	{
	_myProperty = value;
	}
	}
	}

view raw Read-only property hosted with ❤ by GitHub

So, this property is now writable only inside the class declaring it. You could do the same thing and only let the property be read inside the class. Of course there are some rules to this. The following is a copy-paste of the restrictions applied from here, with my brief and shallow explanation on the subject below.

You cannot use accessor modifiers on an interface or an explicit interface member implementation.

I think none of the members of an interface can have an accessor modifier, so this is pretty reasonable. The members in the interface have the same accessibility as the interface itself because when you implement an interface you say that a class definitely has those members, and it would not make sense to hide some of them.

• You can use accessor modifiers only if the property or indexer has both set and get accessors. In this case, the modifier is permitted on one only of the two accessors.

So, you can't specify the getter protected and the setter private. In other words, one of the accessors must be of the same accessibility of the property itself. If you declared the property public, the getter protected and the setter private, what would you be declaring public anyway?

• If the property or indexer has an override modifier, the accessor modifier must match the accessor of the overridden accessor, if any

This means that you can't redefine the accessibility of an accessor that is inherited from a parent class. If you could, it would be possible to override the accessibility by upcasting a variable of a base class, in some cases. So, this will not compile 

	public class Foo
	{
	public object _test;
	public virtual object Test
	{
	get
	{
	return _test;
	}
	protected set
	{
	_test = value;
	}
	}
	}
	public class Bar : Foo
	{
	public override object Test
	{
	get
	{
	return _test;
	}
	public set //Compile error here. You can't override the "protected" accessor.
	{
	_test = value;
	}
	}
	}

view raw Overridden properties hosted with ❤ by GitHub

• The accessibility level on the accessor must be more restrictive than the accessibility level on the property or indexer itself.

This is the most evident one. How can a getter be public when it's property is private? 

	public class Foo
	{
	public object _test;
	protected object Test
	{
	get
	{
	return _test;
	}
	public set //Compile time error. The setter is more accessible than the property itself.
	{
	_test = value;
	}
	}
	}

view raw Less restrictive setter hosted with ❤ by GitHub

Wrap up:
Accessibility on property accessors are a convenient feature that allows you to have more control over how outside code interacts with your's. This is not a feature that you will use frequently but it's nice to know that it will be there when time comes.