How to Implement Thread-Safe Singleton Design Pattern with Lazy

So, we don’t need to write complex thread-safe code.

Implementing Thread-Safe Singleton Using Lazy

Here is the best and clean approach:

public sealed class Singleton
{
    private static readonly Lazy<Singleton> _instance =
        new Lazy<Singleton>(() => new Singleton());

    private Singleton() { }

    public static Singleton Instance => _instance.Value;
}

Explanation (Step-by-Step)

Let’s understand this code:

1. Lazy holds the instance

2. The lambda () => new Singleton() defines how to create it

3. Object is NOT created immediately

4. It is created only when Instance is accessed

5. Lazy ensures thread safety automatically

This makes the code simple, clean, and efficient.

Why Use Sealed Class?

public sealed class Singleton

Reason:

• Prevents inheritance

• Ensures no other class can extend and break Singleton behavior

Benefits of Using Lazy Singleton

• Thread-safe by default

• Lazy initialization (better performance)

• No need for manual locks

• Cleaner and more readable code

Real-World Example

Let’s create a Logger using Singleton:

public sealed class Logger
{
    private static readonly Lazy<Logger> _instance =
        new Lazy<Logger>(() => new Logger());

    private Logger() { }

    public static Logger Instance => _instance.Value;

    public void Log(string message)
    {
        Console.WriteLine($"Log: {message}");
    }
}

Usage:

Logger.Instance.Log("Application started");
Logger.Instance.Log("User logged in");

No matter how many times you call Instance, only one Logger object is created.

Common Mistakes Developers Make

Not Making Constructor Private

If constructor is public:

var obj = new Singleton();

❌ Breaks Singleton

Always make constructor private.

Not Using Lazy Initialization

Creating instance at startup wastes memory if not used.

Lazy solves this problem.

Overusing Singleton

Singleton should not be used everywhere.

Use it only when:

• You truly need a single shared instance

• Global access is required

Overuse can lead to tight coupling.

Ignoring Thread Safety

In multi-threaded apps, ignoring thread safety can cause bugs that are hard to debug.

Always prefer Lazy or other safe approaches.

When to Use Singleton Pattern

Use Singleton when:

• You need a single shared resource

• Configuration should be consistent

• Logging should be centralized

Avoid when:

• You need multiple instances

• Testing becomes difficult

Summary

The Singleton Design Pattern ensures that only one instance of a class exists. However, in multi-threaded applications, making it thread-safe is crucial. Using Lazy in C# is the best and simplest way to implement a thread-safe Singleton. It provides built-in thread safety, lazy initialization, and cleaner code without using locks. By understanding this approach, developers can build efficient, scalable, and reliable .NET applications.