Singleton Design Pattern Example in C#

Singleton design pattern is a creational design pattern that provides the mechanism to create only one instance of a class throughout the application's lifetime. This pattern ensures that only one instance of the object is created and serves the requests of multiple clients. This pattern is commonly used in the software industry for services such as logging, configuration management, and database connections.

Real-world Example

Let's take a real-world example to understand the singleton design pattern. In a company, there is only one CEO. The CEO is responsible for making all the major decisions and manages the company's operations. Similarly, in a software application, there are some classes that need to be created only once and used multiple times throughout the application's lifecycle.

public sealed class CEO
{
    private static CEO instance = null;
    private static readonly object padlock = new object();

    private CEO()
    {
        // Private constructor to prevent creating an instance of this class from outside of this class.
    }

    public static CEO Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance == null)
                {
                    instance = new CEO();
                }
                return instance;
            }
        }
    }

    public void MakeMajorDecision()
    {
        // Implementation of making major decisions for the company.
    }
}

In the above example, we have created a CEO class that has a private constructor, which does not allow the creation of the class from outside of this class. We have a public static property named Instance that creates an instance of CEO class if it is null or returns the already created instance of CEO class.

The singleton design pattern is achieved using the lock keyword and padlock object to make sure that only one thread can access the code inside the lock block at a time. The implementation of the MakeMajorDecision method can be used to make major decisions for the company.

Conclusion

The singleton design pattern is an essential pattern in modern software development. It helps in creating a single instance of a class throughout the application's lifetime and prevents multiple instances of the same class, which can cause memory leaks and other issues. The real-world example of the CEO of a company helps to understand the concept of singleton design pattern easily.