C# - Read and Write only Properties

Read and Write Only Properties in C#

C# is a statically typed, object-oriented programming language developed by Microsoft as part of the .NET platform. One of its powerful features is its support for properties, which provide a flexible mechanism to read, write, or compute the values of private fields. This encapsulation mechanism is a vital part of object-oriented design, promoting data security and abstraction.

Introduction to Properties in C#

Properties in C# are members of a class that provide a flexible mechanism to access or assign values to private fields. Unlike fields, properties can have logic inside their accessors to validate or transform data before returning or setting it.

A property generally contains two accessors:

• Get accessor: returns the property value.
• Set accessor: assigns a new value.

Syntax of a Property

public class Sample
{
    private int _value;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }
}
    

In the above example, the property Value encapsulates the field _value with both get and set accessors. However, it is possible to create properties with only a get or only a set accessor, leading us to Read-Only and Write-Only properties.

Read-Only Properties in C#

What is a Read-Only Property?

A read-only property allows only reading of data. It exposes a get accessor but does not provide a set accessor. Such properties are useful when we want to allow external code to read a property value but restrict it from modifying it.

Syntax

public class Student
{
    private string _name;

    public Student(string name)
    {
        _name = name;
    }

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

Here, Name is a read-only property. It can be read from outside the class, but it cannot be set.

Advantages of Read-Only Properties

• Encapsulation: Protects internal data from being modified from outside.
• Controlled Access: Useful when the data needs to be exposed but not altered.
• Immutable Objects: Helps in creating immutable types.

Use Cases

• Read-only IDs such as employee number or customer ID.
• Timestamp fields like creation date.
• Configuration data that should not change during runtime.

Auto-Implemented Read-Only Properties (C# 6.0+)

public class Product
{
    public string Code { get; }

    public Product(string code)
    {
        Code = code;
    }
}
    

In C# 6.0 and later, you can declare an auto-implemented property with only a get accessor. It can be assigned in the constructor, making it read-only outside the class.

Write-Only Properties in C#

What is a Write-Only Property?

A write-only property provides only a set accessor and no get accessor. It is rarely used but can be useful in specific scenarios where you want to allow data to be written but not read from outside the class.

Syntax

public class Logger
{
    private string _log;

    public string Log
    {
        set { _log = value; }
    }
}
    

Here, the property Log allows data to be set, but not retrieved. This can be useful in security-sensitive applications such as logging passwords or sensitive information.

Advantages of Write-Only Properties

• Security: Prevents unauthorized reading of sensitive data.
• Encapsulation: Allows abstraction of the internal structure.

Use Cases

• Setting passwords or encryption keys.
• Feeding data to a logging or auditing system.
• Updating internal states based on commands from external sources.

Example: Write-Only Password Setter

public class User
{
    private string _passwordHash;

    public string Password
    {
        set { _passwordHash = Hash(value); }
    }

    private string Hash(string input)
    {
        // Simulate hashing
        return "HASHED_" + input;
    }
}
    

This ensures that the password is never stored in plain text and cannot be retrieved from the class instance.

Comparison Between Read-Only and Write-Only Properties

Advanced Scenarios

Internal Set and Public Get

public class Configuration
{
    public string Environment { get; internal set; }
}
    

This allows the value to be read publicly, but only set internally, offering a hybrid between read-only and fully accessible properties.

Protected Set Accessor

public class Employee
{
    public string Name { get; protected set; }
}
    

Here, the property Name can only be set by the class itself or its derived classes. This pattern supports inheritance scenarios.

Private Set with Public Get

public class Session
{
    public string Token { get; private set; }

    public Session()
    {
        Token = GenerateToken();
    }

    private string GenerateToken()
    {
        return Guid.NewGuid().ToString();
    }
}
    

This allows data to be generated and managed internally while exposing it safely.

Best Practices

• Use read-only properties to expose state safely without allowing external modifications.
• Use write-only properties sparingly and only when there's a clear need to hide values from being read.
• Consider the principle of least privilege when exposing data via properties.
• Combine accessors with access modifiers (e.g., public get and private set) to fine-tune accessibility.
• Always encapsulate sensitive data properly to prevent data leaks or unintended access.

Common Mistakes to Avoid

• Creating write-only properties without documenting their purpose.
• Exposing sensitive data via get accessors.
• Failing to initialize read-only properties in constructors.
• Overusing properties for complex logic — prefer methods when behavior gets complicated.

Read-only and write-only properties are essential tools in the C# programmer's toolkit. They offer powerful mechanisms to control access to internal data, enforce encapsulation, and implement secure and maintainable code. While read-only properties are quite common and useful in many scenarios, write-only properties are less frequently used and should be applied judiciously. By understanding and utilizing these property types appropriately, developers can create clean, robust, and secure applications in C#.