你能解释一下延迟加载吗？

目录

介绍

那么我们如何实现延迟加载呢？

.NET中有没有现成的对象可以用来实现延迟加载？

延迟加载的优缺点是什么？

---

 

介绍

延迟加载是一个概念，我们将对象的加载延迟到我们需要它的时候。简而言之，按需加载对象而不是不必要地加载对象。

例如，考虑下面的例子，我们有一个简单的Customer类，这个Customer类里面有很多Order对象。仔细看看Customer类的构造函数。当Customer对象被创建时，它也在那一刻加载Order对象。因此，即使我们需要或不需要该Order 对象，它仍然会被加载。

但是，最初只加载Customer对象然后按需加载Order对象怎么样？

public class Customer
{
	private List<Order> _Orders= null;
	…
	…
	public Customer()
	{
        _CustomerName = "Shiv";
        _Orders = LoadOrders(); // Loads the order object even though //not needed
	}
     
	private List<Order> LoadOrders()
	{
        List<Order> temp = new List<Order>();
        Order o = new Order();
        o.OrderNumber = "ord1001";
        temp.Add(o);
        o = new Order();
        o.OrderNumber = "ord1002";
        temp.Add(o);
        return temp;
	}
} 

因此，让我们考虑您有使用Customer类的客户端代码，如下所示。因此，当Customer创建Order对象时，此时不应加载任何对象。但是只要foreach循环运行，您就希望在该点加载Order对象（按需加载对象）。

Customer o = new Customer();    // order object not loaded
Console.WriteLine(o.CustomerName);
foreach (Order o1 in o.Orders)  // Load order object only at this moment
{
    Console.WriteLine(o1.OrderNumber);
}

那么我们如何实现延迟加载呢？

对于上面的例子，如果我们要实现延​​迟加载，我们需要做如下修改：

• 从构造函数中删除Order对象加载。
• 在Order get属性中，仅当未加载对象时才加载该Order对象。

public class Customer
{
    private List<Order> _Orders= null;
    …
    …
    public Customer()
    {
        _CustomerName = "Shiv";
    }
    public List<Order> Orders
    {
	    get 
        {
            if (_Orders == null)
            {
                _Orders = LoadOrders();
            }
            return _Orders; 
        }
    }

现在，如果您运行客户端代码并在foreach循环运行Orders对象之前停止调试器，您可以看到Orders对象是null（即，未加载）。但是一旦foreach循环运行在Order对象上，它就会创建Order对象集合。

.NET中有没有现成的对象可以用来实现延迟加载？

在.NET中，我们有一个Lazy<T>为延迟加载提供自动支持的类。那么我们假设如果要在上面的代码中实现Lazy<>，我们需要实现两个步骤：

使用Lazy泛型类创建订单对象。

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

将此Lazy<>对象附加到有助于我们加载订单数据的方法。

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

现在，只要任何客户端调用该_Orders对象，它就会调用该LoadOrders函数来加载数据。

您将获得Value属性中的List<orders>数据。

public List<Order> Orders
{
    get 
    {
        return _Orders.Value; 
    }   
} 

下面是完整的代码：

public class Customer
{
    private Lazy<List<Order>> _Orders= null;
    public List<Order> Orders
    {
        get 
        {
            return _Orders.Value; 
        }
    }
    public Customer()
    {
        // Makes a database trip
        _CustomerName = "Shiv";
        _Orders = new Lazy<List<Order>>(() => LoadOrders());
    }
} 

延迟加载的优缺点是什么？

以下是延迟加载的优点：

• 最大限度地减少应用程序的启动时间。
• 由于按需加载，应用程序消耗的内存更少。
• 避免了不必要的数据库SQL执行。

唯一的缺点是代码变得复杂。由于我们需要检查是否需要加载，因此性能略有下降。

但优点远远多于缺点。

仅供参考：延迟加载的反面是预先加载。因此，在预先加载中，我们在创建对象后立即将所有对象加载到内存中。

https://www.codeproject.com/Articles/652556/Can-You-Explain-Lazy-Loading