C# - Read and Write only Properties

Read and Write Only Properties in C# 

Introduction to C# Properties

In C# programming, properties are one of the most important features used to control access to class data. When learning C# Properties, especially Read Only Properties in C# and Write Only Properties in C#, developers understand how encapsulation works in object-oriented programming. This concept is essential for building secure, maintainable, and scalable applications in .NET development.

Properties act as a bridge between private fields and public access. Instead of directly exposing fields, we use properties to define controlled access through get and set accessors. These accessors allow us to implement validation, logic, security, and restrictions when reading or writing data.

What are Properties in C#?

A property in C# is a member of a class that provides a flexible mechanism to read, write, or compute the value of a private field. Instead of exposing fields directly, properties ensure data encapsulation in C#.

Basic property syntax:

class Person
{
    private string name;

    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

Here:

• get accessor returns the value.
• set accessor assigns the value.

But what if we want to allow only reading or only writing? That is where Read Only and Write Only Properties in C# become useful.

Read Only Properties in C#

What is a Read Only Property?

A Read Only Property in C# is a property that exposes only a get accessor. This means the property value can be read from outside the class, but cannot be modified directly.

It is commonly used when:

• Value should not change after initialization
• Data must be protected
• Only internal logic should modify the value

Example of Read Only Property

class Student
{
    private int rollNumber;

    public Student(int roll)
    {
        rollNumber = roll;
    }

    public int RollNumber
    {
        get { return rollNumber; }
    }
}

In this example:

• RollNumber can be read.
• RollNumber cannot be modified outside the class.

Using Auto-Implemented Read Only Property

C# allows a cleaner syntax using auto-properties:

class Employee
{
    public int Id { get; }

    public Employee(int id)
    {
        Id = id;
    }
}

Here:

• The property is initialized through constructor.
• After initialization, it cannot be modified.

Expression-Bodied Read Only Property

class Circle
{
    public double Radius { get; set; }

    public double Area => 3.14 * Radius * Radius;
}

Area is a computed read-only property. It calculates value dynamically.

Write Only Properties in C#

What is a Write Only Property?

A Write Only Property in C# exposes only a set accessor. This means the value can be assigned, but cannot be read from outside the class.

Although less common, write-only properties are useful when:

• Setting sensitive data (e.g., passwords)
• Triggering internal logic
• Logging values without exposing them

Example of Write Only Property

class User
{
    private string password;

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

Here:

• Password can be assigned.
• Password cannot be retrieved.

Write Only Property with Logic

class Logger
{
    private string message;

    public string Message
    {
        set
        {
            message = value;
            Console.WriteLine("Logged: " + message);
        }
    }
}

The property is used to trigger behavior instead of storing just data.

Access Modifiers in Properties

C# allows different access levels for get and set.

class Product
{
    public string Name { get; private set; }

    public Product(string name)
    {
        Name = name;
    }
}

Here:

• get is public.
• set is private.

This is a common technique in C# Encapsulation and Object-Oriented Programming in C#.

Difference Between Read Only Property and Readonly Field

Many beginners confuse properties with readonly fields.

Readonly Field

class Demo
{
    public readonly int Value;

    public Demo(int value)
    {
        Value = value;
    }
}

Read Only Property

class Demo
{
    public int Value { get; }

    public Demo(int value)
    {
        Value = value;
    }
}

Key Differences:

• Readonly fields are fields, not properties.
• Properties provide abstraction.
• Properties can include logic.
• Readonly fields cannot have validation logic.

Real-World Use Cases

1. Banking System

Account balance should be read-only from outside.

class BankAccount
{
    public decimal Balance { get; private set; }

    public void Deposit(decimal amount)
    {
        Balance += amount;
    }
}

2. Secure Password Handling

Password should be write-only.

3. Configuration Settings

Application settings can be read-only after initialization.

Performance Considerations

Properties in C# are compiled into methods. The compiler converts get and set into special methods. There is no significant performance overhead compared to fields.

However:

• Avoid heavy computation in get accessor.
• Do not include database calls inside properties.
• Keep properties lightweight.

Advanced Concepts

Init-Only Properties (C# 9.0)

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

Init-only properties allow assignment only during object initialization.

Abstract Read Only Property

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

Understanding C# Read Only Properties and C# Write Only Properties is essential for mastering C# programming and .NET Framework development.

They help achieve:

• Encapsulation
• Security
• Controlled access
• Data validation
• Clean architecture

Using properties correctly improves maintainability, readability, and scalability of applications.