C# - Properties

C# Properties

C# properties are members of classes, structures, and interfaces that provide a flexible mechanism to read, write, or compute the values of private fields. They are an essential part of encapsulation in object-oriented programming. This guide explains everything about properties in C# from basic usage to advanced features.

1. Introduction to Properties

In C#, a property is a class member that encapsulates a getter and/or a setter method. Instead of accessing the fields directly, properties allow for access control and abstraction by providing a controlled interface to the internal data of a class.

1.1 Why Use Properties?

• Encapsulation: Control access to class fields.
• Validation: Add logic when setting or getting a value.
• Abstraction: Hide internal implementation details.
• Compatibility with binding and serialization frameworks.

1.2 Syntax of a Property

private int _age;

public int Age
{
    get { return _age; }
    set { _age = value; }
}
    

Here, Age is a property with a private backing field _age. The get accessor returns the value, and the set accessor assigns a value.

2. Types of Properties

2.1 Read-Write Property

public string Name { get; set; }
    

This is an auto-implemented property that provides both get and set accessors.

2.2 Read-Only Property

private string _id = Guid.NewGuid().ToString();

public string Id
{
    get { return _id; }
}
    

Only a get accessor is provided, making this a read-only property.

2.3 Write-Only Property

private string _password;

public string Password
{
    set { _password = value; }
}
    

This kind of property is rare. It allows writing but not reading the value.

2.4 Auto-Implemented Properties

public int Age { get; set; }
    

C# allows shorthand syntax for properties with no additional logic in accessors.

3. Backing Fields

A backing field is a private variable that stores the actual data. It is accessed and manipulated through property accessors.

private int _age;

public int Age
{
    get { return _age; }
    set
    {
        if (value > 0)
            _age = value;
    }
}
    

In this example, the setter validates that age must be positive.

4. Property Accessors

4.1 Get Accessor

Used to return the property value. Required for reading the property.

4.2 Set Accessor

Used to assign a new value. The keyword value represents the value being assigned.

4.3 Access Modifiers on Accessors

Accessors can have different access levels than the property itself:

public string Secret
{
    get; 
    private set;
}
    

Here, the property is publicly readable but privately writable.

5. Computed Properties

public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }

    public int Area
    {
        get { return Width * Height; }
    }
}
    

Area is a computed property whose value is calculated on-the-fly and not stored.

6. Expression-Bodied Properties

Introduced in C# 6, you can use lambda-like syntax:

public int Area => Width * Height;
    

This syntax is useful for simple get-only properties.

7. Init-Only Properties (C# 9.0 and Later)

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
    

init makes a property settable only during object initialization.

var person = new Person { FirstName = "John", LastName = "Doe" };
    

8. Static Properties

Like static methods, static properties belong to the type, not instances.

public class Counter
{
    private static int _count = 0;

    public static int Count
    {
        get { return _count; }
        set { _count = value; }
    }
}
    

9. Properties in Interfaces

Interfaces can define property signatures:

public interface IShape
{
    int Area { get; }
}
    

Classes implementing the interface must implement the property.

10. Abstract and Virtual Properties

10.1 Virtual Properties

public class Animal
{
    public virtual string Sound { get; set; }
}
    

Derived classes can override virtual properties.

10.2 Overriding Properties

public class Dog : Animal
{
    public override string Sound { get; set; } = "Bark";
}
    

10.3 Abstract Properties

public abstract class Shape
{
    public abstract int Area { get; }
}
    

Must be overridden by derived classes.

11. Property with Custom Logic

private int _score;

public int Score
{
    get { return _score; }
    set
    {
        if (value >= 0)
            _score = value;
        else
            throw new ArgumentOutOfRangeException("Score cannot be negative.");
    }
}
    

This property validates that score must be non-negative.

12. Using Properties with Data Binding

Properties are critical in frameworks like WPF or WinForms for data binding. They often work with the INotifyPropertyChanged interface.

public class Person : INotifyPropertyChanged
{
    private string name;
    public string Name
    {
        get => name;
        set
        {
            name = value;
            OnPropertyChanged(nameof(Name));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}
    

13. Performance Considerations

Properties are slightly slower than fields due to method calls (getter/setter), but they are the recommended approach for most cases. If raw performance is needed (e.g., game engines), fields might be used with caution.

14. Best Practices

• Use properties instead of public fields.
• Use auto-properties unless additional logic is needed.
• Make properties read-only if they shouldn't be set outside of constructors.
• Use init for immutability in C# 9 and later.
• Keep property logic fast and side-effect free.

15. Differences Between Fields and Properties

C# properties provide an elegant and powerful way to encapsulate data. They form a bridge between private fields and the public API of a class, allowing for control, validation, and flexibility. Understanding properties is essential for writing clean, maintainable, and object-oriented C# code. Whether you're working with UI frameworks, writing business logic, or designing libraries, properties are indispensable tools in your toolkit.