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

public static void Main()

aa a = new aa();

int gg = a.ff + 9;

System.Console.WriteLine(gg);

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

public static void Main()

aa a = new aa();

a.ff = 19;

System.Console.WriteLine(a.ff);

public class aa

public int ff {

get
 {

System.Console.WriteLine(“in 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

public static void Main()

{
aa a = new aa();

a.ff = 19;

System.Console.WriteLine(a.ff);

public class aa

int f1;

public int ff {

get

System.Console.WriteLine(“in 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

public static void Main()

aa a = new aa();

a.ff = 19;

System.Console.WriteLine(a.ff);

public class aa

int f1;

public int ff {

get

{
 System.Console.WriteLine(“in 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

public static void Main()

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 static void Main()

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 static void Main()

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

public static void Main()

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

public static void Main()

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

public static void Main()

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 static void Main()

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 static void Main()

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

{
public static void Main()

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

public static void Main()

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

public static void Main()

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

public static void Main()

yyy a = new yyy();

System.Console.WriteLine(a[1]);

public class yyy

public int this[int i]

set

System.Console.WriteLine(“in get “ + value + “ “ + i);

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

public static void Main()

yyy a = new yyy();

a[“hi”] = 30;

System.Console.WriteLine(a[“hi”]);

public class yyy

public int z;
public int this[string i]

set

System.Console.WriteLine(“in get “ + value + “ “ + i);

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

public static void Main()

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

{
public static void Main()

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

public static void Main()

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.