Introduction
Here we are going to introduce you to the concept of properties in C#. Properties can help simplify programming aspects. Let us understand what these programming aspects are and then understand how properties can be of help to simplify these programming aspects. Let us understand the programming aspects that properties intend to simplify, step by step through small programs.
What makes us use Properties?
Let's write a simple C# program that implements a class named Maths
and contains an entry point function Main()
.
P1.cs
class Maths
{
public static void Main ()
{
}
}
The program compiles successfully. Cool! Now let us add a private integer val
to the class Maths
.
P2.cs
class Maths
{
private int val;
public static void Main ()
{
}
}
Output
P2.cs(3,15): warning CS0169: The private field 'Maths.val' is never used
The program compiles successfully but it throws a warning message. The warning says that we haven't used the private variable val
. We have just declared the variable val
. So it's time to remove the warning. For this we need to assign value to the variable val
. So let's define a new public member function SetVal()
for the class Maths
. This function will accept an integer as argument and assign it to the private variable val
of the Maths
class.
P3.cs
class Maths
{
private int val;
public static void Main ()
{
}
public void SetVal ( int x )
{
val = x;
}
}
Output
Bingo! This program compiles successfully and that too without any warning message. The warning disappeared because the private variable val
is used in the function SetVal()
. Well, but what about the output? We didn't see any output. So let's go ahead and add a public member function Display()
to the Math
class above.
P4.cs
class Maths
{
private int val;
public static void Main ()
{
}
public void SetVal ( int x )
{
val = x;
}
public void Display ( int x )
{
System.Console.WriteLine(val);
}
}
Output
This program compiles successfully but we don't get any output. That's because the Display()
function is not invoked from within Main()
. In order to invoke this function we need to create an object obj
of class Maths
in function Main()
and invoke the function Display()
on this object obj
. This is what is done by the following program.
P5.cs
class Maths
{
private int val;
public static void Main ()
{
Maths obj = new Maths();
obj.Display();
}
public void SetVal ( int x )
{
val = x;
}
public void Display()
{
System.Console.WriteLine(val);
}
}
Output
0
The program compiles and runs successfully to output the value of private member variable val
which is 0. Now that we have functions Display()
and SetVal()
let's have another function GetVal()
. This new function will return the value of the private integer member variable val
. The new function is implemented by the following program.
P6.cs
class Maths
{
private int val;
public static void Main ()
{
Maths obj = new Maths();
obj.Display();
}
public void SetVal ( int x )
{
val = x;
}
public void Display()
{
System.Console.WriteLine(val);
}
public int GetVal ()
{
return val;
}
}
Output
0
As expected the program compiles and runs successfully to output the value of private member variable val
which is 0. Now that we have functions Display()
, SetVal()
and GetVal()
let us use all of them in the above program by enhancing the Main()
function. The enhanced program would look like this.
P7.cs
class Maths
{
private int val;
public static void Main ()
{
int y = 0;
Maths obj = new Maths();
obj.Display();
obj.SetVal(10);
y = obj.GetVal();
System.Console.WriteLine(y);
obj.SetVal(20);
y = obj.GetVal();
System.Console.WriteLine( y );
obj.SetVal(30);
y = obj.GetVal();
System.Console.WriteLine( y );
}
public void SetVal ( int x )
{
val = x;
}
public void Display()
{
System.Console.WriteLine(val);
}
public int GetVal ()
{
return val;
}
}
Output
0
10
20
30
The program compiles and runs successfully. Inside Main()
we create an object obj
of class Maths
and invoke the function Display()
on this object obj
. This outputs the value of private member variable val
which is 0. Next SetVal()
is invoked on obj
which sets the value of the private member variable val
to 10. Next a call is made to the function GetVal()
which returns the value of the private member variable val which is 10. This is passed to the function System.Console.WriteLine()
which displays 10 on the output screen. Next SetVal()
is invoked on obj
which sets the value of the private member variable val
to 20. Next a call is made to the function GetVal()
which returns the value of the private member variable val
which is 20. This is passed to the function System.Console.WriteLine()
which displays 20 on the output screen. Lastly, SetVal()
is invoked on obj
which sets the value of the private member variable val
to 30. Next a call is made to the function GetVal()
which returns the value of the private member variable val
which is 30. This is passed to the function System.Console.WriteLine()
which displays 30 on the output screen. This justifies the output of the above program.
In the above program, every time we had to set the value of the private member variable val
we had to write the statements like
obj.SetVal(10);
obj.SetVal(20);
obj.SetVal(30);
Wouldn't it be of convenience if we could write the above statements as follows to achieve the same results?
obj.val = 10;
obj.val = 20;
obj.val = 30;
Certainly yes!
Similarly, in the above program, every time we had to get the value of the private member variable val we had to write the statements like
y = obj.GetVal();
y = obj.GetVal();
y = obj.GetVal();
Wouldn't it be of convenience if we could write the above statements as follows to achieve the same results?
y =obj.val ;
y =obj.val ;
y =obj.val ;
Certainly yes!
But hold on! Didn't you notice that val
a private member variable of class Maths
? So we cannot access val using statements like
obj.val = 10;
AND
y =obj.val ;
from the Main()
function of the class Maths
. So whats the alternative? The alternative is to go for Properties.
Let's use Properties
We will define a property for the private member variable val
and then access val
using the property. Lets suppose that we define a property named Val
for the private member variable val
, then we will use the following statements to set and get the value of private member variable val
.
obj.Val = 10;
y =obj.Val ;
Doesn't this look very handy? Certainly it does! So let's enhance the above program to make use of Properties. Let's do things step by step. Our first step is to remove the functions Display()
, SetVal()
, GetVal()
and their associated calls from the above program. On doing so the program would look like this:
P8.cs
class Maths
{
private int val;
public static void Main ()
{
int y = 0;
Maths obj = new Maths();
}
}
Output
P8.cs(7,10): warning CS0219: The variable 'y' is assigned but its value is
never used
P8.cs(3,15): warning CS0169: The private field 'Maths.val' is never used
For now let us live with the warnings. Now let's enhance the above program by adding a property Val
. The purpose of this property Val
would be to allow us to set and get the value of the private member variable val
of the class Maths
. The enhanced program would look like this:
P9.cs
class Maths
{
private int val;
public static void Main ()
{
int y = 0;
Maths obj = new Maths();
}
public int Val
{
get
{
return val;
}
set
{
val = value;
}
}
}
Output
P9.cs(7,9): warning CS0219: The variable 'y' is assigned but its value is never
used
The program compiles successfully. This time it throws only one warning. The code in the bold font represents the property Val
. Observe that a property is a definition, and looks like a function definition except that a function has opening and closing parenthesis. So a function of name func
would look like this:
int func ()
{
}
Observe the parenthesis in bold above. Now imagine how would a property of name func
look like? Simple! Just remove the parenthesis we included above. So the property named func
would look like this:
int func
{
}
Observe the absence of parenthesis in the property definition above.
Now let's have a look at the program above. It defines a property Val
as follows:
public int Val
{
}
Simple isn't it?
Now let's focus on the code inside the property Val
.
public int Val
{
get
{
return val;
}
set
{
val = value;
}
}
It contains two accessors named get
and set
. Accessors are defined exactly like properties except that they don't have return types. For example, the property Val
that we defined had a return value of int
.
Now let us focus on the get
accessor.
get
{
return val;
}
As mentioned earlier, the get
accessor has no return type as well as no parenthesis. The code for the get
accessor is present in the curly braces. The get accessor returns the private member variable val
.
Now let us focus on the get
accessor.
set
{
val = value;
}
As mentioned earlier, the set
accessor has no return type as well as parenthesis. The code for the set
accessor is present in the curly braces. The set
accessor sets the private member variable val
to the value of variable value
.
Lastly, let us understand value
. Well, value
is not a variable that we defined in any of the classes or functions that we wrote. value
is a created by C# inside set accessor invisibly. It gets the value of that is assigned to the property in our case Val
. We will see this shortly.
Now let's enhance the above program to put the defined property to use as well as add a PREVIOUS function Display()
that would do the job of displaying the value of the private member variable val
.
P10.cs
class Maths
{
private int val;
public static void Main ()
{
int y = 0;
Maths obj = new Maths();
obj.Val = 100;
y = obj.Val;
obj.Display();
}
public void Display()
{
System.Console.WriteLine(val);
}
public int Val
{
get
{
return val;
}
set
{
val = value;
}
}
}
Output
100
The above program compiles and runs successfully to output the value of the private member variable val
which is 100. The program proves that we were successful in using properties. When the following statement is getting executed:
obj.Val = 100;
the set
accessor that belongs to property Val
gets executed, i.e. the code inside it gets executed. There is only one statement in the set
accessor and that is:
val = value;
This code assigns the value of variable value
to the private member variable val
.
The variable value
as mentioned earlier is created by C# inside the set
accessor invisibly. It gets the value that is assigned to the property Val
. The value assigned to the property Val
of object obj
is 100. So the value of the variable value
is 100.
Let us enhance the above program by adding some print statements to get a firm grip.
P11.cs
class Maths
{
private int val;
public static void Main ()
{
int y = 0;
Maths obj = new Maths();
System.Console.WriteLine("Before set call");
obj.Val = 100;
System.Console.WriteLine("After set call");
System.Console.WriteLine("Before get call");
y = obj.Val;
System.Console.WriteLine("After get call");
obj.Display();
}
public void Display()
{
System.Console.WriteLine(val);
}
public int Val
{
get
{
System.Console.WriteLine("Inside get");
return val;
}
set
{
System.Console.WriteLine("Inside set");
val = value;
}
}
}
Output
Before set call
Inside set
After set call
Before get call
Inside get
After get call
100
The above program compiles and executes successfully. The output clearly proves that when the following statement is getting executed:
obj.Val = 100;
the set
accessor that belongs to property Val
gets executed i.e the code inside it gets executed.
The output also clearly proves that when the following statement is getting executed:
y =obj.Val;
the get
accessor that belongs to property Val
gets executed i.e. the code inside it gets executed.
With this I hope that you have understood the basic concept of property. Now let's go through a simple exercise to gain a firm understanding of property.
Let us define a class called cable
. Inside this class let us have a private member variable length. We will need to get access to the length of the cable. So we need to define a property for the class cable
. Let the name of the property be Length
. The property Length
will help us to set the value of length
as well as get the value of length
. So the Length
property will have set as well as get accessors. Now, inside Main
we will create an object of class cable
. We will name this object as CoaxialCable
. Using the property Length
we will set its value to 100. Based on what we have studied so far the program will look like this…
P12.cs
class cable
{
private int length;
public static void Main ()
{
int y = 0;
cable CoaxialCable = new cable();
System.Console.WriteLine("Before set call");
CoaxialCable.Length = 100;
System.Console.WriteLine("After set call");
System.Console.WriteLine("Before get call");
y = CoaxialCable. Length;
System.Console.WriteLine("After get call");
obj.Display();
}
public void Display()
{
System.Console.WriteLine(length);
}
public int Length
{
get
{
System.Console.WriteLine("Inside get");
return val;
}
set
{
System.Console.WriteLine("Inside set");
val = value;
}
}
}
Output
Before set call
Inside set
After set call
Before get call
Inside get
After get call
100
By now the above program must have become a self-explainatory one for you. So let's move on…
Read Only Properties
Read Only Properties are the properties with only get accessor and no set accessor. Checkout the following program.
P13.cs
class cable
{
private int length;
public static void Main ()
{
int y = 0;
cable CoaxialCable = new cable();
System.Console.WriteLine("Before get call");
y = CoaxialCable. Length;
System.Console.WriteLine("After get call");
obj.Display();
}
public void Display()
{
System.Console.WriteLine(length);
}
public int Length
{
get
{
System.Console.WriteLine("Inside get");
return val;
}
}
}
Output
Before get call
Inside get
After get call
0
The above program compiles and runs successfully. Observe that property Length
defined in the above program is a read-only property as it has only one get accessor.
Write Only Properties
Write Only Properties are the properties with only set accessor and no get accessor. Checkout the following program.
P14.cs
class cable
{
private int length;
public static void Main ()
{
int y = 0;
cable CoaxialCable = new cable();
System.Console.WriteLine("Before set call");
CoaxialCable.Length = 100;
System.Console.WriteLine("After set call");
obj.Display();
System.Console.WriteLine("Before set call");
CoaxialCable.Length = 200;
System.Console.WriteLine("After set call");
obj.Display();
}
public void Display()
{
System.Console.WriteLine(length);
}
public int Length
{
set
{
System.Console.WriteLine("Inside set");
val = value;
}
}
}
Output
Before set call
Inside set
After set call
100
Before set call
Inside set
After set call
200
The above program compiles and runs successfully. Observe that property Length
defined in the above program is a write-only property as it has only one set accessor.
I am a Software engineer with around 7+ years of experience. Most of my experience is in Storage technology.