Immutability in C#: Understanding and Implementing Immutable Objects

Learn about immutability in C# and its benefits for creating robust and thread-safe code. This guide explores how to design and implement immutable objects, including practical examples and best practices.

Immutability in C#

Immutability is a design principle that states the state of an object cannot be altered after it has been created. While it may seem like a simple concept, it has profound implications for how developers design their codebase. This tutorial explores immutability in C#, its benefits, and how to implement it effectively.

What is Immutability?

Immutability refers to the inability of an object to be modified after it is created. Once a value has been set, it cannot be changed. In C#, immutable objects are commonly used in multi-threaded applications as they don’t require synchronization. This helps avoid issues like race conditions or data corruption in concurrent environments.

In simple terms, an immutable object’s state remains constant throughout its lifecycle. For example, the string type in C# is immutable—modifying a string creates a new instance rather than changing the original one.

Immutability in C#

While immutability is a common principle across many languages, C# has specific features built-in to make the process easier. The string type is one of the most popular examples of immutability in C#. Once a string instance is created, its value cannot be changed.

How to Create an Immutable Class in C#

To create an immutable class in C#, follow these steps:

1. Make all fields read-only using the readonly keyword.
2. Use the sealed keyword to prevent inheritance and modification of the class’s state.
3. Ensure that no mutable objects are exposed within the class by wrapping mutable references in immutable types or marking them as volatile.

Example: Immutable Class in C#

Here’s an example of an immutable class in C#:

public class Customer
{
    public Guid Id { get; init; }
    public string LastName { get; }
    public string FirstName { get; }

    public Customer(string firstName, string lastName)
    {
        Id = Guid.NewGuid();
        FirstName = firstName;
        LastName = lastName;
    }
}
      

Output

// No output, as this example only defines the class.
      

This class ensures that its properties cannot be changed after creation. The use of the init keyword for the properties ensures that they can only be set during object initialization.

Example: Immutable Class with Read-Only Fields

Another approach is to use read-only fields in an immutable class:

public class Customer
{
    public readonly Guid Id;
    public readonly string FirstName;
    public readonly string LastName;

    public Customer(string firstName, string lastName)
    {
        Id = Guid.NewGuid();
        FirstName = firstName;
        LastName = lastName;
    }
}
    

Output

 // No output, as this example only defines the class.
    

In this example, the readonly keyword ensures that the fields are initialized only within the constructor and cannot be changed later.

Immutability and Record Types in C#

Record types in C# are immutable by default. Once you create an instance of a record type, its properties cannot be modified. This makes record types ideal for transferring data within applications as they guarantee data consistency.

public record Customer
{
    public Guid Id { get; init; } = Guid.NewGuid();
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
    

Output

 // No output, as this example only defines the record.
    

The init keyword allows you to set the values of properties at the time of object creation but prevents further modification.

Immutability and Data Transfer Objects (DTOs)

Immutable objects are ideal for creating Data Transfer Objects (DTOs). A DTO is a type used to transfer data between parts of an application. Because DTOs are immutable, once an object is created, it cannot be modified, ensuring that data remains consistent throughout the application.

Using immutable types for DTOs prevents concurrency issues and stale data, making them a robust choice for managing data in large-scale applications.