单例模式的C#实现

class SingletonPattern
{
public sealed class Singleton1
{
private static readonly Singleton1 instance = new Singleton1();
static Singleton1() { }
private Singleton1() { }
public static Singleton1 Instance
{
get
{
return instance;
}
}
//测试方法
public void Hello() { Console.WriteLine("Hello1"); }
}
public sealed class Singleton2
{
private static readonly Singleton2 instance = null;
static Singleton2()
{
instance = new Singleton2();//静态初始化，不同于Singleton1
}
private Singleton2() { }
public static Singleton2 Instance
{
get
{
return instance;
}
}
//测试方法
public void Hello() { Console.WriteLine("Hello2"); }
}
public sealed class Singleton3
{
private static readonly Lazy<Singleton3> lazy = new Lazy<Singleton3>(() => new Singleton3());
public static Singleton3 Instance
{
get
{
return lazy.Value;
}
}
private Singleton3() { }
//测试方法
public void Hello() { Console.WriteLine("Hello3"); }
}
/// <summary>
/// 最简单的单例，但线程不安全，对于单线程已然满足
/// </summary>
public sealed class Singleton4
{
private static Singleton4 instance = null;
private Singleton4() { }
public static Singleton4 Instance
{
get
{
if (instance == null)
{
instance = new Singleton4();
}
return instance;
}
}
//测试方法
public void Hello() { Console.WriteLine("Hello4"); }
}
/// <summary>
/// 一重加锁，增加开销，保证线程安全
/// </summary>
public sealed class Singleton5
{
private static Singleton5 instance = null;
private static readonly object padlock = new object();
private Singleton5() { }
public static Singleton5 Instance
{
get
{
lock (padlock)
{
if (instance == null)
{
instance = new Singleton5();
}
return instance;
}
}
}
//测试方法
public void Hello() { Console.WriteLine("Hello5"); }
}
/// <summary>
/// 两重加锁，减少一重加锁的性能消耗，线程安全
/// </summary>
public sealed class Singleton6
{
private static Singleton6 instance = null;
private static readonly object padlock = new object();
private Singleton6() { }
public static Singleton6 Instance
{
get
{
if (instance == null)
{
lock (padlock)
{
if (instance == null)
{
instance = new Singleton6();
}
}
}
return instance;
}
}
//测试方法
public void Hello() { Console.WriteLine("Hello6"); }
}
public sealed class Singleton7
{
private Singleton7() { }
public static Singleton7 Instance
{
get
{
return Nested.instance;
}
}
private class Nested//通过内嵌的私有类做延时初始化
{
static Nested() { }
private Nested() { }
internal static readonly Singleton7 instance = new Singleton7();
}
//测试方法
public void Hello() { Console.WriteLine("Hello7"); }
}
public sealed class Singleton8
{
private Singleton8() { }
public static Singleton8 Instance
{
get
{
return Nested.instance;
}
}
private class Nested
{
internal static readonly Singleton8 instance = null;
static Nested()
{
instance = new Singleton8();//都是延时初始化，但不同于Singleton7的是静态初始化，类似Singleton1和Singleton2的区别
}
private Nested() { }
}
//测试方法
public void Hello() { Console.WriteLine("Hello8"); }
}
//对于使用Unity的朋友Singleton4够了
}