Implementing Thread Safe Singleton Pattern in C#

Singleton (Thread Safe)

private static readonly Lazy<DbConnectionThreadSafe> _instance = null!;

Using Lazy<T> Because

• Thread safe by default


• Provides lazy initialization
  

static DbConnectionThreadSafe()

{

    _instance = new Lazy<DbConnectionThreadSafe>(

        () => new DbConnectionThreadSafe(_connectionString),

        LazyThreadSafetyMode.ExecutionAndPublication

    );

}

Let's break down this static constructor and the Lazy initialization:

static DbConnection()  // This is a static constructor

{

    _lazyInstance = new Lazy<DbConnection>(

        () => new DbConnection(_connectionString),  // Lambda expression

        LazyThreadSafetyMode.ExecutionAndPublication  // Thread safety mode

    );

}

Let's examine each part:

1. 
   

   Static Constructor (static DbConnection())

   
   
   
   
   
   • A static constructor is called automatically before any static members are referenced
   
   
   • It runs only once per app domain
   
   
   • It's thread-safe by default (CLR guarantees this)
   
   
   • Used to initialize static fields
   
   
   
   


2. 
   

   Lazy

   
   
   
   
   
   • 
     Lazy<T> is a class that provides lazy initialization
   
   
   • The actual object isn't created until it's first accessed
   
   
   • When you access Lazy<T>.Value for the first time, it creates the instance
   
   
   
   


3. 
   

   Lambda Expression (() => new DbConnection(_connectionString))

   
   
   
   
   
   • This is a factory function that creates the DbConnection instance
   
   
   • It's only executed when the Lazy.Value is first accessed
   
   
   • The => syntax defines a lambda expression (anonymous function)
   
   
   
   


4. 
   

   LazyThreadSafetyMode.ExecutionAndPublication

   
   
   
   
   
   • This enum value specifies how the Lazy instance handles thread safety
   
   
   • Three possible modes:
     
   
   
   
   

// No thread safety

LazyThreadSafetyMode.None



// Locks initialization

LazyThreadSafetyMode.ExecutionAndPublication



// Multiple threads can attempt initialization

LazyThreadSafetyMode.PublicationOnly

The execution flow:

1. When the class is first referenced, the static constructor runs


2. The _lazyInstance is created, but the DbConnection instance is not yet created


3. When Instance is first accessed:
   
   
   
   
   • The lambda expression runs
   
   
   • Creates new DbConnection with the connection string
   
   
   • Stores it in the Lazy instance
   
   
   
   


4. Subsequent accesses to Instance return the same stored instance