Singleton Design Pattern in C# – Simple and Easy Explanation 🔒

Introduction

In many applications, we need only one object of a particular class. Creating multiple objects may lead to wrong results, wasted memory, or conflicts.

The Singleton Design Pattern solves this problem by ensuring that only one instance of a class exists during the application lifetime.

What Is the Singleton Pattern?

The Singleton pattern:

• Restricts object creation to one instance

• Provides a global access point

• Keeps the instance thread-safe

In simple words: Create once, use everywhere.

Real-Life Examples

Here are some practical use cases:

• Database Connection – Only one connection manager

• Logger Class – One logger writing logs

• Configuration Settings – Loaded once and reused

• Printer Spooler – One controller managing print jobs

In all these cases, creating multiple objects makes no sense.

Singleton Implementation in C#

Below is a simple, thread-safe Singleton implementation using basic C# concepts.

Singleton Class

namespace DesignPattern
{
    public sealed class SingleTonClass
    {
        private static readonly object _obj = new object();
        private static SingleTonClass _instance = null;

        private int _value = 0;

        private SingleTonClass()
        {
        }

        public static SingleTonClass GetInstance()
        {
            if (_instance == null)
            {
                lock (_obj)
                {
                    if (_instance == null)
                    {
                        _instance = new SingleTonClass();
                    }
                }
            }
            return _instance;
        }

        public void IncrementValue()
        {
            _value++;
        }

        public int GetValue()
        {
            return _value;
        }
    }
}

Code Explanation (Step by Step)

sealed class SingleTonClass

• Prevents inheritance

• Ensures no subclass can create another instance

private static SingleTonClass _instance

• Stores the single instance of the class

• Static ensures it belongs to the class, not objects

private static readonly object _obj

• Used for locking

• Prevents multiple threads from creating multiple instances

private SingleTonClass()

• Private constructor blocks object creation from outside

• Forces usage of GetInstance()

GetInstance() Method

• Acts as the global access point

• Creates the object only once

• Uses double-checked locking for performance and safety

_value as Instance Variable

• Belongs to the Singleton object, not the class

• Ensures shared state truly comes from one instance

Testing the Singleton

using System;

namespace DesignPattern
{
    public class Program
    {
        static void Main(string[] args)
        {
            var s1 = SingleTonClass.GetInstance();
            s1.IncrementValue();
            s1.IncrementValue();

            var s2 = SingleTonClass.GetInstance();
            s2.IncrementValue();
            s2.IncrementValue();

            Console.WriteLine(s2.GetValue()); // 4
            Console.WriteLine(s1.GetValue()); // 4

            if (s1 == s2)
            {
                Console.WriteLine("Both are same instance");
            }

            Console.WriteLine("Happy,Coding!");
        }
    }
}

Output Explanation

• s1 and s2 both point to the same instance

• _value is incremented four times in total

• Both GetValue() calls return 4

• Reference comparison confirms both variables refer to the same object

Why Both s1 and s2 Have the Same Value (4)

Although s1 and s2 look like different variables, they both reference the same Singleton instance.

Step-by-Step Value Flow

• s1.IncrementValue(); → _value = 1

• s1.IncrementValue(); → _value = 2

• s2.IncrementValue(); → _value = 3

• s2.IncrementValue(); → _value = 4

_value belongs to the single object. Any change through one reference is visible through the other.

That is why:

s1.GetValue(); // 4
s2.GetValue(); // 4

Why This Proves Singleton Works

• Only one object is created

• State (_value) is shared

• Thread-safe creation

• Controlled access

Advantages

• Ensures single instance

• Saves memory

• Maintains consistent state

• Easy global access

Disadvantages

• Global state can be misused

• Harder to unit test

• Should not be overused

When to Use Singleton?

Use it when:

• Exactly one object is required

• Shared data must remain consistent

• Object creation is expensive

Avoid it when:

• Multiple independent instances are needed

Conclusion

The Singleton Design Pattern is a fundamental and widely used pattern in C#. This simple implementation clearly shows how one instance maintains shared state across the application.

Understanding this pattern builds a strong foundation for writing clean, efficient, and maintainable code.

Happy Coding!