| |
The Singleton design pattern is defined in the book, . This book provides implementations in C++ and Smalltalk, and this tutorial provides the code to do it in C#.
Singleton Pattern Definition
The Singleton pattern ensures that a class only has one instance and provides a global point of access to it from a well-known access point. The class implemented using this pattern is responsible for keeping track of its sole instance rather than relying on global variables to single instances of objects.
Often, this pattern is used to represent parts of the system that there can only be one of, like the file system or window manager. Or, parts of your application that there will only ever be one of.
Singleton Pattern Code
The following is the code for the implementation of the Singleton pattern:
namespace DesignPatterns
{
public sealed class Singleton
{
private static readonly Singleton instance = new Singleton();
private Singleton()
{
}
public static Singleton Instance
{
get
{
return instance;
}
}
}
}
using System.Diagnostics;
using DesignPatterns;
Trace.WriteLine(Singleton.Instance.ToString());
|
Singleton Code Explained
First, you'll notice that the Singleton's constructor is set to private. This ensures that no other code in your application will be able to create an instance of this class. This enforces the requirement that there ever only be one instance of this class.
Then, an instance member variable is defined of the same type as the class. This instance member is used to hold the only instance of our class. The variable is static so that it is defined only once. In the .NET Framework, static variables are defined at a point before their first use (that's the actual description of their implementation). Also, the instance variable is readonly so that it cannot be modified - not even by any code that you may write in the class's implementation.
And, a public Instance property is defined with only a get method that way callers can access the instance of this class without ever being able to change it. The property is also static to provide global access from anywhere in your program. This ensures the global point of access requirement for the Singleton.
Finally, to test the code, you can run code that accesses your Singleton class. As you can see above, it's easy enough to get at the instance of your class:
Place a breakpoint in instance member variable definition and another one in the Instance property get code, then run the Debugger on this code. You will notice that the member variable creation is hit just before the call to the Instance property. Also, if you place multiple calls to Singleton.Instance, you will notice that the instance member variable is only the first time, all other calls just return the cached instance variable.
And, that is the only way to get an instance of a singleton class. If you try to create an instance of the Singleton class using the new operator:
Singleton NewInstance = new Singleton();
|
Than, you will get a compiler error stating that the class cannot be created because the constructor is inaccessible due to its protection level.
Thread-Safe Singleton Code
The previous code is the simplest implementation of a Singleton and can be used for most purposes. Typical WinForms applications are typically running in the UI thread, so the simple singleton will provide you with the functionality that you're looking for. However, if you are creating a multi-threaded application that needs to access a singleton across all of its threads, then you will need to create a thread-safe singleton class instead. What you gain in functionality comes at the cost of some performance, so you shouldn't use this form of the class unless you actually intend to use the class from multiple threads.
Here is the code for the thread-safe Singleton:
namespace DesignPatterns
{
public sealed class MTSingleton
{
private static volatile MTSingleton instance = null;
private static object syncRoot = new object();
private MTSingleton()
{
}
public static MTSingleton Instance
{
get
{
if (instance == null)
{
lock(syncRoot)
{
if (instance == null)
instance = new MTSingleton();
}
}
return instance;
}
}
}
}
using System.Diagnostics;
using DesignPatterns;
Trace.WriteLine(MTSingleton.Instance.ToString());
|
As you can see, this class is similar in structure to the Singleton class. The instance member variable is no longer set at creation time, but in the Instance property instead. The instance variable is declared to be volatile in order to assure that the assignment of instance complete before the instance can be accessed.
The syncRoot object is used to lock on. The lock ensures that only one thread can access the instance creation code at once. That way, you won't get into a situation where two different threads are trying to create the singleton simultaneously.
And, you'll notice that we double-check the existence of the instance variable within the locked code to be sure that exactly one instance is ever created.
Finally, in your application code, access to the MTSingleton class is done in exactly the same way as with the simple singleton.
Conclusion
The Singleton design pattern has proven to be a useful pattern in many programs that I've written. Now, the code in this tutorial shows how to implement that same pattern in the .NET Framework.
|
|