The singleton is one of the most used and well know design patterns in programming. The idea of a singleton is to have a class which can only be instantiated once. These are very useful for state objects and global resource objects. I will go over several different ways to create singletons and also how to create a generic singleton class.
There are several different places you find information on singletons and creating them for all different languages. One great resources is the Gang of Four book, Design Patterns: Elements of Reusable Object-Oriented Software.
One of the main concerns when using/creating singletons is multi threaded applications/environments. The issue occurs when two threads decided to get an instance of a never made singleton then they have the chance of creating two instances. All the solutions I will present are thread safe.
The first solution presented is a singleton class that you would template your classes after. It creates the singleton instance at the beginning of the start of the application, which makes the class thread safe. As you can notice below the class has a private constructor so the class can't be created outside the class. A static private variable to hold our single instance of our class is included along with a method that returns the instance.
{
private static Singleton1 instance = new Singleton1();
private Singleton1(){}
public static Singleton1 GetInstance()
{
return instance;
}
}
Now to create an instance of this class all we need to do is:
The second solution uses lazy instantiation, which means that the class is not created until it is needed. This is good if your class is only used on rare occasions and has a decent memory footprint. You will notice in the code below we again have the static private variable but this time it is not set to a new instance. And we have the same empty private constructor and the getInstance method. But this time you see a little more code in the method.
The first thing you will see is a lock command with the parameter typeof(Singleton2). This is locking the code in this block for one thread at a time. And the next item is an if statement to see if we have created an instance yet. If the instance is null we will create one. And finally we just return the instance. Now to get an instance we use the same technique as above.
{
private static Singleton2 instance;
private Singleton2() { }
public static Singleton2 GetInstance()
{
lock (typeof(Singleton2))
{
if (instance == null)
{
instance = new Singleton2();
}
return instance;
}
}
}
The last singleton implementation I am going to go over is a generic singleton. This implementation is very similar to the last except that it now uses generics syntax to create a singleton of any class. This does not however prevent the class T from being created by itself. So this implementation has the benefit of being used as is but has the downfall of not being able to force strict control over the singleton.
{
private static T instance;
public static T GetInstance()
{
lock (typeof(T))
{
if (instance == null)
{
instance = new T();
}
return instance;
}
}
}
To use this you simply would use a piece of code like below, assuming you have the class AutoFactory defined. AutoFactory's constructor would also not be able to take parameters in this implementation.
This should give a decent understanding of the singleton pattern and how to implement it using C#. Please post any questions in the comments.
09/22/2007 - 12:52
You can use the following
readonlykeyword to implement Singleton pattern in .NET{
private static readonly Singleton1 instance = new Singleton1();
private Singleton1(){}
public static Singleton1 GetInstance()
{
return instance;
}
}
12/23/2007 - 08:32
I would prefer something like
...
}
So you know what's Singleton and you could more easy get it via
ChoordServer = ChoordServer.GetSingleton();12/23/2007 - 08:33
Sorry I meant
...
}
12/23/2007 - 08:34
Why is he cutting the template parameter? Must be ChoordServer as singleton parameter
06/06/2008 - 04:57
singleton is best explained here..good work ..keep it up !
09/01/2008 - 06:57
using System.Runtime.InteropServices;
using mscoree;
namespace Framework.Patterns
{
public class CrossAppDomainSingleton :
MarshalByRefObject where T : new()
{
private static readonly string m_AppDomainName =
"AppDomain.Singletons";
private static T m_Instance;
public static T Instance
{
get
{
if (m_Instance == null)
{
AppDomain appDomain = GetAppDomain(m_AppDomainName);
if (null == appDomain)
{
appDomain = AppDomain.CreateDomain(m_AppDomainName);
}
Type type = typeof(T);
T instance = (T)appDomain.GetData(type.FullName);
if (instance == null)
{
instance = (T)appDomain.CreateInstanceAndUnwrap(
type.Assembly.FullName, type.FullName);
appDomain.SetData(type.FullName, instance);
}
m_Instance = instance;
}
return m_Instance;
}
}
private static AppDomain GetAppDomain(string pFriendlyName)
{
IntPtr p_Handle = IntPtr.Zero;
CorRuntimeHostClass runtime = new CorRuntimeHostClass();
try
{
runtime.EnumDomains(out p_Handle);
do
{
object domain = null;
runtime.NextDomain(p_Handle, out domain);
if (domain == null)
{
break;
}
AppDomain appDomain = (AppDomain)domain;
if (appDomain.FriendlyName.Equals(pFriendlyName))
{
return appDomain;
}
}while (true);
}
finally
{
runtime.CloseEnum(p_Handle);
Marshal.ReleaseComObject(runtime);
runtime = null;
}
return null;
}
}
}
12/18/2008 - 09:32
This page is one of top pages in Google on C# singletons. It helped me greatly. All I needed is to get my memory refreshed. Thank you very much.
George
01/01/2009 - 01:05
this is vry infomative article but shuld hv more explore
12/05/2009 - 09:20
Good introduction to the pattern. The line:
Singleton1 single = Singleton1.getInstance();
should read
Singleton1 single = Singleton1.GetInstance();
Mark