Mastering the Singleton Design Pattern in C#

1. Eager Initialization Singleton

Creates the Singleton instance at class loading time, regardless of whether it's used.

public sealed class Singleton
{
    private static readonly Singleton _instance = new Singleton();
    public static Singleton Instance => _instance;
    private Singleton() { }
}

• Pros : Simple , Thread-safe by CLR (static initialization is atomic)
• Cons : No lazy loading, Instance created even if never used
• Use When : Instance is lightweight, Always needed (e.g., config manager)

2. Basic Implementation | Lazy Initialization (Not Thread-Safe)

Instance is created only when requested for the first time - but no locking is used.

public class Singleton
{
    private static Singleton _instance;
    private Singleton() { }
    public static Singleton GetInstance()
    {
        if (_instance == null)
        {
            _instance = new Singleton();
        }
        return _instance;
    }
}

⚠️ Not safe for multi-threaded environments. Two threads can create two instances.

• Pros : Lazy loaded, Simple for single-threaded use
• Cons : Not thread-safe, Breaks in multi-threaded apps
• Use When : In simple CLI tools, scripts or prototypes

3. Thread-Safe Singleton (With Lock)

Ensures thread safety by using lock during initialization.

public class Singleton
{
    private static Singleton _instance;
    private static readonly object _lock = new object();
    private Singleton() { }
    public static Singleton GetInstance()
    {
        lock (_lock)
        {
            if (_instance == null)
            {
                _instance = new Singleton();
            }
        }
        return _instance;
    }
}

✅ Prevents multiple threads from creating multiple instances.

• Pros : Thread-safe, Lazy loaded
• Cons : Slightly slower due to locking every time
• Use When : Performance is not critical, but thread safety is required

4. Double-Checked Locking Singleton

Double-Checked Locking is a pattern used to reduce the overhead of acquiring a lock by first testing the locking criterion without actually acquiring the lock. Only if the check indicates that locking is required, the lock is acquired and then checked again. This is used to avoid the performance cost of locking every time the instance is accessed.

public sealed class Singleton
{
    private static Singleton _instance = null;
    private static readonly object _lock = new object();
    private Singleton() { }
    public static Singleton GetInstance()
    {
        if (_instance == null) // 1st check (no lock)
        {
            lock (_lock)       // Lock only if instance is null
            {
                if (_instance == null) // 2nd check (inside lock)
                {
                    _instance = new Singleton();
                }
            }
        }
        return _instance;
    }
}

• 1st Check: Improves performance — avoids lock overhead after the instance is created
• 2nd Check: Ensures that only one thread creates the instance, even if multiple threads pass the first check
• Pros : Thread-safe, Locking happens only once
• Cons : More complex and error-prone
• Use When : High-performance multithreading and manual control needed

5. Singleton Using Lazy<T> (Best in C#)

Uses System.Lazy<T> which handles lazy loading + thread-safety internally.

public sealed class Singleton
{
    private static readonly Lazy<Singleton> _lazy =
        new Lazy<Singleton>(() => new Singleton());
    public static Singleton Instance => _lazy.Value;
    private Singleton() { }
}

• Pros : Thread-safe, Lazy initialized, Minimal and modern
• Cons: Slight learning curve for Lazy<T>
• Use When: in modern .NET applications — this is the preferred pattern

6. Static Constructor Singleton

Uses a static constructor to create the instance.

public sealed class Singleton
{
    public static readonly Singleton Instance;
    static Singleton()
    {
        Instance = new Singleton();
    }
    private Singleton() { }
}

• Pros : Thread-safe (CLR guarantees static constructor runs once), Clean, minimal
• Cons: Not lazy (static constructor runs at first type access)
• Use When: You want thread-safety without Lazy<T> and don’t care about laziness

7. Singleton via Dependency Injection (DI Managed)

Register the class as a Singleton in your IoC container (e.g., ASP.NET Core).

// Startup.cs or Program.cs
services.AddSingleton<ILogger, Logger>();

• Pros : Fully testable, Easy to mock/replace in unit tests, Promotes good design (no global state)
• Cons : Not a "true pattern" - DI container controls lifecycle, Requires IoC setup
• Use When : In ASP.NET Core, Blazor, WPF, MAUI etc.