System.Lazy<T>延迟加载

原文:System.Lazy<T>延迟加载

在很多情况下，有些对象需要在使用时加载或根据逻辑动态加载。有些情况如果不延迟加载，可能会影响效率甚至抛出Timeout Exception。如网络操作、数据库操作、文件IO操作

直接上代码，方便我们理解怎么通过Lazy类实现对象的延迟加载。

   class Program
    {
        static void Main(string[] args)
        {
            foreach (var item in Product.GetProductListLazy())
            {
                //下面的操作会执行Product类的构造函数
                Product p = item.Value;
                //构造函数执行完成
                int id = item.Value.Id;
                Console.WriteLine(id);
            }
            Console.ReadKey();
        }
    }

    public class Product
    {
        public int Id { set; get; }
        public string Title { set; get; }

        public Product()
        {
            Thread.Sleep(5000);
        }
        public static IList<Lazy<Product>> GetProductListLazy()
        {
            try
            {
                Console.WriteLine("非LazyLoad加载");
                Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
                Lazy<Product> product1 = new Lazy<Product>(() => new Product() { Id = 1, Title = "产品 1" });
                Lazy<Product> product2 = new Lazy<Product>(() => new Product() { Id = 2, Title = "产品 2" });
                Lazy<Product> product3 = new Lazy<Product>(() => new Product() { Id = 3, Title = "产品 3" });
                return new List<Lazy<Product>> { product1, product2, product3 };
            }
            finally {
                Console.WriteLine(DateTime.Now.ToString("HH:mm.ss.fff"));            
            }
        }

        public static IList<Product> GetProductList()
        {
            try
            {
                Console.WriteLine("非LazyLoad加载");
                Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
                Product product1 = new Product() { Id = 1, Title = "产品 1" };
                Product product2 = new Product() { Id = 1, Title = "产品 2" };
                Product product3 = new Product() { Id = 1, Title = "产品 3" };
                return new List<Product> { product1, product2, product3 };
            }
            finally {
                Console.WriteLine(DateTime.Now.ToString("HH:mm.ss.fff"));
            }
        }
    }

还有一种情况，我们知道多线程情况下的单件设计模式需要做数据同步的：

    public class Singleton
    {
        private static Singleton _Instance = new Singleton();

        public static Singleton GetInstance()
        {
            return _Instance;
        }
    }

这样可以保证多线程的情况下，只有一个实例，因为是在程序加载时，初始化的对象，但是也正因为这样，失去了单件的一个优势，按需加载。

所以，我们可以这样实现：

    public class SingletonLazy
    {
        private static Lazy<SingletonLazy> _Instance = new Lazy<SingletonLazy>();

        public static SingletonLazy GetInstance()
        {
            return _Instance.Value;
        }
    }

这样的话，可以保证有一个实例，同时实现延迟加载，按需加载。

以上内容介绍完了，欢迎大家交流和指正

另附：

参考文章：http://www.codeproject.com/Articles/612801/Lazy-Object-Initialization-with-System-Lazy-of-T-c

Demo下载：http://files.cnblogs.com/wpfworld/LazyLoadDemo.rar

来源：https://www.cnblogs.com/lonelyxmas/p/12082282.html