C#面向对象设计模式纵横谈二之Singleton单件（建立型模式）

模式分类：

从目的来看：

1）建立型（Creational）模式；负责对象建立

2）结构型（Structural）模式；处理类与对象间的组合

3）行为型（Behavioral）模式；类与对象交互中的职责分配

从范围来看：

1）类模式处理类与子类的静态关系

2）对象模式处理对象间的动态关系

 

动机（Motivation）：

在软件系统中，常常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率。

如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？

 

这应该是类设计者的责任，而不是使用者的责任。

 

意图（Intent）：

保证一个类仅有一个实例，并提供一个该实例的全局访问点。

 

单线程单件模式代码示例：

///   <summary>
     ///  单线程单例模式示例
     ///   </summary>
     public  class Singleton
    {
         ///   <summary>
         ///  静态的对象实例
         ///   </summary>
         private  static Singleton instance;
        
         ///   <summary>
         ///  私有的构造函数
         ///   </summary>
         private Singleton()
        {
        
        }
        
         ///   <summary>
         ///  获取对象实例的惟一入口
         ///   </summary>
         public  static Singleton GetInstance            
        {
             get
            {
                 if( null == instance)
                    instance =  new Singleton();
                
                 return instance;
            }
        }
    }

 

单线程Singleton模式的几个要点：

1）Singleton模式中的实例构造器能够设置为Protected以容许子类派生。

2）Singleton模式通常不要支持ICloneable接口，由于这可能会致使多个对象实例，与Singleton模式的初衷违背。

3）Singleton模式通常不支持序列化，由于这也有可能致使多个对象实例，一样与Singleton模式的初衷违背。

4）Singleton模式只考虑到了对象建立的管理，没有考虑对象销毁的管理。就支持垃圾回收的平台和对象的开销来说，咱们通常没有必要对其销毁进行特殊的管理。

5）不能就对多线程环境：在多线程环境下，使用Singleton模式依然有可能获得Singleton类的多个实例对象。

 

///   <summary>
     ///  多线程饿汉式单例模式示例
     ///   </summary>
     public  class Singleton
    {
         ///   <summary>
         ///  静态的对象实例，在类声明时就对该对象进行实例化
         ///   </summary>
         private  static  readonly Singleton instance =  new Singleton();
        
         ///   <summary>
         ///  私有的构造函数
         ///   </summary>
         private Singleton()
        {
        
        }
        
         ///   <summary>
         ///  获取对象实例的惟一入口
         ///   </summary>
         public  static Singleton GetInstance            
        {
             get
            {
                 lock(instance)
                {
                     return instance;
                }
            }
        }
    }

 

///   <summary>
     ///  多线程懒汉式单例模式示例
     ///   </summary>
     public  class Singleton
    {
         ///   <summary>
         ///  静态的对象实例
         ///   </summary>
         private  static  volatile Singleton instance;
            
         ///   <summary>
         ///  同步锁
         ///   </summary>
         private  static  object lockObject =  new  object();
        
         ///   <summary>
         ///  私有的构造函数
         ///   </summary>
         private Singleton()
        {
        
        }
        
         ///   <summary>
         ///  获取对象实例的惟一入口
         ///   </summary>
         public  static Singleton GetInstance            
        {
             get
            {
                 if( null == instance)
                {
                     lock(instance)
                    {
                         if( null == instance)
                        {
                            instance =  new Singleton();
                        }
                    }
                }
                
                 return instance;
            }
        }
    }

 

///   <summary>
     ///  多线程饿汉式单例模式示例（简）
     ///   </summary>
     public  class Singleton
    {        
         public  static  readonly Singleton instance =  new Singleton();
        
         private Singleton()
        {
        
        }
    }

 

Singleton模式扩展：

1）将一个实例扩展到N个实例，例如对象池的实现。

2）将new构造器的调用转移到其余类中，例如多个类协同工做环境中，某个局部环境只须要拥有某个类的一个实例。

3）理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的实例构造器的任意调用”。