Jin on Code

Introduction

I still remember a particular interview where immutable objects were asked.

My first impression when it comes to immutability is the string data type in C# as an example (for general concept).

However, I did feel that they wanted to hear the design pattern (implementation).

So, for me, it is unclear whether they pertain to the immutable object design pattern or not.

That’s why in this post, we’ll try to explore this immutable object design pattern, what it is, its characteristics, where it is useful, and provide a code sample.

So, let’s get started.

What is an Immutable Object?

An immutable object is an object whose state cannot change after it is created, both internally and externally.

Once initialized, its fields and properties remain the same throughout its lifetime.

If you need to modify it, create a new object rather than updating the existing one.

Characteristics of an Immutable Object

Here are some of the characteristics that make immutable objects unmodifiable.

First, no setters, developers don’t allow properties to be reassigned after construction.

Second, read-only fields, meaning making private members read-only fields that can only be set during declaration inside the constructor.

Third, when a new object is updated, any change created creates a fresh object instead of modifying the original object.

A good everyday example is the string type in C#.

Let’s try to see an example.

string name = "Jin";
name = name.ToUpper(); 
// Original "Jin" is not modified — a new string "JIN" is created.

Where Immutable Objects Are Useful?

Let’s try to see where immutable objects are perfectly fit.

Singleton Objects

It is because singleton objects are often used for shared static data, and this shared static data does not change, making it immutable, which guarantees safety in concurrent access.

Configuration Data

Application settings loaded from a configuration file (app.config or web.config). Once loaded, configuration values should not be changed during runtime.

Thus, representing them as immutable objects ensures consistency.

Immutable Object Example

using System;

var c1 = new CountryConfig("$", "USA");
Console.WriteLine(c1.Currency); // $
Console.WriteLine(c1.Region); // USA
//Here, c1 stays unchanged — the essence of immutability.

public class CountryConfig
{
    private readonly string _currency;
    private readonly string _region;

    public string Currency { get { return this._currency; } }
    public string Region { get { return this._region; } }

    public CountryConfig(string currency, string region)
    {
        this._currency = currency;
        this._region = region;

    }
}

Benefits of Immutable Object

First, the thing is “easier reasoning” that you don’t have to track changes over time.

Second, cache-friendliness is safe to reuse without worrying about corruption.

Last, I think it is thread safe, so no locks are needed since the state can’t change.

Summary

Hopefully, in this brief post, we have explored what an immutable object is, its characteristics, its applications, and the benefits it offers.

For our takeaway, Immutable objects are objects whose state can’t change once created, like a string in C#. We can do this by removing setters, using readonly fields, and providing methods that create new instances instead of modifying existing ones.

Once again, I hope you have enjoyed this article/tutorial as I have enjoyed writing it.

Stay tuned for more (keep visiting our blog and share this with your friends, colleagues, and network).

Until next time, happy programming!

Please don’t forget to bookmark, like, and comment. Cheers! And thank you!