Lazy Loading in C# 4.0

Lazy loading is a pattern which delay initialization of object. C# 4.0 introduced new class which defers the creation of expensive objects when not in use. In this article I’ll explain the use of Lazy<T> class. Suppose we have Customer class and one customer can have many Accounts, if you want show Accounts for one customer, you need to load accounts associated with customer. Loading of accounts can make performance hit badly if data is huge while initializing Customer object. To avoid this situation Lazy loading comes for rescue. Loading of Accounts will only happen when you will use accounts list. This will make sure fast loading of customer object and give performance boost to application.

Here I am explaining example of Customer and Accounts relationship by Lazy loading:

First we create entity classes of Customer and Account:

public class Account
        public int Id { get; set; }

    public class Customer
        public string Name { get; set; }
        public int CustomerId { get; set; }

        public List GetAccounts()
            return lazylist.Value;

        Lazy<List<Account>> lazylist;

        public Customer(string name, int id)
            Console.WriteLine("Initializing Customer Object");
            Name = name;
            CustomerId = id;
            lazylist = new Lazy<List<Account>>(() => { return GetAccountList(id); });
            Console.WriteLine("Initialization done");

        private List GetAccountList(int id)
            Console.WriteLine("Loading Accounts:");
            List list = new List();
            Parallel.For(100, 110, (int i) =>
                Account a = new Account();
                a.Id = i;
            return list;

In the constructor of customer class, properties are initializing and declaring lazylist object, which is generic List of account and filled by GetAccountList method. This method will only call when lazylist object will be use. Below is main method which shows behavior of lazy loading:

static void Main(string[] args)

            Customer cust = new Customer("Neeraj", 1);//constructor should not load accounts

            foreach(Account ac in cust.GetAccounts())// it will actually load accounts, ie. lazy loading


In above code when this statement foreach(Account ac in cust.GetAccounts()) is called then acccount list is filled.


Initializing Customer Object

Initialization done

Loading Accounts:











Syntax of Lazy<T> object

        public Lazy();
        public Lazy(bool isThreadSafe);
        public Lazy(Func valueFactory);
        public Lazy(LazyThreadSafetyMode mode);
        public Lazy(Func valueFactory, bool isThreadSafe);
        public Lazy(Func valueFactory, LazyThreadSafetyMode mode);

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.