1.单件模式(Singleton Pattern)

意图：为了保证一个类仅有一个实例，并提供一个访问它的全局访问点。

1.简单实现(多线程有可能产生多个实例)

    public class CommonSigleton
    {
        /// <summary>
        /// 私有的对象
        /// </summary>
        private static CommonSigleton instance;

        /// <summary>
        /// 构造方法为Private
        /// </summary>
        private CommonSigleton()
        {

        }

        /// <summary>
        /// 公有的属性
        /// </summary>
        public static CommonSigleton Instance
        {
            get
            {
                if(instance == null)
                {
                    instance = new CommonSigleton();
                }

                return instance;
            }
        }
    }

2．双重锁定实现(lock关键字)

    public class DoubLockSigleton
    {
        private static volatile DoubLockSigleton instance;

        /// <summary>
        /// 辅助锁对象，本身没有意义
        /// </summary>
        private static object syncRoot = new Object();

        /// <summary>
        /// 构造方法改为Private
        /// </summary>
        private DoubLockSigleton()
        {

        }

        public static DoubLockSigleton Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (syncRoot)
                    {
                        if (instance == null)
                            instance = new DoubLockSigleton();
                    }
                }

                return instance;
            }
        }
    }

3.利用C#特性实现

    ///该类标记sealed阻止发生派生增加实例
    public sealed class DotNetSigleton
    {
        //变量标记为 readonly，这意味着只能在静态初始化期间（此处显示的示例）或在类构造函数中分配变量。
        //公共静态属性为访问实例提供了一个全局访问点。此外，由于构造函数是私有的，因此不能在类本身以外实例化
        private static readonly DotNetSigleton instance = new DotNetSigleton();

        //由于 Singleton 实例被私有静态成员变量引用，因此在类首次被对Instance属性的调用所引用之前，不会发生实例化。
        private DotNetSigleton(){}

        public static DotNetSigleton Instance
        {
            get
            {
                return instance;
            }
        }
    }