2. Singleton单件（创建型模式）

模式分类
从目的来看：
– 创建型（Creational）模式：负责对象创建。
– 结构型（Structural）模式：处理类与对象间的组合。
– 行为型（Behavioral）模式：类与对象交互中的职责分配。
从范围来看：
– 类模式处理类与子类的静态关系。
– 对象模式处理对象间的动态关系。

动机（Motivation）
在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、
以及良好的效率。
如何绕过常规的构造器，提供一种机制来保证一个类只有
一个实例？
这应该是类设计者的责任，而不是使用者的责任。

意图（Intent）
保证一个类仅有一个实例，并提供一个该实例的全局访问点。——《设计模式》GoF

结构（Structure）

 

单线程Singleton 模式实现

/// <summary>
/// 单线程Singleton模式
/// </summary>
public class Class1
{
     private static Class1 c1;
     private Class1()  {}

  public static Class1 C1
  {
      get
      {
          if (c1 == null)
          {
              c1 = new Class1();
          }
          return c1;
      }
  }
}

单线程Singleton模式的几个要点

1. Singleton模式中的实例构造器可以设置为protected以允许子类派生。
2. Singleton模式一般不要支持ICloneable接口，因为这可能会导致多个对象实例，与Singleton模式的初衷违背。
3. Singleton模式一般不要支持序列化，因为这也有可能导致多个对象实例，同样与Singleton模式的初衷违背。
4. Singletom模式只考虑到了对象创建的管理，没有考虑对象销毁的管理。就支持垃圾回收的平台和对象的开销来讲，我们一般没有必要对其销毁进行特殊的管理。
5. 不能应对多线程环境：在多线程环境下，使用Singleton模式仍然有可能得到Singleton类的多个实例对象。

多线程Singleton 模式实现

/// <summary>
/// 多线程Singleton模式,方法1
/// </summary>
public class Class2
{
    public static readonly Class2 C2 = new Class2();
    private Class2(){}
}

/// <summary>
//多线程Singleton模式,方法1,相当于这样
/// </summary>
public class Class3
{
    public static Class3 c3;
    static Class3()
    {
        c3 = new Class3();
    }

    private Class3(){}
}

/// <summary>
/// 多线程Singleton模式,方法2
/// </summary>
public class Class4
{
    private static volatile Class4 c4 = null;

    private static object lockHelper = new object();

    private Class4() { }

    public static Class4 C4()
    {
        if (c4 == null)
        {
            lock (lockHelper)
            {
                if (c4 == null)
                {
                    c4 = new Class4();
                }
            }
        }
        return c4;
    }
}

 

 

 单,多线程Singleton模式.构造函数带参数

/// <summary>
/// 单线程Singleton模式,构造函数带参数
/// </summary>
public class Class5
{
    int _x, _y;
    private static Class5 c5;
    private Class5(int x, int y)
    {
        this._x = x;
        this._y = y;
    }

    public static Class5 getClass5(int x, int y)
    {
        if (c5 == null)
        {
            c5 = new Class5(x, y);
        }
        else
        {
            c5._x = x;
            c5._y = y;
        }
        return c5;
    }
}

/// <summary>
/// 多线程Singleton模式,方法2,构造函数带参数
/// </summary>
public class Class6
{
    private static volatile Class6 c6 = null;

    private static object lockHelper = new object();

    int _x, _y;

    private Class6(int x, int y)
    {
        this._x = x;
        this._y = y;
    }

    public static Class6 C6(int x, int y)
    {
        if (c6 == null)
        {
            lock (lockHelper)
            {
                if (c6 == null)
                {
                    c6 = new Class6(x, y);
                }
            }
        }
        else
        {
            c6._x = x;
            c6._y = y;
        }
        return c6;
    }
}

/// <summary>
/// 多线程Singleton模式,方法1,构造函数带参数.
/// </summary>
public class Class7
{
    public static readonly Class7 c7 = new Class7();
    int _x, _y;

    private Class7()
    {
    }

    public void Init(int x, int y)
    {
        this._x = x;
        this._y = y;
    }

    //或者
    public int x
    {
        get
        {
            return this._x;
        }
        set
        {
            this._x = value;
        }
    }

    public int y
    {
        get
        {
            return this._y;
        }
        set
        {
            this._y = value;
        }
    }

}

 

 

 测试代码:

    private void button1_Click(object sender, System.EventArgs e)
    {
        Class1 c1 = Class1.C1;
        Class2 c2 = Class2.C2;
        Class3 c3 = Class3.c3;
        Class4 c4 = Class4.C4();
        Class5 c5 = Class5.getClass5(3, 4);
        Class6 c6 = Class6.C6(3, 4);

        Class7 c7 = Class7.c7;
        c7.Init(3, 4);
        c7.x = 3;
        c7.y = 4;

        Class1 cc1 = Class1.C1;
        Class2 cc2 = Class2.C2;
        Class3 cc3 = Class3.c3;
        Class4 cc4 = Class4.C4();
        Class5 cc5 = Class5.getClass5(3, 4);
        Class6 cc6 = Class6.C6(3, 4);

        Class7 cc7 = Class7.c7;
        cc7.Init(3, 4);
        cc7.x = 9;
        cc7.y = 10;

        if (c1 == cc1 && c2 == cc2 && c3 == cc3 && c4 == cc4
         && c5 == cc5 && c6 == cc6 && c7 == cc7)
        {
            MessageBox.Show("Yes");
        }
        else
        {
            MessageBox.Show("No");
        }

        MessageBox.Show(c7.x.ToString());
        MessageBox.Show(cc7.x.ToString());

    }