设计模式-单例模式_.NET_编程开发_程序员俱乐部

1、什么是单例模式                                                                                                                                                                             

单例模式（Singleton）：一个类仅有一个实例，并提供一个访问它的全局访问点。

2、特点                                                                                                                                                                                                                

（1）有一个私有的无参构造函数，这可以防止其他类实例化它，而且单例类也不应该被继承，如果单例类允许继承那么每个子类都可以创建实例，这就违背了

       Singleton模式“唯一   实例”的初衷。

（2）单例类被定义为sealed,就像前面提到的该类不应该被继承，所以为了保险起见可以把该类定义成不允许派生，但没有要求一定要这样定义。

（3）一个静态的变量用来保存单实例的引用。

（4）一个公有的静态方法用来获取单实例的引用，如果实例为null即创建一个。

3、经典单例模式                                                                                                                                                                                                                   

//类被sealed修饰保证了没有派生类
    public sealed class Singleton
    {
        //使用静态变量保存单例实例的引用，可以使用static修饰
        private static Singleton _instance = null;
        //私有构造函数-
        private Singleton()
        {
        }
        //公有静态方法来获取单利
        public static Singleton Instance
        {
            get
            {
                return _instance ?? (_instance = new Singleton());
            }
        }
    }

线程安全的单利模式

public sealed class SingletonSafety
    {
        private static SingletonSafety _instance = null;
        private static readonly object obj = new object();
        public static SingletonSafety Instance
        {
            get
            {
                lock (obj)
                {
                    return _instance ?? (_instance = new SingletonSafety());
                }
            }
        }
    }

变化版

public sealed class SingleDoubleSafe
    {
        public static SingleDoubleSafe _single = null;
        public static readonly object obj = new object();
        private SingleDoubleSafe() { }
        public static SingleDoubleSafe Single
        {
            get
            {
                if (_single == null)
                {
                    lock (obj)
                    {
                        _single = new SingleDoubleSafe();
                    }
                }
                return _single;
            }
        }
    }

4、简单实例                                                                                                                                                                                                                               

 class SingletonTest
    {
        private static SingletonTest _instance;
        public static SingletonTest Instance()
        {
            if (_instance == null)
            {
                _instance = new SingletonTest();
            }
            return _instance;
        }
        protected SingletonTest() { }
        private int x = 0;
        public void SetX(int newVal)
        {
            x = newVal;
        }
        public int GetX()
        {
            return x;
        }
    }
    class Program
    {
        static void Main( string[] args )
        {
            int n;
            SingletonTest firstSingle = SingletonTest.Instance();
            SingletonTest secondSingle = SingletonTest.Instance();
            Console.WriteLine( "使用第一个实例对象去设置x的值：x=2" );
            firstSingle.SetX(2);
            n = secondSingle.GetX();
            Console.WriteLine("使用第二个实例对象去获取x的值："+n);            
            Console.ReadKey();
        }
    }

5、总结：                                                                                                                                                                                         

单例模式的优点：

单例模式（Singleton）会控制其实例对象的数量，从而确保访问对象的唯一性。

（1）实例控制：单例模式防止其它对象对自己的实例化，确保所有的对象都访问一个实例。

（2）伸缩性：因为由类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。

单例模式的缺点：

（1）系统开销。虽然这个系统开销看起来很小，但是每次引用这个类实例的时候都要进行实例是否存在的检查。这个问题可以通过静态实例来解决。

（2）开发混淆。当使用一个单例模式的对象的时候（特别是定义在类库中的），开发人员必须要记住不能使用new关键字来实例化对象。因为开发者看不到在类库中的源代码，所以当他们发现不能实例化一个类的时候会很惊讶。

（3）对象生命周期。单例模式没有提出对象的销毁。在提供内存管理的开发语言（比如，基于.NetFramework的语言）中，只有单例模式对象自己才能将对象实例销毁，因为只有它拥有对实例的引用。在各种开发语言中，比如C++，其它类可以销毁对象实例，但是这么做将导致单例类内部的指针指向不明。

单例适用性：

使用Singleton模式有一个必要条件：在一个系统要求一个类只有一个实例时才应当使用单例模式。反之，如果一个类可以有几个实例共存，就不要使用单例模式。

参考文章：http://csharpindepth.com/Articles/General/Singleton.aspx