Topic 18418 min readStructured Tutorial

Singleton Pattern in C#

Quick Answer

The Singleton pattern ensures a class has only one instance and provides a global point of access to it. In C#, it is commonly implemented using a private constructor, a static readonly instance, and thread-safe initialization to control object creation.

Learning Objectives

Explain the purpose of Singleton Pattern in a practical learning context.
Identify the main ideas, terms, and decisions involved in Singleton Pattern.
Apply Singleton Pattern in a simple real-world scenario or practice task.

Introduction

Design patterns provide reusable solutions to common software design problems. The Singleton pattern is one of the simplest and most widely used patterns.

In C#, the Singleton pattern restricts a class to a single instance and provides a global access point to that instance.

Ensure a class has only one instance, and provide a global point of access to it.

What is the Singleton Pattern?

The Singleton pattern is a creational design pattern that ensures a class has only one instance throughout the application's lifecycle.

It provides a controlled way to access this instance globally, preventing multiple instantiations that could lead to inconsistent behavior.

Restricts instantiation of a class to one object.
Provides a global access point to that instance.
Useful for managing shared resources like configuration settings or logging.

Implementing Singleton Pattern in C#

There are several ways to implement the Singleton pattern in C#. The most common approach uses a private constructor and a static readonly instance.

Thread safety is important to ensure that multiple threads do not create multiple instances simultaneously.

Private constructor prevents external instantiation.
Static readonly field holds the single instance.
Static constructor or lazy initialization ensures thread safety.

Basic Singleton Implementation

This implementation uses a static readonly field initialized at runtime, which is thread-safe in C#.

Thread-Safe Singleton with Lazy<T>

Using the Lazy<T> type provides lazy initialization and thread safety without explicit locks.

Lazy initialization delays instance creation until it is first accessed.
Built-in thread safety ensures only one instance is created.

When to Use the Singleton Pattern

Singletons are ideal when exactly one object is needed to coordinate actions across the system.

Common use cases include logging, configuration management, caching, and thread pools.

Managing shared resources.
Controlling access to hardware or external devices.
Centralizing configuration or state information.

Practical Example

This example shows a thread-safe Singleton using a static readonly instance and a private constructor.

This example uses Lazy<T> to ensure thread-safe lazy initialization of the Singleton instance.

Examples

Basic Singleton Implementation in C#

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

    private Singleton() { }

    public static Singleton Instance {
        get {
            return instance;
        }
    }

    public void DoAction() {
        Console.WriteLine("Singleton instance method called.");
    }
}

This example shows a thread-safe Singleton using a static readonly instance and a private constructor.

Thread-Safe Singleton Using Lazy<T>

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

    private Singleton() { }

    public static Singleton Instance {
        get {
            return lazyInstance.Value;
        }
    }

    public void DoAction() {
        Console.WriteLine("Lazy Singleton instance method called.");
    }
}

This example uses Lazy<T> to ensure thread-safe lazy initialization of the Singleton instance.

Best Practices

Use a private constructor to prevent external instantiation.
Implement thread safety to avoid multiple instances in multithreaded environments.
Consider using Lazy<T> for simpler and efficient lazy initialization.
Seal the Singleton class to prevent inheritance which can break the pattern.
Avoid using Singletons for objects that require frequent state changes or multiple instances.

Common Mistakes

Not making the constructor private, allowing multiple instances.
Ignoring thread safety, leading to multiple instances in concurrent scenarios.
Using Singletons for classes that do not require a single instance.
Overusing Singletons, which can lead to tight coupling and testing difficulties.

Hands-on Exercise

Implement a Logger Singleton

Create a thread-safe Singleton Logger class in C# that writes messages to the console.

Expected output: A Singleton Logger instance that outputs log messages to the console.

Hint: Use a private constructor and Lazy<T> for thread safety.

Modify Singleton to Support Reset

Extend the Singleton class to allow resetting the instance for testing purposes.

Expected output: A Singleton class that can reset its instance without breaking thread safety.

Hint: Consider adding a method to clear or recreate the instance carefully.

Interview Questions

What is the Singleton pattern and why is it used?

Interview

The Singleton pattern ensures a class has only one instance and provides a global point of access to it. It is used to manage shared resources or coordinate actions across the system.

How do you implement a thread-safe Singleton in C#?

Interview

You can implement a thread-safe Singleton using a static readonly instance initialized at runtime or by using Lazy<T> for lazy and thread-safe initialization.

What are the drawbacks of using the Singleton pattern?

Interview

Singletons can lead to tight coupling, make unit testing difficult, and may introduce global state that complicates program behavior.