一、单件模式

本文试图描述单件模式在C#中的实际用法。由于理解上的偏差，在此仅描述我的观点，以及分析。
前几天写的该问有错误遗漏的地方，在此感谢指正。2006年6月15日

一、单件模式的意图
保证一个类仅有一个实例，并提供一个访问它的全局访问点。

我对这句话的理解是该类只能被实例化一次，然后提供一个全局的访问，在以后若干次的访问中，所有的访问都是访问 该全局的访问，而不再次进行实例化。

前段时间我把这个观点发上来以后，很多人都建议我去看看其他人写的设计模式(在此对这些温和的批评表示感谢，也坚定我更深入研究的决心)。争议主要是类是否只能实例化一次。因为单件模式的意图中从来没有说明单件模式是否只能实例化一次，而且我在很多设计模式的文章中都没有看到这些字眼。但是经过我仔细分析了很多实例，我认为实现单件模式，实际上也就是如何保证需要使用单件模式的类在生命周期内只实例化一次。

二、单件模式的主要示例
我将会使用到2书上和网上都有流行的例子。

示例一：
第一个实例就用我看的书《C#设计模式》中的第一个例子。

using  System;

namespace  GlobalSpooler
{
    /**//// <summary>
    /// Summary description for Spooler.
    /// </summary>
    public class Spooler     {
        private static bool instance_flag= false;
        private Spooler()  {
        }
        public static Spooler getSpooler() {
            if (! instance_flag) 
                return new Spooler ();
            else
                return null;
        }

    }
}

using  System;

namespace  GlobalSpooler
{
    /**//// <summary>
    /// Summary description for Class1.
    /// </summary>
    class GlobSpooler
    {
        static void Main(string[] args)         {
            Spooler sp1 = Spooler.getSpooler();
            if (sp1 != null)
                Console.WriteLine ("Got 1 spooler");
            Spooler sp2 = Spooler.getSpooler ();
            if (sp2 == null)
                Console.WriteLine ("Can\'t get spooler");


            //fails at compile time
            Spooler sp3 = new Spooler ();
        }
    }
}

这个是书上的实例。分析下程序是如何执行的：
1、调用程序入口点Main
2、调用Spooler类的静态方法Spooler.getSpooler();
3、因为instance_flag = false ,所以 返回 new Spooler (); ——实际上就是 Spooler sp1 = new Spooler ();
4、输出部分(在这里是用于调试)。这里输出了Got 1 spooler
5、  Spooler sp2 = Spooler.getSpooler ();的时候通过分析可以看出Spooler sp2 = new Spooler (); 这一事实。先放一边。
6、由于sp2!=null，因此没有输出。
7、Spooler 的构造函数是private,所以prooler sp3 = new Spooler ();产生错误。

实际上这个例子是和我的论点相冲突的。因为这个例子里类被实例化了2次。为了验证，我给程序加上了
if(sp1==sp2)
          Console.WriteLine ("They are same");
else
          Console.WriteLine ("They are not same");
判断以后发现sp1和sp2并不相等！所以书上的例子是错的！
要使sp1==sp2,那么sp1和sp2应该是同一个对象，而不应该实例化2次。

如果对程序进行修改，那么可以修改成

using  System;

namespace  GlobalSpooler
{
    /**//// <summary>
    /// Summary description for Spooler.
    /// </summary>
    public class Spooler     {
        private static Spooler MySpooler ;
        private static bool instance_flag= false;
        private Spooler()  {
            instance_flag = true;
        }
        public static Spooler getSpooler() {
            if (! instance_flag) 
                MySpooler = new Spooler ();
             return MySpooler;
        }

    }
}

添加了全局访问对象MySpooler ，构造函数中添加了instance_flag=true; 虽然MySpooler 是私有的，但是访问过程中：instance_flag为false的时候MySpooler 成为类Spooler的实例，在以后的访问中将仅仅使用该实例而不再次实例化。看看示例二就是这样的。

示例二：

 1 public   sealed   class  Spooler 
 2 {
 3    static Spooler instance=null;
 4
 5    private Spooler()
 6    {
 7    }
 8
 9    public static Spooler Instance
10    {
11        get
12        {
13            if (instance==null)
14            {
15                instance = new Spooler();
16            }
17            return instance;
18        }
19    }
20}

这个例子就比较清晰了，可以看出程序怎么执行只实例化一次该类，以后一直返回私有静态字段instance。
由于网上关于单件模式多线程的例子讲了很多，这里就不再敷述。
三、单件模式的特点
我觉得到现在再来讨论单件模式的特点才更加深刻。

单例类只能有一个实例。

单例类必须自己创建自己的唯一实例。

单例类必须给所有其它对象提供这一实例。

以上特点摘自  吕震宇 老师的 C#设计模式（7）－Singleton Pattern

单例类只能有一个实例——虽然没有说到类只能实例化一次，但是我认为在一个生命周期内是只能实例化一次的。
单例类必须自己创建自己的唯一实例——意思和上句差不多，只是只能由自己创建。
单例类必须给所有其它对象提供这一实例——这就不多解释了。

我以前就是忽略了第二条，呵呵。这里讲下为什么需要自己创建自己的实例。我是这么理解的：如果不是由自己创建自己的实例，那么创建实例的方法是对外开放的，不遵守开发—关闭原则。至于为什么要有这个原则？答案是——这是大家在设计过程中的经验。当然你不遵守这个原则也能写出程序，但是你假设使用单件模式，你在类外部实例化类，那么你要随时注意该类在其它地方不能实例化，而且在实例化的地方使用的代码只执行一次实例化。

四、C#中的单件模式
以下摘自 吕震宇 老师的 C#设计模式（7）－Singleton Pattern 以便保持本文的完整。

C#的独特语言特性决定了C#拥有实现Singleton模式的独特方法。这里不再赘述原因，给出几个结果：

方法一：

下面是利用.NET Framework平台优势实现Singleton模式的代码：

sealed   class  Singleton
{
   private Singleton();
   public static readonly Singleton Instance=new Singleton();
}

这使得代码减少了许多，同时也解决了线程问题带来的性能上损失。那么它又是怎样工作的呢？

注意到，Singleton类被声明为sealed，以此保证它自己不会被继承，其次没有了Instance的方法，将原来_instance成员变量变成public readonly，并在声明时被初始化。通过这些改变，我们确实得到了Singleton的模式，原因是在JIT的处理过程中，如果类中的static属性被任何方法使用时，.NET Framework将对这个属性进行初始化，于是在初始化Instance属性的同时Singleton类实例得以创建和装载。而私有的构造函数和readonly(只读)保证了Singleton不会被再次实例化，这正是Singleton设计模式的意图。
（摘自：http://www.cnblogs.com/huqingyu/archive/2004/07/09/22721.aspx ）

不过这也带来了一些问题，比如无法继承，实例在程序一运行就被初始化，无法实现延迟初始化等。

详细情况可以参考微软MSDN文章：《Exploring the Singleton Design Pattern》

方法二：

既然方法一存在问题，我们还有其它办法。

public   sealed   class  Singleton
{
  Singleton()
  {
  }

  public static Singleton GetInstance()
  {
    return Nested.instance;
  }
    
  class Nested
  {
    // Explicit static constructor to tell C# compiler
    // not to mark type as beforefieldinit
    static Nested()
    {
    }

    internal static readonly Singleton instance = new Singleton();
  }
}

这实现了延迟初始化，并具有很多优势，当然也存在一些缺点。详细内容请访问：《Implementing the Singleton Pattern in C#》。文章包含五种Singleton实现，就模式、线程、效率、延迟初始化等很多方面进行了详细论述。