Ebooks

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

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

Program.cs
using System;

namespace SimpleProperties
{
    class Person
    {
        private string _name;

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

    class Program
    {
        static void Main(string[] args)
        {
            var 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; } 

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.

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.

$ dotnet run
Jane

This is the outcome of the program.

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.

Program.cs
using System;

namespace Readonly
{
    class Person
    {
        private string _name = "Jane";

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

    class Program
    {
        static void Main(string[] args)
        {
            var 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 C# compiler would issue the following error: Program.cs(21,13): error CS0200: Property or indexer 'Person.Name' cannot be assigned to -- it is read 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.

Program.cs
using System;

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

    class Program
    {
        static void Main(string[] args)
        {
            var p = new Person();
            p.Name = "Jane";
            p.Age = 17;

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

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

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.

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.

$ dotnet run
Jane is 17 years old

This is the output of the example.

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.

Program.cs
using System;

namespace ExpBodyDef
{
    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;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var u = new User("John Doe", "gardener");

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

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

$ dotnet run
John Doe is a gardener

This is the output.

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.

Program.cs
using System;

namespace OtherNotes
{
    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; }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var bs = new Base();
            var dr = new Derived();

            Console.WriteLine(bs.Name);
            Console.WriteLine(dr.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.