In this part of the C# tutorial, we cover 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.

Properties can be read-write (they have both a get and a set accessor), read-only (they have only a get accessor), or write-only (they have only a set accessor).

using System;

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

Console.WriteLine(p.Name);

class Person
{
    private string _name;

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

We have a simple Person class with one property.

var 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.

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; }

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

$ dotnet run
Jane

C# 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;

var p = new Person();
// p.Name = "Beky";

Console.WriteLine(p.Name);

class Person
{
    private string _name = "Jane";

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

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

// p.Name = "Beky";

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

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.

C# auto-implemented properties

C# has 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;

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

Console.WriteLine($"{p.Name} is {p.Age} years old");

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

This code is much shorter. We have a Person class in which we have two properties: Name and Age.

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

Console.WriteLine($"{p.Name} is {p.Age} years old");

We normally use the properties as usual.

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.

$ dotnet run
Jane is 17 years old

Expression body definitions

Since C# 7.0, properties can be simplified with expression body definitions. Expression body definitions consist of the => symbol followed by the expression to assign to or retrieve from the property.

using System;

var u = new User("John Doe", "gardener");

Console.WriteLine($"{u.Name} is a {u.Occupation}");

class User
{
    string name;
    string occupation;

    public User(string name, string occupation)
    {
        this.name = name;
        this.occupation = occupation;
    }

    public string Name
    {
        get => name;
        set => name = value;
    }

    public string Occupation
    {
        get => occupation;
        set => occupation = value;
    }
}

In the example, we use the expression body definitions to define properties for the User class.

$ dotnet run
John Doe is a gardener

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;

var bs = new Base();
var dr = new Derived();

Console.WriteLine(bs.Name);
Console.WriteLine(dr.Name);
       
class Base
{
    protected string _name = "Base class";

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

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

    public override string Name
    {
        set { _name = value; }
        get { return _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.