当前位置 : 主页 > 网络编程 > c#编程 >

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

来源:互联网 收集:自由互联 发布时间:2023-01-31
延迟加载是指在需要的时候再加载数据。比如获得一个Customer信息,并不会把该Customer的Orders信息一下加载出来,当需要显示Orders的时候再加载。简单来说,就是按需加载。使用延迟加载

"延迟加载"是指在需要的时候再加载数据。比如获得一个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>类型字段的初始化。

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对自由互联的支持。如果你想了解更多相关内容请查看下面相关链接

上一篇:C#中Timer实现Tick使用精度的问题
下一篇:没有了
网友评论