Properties

In this part of the C# tutorial, we will talk about properties.

Properties are special kind of class members. We use predefined set and get methods to access and modify them. Property reads and writes are translated to get and set method calls. Accessing variables with a field notation (e.g. object.Name) is easier than with custom method calls (e.g. object.GetName()). However with properties, we still have the advantage of encapsulation and information hiding. In other words, properties shield the data from the outside world while having a convenient field access.

Interfaces can have properties but not fields.

using System;

public class Person 
{
    private string _name; 

    public string Name
    {
        get { return _name; }
        set { _name = value;} 
    }
}

public class CSharpApp
{
    static void Main()
    {
        Person p = new Person();
        p.Name = "Jane";
        
        Console.WriteLine(p.Name);
    }
}

We have a simple Person class with one property.

public string Name
{
   ...
}

We have a property that is called Name. It looks like a regular method declaration. The difference is that it has specific accessors called get and set.

get { return _name; }
set { _name = value; } 

A get property accessor is used to return the property value, and a set accessor is used to assign a new value. The value keyword is used to define the value being assigned by the set indexer.

Person p = new Person();
p.Name = "Jane";

Console.WriteLine(p.Name);

We create an instance of the Person class. We access the member field using the field notation.

$ ./properties.exe 
Jane

This is the outcome of the program.

Read-only properties

It is possible to create read-only properties. To create a read-only property, we omit the set accessor and provide only the get accessor in the implementation.

using System;

public class Person 
{
    private string _name = "Jane"; 

    public string Name
    {
        get { return _name; }
    }
}

public class ReadonlyProperties
{
    static void Main()
    {
        Person p = new Person();
        // p.Name = "Beky";
        
        Console.WriteLine(p.Name);
    }
}

In the preceding example, we demonstrate the use of a read-only property.

private string _name = "Jane";

We initialize the member right away, because later it is not possible.

public string Name
{
    get { return _name; }
}

We make the property read-only by providing a get accessor only.

// p.Name = "Beky";

This line is now commented. We cannot change the property. If we uncommented the line, the Mono C# compiler would issue the following error: readonly.cs(18,11): error CS0200: Property or indexer `Person.Name' cannot be assigned to (it is read-only).

Automatic properties

C# version 3.0 introduced auto-implemented or automatic properties. In a software project, there are lots of simple properties that only set or get some simple values. To simplify programming and to make the code shorter, automatic properties were created. Note that we cannot use automatic properties in all cases. Only for the simple ones.

using System;

public class Person 
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class AutomaticProperties
{
    public static void Main()
    {
        Person p = new Person();
        p.Name = "Jane";
        p.Age = 17;
        
        Console.WriteLine("{0} is {1} years old", 
            p.Name, p.Age);
    }
}

This code is much shorter. We have a person class in which we have two properties.

public string Name { get; set; }
public int Age { get; set; }

Here we have two automatic properties. There is no implementation of the accessors. And there are no member fields. The compiler will do the rest for us.

Person p = new Person();
p.Name = "Jane";
p.Age = 17;

Console.WriteLine("{0} is {1} years old", 
    p.Name, p.Age);

We normally use the properties as usual.

$ ./automatic.exe 
Jane is 17 years old

This is the output of the example.

Other notes

We can mark properties with access modifiers like public, private or protected. Properties can be also static, abstract, virtual and sealed. Their usage is identical to regular methods.

using System;

public class Base 
{
    protected string _name = "Base class"; 

    public virtual string Name
    {
        set { _name = value; }
        get { return _name; }
    }
}

public class Derived : Base
{
    protected new string _name = "Derived class"; 

    public override string Name
    {
        set { _name = value; }
        get { return _name; }
    }
}

public class CSharpApp
{
    public static void Main()
    {
        Base b = new Base();
        Derived d = new Derived();
        
        Console.WriteLine(b.Name);
        Console.WriteLine(d.Name);
    }
}

In the preceding example, we define a virtual property and override it in the Derived class.

public virtual string Name
{
    set { _name = value; }
    get { return _name; }
}

The Name property is marked with the virtual keyword.

protected new string _name = "Derived class"; 

We are hiding a member in the Derived class. To suppress the compiler warning, we use the new keyword.

public override string Name
{
    set { _name = value; }
    get { return _name; }
}

And here we override the Name property of the Base class.

This chapter covered C# properties. We described the properties and showed how they are implemented. We mentioned automatic properties and read-only properties.