Singleton pattern im C#

Hello, C# lovers! 👋

In this post, I’m going to talk about one of the most popular and useful design patterns in C#: the Singleton pattern. 🌟

The Singleton pattern is a way to ensure that only one instance of a class exists in the program and that it can be accessed globally by other classes. This can be useful when you need to share some state or resources across the application, such as a database connection, a configuration file, a logger, etc. 😎

But how do we implement the Singleton pattern in C#? There are many ways to do it, but they all follow some common guidelines:

  • The class constructor should be private and parameterless, so that it cannot be instantiated from outside the class.
  • The class should be sealed, so that it cannot be inherited by other classes.
  • The class should have a private static field that holds the reference to the single instance of the class.
  • The class should have a public static property or method that returns the single instance of the class. This property or method should check if the instance is already created or not, and create it if needed.

Sounds simple, right? Let’s see some examples of how to implement the Singleton pattern in C# using different approaches. 🚀

No Thread-Safe Singleton

This is the simplest way to implement the Singleton pattern, but it is not thread-safe. That means that if multiple threads try to access the instance at the same time, they might end up creating more than one instance, which violates the Singleton principle. 😱

Here is how it looks like:


public sealed class Singleton1
{
    private Singleton1() {} // private constructor
    
    private static Singleton1 instance = null; // private static field
    
    public static Singleton1 Instance // public static property
    {
        get
        {
            if (instance == null) // check if instance is created
            {
                instance = new Singleton1(); // create instance if not
            }
            return instance; // return instance
        }
    }
}


To use this Singleton class, you can simply call Singleton1.Instance from anywhere in your code. For example:


Singleton1 s1 = Singleton1.Instance; // get singleton instance
Singleton1 s2 = Singleton1.Instance; // get singleton instance again
Console.WriteLine(s1 == s2); // true - same instance

Thread-Safe Singleton using Lock

This is a more robust way to implement the Singleton pattern, which ensures thread-safety using a lock statement. This statement prevents multiple threads from entering a critical section of code at the same time, so that only one thread can create the instance. 🔒

Here is how it looks like:


public sealed class Singleton2
{
    private Singleton2() {} // private constructor
    
    private static readonly object padlock = new object(); // lock object
    
    private static Singleton2 instance = null; // private static field
    
    public static Singleton2 Instance // public static property
    {
        get
        {
            lock (padlock) // lock critical section
            {
                if (instance == null) // check if instance is created
                {
                    instance = new Singleton2(); // create instance if not
                }
                return instance; // return instance
            }
        }
    }
}


To use this Singleton class, you can also call Singleton2.Instance from anywhere in your code. For example:


Singleton2 s1 = Singleton2.Instance; // get singleton instance
Singleton2 s2 = Singleton2.Instance; // get singleton instance again
Console.WriteLine(s1 == s2); // true - same instance

The downside of this approach is that it has some performance overhead, since every time you access the instance, you need to acquire and release the lock. 😕

Thread-Safe Singleton using Double-Check Locking

This is a variation of the previous approach, which uses a technique called double-check locking. This technique reduces the performance overhead by checking if the instance is created before acquiring the lock, and then checking again inside the lock. This way, only the first time you access the instance, you need to acquire and release the lock. 🙌

Here is how it looks like:


public sealed class Singleton3
{
    private Singleton3() {} // private constructor
    
    private static readonly object padlock = new object(); // lock object
    
    private static Singleton3 instance = null; // private static field
    
    public static Singleton3 Instance // public static property
    {
        get
        {
            if (instance == null) // check if instance is created (first check)
            {
                lock (padlock) // lock critical section
                {
                    if (instance == null) // check if instance is created (second check)
                    {
                        instance = new Singleton3(); // create instance if not
                    }
                }
            }
            return instance; // return instance
        }
    }
}


To use this Singleton class, you can also call Singleton3.Instance from anywhere in your code. For example:


Singleton3 s1 = Singleton3.Instance; // get singleton instance
Singleton3 s2 = Singleton3.Instance; // get singleton instance again
Console.WriteLine(s1 == s2); // true - same instance

The downside of this approach is that it is not fully reliable in some versions of .NET, due to some memory model issues. 😬

Thread-Safe Singleton without a Lock

This is another way to implement the Singleton pattern, which does not use a lock at all. Instead, it relies on the static constructor of the class, which is guaranteed to be called only once and before any other members of the class are accessed. This way, the instance is created eagerly when the class is loaded, and no synchronization is needed. 🙃

Here is how it looks like:


public sealed class Singleton4
{
    private static readonly Singleton4 instance = new Singleton4(); // private static field initialized eagerly
    
    static Singleton4() {} // static constructor
    
    private Singleton4() {} // private constructor
    
    public static Singleton4 Instance // public static property
    {
        get
        {
            return instance; // return instance
        }
    }
}


To use this Singleton class, you can also call Singleton4.Instance from anywhere in your code. For example:


Singleton4 s1 = Singleton4.Instance; // get singleton instance
Singleton4 s2 = Singleton4.Instance; // get singleton instance again
Console.WriteLine(s1 == s2); // true - same instance

The downside of this approach is that it does not support lazy initialization, which means that the instance is created even if you never use it. 😮

Thread-Safe Singleton using Lazy<T>

This is the most elegant and recommended way to implement the Singleton pattern in C#, using the Lazy<T> class. This class provides a simple and efficient way to create and access a lazy-initialized object, which means that the object is created only when you first access it. The Lazy<T> class also takes care of thread-safety and memory barriers for you, so you don’t need to worry about them. 😍

Here is how it looks like:


public sealed class Singleton5
{
    private static readonly Lazy<Singleton5> lazy = new Lazy<Singleton5>(() => new Singleton5()); // private static field initialized lazily
    
    private Singleton5() {} // private constructor
    
    public static Singleton5 Instance // public static property
    {
        get
        {
            return lazy.Value; // return lazy-initialized value
        }
    }
}


To use this Singleton class, you can also call Singleton5.Instance from anywhere in your code. For example:


Singleton5 s1 = Singleton5.Instance; // get singleton instance
Singleton5 s2 = Singleton5.Instance; // get singleton instance again
Console.WriteLine(s1 == s2); // true - same instance

This approach has no major drawbacks, and it supports both eager and lazy initialization, depending on how you configure the Lazy<T> object. 😊

Conclusion

In this post, we learned what the Singleton pattern is, what are its advantages and disadvantages, and how to implement it in C# using different approaches. We also saw some examples of how to use the Singleton pattern in our code. 🎉

I hope you enjoyed this post and learned something new. If you have any questions or feedback, please leave a comment below. And don’t forget to share this post with your friends and colleagues who might be interested in learning more about C# design patterns. 🙏

Thanks for reading and happy coding! 😄


You can find the code examples here: source code


References

Comments

Post a Comment

Popular posts from this blog

Which GOF patterns are good for C#?

Hello, C# fans! 😊 In this article, I will answer a common question that many C# developers have: which GOF patterns are good for C#? 🤔 GOF patterns are the 23 design patterns that were described in the book “ Design Patterns: Elements of Reusable Object-Oriented Software ” by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. They are also known as the Gang of Four (GoF) patterns. They are divided into three categories: creational, structural, and behavioral. 📚 These patterns provide solutions to common software design problems that you may encounter in your projects. They help you write code that is more reusable, flexible, maintainable, and elegant. 😍 But not all GOF patterns are equally useful or applicable in C#. Some of them are more relevant and popular than others. Some are already supported by the language features or the .NET framework. Some of them may be outdated or replaced by newer patterns. 😮 So, which GOF patterns are good for C#?  Creational patterns...
Read more

Angular on a regular SharePoint page (part 2)

Image
In my  previous article , we have added an empty angular element to the SharePoint page.  And now we are ready to move forward and add some functionality to our elements. Before we begin      First of all, let's create in SharePoint Announcements list with the name "Announcements" and add a couple of items with some text. We will access data in our list via the SharePoint REST API, calling "/_api/web/lists/getbytitle('Announcements')/Items" endpoint. Angular project      Now, open the angular elements project which we have created in the previous article in VS Code.      For convenience let's create an interface to work with our data model. Create the "data" folder wonder the "src/app" and create a new file named Announcement.ts.      Add this code to it: export interface Announcement { ID : number ; Title : string ; Body : string ; }      We will use the service to get the data from our list. ...
Read more

Chain of Responsibility pattern in C#

Hello, C# lovers! 😍 Today I want to talk about a very useful design pattern called Chain of Responsibility. This pattern allows you to pass a request along a chain of handlers until one of them can handle it. This way, you can avoid coupling the sender of the request with the receiver, and you can dynamically compose the chain at runtime. Sounds cool, right? 😎 Let’s see an example of how to implement this pattern in C#. Suppose you have a simple ATM machine that can dispense bills of 10, 20, and 50 dollars. You want to write a program that can handle any amount of money requested by the user, using the least number of bills possible. To do this, you can create an abstract class called Handler that defines an interface for handling the requests. It also has a reference to the next handler in the chain, and a method to set it. // The 'Handler' abstract class public abstract class Handler { protected Handler successor; public void SetSuccessor ( Handler successo...
Read more