C# 使用Lazy 懒加载

用Lazy对象能实现懒加载的效果，就是预先定制好对象，但是不去创建它，直到第一次使用的时候才会真正的创建，而且这个还是线程安全的，有了这个玩意，就不用自己去写类似的东西以及单例模式了

static void Start() {
            Lazy<AAA> aaa = new Lazy<AAA>();
            Console.WriteLine("AAA已经懒加载了,但是还没创建");
            aaa.Value.Do();
        }
        class AAA {
            public AAA() {
                Console.WriteLine("AAA创建");
            }
            public void Do() {
                Console.WriteLine("AAA Do");
            }
        }

 通过Lazy实现单例模式

internal class AAA {
        /// <summary>
        /// 通过懒加载实现单例模式，so easy!
        /// </summary>
        public static AAA Instance = new Lazy<AAA>(() => new AAA()).Value;
        /// <summary>
        /// 将无参构造函数设置成私有的
        /// </summary>
        private AAA() {
            Console.WriteLine("create AAA");
        }
        public void Test() {
            Console.WriteLine("test");
        }
        /// <summary>
        /// 貌似调用静态成员，Lazy就开始实际创建AAA对象了
        /// </summary>
        public static void TestAAA() {
            Console.WriteLine("testAAA");
        }
    }

　　稍微改进一下就不会在调用其他成员的时候就触发的lazy了，否则懒加载就没意义了

internal class AAA {
        static readonly Lazy<AAA> instance = new Lazy<AAA>(() => new AAA("aaa"));
        /// <summary>
        /// 不能直接new Lazy<AAA>(() => new AAA("aaa")).Value，这样会立刻创建对象，懒加载就没有意义了
        /// </summary>
        public static AAA Instance { get { return instance.Value; } }
        static readonly Lazy<AAA> instance2 = new Lazy<AAA>(() => new AAA("bbb"));
        public static AAA Instance2 { get { return instance2.Value; } }
        /// <summary>
        /// 将无参构造函数设置成私有的
        /// </summary>
        private AAA(string id) {
            Console.WriteLine("create AAA:" + id);
        }
        public void Test() {
            Console.WriteLine("test");
        }
        /// <summary>
        /// 这次调用其他成员，就不会创建懒加载的对象了
        /// </summary>
        public static void TestAAA() {
            Console.WriteLine("testAAA");
        }
    }