单例模式

1：饥饿模式

 public class Class1
    {
        public readonly static Class1 c1 = new Class1();//直接创建一个
        //构造函数私有化 禁止其他地方创建实例
        private Class1()
        { }
        //对外提供一个方法来返回
        public static Class1 GetSign()
        {
            return c1;
        }
    }

2：懒加载

public class Class2
    {
        private static Class2 c2 = null;
        private readonly static object objLock = new object();

        private Class2()
        {

        }
        public static Class2 GetSign()
        {
            if (c2 == null)//提高性能 是null的时候才加锁
            {
                lock (objLock)//加锁 为了 线程安全
                {
                    if (c2 == null)
                    {
                        c2 = new Class2();
                    }
                }
            }
            return c2;
        }
    }

进阶的懒惰：参考的:https://www.cnblogs.com/leolion/p/10241822.html

 public sealed class Class3
    {
        //构造函数私有化
        //说实话 这种我还不太懂，可以去看看原文
        private Class3()
        { }
        public static Class3 c3 { get { return GetSign.c3; } }

        private class GetSign
        {
            // 显式静态构造告诉C＃编译器
            // 未标记类型BeforeFieldInit
            static GetSign()
            {
            }

            internal static readonly Class3 c3 = new Class3();
        }
      

    }

进阶2：使用Lazy

public sealed class Class4
    {
        //延迟初始化
        // 初始化 System.Lazy`1 类的新实例。 当延迟初始化发生时，将使用指定的初始化函数和初始化模式。
        //第二个参数 表示 线程安全为true 
        //哈哈，我也第一次晓得这个方式。新奇
        private static readonly Lazy<Class4> lazyC4 = new Lazy<Class4>(() => new Class4(),true);
        public static Class4 c4 { get { return lazyC4.Value; } }
        private Class4()
        { }
    }