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");
        }
    }

 2025-11-10加深理解，实现懒加载单例模式

        public void Test() {
            Handler handler = new Handler();
            Console.WriteLine("2，创建Handler时并不会立刻创建Service");
            handler.Process();
        }
        class Handler {
            readonly Lazy<Service> lazy = new Lazy<Service>(() => {
                Console.WriteLine("4，开始创建Service对象");
                return new Service("abc123");
            });
            Service Service => lazy.Value;
            public Handler() {
                Console.WriteLine("1，使用懒加载延迟创建成员对象");
            }
            public void Process() {
                Console.WriteLine("3，调用时执行的时候才会创建Service");
                Service.DoSomething(6);
                Console.WriteLine("7，懒加载只会执行一次");
                Service.DoSomething(8);
            }
        }
        class Service {
            public string Param;
            public Service(string param) {
                Console.WriteLine("5，创建Service对象");
                Param = param;
            }
            public void DoSomething(int tag) {
                Console.WriteLine(tag + "，Service具体,Param=" + Param);
            }
        }