C# Property

Array Collections File Keyword String .NET Cast Class Data Dictionary Enum Exception If Interface Lambda LINQ List Loop Method Number Process Property Regex Sort Split StringBuilder Struct Substring Switch Time Windows

Property

On a class,
a property gets
and sets values. A simplified syntax form, properties are implemented in the IL as methods. With them, we create standard access points from external places.

Get, set

First, this program introduces an Example class. One field is present and it is used as a backing store for the Number property. The Number property provides get { } and set { } implementations.

Property

Get:The get { } implementation must include a return statement. It can access any member on the class.

Set:The set { } implementation receives the implicit argument "value." This is the value to which the property is assigned.

Value
C# program that uses public int property

using System;

class Example
{
    int _number;
    public int Number
    {
	get
	{
	    return this._number;
	}
	set
	{
	    this._number = value;
	}
    }
}

class Program
{
    static void Main()
    {
	Example example = new Example();
	example.Number = 5; // set { }
	Console.WriteLine(example.Number); // get { }
    }
}

Output

5

Enum

Enum

We can use other types in properties, such as enum types. This example shows the DayOfWeek enum type in a property. We also insert code in the getter (or setter) that checks the backing store or the parameter value.

EnumDayOfWeek
C# program that uses enum property

using System;

class Example
{
    DayOfWeek _day;
    public DayOfWeek Day
    {
	get
	{
	    // We don't allow this to be used on Friday.
	    if (this._day == DayOfWeek.Friday)
	    {
		throw new Exception("Invalid access");
	    }
	    return this._day;
	}
	set
	{
	    this._day = value;
	}
    }
}

class Program
{
    static void Main()
    {
	Example example = new Example();
	example.Day = DayOfWeek.Monday;
	Console.WriteLine(example.Day == DayOfWeek.Monday);
    }
}

Output

True

Private

Private keyword

We can also use the private accessibility modifier on a property setter or getter. In this example, we require that the IsFound property only be set in the Example class domain. We set the IsFound property in the Example constructor.

Then:We can only get the property in the Program.Main method by using an Example instance.

C# program that uses private setter in property

using System;

class Example
{
    public Example()
    {
	// Set the private property.
	this.IsFound = true;
    }
    bool _found;
    public bool IsFound
    {
	get
	{
	    return this._found;
	}
	private set
	{
	    // Can only be called in this class.
	    this._found = value;
	}
    }
}

class Program
{
    static void Main()
    {
	Example example = new Example();
	Console.WriteLine(example.IsFound);
    }
}

Output

True
Tip

Entire property. We can also make an entire property private. If we do this, we can only use the property in the same enclosing class. The Display method in the example (below) shows how to use the private property.

Note:This syntax is less useful in most programs. But it exists, and may be helpful in a complex class.

Class
C# program that uses private property

using System;

class Example
{
    int _id;
    private int Id
    {
	get
	{
	    return this._id;
	}
	set
	{
	    this._id = value;
	}
    }
    public void Display()
    {
	// Access the private property in this method.
	this.Id = 7;
	Console.WriteLine(this.Id);
    }
}

class Program
{
    static void Main()
    {
	Example example = new Example();
	example.Display();
    }
}

Output

7

Static

Static

Properties can also be static. This means they are associated with the type and not an instance. Static classes can only have static properties. Count here has a side effect that causes the field to be incremented upon each access.

Caution:Side effects are not usually a good design feature in programs. They can make the logic hard to follow.

StaticStatic ClassStatic Property

Omitting the setter. In this program, the setter is omitted. It is sometimes useful to omit the setter when we have a property that computes a value entirely in memory or based on other fields or properties.

C# program that uses static property

using System;

class Example
{
    static int _count;
    public static int Count
    {
	get
	{
	    // Side effect of this property.
	    _count++;
	    return _count;
	}
    }
}

class Program
{
    static void Main()
    {
	Console.WriteLine(Example.Count);
	Console.WriteLine(Example.Count);
	Console.WriteLine(Example.Count);
    }
}

Output

1
2
3

Automatic

Syntax

Next, we see automatically implemented property syntax. A hidden field is generated and used as the backing store. Then, the get and set statements are expanded to use that hidden field.

Expression:The *= operator is used to multiply the property by itself. This is the same as "example.Number = example.Number * 4".

Tip:Because properties are meant to look like fields, this is allowed. Obviously methods are not allowed to do this.

Program with automatically implemented property: C#

using System;

class Example
{
    public int Number
    {
	get;
	set;
    }
}

class Program
{
    static void Main()
    {
	Example example = new Example();
	example.Number = 8;
	example.Number *= 4;
	Console.WriteLine(example.Number);
    }
}

Output

32

Automatic, private. Let us consider how to make getters or setters on an automatic property. The syntax is clear. Please note we cannot omit either the getter or setter in automatically implemented property.

Info:The error reported by the C# compiler reads: "Automatically implemented properties must define both get and set accessors."

Program with automatically implemented property 2: C#

using System;

class Example
{
    public Example()
    {
	// Use private setter in the constructor.
	this.Id = new Random().Next();
    }
    public int Id
    {
	get;
	private set;
    }
}

class Program
{
    static void Main()
    {
	Example example = new Example();
	Console.WriteLine(example.Id);
    }
}

Output

2077325073

Indexer

This keyword

Indexers are another form of property. They use the token "this" for their name, and square brackets with an argument. If you are not creating a reusable type, you probably won't need to implement this.

Indexer

Tip:Types such as the List (one of my favorites) use indexers to do element accesses. It looks like an array but is not.

Interface

Interface

We can also specify that a property be required by an interface. There is a special syntax for this. On types that implement the interface, we must provide implementations for the property.

Interface

Note:The special syntax required here is a reason to avoid properties in some programs. No one wants to deal with complex syntax rules.

Performance

Performance

The C# compiler and .NET Framework use advanced optimizations to ensure that properties are efficient. These same optimizations are used on methods, which share the underlying implementation with properties.

Here:This program benchmarks with Stopwatch and performs the two loops ten times. Each inner loop has 100,000,000 iterations.

C# program that benchmarks properties

using System;
using System.Diagnostics;

class Program
{
    static string _backing; // Backing store for property
    static string Property // Getter and setter
    {
	get
	{
	    return _backing;
	}
	set
	{
	    _backing = value;
	}
    }
    static string Field; // Static field

    static void Main()
    {
	const int m = 100000000;
	for (int x = 0; x < 10; x++) // Ten tests
	{
	    Stopwatch s1 = new Stopwatch();
	    s1.Start();
	    for (int i = 0; i < m; i++) // Test property
	    {
		Property = "string";
		if (Property == "cat")
		{
		}
	    }
	    s1.Stop();
	    Stopwatch s2 = new Stopwatch();
	    s2.Start();
	    for (int i = 0; i < m; i++) // Test field
	    {
		Field = "string";
		if (Field == "cat")
		{
		}
	    }
	    s2.Stop();
	    Console.WriteLine("{0},{1}",
		s1.ElapsedMilliseconds,
		s2.ElapsedMilliseconds);
	}
	Console.Read();
    }
}

Results

Property get/set:  604.6 ms
Field read/assign: 603.6 ms
Program

There was no difference in performance with the property and the direct field. I conclude the property access is completely inlined. There is no need to use manual inlining of properties for performance optimization in regular cases.

Tip:The JIT compiler is smart enough to inline properties that don't have logic inside of them. So they are as efficient as fields.

Compiler

Research

Books

I researched properties in the C# specification. This is the most important concept: a property is not a storage location like a field. It is just a method. It has special syntax that looks more like a field.

Unlike fields, properties do not denote storage locations. Instead, properties have accessors that specify the statements to be executed when their values are read or written.

The C# Programming Language

Prop

Prop snippet: Visual Studio screenshot

I like the prop snippet. It is one of my favorites. In Visual Studio, try typing prop and pressing tab twice where you want to put a property. Then change the fields as needed. We get an automatically implemented property.

Snippets

Summary

Properties are used throughout programs. They are a powerful way to replace methods and present a more intuitive way to use your objects. They combine fields and methods on a conceptual level.

C#