Comparing Init-Only Properties and Private Setters in C#

In C#, managing property access and immutability is crucial for building robust and maintainable applications. Two key features that help developers control property assignment are init-only properties, introduced in C# 9, and private setters. This article delves into these features, comparing their uses, benefits, and the best scenarios to employ each.

What Are Init-Only Properties?

Init-only properties allow properties to be set during object initialization but remain immutable afterward. This feature is enabled by the init accessor, which can only be used in object initializers and constructors within the declaring type, similar to readonly fields, but with more flexibility.

Example of Init-Only Property

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

What Are Private Setters?

Private setters restrict the modification of a property to the class that declares it. Unlike init-only properties, private setters allow properties to be changed within any method of the class, not just during initialization.

Example of Private Setter

public class Person
{
    public string Name { get; private set; }
    public void ChangeName(string newName)
    {
        Name = newName; // Valid since setter is private but accessible within the class
    }
}

Key Differences Between Init-Only and Private Setters

Immutability Scope:

Init-Only: Property values are immutable after the object's construction phase.
Private Set: Property values can be changed, but only by the class that declares them.

Flexibility in Modification:

Init-Only: Provides true immutability after object initialization, making it suitable for truly immutable data models.
Private Set: Offers controlled mutability, which is useful for encapsulating property-setting logic within the class while protecting it from external changes.

Use Cases:

Init-Only: Best used in scenarios where a class needs to maintain strict immutability once fully constructed. Ideal for records and data transfer objects where thread safety and predictability are important.
Private Set: Useful when the class needs to change its own state internally but should not allow external modifications. Good for cases where the class manages its own state based on internal conditions or methods.

Choosing Between Init-Only and Private Setters

When deciding whether to use an init-only property or a private setter, consider the following:

Object Lifecycle: If the property should be settable only during initialization and truly immutable afterward, use init.
Control Needs: If the class should retain the ability to modify its properties internally after initialization, use a private setter.
Design Philosophy: Init-only aligns with immutable object patterns, which are central to functional programming concepts. Private setters fit well with an object-oriented approach where encapsulation is key.

Conclusion

Both init-only properties and private setters serve important roles in property management in C#. Choosing between them depends on your specific needs for immutability, encapsulation, and control within your application. By understanding the differences and appropriate use cases for each, developers can create more secure and well-structured applications.

c# init vs private set