单例的各种方式实现，本写法以类A为例，泛型可以使用T

#region 单例的各种方式实现，本写法以类A为例，泛型可以使用T

    public class A
    {
        #region 单线程----常规，多线程不安全
        ///// <summary>
        ///// 私有构造函数，防止初始化
        ///// </summary>
        //private A()
        //{

        //}

        ///// <summary>
        ///// 私有变量，延迟加载
        ///// </summary>
        //private static A linjieInstance = null;

        ///// <summary>
        ///// 公开实例，供外界使用
        ///// </summary>
        //public static A LinjieInstance
        //{
        //    get
        //    {
        //        if (linjieInstance == null)
        //        {
        //            linjieInstance = new A();

        //        }
        //        return linjieInstance;
        //    }
        //}
        #endregion

        #region 单线程----常规，多线程不安全---饿汉模式
        ///// <summary>
        ///// 私有构造函数，防止初始化
        ///// </summary>
        //private A()
        //{

        //}

        ///// <summary>
        ///// 私有变量，延迟加载
        ///// </summary>
        //private static readonly A linjieInstance = new A();

        ///// <summary>
        ///// 公开实例，供外界使用
        ///// </summary>
        //public static A LinjieInstance => linjieInstance;
        ////public static A LinjieInstance
        ////{
        ////    get
        ////    {
        ////        return linjieInstance;
        ////    }
        ////}
        #endregion

        #region 单线程----常规，多线程不安全---饥(饿)汉模式
        ///// <summary>
        ///// 私有构造函数，防止初始化
        ///// </summary>
        //private A()
        //{

        //}

        ///// <summary>
        ///// 私有变量，延迟加载
        ///// </summary>
        //private static readonly A linjieInstance = new A();

        ///// <summary>
        ///// 公开实例，供外界使用
        ///// </summary>
        //public static A LinjieInstance => linjieInstance;
        ////public static A LinjieInstance
        ////{
        ////    get
        ////    {
        ////        return linjieInstance;
        ////    }
        ////}
        #endregion

        #region 单线程----常规，多线程安全---饱(懒)汉模式---并发字典
        ///// <summary>
        ///// 私有构造函数，防止初始化
        ///// </summary>
        //private A()
        //{

        //}

        ///// <summary>
        ///// 私有变量，延迟加载
        ///// </summary>
        //private static readonly A linjieInstance = null;

        //private static readonly ConcurrentDictionary<int, A> keyValuePairs = new ConcurrentDictionary<int, A>();

        ///// <summary>
        ///// 公开实例，供外界使用
        ///// </summary>
        ////public static A LinjieInstance => keyValuePairs.GetOrAdd(0, new A()); 
        //public static A LinjieInstance
        //{
        //    get
        //    {
        //        return keyValuePairs.GetOrAdd(0, new A());
        //    }
        //}
        #endregion

        #region 单线程----常规，多线程安全---饱(懒)汉模式---Lazy<A>
        ///// <summary>
        ///// 私有构造函数，防止初始化
        ///// </summary>
        //private A()
        //{

        //}

        ///// <summary>
        ///// 私有变量，延迟加载
        ///// </summary>
        //private static readonly A linjieInstance = null;

        //private static readonly Lazy<A> LazyInstance = new Lazy<A>(() => new A());

        ////private static readonly Lazy<A> LazyInstance = new Lazy<A>(() => new A(),true);// isThreadSafe:true 表示此示例可由多个线程同时使用；false 表示此实例一次只能由一个线程使用。 

        ///// <summary>
        ///// 公开实例，供外界使用
        ///// </summary>
        ////public static A LinjieInstance => LazyInstance.Value; 
        //public static A LinjieInstance
        //{
        //    get
        //    {
        //        return LazyInstance.Value;
        //    }
        //}
        #endregion

        #region 单线程----常规，多线程安全---原子操作累加
        ///// <summary>
        ///// 变量
        ///// </summary>
        //private int linjieInstance;
        //public int GetValue() => Interlocked.Increment(ref linjieInstance);
        ////public int GetValue()
        ////{
        ////    return Interlocked.Increment(ref linjieInstance);
        ////}
        #endregion

        #region 单线程----常规，多线程安全---原子操作累加
        ///// <summary>
        ///// 变量
        ///// </summary>
        //private volatile int linjieInstance;
        //public int GetValue() => ++linjieInstance;
        ////public int GetValue()
        ////{
        ////    return ++linjieInstance;
        ////}
        #endregion

        #region 单线程----常规，多线程不安全----加锁
        ///// <summary>
        ///// 私有构造函数，防止初始化
        ///// </summary>
        //private A()
        //{

        //}

        ///// <summary>
        ///// 私有变量，延迟加载
        ///// </summary>
        //private static A linjieInstance = null;

        ///// <summary>
        ///// 锁
        ///// </summary>
        //private static readonly object objectlock = new object();

        ///// <summary>
        ///// 公开实例，供外界使用
        ///// </summary>
        //public static A LinjieInstance
        //{
        //    get
        //    {
        //        if (linjieInstance == null)
        //        {
        //            lock (objectlock)
        //            {
        //                if (linjieInstance == null)
        //                {
        //                    linjieInstance = new A();
        //                }
        //            }
        //        }
        //        return linjieInstance;
        //    }
        //}
        #endregion

        #region 单线程----常规，多线程不安全----私有静态内部类
        ///// <summary>
        ///// 私有构造函数，防止初始化
        ///// </summary>
        //private A()
        //{

        //}

        ///// <summary>
        ///// 公开实例，供外界使用
        ///// </summary>
        //public static A LinjieInstance => Nest.linjieInstance;
        ////public static A LinjieInstance
        ////{
        ////    get
        ////    {
        ////        return Nest.linjieInstance;
        ////    }
        ////}

        ///// <summary>
        ///// 内部静态类
        ///// </summary>
        //private class Nest
        //{
        //    /// <summary>
        //    /// 私有变量，延迟加载
        //    /// </summary>
        //    public static readonly A linjieInstance = null;

        //    static Nest()
        //    {
        //        linjieInstance = new A();
        //    }

        //    ////上面的写法还可以写成
        //    ///// <summary>
        //    ///// 私有变量，延迟加载
        //    ///// </summary>
        //    //public static readonly A linjieInstance = new A();
        //}
        #endregion
    }

    #region 单例的各种方式实现，本写法以泛型T
    public abstract class B<T> where T : class
    {
        #region 单线程----常规，多线程不安全----泛型
        /// <summary>
        /// 私有构造函数，防止初始化
        /// </summary>
        private B()
        {

        }

        /// <summary>
        /// 公开实例，供外界使用
        /// </summary>
        public static T LinjieInstance => Nest.linjieInstance;
        //public static T LinjieInstance
        //{
        //    get
        //    {
        //        return Nest.linjieInstance;
        //    }
        //}

        /// <summary>
        /// 内部静态类
        /// </summary>
        private class Nest
        {
            /// <summary>
            /// 私有变量，延迟加载
            /// </summary>
            internal static readonly T linjieInstance = null;

            static Nest()
            {
                //linjieInstance = new T();//必须有公开的构造函数，同时泛型约束SingletonBase<T> where T : class, new()
                //nonPublic:如果公共或非公共默认构造函数可以匹配，则为 true；如果只有公共默认构造函数可以匹配，则为 false。
                linjieInstance = Activator.CreateInstance(typeof(T), true) as T;
                //使用指定类型的默认构造函数来创建该类型的实例,公共或非公共默认构造函数可以匹配
                //linjieInstance = Activator.CreateInstance<T>() as T;
            }
        }
        #endregion
    }
    #endregion
    #endregion