Understanding the Differences Between Init and Set Accessors in C#

In C#, properties play a crucial role in data encapsulation, providing a controlled way of accessing and modifying the data within classes. With the introduction of C# 9.0, a new accessor, init, has been added alongside the traditional set accessor. This article explores the differences between init and set accessors, shedding light on their uses, benefits, and when to choose one over the other.

What is a Set Accessor?

The set accessor in a property is used to assign a value to a private field from outside the class, while still encapsulating the underlying data. It can be called multiple times during the lifespan of an object, allowing for the modification of the property value at any point.

Example of Set Accessor

public class Person
{
    private string _name;

    public string Name
    {
        get => _name;
        set => _name = value ?? throw new ArgumentNullException("Name cannot be null.");
    }
}

In this example, the Name property can be set at any time, and each time it's set, it can be validated and manipulated as necessary.

What is an Init Accessor?

Introduced with C# 9.0 to facilitate immutable data structures, the init accessor allows a property to be set only during object initialization—such as in a constructor or with an object initializer. Once the object is fully constructed, the property becomes immutable.

Example of Init Accessor

public class Person
{
    public string Name { get; init; }
}

var person = new Person { Name = "John" };  // Valid during initialization
// person.Name = "Jane";  // Compiler error: cannot modify init-only property

In this case, Name can only be set during the initialization phase and remains immutable thereafter, ensuring the integrity of the object once it has been fully constructed.

Key Differences Between Init and Set

Mutability: set allows for changing the property's value throughout the object's lifecycle, whereas init makes the property immutable after the object's initial construction.
Use Case: set is suitable for data that needs to change over time, such as a user's location in a session. init is ideal for data that should not change once set, like a user's ID or birthdate.
Safety: init properties contribute to safer multithreaded programming by ensuring that once a property is set, it cannot be altered unexpectedly, which helps prevent race conditions and other threading issues.

When to Use Set vs. Init

Use set when:

The property value needs to change in response to different conditions after the object has been initialized.
You need to enforce business rules that might change the property value throughout the object's life.

Use init when:

The property value represents a state that should remain constant after the object is first configured, promoting immutability.
You are working with data models that are transferred between different parts of an application and need to guarantee the data remains unchanged.

Conclusion

Choosing between init and set depends on the specific requirements of your application and the nature of the data being encapsulated. For scenarios requiring immutable properties, init provides a robust solution, while set continues to be indispensable for mutable properties. Understanding and correctly implementing these accessors can significantly enhance the robustness, safety, and clarity of your C# applications.

init vs set c#