C# - Singleton Design Pattern with Lazy Initialization

The Singleton design pattern ensures that a class has only one instance and provides a global access point to that instance. In C#, you can implement a Singleton pattern using lazy initialization for efficient resource usage. Here's an example of how to do it:

using System; public class Singleton { private static readonly Lazy<Singleton> instance = new Lazy<Singleton>(() => new Singleton()); // Private constructor to prevent instantiation from other classes. private Singleton() { Console.WriteLine("Singleton instance created."); } // Public static method to access the Singleton instance. public static Singleton Instance => instance.Value; public void SomeMethod() { Console.WriteLine("Singleton method called."); } } class Program { static void Main() { // Access the Singleton instance Singleton singleton1 = Singleton.Instance; Singleton singleton2 = Singleton.Instance; // Verify that both instances are the same Console.WriteLine($"singleton1 == singleton2: {singleton1 == singleton2}"); // Use the Singleton singleton1.SomeMethod(); } } 

In this example:

1. We define a Singleton class with a private constructor, preventing direct instantiation from other classes.

2. We use Lazy<T> to ensure lazy initialization of the Singleton instance. This means that the instance is created only when it is first accessed, improving performance and resource usage.

3. The Instance property provides a static way to access the Singleton instance.

4. In the Main method, we demonstrate that two calls to Singleton.Instance result in the same instance being returned, confirming that it's indeed a Singleton.

Implementing the Singleton pattern with lazy initialization ensures thread safety, minimizes resource usage, and provides a single point of access to a shared instance, making it a valuable design pattern in many scenarios, such as managing application configuration, logging, and caching.