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:
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:
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:
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.
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.
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:
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:
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.
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 cannot use accessor modifiers on an interface or an explicit interface member implementation.
- 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.
- If the property or indexer has an override modifier, the accessor modifier must match the accessor of the overridden accessor, if any
- 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?
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.
Comments
Post a Comment