Csharp_Chap10

Properties and Indexers - C# The Basics - Beta2 Page 1 of 13

10
Properties and Indexers
Properties
Properties are a natural extension to fields. Very few programming languages support the notion of a property.
Unlike a variable, a property is not stored in a memory location. It is made up of functions. Thus even though
a property and a field share the same syntax a property has the advantage that code gets called. When we
initialize a variable, no code in our class gets called. We are not able to execute any code for a variable access
or initialization at all. In the case of a property, we can execute tons of code. This is one singular reason for
the popularity of a product like Visual Basic - the use of properties. One simple example is setting the value of
a variable. If it is through a variable, we have no control over the value used. If the same access is through a
property, the programmer has no inkling of whether it is a property or a variable, we can build range checks to
make sure that the variable does not cross certain bounds.

Lets start by creating a simple property. A property is a member of a class. It behaves like a variable for the
user.

a.cs
public class zzz
{
public static void Main()
{
}
}
public class aa
{
public int ff {
}
}

Compiler Error
a.cs(9,12): error CS0548: ‘aa.ff’ : property or indexer must have at least one accessor

We have tried to create a property called ff which is of type int. We get an error because a property is used
either on the left or the right of an equal to sign. If we had created a variable ff, we would like to write a
statement as gg = ff + 9. Here ff should return some value which is of the data type int.

a.cs
public class zzz
{
{
aa a = new aa();
int gg = a.ff + 9;
System.Console.WriteLine(gg);
}
}

file://E:!KrarCSharpcsharpthebasicschap10.htm 9/29/2007


public class aa
{
public int ff {
get
{
System.Console.WriteLine(“in get”);

return 12;
}
}
}

Output
in get
21

A property should have at least one accessor, in our case, a get as we want to read the value of the property.
Thus a.ff calls the get accessor which returns an int, in this case 12. If we did not have access to the code of
the class aa, we would have assumed ff to have been a variable.

a.cs
public class zzz
{
{
aa a = new aa();
a.ff = 19;
System.Console.WriteLine(a.ff);
}
}
public class aa
{
public int ff {
get
{
return 12;
}
set
{
System.Console.WriteLine(value);
}
}
}

Output
19
in get
12

A variable can also be used on the left-hand side of the equalto sign. In this case we are writing or changing
the value of the variable. We are passing it some value. If it is a property, ff in our case, a.ff = 19 will call the
accessor set. The set accessor has a free variable available in it called value. It gets created automatically, we
do not create this variable. In our case, this has the value 19, which we are displaying in WriteLine. Then to
display the value of the property ff, the get needs to be called again. The get always returns the same answer
as the set does not store the value of the variable anywhere. To resolve this issue, we do the following.

a.cs
public class zzz
{



{
aa a = new aa();
a.ff = 19;
}
}
public class aa
{
int f1;
public int ff {
get
{
return f1;
}
set
{
System.Console.WriteLine(“in set “ + value);
f1 = value;
}
}
}

Output
in set 19
in get
19

To implement a property in real life, we create a public variable which will hold the value of the property.
This variable f1 will have the same data type as the property i.e. an int in our case. In the get, we return f1 and
in the set we initialize f1 to value. This is the simplest case possible.

The reason we use a property and not a variable is because if we change the value of a variable/field, then
code in our class is not aware of the change. Also we have no control over what values the variable will
contain. The user can change them to whatever he/she likes and we cannot implement range checks on the
variable. Also the user may want to associate some action with the changes in the value of the variable. Using
a property, reading or writing to the variable also can be monitored.

a.cs
public class zzz
{
{
aa a = new aa();
a.ff = 19;
}
}
public class aa
{
int f1;
public int ff {
get
{
return f1;
}
}
}

Compiler Error



a.cs(6,1): error CS0200: Property or indexer ‘aa.ff’ cannot be assigned to — it is read only

You are allowed to declare a property readonly by omitting the set accessor. No one is now allowed to change
the value of the property. It now behaves as a const or readonly field.

a.cs
public class zzz
{
{
aa a = new aa();
a.ff = 19;
}
}
public class aa
{
int f1;
public int ff {
set
{
System.Console.WriteLine(“in set “ + value);
f1 = value;
}
}
}

Output
in set 19

Theoretically, you can have a property which is write only i.e. only with a set accessor. With set, you can
change the value of ff but it is of limited use because you can never access the value of ff. A property differs
from a field by ending with {}.

a.cs
public class zzz
{
{
}
}
public class aa
{
public int ff {
set
{
}
}
public int ff {
get
{
}
}
}

Compiler Error
a.cs(12,12): error CS0102: The class ‘aa’ already contains a definition for ‘ff’

You cannot create a property in 2 separate bits and pieces. It has to be in one whole. This is part of the syntax.
The above creates two properties, both called ff, the first one being write only, the second, read only. The
compiler tells you that you cannot create two properties by the same name.



a.cs
public class zzz
{
{
}
}
public class aa
{
private int ff;
public int ff {
get {
}
set {
}
}
}

Compiler Error
a.cs(10,12): error CS0102: The class ‘aa’ already contains a definition for ‘ff’

You obviously cannot have a property and variable with the same name. The compiler would not know
whether to invoke the property or the field. They both are stored in the same namespace.

a.cs
class zzz
{
{
yyy.i = 20;
System.Console.WriteLine(yyy.i);
}
}
class yyy
{
public static int i
{
get {
System.Console.WriteLine(“get”);
return 10;
}
set {
System.Console.WriteLine(“set “ + value);
}
}
}

Output
set 20
get
10

The rules of static apply to properties also. Like variable we access them using the class and not the instance.
Everything that we have learned about static in the past applies to properties also.

a.cs
class zzz
{
{



yyy a = new yyy();
a.i = 100;
System.Console.WriteLine(a.i);
}
}
abstract class xxx
{
public abstract int i
{
get ;
set ;
}
}
class yyy : xxx
{
public override int i {
get
{
System.Console.WriteLine(“get”);
return 10;
}
set
{
System.Console.WriteLine(“set “ + value);
}
}
}

Output
set 100
get
10

The abstract property i in class xxx carries no code at all. The get and set accessors are simply represented by
a semicolon. In the derived class, we must implement both the get and the set accessors. If we do not use the
override keyword, it is new. We hope you have finally understood new and override.

a.cs
class zzz
{
{
}
}
abstract class xxx
{
public abstract int i
{
get ;
}
}
class yyy : xxx
{
public override int i {
get
{
}
set
{
}
}



}

Compiler Error
a.cs(20,1): error CS0546: ‘yyy.i.set’: cannot override because ‘xxx.i’ does not have an overridable set
accessor

In class xxx, the abstract property has only a get accessor. In the derived class we are implementing both the
get and the set. The original never ever had a set. This is unacceptable to the compiler. Thus we have no
choice but to implement only the accessors that are present in the original. A get accessor can be viewed as a
method which returns a value but accepts no parameters.

a.cs
class yyy
{
public void i {
}
}

Compiler Error
a.cs(3,13): error CS0547: ‘i’ : property or indexer cannot have void type

It makes no sense for an accessor to have a void type as a variable cannot be of type void. Void literally
means ‘I do not know the type’ or no type at all.

a.cs
class yyy
{
public int i {
set
{
return 10;
}
}
}

Compiler Error
a.cs(6,2): error CS0127: Since ‘yyy.i.set’ returns void, a return keyword must not be followed by an
object expression

A set accessor can be viewed as function which returns void but accepts one parameter which stands for the
value of the property. Thus a set cannot return a value. If we remove the 10, we will not get an error.

a.cs
class zzz
{
{
}
public int i {
set
{
value = 20;
}
}
}

The reserved variable value in the set can be changed at will. Though, understanding why anyone would want
to do such dumb stuff is beyond us.

a.cs
class zzz



{
{
}
public int i {
set
{
int value;
}
}
}

Compiler Error
a.cs(9,6): error CS0136: A local variable named ‘value’ cannot be declared in this scope because it
would give a different meaning to ‘value’, which is already used in a ‘parent or current’ scope to
denote something else

We cannot however create a variable value as it will clash with the variable value which is already present by
default in the set.

a.cs
class zzz
{
{
yyy a = new yyy();
a.i = 10;
xxx b = new xxx();
((yyy)b).i = 20;
b.i = 10;
}
}
class yyy
{
public int i {
set {
}
}
}
class xxx : yyy
{
public int i {
get {
return 10;
}
}}
Compiler Error
a.cs(9,1): error CS0200: Property or indexer ‘xxx.i’ cannot be assigned to — it is read only

In the class yyy, the property i has only the set accessor. In the class xxx which derives from yyy, we have
implemented only the get accessor. The property i in class xxx hides the i of yyy. They do not add up. What
we are trying to say is that both these properties are independent of each other. What we had thought C#
would have done is, taken the set from one class and added it to the second. However, that does not make
sense. It treats them independently. If we want to use the property of the class yyy, then we need to explicitly
cast it as we have done for b. Thus the property i of class yyy gets hidden but can be accessed.

A property is not necessarily slower than a variable. A variable access normally initializes some memory,
whereas a property executes a method. This is not necessarily slower as at times, C# will rewrite your
property methods to memory accesses. This is called inlining of code. Except for minor differences, all that
we mentioned about virtual, abstract and new apply also to a property. The difference is, if the original
property has a get and a set, the derived class will only implement a set or a get.



Indexers
An indexer lets us access members of a class as if it were an array.

a.cs
public class zzz
{
{
yyy a = new yyy();
a[1] = 10;
}
}
public class yyy {
}
Compiler Error
a.cs(6,1): error CS0021: Cannot apply indexing with [] to an expression of type ‘yyy’

We have created an object a that looks like yyy. The object a, in no sense of the word is an array. We are
assuming that a is an array and we’ve used the array syntax a[], hence it gives us an error.

a.cs
public class zzz
{
{
yyy a = new yyy();
a[1] = 10;
}
}
public class yyy
{
public int this[int i]
{
set {
System.Console.WriteLine(“in get “ + value + “ “ + i);
}
}
}

Output
in get 10 1

We’ve added a few lines to have the array notation work with an object that looks like yyy. To implement
indexers, we need to create a special property called this. This is a reserved word. As of now, we have a
parameter i (an int) in the square brackets. When we did properties earlier,we learnt that a set gets called
whenever we want to initialize or set a variable. Within the set accessor we have a special variable called
value which stores the value passed to the set, in this case 10. The variable i will hold the value 1 as the array
parameter is 1.
This is how we implement arrays when there are none.

a.cs
public class zzz
{
{
yyy a = new yyy();
System.Console.WriteLine(a[1]);
}



}
public class yyy
{
public int this[int i]
{
set
{
}
get
{
System.Console.WriteLine(“in set “ + i);
return 23;
}
}
}

Output
in set 1
23

The rules binding properties are applicabe to indexers too. When you want to read the value of a[1], the get
gets called. The major difference between properties and indexers is that when you implement the code for
indexers you have to understand that the get and set get called with a variable which is the array parameter
value. The code will have to understand array simulation.

a.cs
public class zzz
{
{
yyy a = new yyy();
a[“hi”] = 30;
System.Console.WriteLine(a[“hi”]);
}
}
public class yyy
{
public int z;
public int this[string i]
{
set
{
z = value;
}
get
{
System.Console.WriteLine(“in set “ + i);
return z;
}
}
}

Output
In get 30 hi
In set hi
30

The this property has a return value, in this case, an int. Also the [] brackets can contain data types other than



an int. In this case a string. The string i has a value hi as that is what we passed in the array brackets. You can
have two this’s in your class. You have to decide what data type to use in the array brackets. An indexer is
very useful when you have a database object and you want to access the data in the fields using a notation
[“fieldname”]
Indexers follow the same concepts of virtual, new, override etc.

a.cs
class zzz
{
{
yyy a = new yyy();
a[1] = 10;
a[“one”] = 10;
a[“hi”,2] = 30;
}
}
class yyy
{
public int this [ int i]
{
set
{
System.Console.WriteLine(“one int “+ i + “ “ + value);
}
}
public int this [ string i]
{
set
{
System.Console.WriteLine(“one string “+ i + “ “ + value);
}
}
public int this [ string i, int j]
{
set
{
System.Console.WriteLine(“one string and int “+ i + “ “ + j + “ “ + value);
}
}
}

Output
one int 1 10
one string one 10
one string and int hi 2 30

The signature of an indexer is the number and types of formal parameters. The return value and the names of
the parameters do not contribute to the indexers signature. Thus we have overloaded the indexers to take an
int, string or a string int combination. Each time a different function gets called. The point to understand is
that all the indexers have to return the same data type, in our case int. The same rules that apply to function
overloading apply here also. Functions cannot differ only by return values. We are sure that for indexers in the
next version, C# should/must make an exception.

A property is identified by its name, an indexer by its signature. There is no concept of property overloading
in C#.

a.cs
class zzz



{
{
}
}
class yyy
{
public static int this [ int i]
{
set
{
}
}
}

Compiler Error
a.cs(9,19): error CS0106: The modifier ‘static’ is not valid for this item

A property can be both an instance member which is the default or static. An indexer unfortunately can only
be an instance member and not static. God alone knows why this discrimination against indexers. Once again
no rational reason for the above error. Obviously you cannot create a variable with the same name as that of
the parameter passed in the indexer.

a.cs
class zzz
{
{
xxx a = new xxx();
a[2] = 20;
System.Console.WriteLine(a[2]);
}
}
class yyy
{
public virtual int this [ int i]
{
get
{
System.Console.WriteLine(“yyy get “ + i);
return 20;
}
set
{
System.Console.WriteLine(“yyy set “ + value + “ “ + i);
}
}
}
class xxx : yyy
{
public override int this [ int i]
{
get
{
int p = base[i];
System.Console.WriteLine(“xxx get “ + i + “ “ + p);
return 200;
}
set
{



System.Console.WriteLine(“xxx set “ + value + “ “ + i);
base[i] = value;
}
}
}

Output
xxx set 20 2
yyy set 20 2
yyy get 2
xxx get 2 20
200

The above example deals with calling the indexers of the base class. At times when we are overriding code in
the derived class, we would like to call the original indexer in the base class first. The first rule that we have
to adhere to is that the indexer in the base class must be declared virtual. In the derived class, we are now
declaring it with the modifier override. Same rules as above. In the set accessor, we have to call the original as
base[i], where i is the index to the indexer. Also we need to pass it the value to initialize itself. This is stored
in the variable value. This a[2] in Main gets replaced by base[2] in the set. In get the reverse takes place. Here
we need to place base[i] on the right of the equalto sign, the original get will return a value, in this case 20,
which we are storing in a variable p. What we do with p as well as the value from the get is our business.

a.cs
class yyy
{
public int this [ byte i , string j]
{
get
{
return 10;
}
set
{
}
}
int get_Item(byte i,string j)
{
return 20
}
void set_Item(byte i,string j , int value)
{
}
}

Compiler Error
a.cs(5,1): error CS0111: Class ‘yyy’ already defines a member called ‘get_Item’ with the same
parameter types
a.cs(9,1): error CS0111: Class ‘yyy’ already defines a member called ‘set_Item’ with the same
parameter types

Like a property, an indexer also gets a name change. If people can get their bodies pierced then why
cannot a indexer get converted to a series of functions starting with get? For a get, the parameters are
the same as we pass to an indexer. It has a return value and the type of the indexer. Also the set has
one more added parameter and that is the free variable value.


Csharp_Chap10

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Csharp_Chap10

Similar to Csharp_Chap10 (20)

More from Mohamed Krar

More from Mohamed Krar (17)

Recently uploaded

Recently uploaded (20)

Csharp_Chap10