Singleton Pattern

The Singleton pattern is a creational design pattern that ensures that a class has only one instance and provides a global point of access to that instance. 

In other words, it restricts the instantiation of a class to a single object. The Singleton pattern is often used in situations where you need to ensure that there is only one instance of a class and that it can be easily accessed throughout your application. 

Examples of situations where Singleton pattern can be used 

     When you need to access a shared resource, such as a database connection or a configuration file. When you want to limit the number of instances of a class that can be created, such as in a game where you only want one instance of a player character. 

     To implement the Singleton pattern, you typically define a class with a private constructor, a static method that returns the single instance of the class, and a static variable that holds that instance.

   public sealed class Singleton
{
    private static Singleton instance = null;
    private static readonly object lockObject = new object();
    
    private Singleton()
    {
        // private constructor
    }
    
    public static Singleton Instance
    {
        get
        {
            lock (lockObject)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}

Feature

Feature	Description
Type	Creational design pattern
Purpose	Ensures that only one instance of a class is created
Scope	Global
Implementation	Private constructor, static variable, static method
Access	Single point of access to the instance
Concurrency	Thread-safe using locking or other synchronization mechanisms
Testing	Can be difficult to test due to global state and tight coupling
Use cases	Shared resources, limited instances, configuration objects, caching, logging, etc.