/// <summary>

    /// 静态代码块

    /// 仅在第一次调用类的任何成员时自动执行

    /// </summary>

    public class SingletonStatic

    {

        private static readonly SingletonStatic _instance =null;

        static SingletonStatic()

        {

            _instance = new SingletonStatic();

        }

        private SingletonStatic()

        {

        }

        public static SingletonStatic Instance

        {

            get { return _instance; }

        }

    }

   /// <summary>

    /// 内部类

    /// </summary>

    public class SingletonInner

    {

        private SingletonInner()

        {

        }

        public static SingletonInner Instance

        {

            get{ return InnerClass.inner; }

        }

        private class InnerClass

        {

            internal static readonly SingletonInner inner = new SingletonInner();

        }

    }

    /// <summary>

    /// Lazy单例

    /// </summary>

    public class SingletonLazy

    {

        private static readonly SingletonLazy _instance = new Lazy<SingletonLazy>().Value;

        private SingletonLazy()

        {

        }

        public SingletonLazy Instance

        {

            get { return _instance; }

        }

    }

/// <summary>

    /// https://www.cnblogs.com/zhouzl/archive/2019/04/11/10687909.html

    /// </summary>

    /// <typeparam name="T"></typeparam>

    public abstract class Singleton<T> where T : class

    {

        // 这里采用实现5的方案，实际可采用上述任意一种方案

        class Nested

        {

            // 创建模板类实例，参数2设为true表示支持私有构造函数

            internal static readonly T instance = Activator.CreateInstance(typeof(T), true) as T;

        }

        private static T instance = null;

        public static T Instance { get { return Nested.instance; } }

    }

    class TestSingleton : Singleton<TestSingleton>

    {

        // 将构造函数私有化，防止外部通过new创建

        private TestSingleton() { }

    }