使用Lazy<T>实现对客户订单的延迟加载

"延迟加载"是指在需要的时候再加载数据。比如获得一个Customer信息，并不会把该Customer的Orders信息一下加载出来，当需要显示Orders的时候再加载。简单来说，就是按需加载。使用"延迟加载"的好处是减少应用程序响应时间，降低内存消耗，避免不必要的数据库交互。

□ 即时加载

创建Order类和Customer类，Customer中维护着Order的一个集合，在Customer的构造函数中给Order集合赋值。即，只要创建Customer实例，就会加载该Customer的所有Order。

关于Customer和Order类。

    public class Customer

    {

        private List<Order> _orders = null;


        public List<Order> Orders

        {

            get { return _orders; }

        }


        private string _customerName;


        public string CustomerName

        {

            get { return _customerName; }

            set { CustomerName = value; }

        }


        public Customer()

        {

            _customerName = "darren";

            _orders = LoadOrders();

        }


        private List<Order> LoadOrders()

        {

            List<Order> result = new List<Order>();


            Order o = new Order();

            o.OrderNumber = "001";

            result.Add(o);


            o = new Order();

            o.OrderNumber = "002";

            result.Add(o);


            return result;

        }

    }


    public class Order

    {

        private string _orderNumber;


        public string OrderNumber

        {

            get { return _orderNumber; }

            set { _orderNumber = value; }

        }

    }

客户端调用：

    class Program

    {

        static void Main(string[] args)

        {

            Customer customer = new Customer();

            Console.WriteLine(customer.CustomerName);


            foreach (var order in customer.Orders)

            {

                Console.WriteLine(order.OrderNumber);

            }


            Console.ReadKey();

        }

    }

把断点打在foreach所在行，为customer变量添加监视， 就发现：在创建Customer实例的同时，加载了该Customer的所有Order。

□ Lazy<T>实现延迟加载

对于延迟加载，在这里，需求变成：在创建Customer实例的时候先不要加载该Customer的任何Order，等到遍历、显示Orders的时候再加载该Customer的所有的Order。

把Customer的_orders字段设置为验证加载。

private Lazy<List<Order>> _orders = null;

Customer的Orders属性的get访问器中修改如下。

        public List<Order> Orders

        {

            get { return _orders.Value; }

        }

构造函数中修改如下：

        public Customer()

        {

            _customerName = "darren";

            _orders = new Lazy<List<Order>>(() => LoadOrders());

        }

Customer类，修改后，完整如下：

    public class Customer

    {

        private Lazy<List<Order>> _orders = null;


        public List<Order> Orders

        {

            get { return _orders.Value; }

        }


        private string _customerName;


        public string CustomerName

        {

            get { return _customerName; }

            set { CustomerName = value; }

        }


        public Customer()

        {

            _customerName = "darren";

            _orders = new Lazy<List<Order>>(() => LoadOrders());

        }


        private List<Order> LoadOrders()

        {

            List<Order> result = new List<Order>();


            Order o = new Order();

            o.OrderNumber = "001";

            result.Add(o);


            o = new Order();

            o.OrderNumber = "002";

            result.Add(o);


            return result;

        }

    }

还是把断点打在客户端foreach代码行，运行。

可见，在没有遍历之前，Customer的_orders字段的Value属性值为null。

F11，进入循环遍历

可见，当进入遍历，获取Customer实例的Order值的时候，延迟加载开始，_orders字段的属性值不再为null。

总结：当我们希望类的某个属性实现延迟加载，首先设计一个Lazy<T>类型的字段，然后在该属性的get访问器中，通过Lazy<T>类型字段的Value属性获取值，最后在该类构造函数中实现针对Lazy<T>类型字段的初始化。