Introduction
Lazy loading is a concept where we delay the loading of the object until the point where we need it. Putting in simple words, on demand object loading rather than loading objects unnecessarily.
For example, consider the below example where we have a simple Customer
class and this Customer
class has many Order
objects inside it. Have a close look at the constructor of the Customer
class. When the Customer
object is created it also loads the Order
object at that moment. So even if we need or do not need the Order
object, it’s still loaded.
But how about just loading the Customer
object initially and then on demand basis load the Order
object?
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;
}
}
So let’s consider you have client code which consumes the Customer
class as shown below. So when the Customer
object is created no Order
objects should be loaded at that moment. But as soon as the foreach
loop runs you would like to load the Order
object at that point (on demand object loading).
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);
}
So how do we implement lazy loading?
For the above example if we want to implement lazy loading we will need to make the following changes:
- Remove the
Order
object loading from the constructor. - In the
Order
get property, load theOrder
object only if it’s not loaded.
public class Customer
{
private List<Order> _Orders= null;
…
…
public Customer()
{
_CustomerName = "Shiv";
}
public List<Order> Orders
{
get
{
if (_Orders == null)
{
_Orders = LoadOrders();
}
return _Orders;
}
}
Now if you run the client code and halt your debugger just before the foreach
loop runs over the Orders
object, you can see the Orders
object is null
(i.e., not loaded). But as soon as the foreach
loop runs over the Order
object it creates the Order
object collection.
Are there any readymade objects in .NET by which we can implement lazy loading?
In .NET we have the Lazy<T>
class which provides automatic support for lazy loading. So let’s say if you want to implement Lazy<>
in the above code, we need to implement two steps:
Create the object of orders using the Lazy
generic class.
private Lazy<List<Order>> _Orders= null;
Attach this Lazy<>
object with the method which will help us load the order’s data.
_Orders = new Lazy<List<Order>>(() => LoadOrders());
Now as soon as any client makes a call to the _Orders
object, it will call the LoadOrders
function to load the data.
You will get the List<orders>
data in the Value
property.
public List<Order> Orders
{
get
{
return _Orders.Value;
} }
Below goes the full code for this:
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());
}
}
What are the advantages and disadvantages of lazy loading?
Below are the advantages of lazy loading:
- Minimizes start up time of the application.
- Application consumes less memory because of on-demand loading.
- Unnecessary database SQL execution is avoided.
The only one disadvantage is that the code becomes complicated. As we need to do checks if the loading is needed or not, there is a slight decrease in performance.
But the advantages are far more than the disadvantages.
FYI: The opposite of Lazy Loading is eager loading. So in eager loading we load all the objects in memory as soon as the object is created.
Also have a look at below posted video on Lazy Loading: -
License
This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)
原文链接:http://www.codeproject.com/Articles/652556/Can-you-explain-Lazy-Loading
本文地址:http://www.cnblogs.com/Interkey/articles/LazyLoading.html
.NET version 4.0 Framework or later and VS2010 or later is required for the Lazy class.
Lazy<T> Class: http://msdn.microsoft.com/en-us/library/dd642331(v=vs.100).aspx
建议阅读原文后面的 Comments and Discussions .
相关阅读:
http://www.cnblogs.com/Allen-Li/archive/2012/03/15/2398063.html