Lazy Loading In C# 4.0 (Object On Demand)

Akash Varshney

Lazy Loading C# 4.0C# Lazy loadingObject On Demand

14 Comments

Join the conversation! Your thoughts help the community grow.

vibhor dhawan5y ago
A lot of typos and others issues with this code.
Trần Khoa6y ago
You make alot of mistakes in your code.
flamecrow flamecrow6y ago
Holy shit typos.
Mahesh Anakali7y ago
Nice Article, But lot of errors when I copy pasted the code into editor.
Santhakumar Munuswamy11y ago
Good one
Shakti Saxena11y ago
Good one
Vipul Malhotra11y ago
nice article. Thanks for sharing
Humayun Kabir Mamun11y ago
Nice...
Gopi Chand11y ago
Nice work
Sujeet Suman11y ago
Good Article.............
Rakesh11y ago
Good share
Mukesh Kumar11y ago
Great.. thanks for sharing
Nilesh Jadav11y ago
Good Share sir
Harshad Pansuriya11y ago
Nice one

Object on Demand is also called Lazy loading pattern, Lazy loading delays the initialization of object. This is a new feature of C# 4.0 and can be used when we are working with large objects when it is not in use. This article will explain you about "Lazy" class.

Suppose we have Candidate class and EducationProfile class. One candidate can have more than one EducationProfile (like: Bachelors (BBA), Master(MBA)). If you want to show the EducationProfile with the respective Candidate, you need to load EducationProfiles associated with that Candidate. If you are loading an Education Profile with the respective candidate you need to initialize a Candidate object and that is supposed to be huge .

For avoiding the situation you can use the Lazy Loading Pattern. Loading of EdutioanProfile will only happen when you will use EducationProfile list. And this will make sure fast action in comparison to the normal one and performance will also increase.

Explaining an example of Candidate and EducationProfile relationship by Lazy loading:

First we need to create classes of Candidate and EducationProfile.

public class EducationProfile
{
public int Id { get; set; }
public string Digree { get; set; }
public DateTime PassingYear { get; set; }
}
//Hope this will give you a little reference of lazy loading
public class Candiate
{
public string Name { get; set; }
public int EducationProfileId { get; set; }
public List GetAllEducationProfile()
{
return educationProileList.value;
}
Lazy<list<educationproile>> educationProileList;
public Candiate(string name, int id)
{
//Initializing Candiate Object
Name = name;
EducationProfileId = id;
educationProileList = new Lazy<list<educationproile>>(() => { return GetEducationProfileList(id); });
//Initialization done
}
private List GetEducationProfileList(int id)
{
//Loading EducationProiles
List list = new List();
Parallel.For(100, 110, (int i) =>
{
EducationProile educationprofile = new EducationProile();
educationprofile.Id = i;
list.Add(educationprofile);
});
return list;
}
}
</list<educationproile></list<educationproile>

In the constructor of Candidate class, properties are initializing and declaring educationProileList object, which is the generic List of educationProile and filled by GetEducationProfileList method. This method will only call when educationProileList object will be used. The following is the main method which shows the behavior of lazy loading:

public static void Main(string[] args)
{
Candidate candidate = new Candidate("AnyName", 1);
foreach(EducationProile eduProfile in candiate.GetAllEducationProfile())
// it will actually load accounts, ie. lazy loading
Console.WriteLine("Id:{0}",eduProfile.Id);
Console.Read();
}