// It applies only to single-threaded
public sealed class Singleton1
{
private Singleton1()
{
}
private static Singleton1 instance = null;
public static Singleton1 Instance
{
get
{
if(null == instance)
instance = new Singleton1();
return instance;
}
}
}
// It can be used for multi-threaded
public sealed class Singleton2
{
private Singleton2()
{
}
private static readonly object syncObj = new object();
private static Singleton2 instance = null;
public static Singleton2 Instance
{
get
{
lock(syncObj)// This step spent a lot of time
{
if(null == instance)
instance = new Singleton2();
}
return instance;
}
}
}
// The better way than the second method
public sealed class Singleton3
{
private Singleton3()
{
}
private static readonly object syncObj = new object();
private static Singleton3 instance = null;
public static Singleton3 Instance
{
get
{
if(null == instance)
{
lock(syncObj)// This step spent a lot of time
{
if(null == instance)
instance = new Singleton3();
}
}
return instance;
}
}
}
// The C# language way
public sealed class Singleton4
{
private Singleton4()
{
}
private static Singleton4 instance = new Singleton4();
public static Singleton4 Instance
{
get
{
return instance;
}
}
}
//The C# language way 2
public sealed class Singleton5
{
Singleton5()
{
}
public static Singleton5 Instance
{
get{
return Nested.instance;
}
}
class Nested{
static Nested(){}
internal static readonly Singleton5 instance = new Singleton5();
}
}