Read-only and write-only properties in C Sharp (C#) - Deep Dive

Overview - Read-only and write-only properties

What is it?

Read-only and write-only properties in C# are special ways to control how data inside a class can be accessed or changed. A read-only property lets you see the value but not change it from outside the class. A write-only property lets you change the value but not see it directly. These properties help protect data and control how other parts of the program interact with it.

Why it matters

Without read-only and write-only properties, anyone could change or see data inside a class freely, which can cause bugs or security problems. These properties help keep data safe and make sure it is used correctly. This control is important in big programs where many parts work together and need clear rules about data access.

Where it fits

Before learning this, you should understand basic classes and properties in C#. After this, you can learn about advanced property features like auto-properties, computed properties, and property validation.

Mental Model

Core Idea

Read-only and write-only properties let a class control whether its data can be read, written, or both from outside, protecting and managing access.

Think of it like...

It's like a mailbox with a slot for dropping letters (write-only) or a glass window to see inside but no way to put letters in (read-only).

┌───────────────┐
│   Class Data  │
├───────────────┤
│  ┌─────────┐  │
│  │ Read-   │  │
│  │ Only    │◄─┤  Outside code can see but not change
│  └─────────┘  │
│  ┌─────────┐  │
│  │ Write-  │  │
│  │ Only    │─►┤  Outside code can change but not see
│  └─────────┘  │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Basic Properties

Concept: Introduce what properties are in C# and how they provide controlled access to class data.

In C#, properties are like special methods that let you get or set values safely. For example: public class Person { private string name; public string Name { get { return name; } set { name = value; } } } Here, Name is a property that lets you read and write the private field 'name'.

Result

You can now read and change the 'Name' property from outside the class safely.

Understanding properties is key because they act as controlled doors to your class data, not just plain variables.

2

Foundation

Private Fields and Encapsulation

Concept: Explain why fields are kept private and accessed through properties to protect data.

Fields like 'name' are private so no one outside the class can change them directly. Properties act as guards that check or control access. This is called encapsulation, which keeps data safe and hides internal details.

Result

Data inside the class is protected, and external code must use properties to interact with it.

Encapsulation helps prevent accidental or harmful changes to data by forcing controlled access.

3

Intermediate

Creating Read-Only Properties

🤔Before reading on: do you think a read-only property can be set from outside the class? Commit to your answer.

Concept: Show how to make a property that can only be read, not changed from outside.

To make a read-only property, you provide only a 'get' accessor and no 'set'. For example: public class BankAccount { private decimal balance; public decimal Balance { get { return balance; } } public BankAccount(decimal initial) { balance = initial; } } Here, 'Balance' can be read but not changed from outside. Only the class can change 'balance'.

Result

External code can see the balance but cannot modify it directly.

Knowing that omitting 'set' makes a property read-only helps you protect important data from unwanted changes.

4

Intermediate

Creating Write-Only Properties

🤔Before reading on: do you think a write-only property can be read from outside the class? Commit to your answer.

Concept: Show how to make a property that can only be written to, not read from outside.

To make a write-only property, you provide only a 'set' accessor and no 'get'. For example: public class Secret { private string password; public string Password { set { password = value; } } } Here, outside code can set the password but cannot read it back.

Result

External code can assign a value but cannot see what it is.

Understanding write-only properties helps you hide sensitive data while still allowing updates.

5

Intermediate

Auto-Implemented Read-Only Properties

Concept: Introduce the simpler syntax for read-only properties using auto-implemented properties with init or no set.

C# lets you write read-only properties more simply: public class Person { public string Name { get; } public Person(string name) { Name = name; } } Here, 'Name' can be set only inside the constructor and read everywhere else.

Result

Cleaner code that still protects the property from outside changes.

Using auto-properties reduces boilerplate while keeping control over data access.

6

Advanced

Using Write-Only Properties in Practice

🤔Before reading on: do you think write-only properties are common in real-world code? Commit to your answer.

Concept: Explain when and why write-only properties are used, and their limitations.

Write-only properties are rare but useful for sensitive data like passwords. They prevent reading sensitive info but allow setting it. However, they can make debugging harder because you can't check the value directly. Example: public class User { private string password; public string Password { set { password = Hash(value); } } private string Hash(string input) { // hash logic here return "hashed" + input; } } Here, the password is hashed when set, and never exposed.

Result

Sensitive data is protected from exposure but can be updated securely.

Knowing the trade-offs of write-only properties helps you decide when to use them safely.

7

Expert

Immutable Objects with Read-Only Properties

🤔Before reading on: do you think read-only properties alone guarantee immutability? Commit to your answer.

Concept: Explore how read-only properties contribute to immutable objects and the deeper implications.

Read-only properties help create immutable objects whose state cannot change after creation. But immutability also depends on the data types used. For example, if a read-only property returns a reference type like a list, the list's contents can still change. Example: public class Order { public IReadOnlyList Items { get; } public Order(List items) { Items = items.AsReadOnly(); } } Here, the property is read-only, and the list is wrapped to prevent changes, achieving immutability.

Result

Objects become safer and easier to reason about in complex programs.

Understanding that read-only properties alone don't guarantee immutability prevents subtle bugs in data handling.

Under the Hood

At runtime, properties are compiled into special methods called getters and setters. A read-only property has only a getter method, so external code cannot call a setter to change the value. A write-only property has only a setter method, so external code cannot call a getter to read the value. The backing field storing the data is usually private and accessed only inside these methods.

Why designed this way?

C# was designed to encourage encapsulation and data safety. Properties provide a clean syntax that looks like fields but actually run code, allowing validation, logging, or protection. Separating get and set accessors lets developers finely control how data is exposed or hidden, improving security and maintainability.

┌───────────────┐
│   Property    │
├───────────────┤
│  get method   │◄───── External read calls
│  set method   │─────► External write calls
└───────────────┘
       │
       ▼
┌───────────────┐
│ Private Field │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can a read-only property be changed from outside the class? Commit to yes or no.

Common Belief: A read-only property means you can read and write it freely.

Reality: A read-only property only allows reading from outside; writing is blocked.

Why it matters: Assuming you can write to a read-only property leads to compile errors and confusion about data flow.

Quick: Does a write-only property let you read the value back? Commit to yes or no.

Common Belief: Write-only properties let you both write and read the value.

Reality: Write-only properties allow only writing; reading is not possible from outside.

Why it matters: Expecting to read a write-only property causes runtime confusion and debugging difficulty.

Quick: Does a read-only property guarantee the object is fully immutable? Commit to yes or no.

Common Belief: If a property is read-only, the object cannot change at all.

Reality: Read-only properties prevent changing the property itself but do not guarantee immutability if the property returns mutable objects.

Why it matters: Ignoring this can cause bugs where data changes unexpectedly despite read-only properties.

Quick: Are write-only properties commonly used in everyday programming? Commit to yes or no.

Common Belief: Write-only properties are common and used everywhere.

Reality: Write-only properties are rare and mostly used for sensitive data like passwords.

Why it matters: Misusing write-only properties can make code hard to maintain and debug.

Expert Zone

1

Read-only properties can be combined with 'init' accessors to allow setting only during object initialization, blending immutability with flexibility.

2

Write-only properties can hide sensitive data but complicate debugging and testing because the value cannot be inspected externally.

3

Backing fields for properties can be manually controlled or auto-generated, affecting how read-only or write-only behavior is implemented under the hood.

When NOT to use

Avoid write-only properties when you need to verify or debug data externally; use private setters or methods instead. For full immutability, combine read-only properties with immutable data types or readonly collections rather than relying on properties alone.

Production Patterns

In real-world systems, read-only properties are widely used to expose safe data views, while write-only properties appear mainly for sensitive inputs like passwords or tokens. Immutable objects with read-only properties improve thread safety and reduce bugs in concurrent applications.

Connections

Encapsulation

Read-only and write-only properties are practical tools to implement encapsulation.

Understanding these properties deepens your grasp of encapsulation, which is a core principle of object-oriented programming.

Immutable Data Structures

Read-only properties help create immutable objects by restricting data changes.

Knowing how properties control access helps you design safer, more predictable data structures.

Security Principles

Write-only properties relate to security by hiding sensitive information from exposure.

This connection shows how programming features support security best practices like data hiding and least privilege.

Common Pitfalls

#1 Trying to set a read-only property from outside the class.

Wrong approach:

account.Balance = 1000m; // Error: no setter available

Correct approach:

Use a method inside the class to update balance or set it in the constructor.

Root cause:

Misunderstanding that read-only means no external write access.

#2 Expecting to read a write-only property value.

Wrong approach:

string pwd = user.Password; // Error: no getter available

Correct approach:

Store the value internally and provide methods to verify or use it without exposing it.

Root cause:

Confusing write-only with normal read-write properties.

#3 Assuming read-only properties make objects fully immutable.

Wrong approach:

public List Items { get; } // but list can be modified externally

Correct approach:

Use IReadOnlyList or return copies to prevent external modification.

Root cause:

Not realizing that reference types can be changed even if the property is read-only.

Key Takeaways

Read-only properties allow external code to see data but not change it, protecting important values.

Write-only properties let external code set data but hide it from being read, useful for sensitive information.

Properties are compiled into getter and setter methods that control access at runtime.

Using read-only and write-only properties helps enforce encapsulation and improve program safety.

Understanding their limits, like immutability and debugging challenges, is key to using them effectively.

Practice

1.

Which statement correctly describes a read-only property in C#?

easy

A. It has only a set accessor and no get accessor.

B. It has only a get accessor and no set accessor.

C. It has both get and set accessors.

D. It has no accessors at all.

Solution

1. Step 1: Understand property accessors

   A property with only a get accessor allows reading but not writing.

2. Step 2: Identify read-only property

   Read-only properties have no set accessor, so they cannot be assigned a value.

3. Final Answer:

   It has only a get accessor and no set accessor. -> Option B

4. Quick Check:

   Read-only = get only [OK]

Hint: Read-only means only get accessor present [OK]

Common Mistakes:

• Confusing read-only with write-only properties
• Thinking both get and set are needed for read-only
• Assuming no accessors means read-only

2.

Which of the following is the correct syntax for a write-only property named Password in C#?

public string Password { ? }

easy

A. set { _password = value; }

B. get { return _password; }

C. get; set;

D. private get; public set;

Solution

1. Step 1: Identify write-only property syntax

   A write-only property has only a set accessor to allow writing but no reading.

2. Step 2: Match syntax to write-only

   set { _password = value; } shows only a set accessor with assignment, which is correct for write-only.

3. Final Answer:

   set { _password = value; } -> Option A

4. Quick Check:

   Write-only = set only [OK]

Hint: Write-only means only set accessor present [OK]

Common Mistakes:

• Using get accessor in write-only property
• Using both get and set for write-only
• Incorrect accessor visibility modifiers

3.

What will be the output of the following C# code?

class User {
    private string _name = "Alice";
    public string Name { get { return _name; } }
}

var user = new User();
Console.WriteLine(user.Name);

medium

A. Compilation error

B. null

C. Runtime error

D. Alice

Solution

1. Step 1: Analyze the property

   The Name property is read-only with a get accessor returning "Alice".

2. Step 2: Check output of Console.WriteLine

   Calling user.Name returns "Alice", so it prints "Alice".

3. Final Answer:

   Alice -> Option D

4. Quick Check:

   Read-only property returns stored value [OK]

Hint: Read-only property returns stored value when accessed [OK]

Common Mistakes:

• Expecting a compilation error due to missing set
• Thinking write-only properties can be read
• Confusing private field with property access

4.

Identify the error in this C# code snippet:

class Account {
    private string _pin;
    public string Pin {
        get { return _pin; }
        set { _pin = value; }
    }
}

var acc = new Account();
acc.Pin = "1234";
Console.WriteLine(acc.Pin);

The goal is to make Pin write-only.

medium

A. The private field _pin should be public.

B. The set accessor should return a value.

C. The property has both get and set accessors, so it is not write-only.

D. The property should be static.

Solution

1. Step 1: Check property accessors

   The property has both get and set accessors, allowing reading and writing.

2. Step 2: Understand write-only requirement

   Write-only properties must have only a set accessor and no get accessor.

3. Final Answer:

   The property has both get and set accessors, so it is not write-only. -> Option C

4. Quick Check:

   Write-only = set only, no get [OK]

Hint: Write-only means no get accessor allowed [OK]

Common Mistakes:

• Leaving both get and set for write-only
• Changing field visibility instead of property
• Expecting set to return a value

5.

You want to create a class Secret that stores a string value. The value should be settable but never readable from outside the class. Inside the class, you want to log the value whenever it is set. Which property implementation achieves this?

hard

A. public string Data { set { Console.WriteLine(value); _data = value; } }

B. public string Data { get { return _data; } private set { _data = value; } }

C. public string Data { get; set; }

D. public string Data { private get; set { Console.WriteLine(value); _data = value; } }

Solution

1. Step 1: Identify write-only property with logging

   The property must have only a set accessor to be write-only and log the value when set.

2. Step 2: Check each option

   public string Data { set { Console.WriteLine(value); _data = value; } } has only a set accessor that logs and assigns the value, matching requirements.

3. Final Answer:

   public string Data { set { Console.WriteLine(value); _data = value; } } -> Option A

4. Quick Check:

   Write-only with logging in set accessor [OK]

Hint: Write-only property has only set accessor with logging code [OK]

Common Mistakes:

• Adding get accessor making property readable
• Using private get instead of no get
• Not logging inside set accessor