Implement Lazy Loading in C# Using Lazy<T> Class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleAPP
{
    public class PersonalLoan
    {
        public string AccountNumber { get; set; }
        public string AccounHolderName { get; set; }
        public Loan LoanDetail { get; set; }
        public PersonalLoan(string accountNumber)
        {
            this.AccountNumber = accountNumber;
            this.AccounHolderName = "Sourav";
        }
    }
    public class Loan
    {
        public string AccountNumber { get; set; }
        public float LoanAmount { get; set; }
        public bool IsLoanApproved { get; set; }
        public Loan(string accountNumber)
        {
            Console.WriteLine("Loan loading started");
            this.AccountNumber = accountNumber;
            this.LoanAmount = 1000;
            this.IsLoanApproved = true;
            Console.WriteLine("Loan loading started");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            PersonalLoan p = new PersonalLoan("123456");
            //Load Detail started to load
            p.LoanDetail = new Loan("123456");
            Console.WriteLine(p.LoanDetail.AccountNumber);
            Console.WriteLine(p.LoanDetail.IsLoanApproved);
            Console.WriteLine(p.LoanDetail.LoanAmount);
            Console.ReadLine();
        }
    }
}

So, we are seeing that the LoanDetail Property is still null. As soon as we load the property in our code , it will be populated.

Finally

Lazy loading is a nice feature of application development, the developer should implement it wisely to enhance performance and reduce the cost of application execution.

Implement lazy loading using Lazy<T> class

As we know, lazy loading is a nice feature of applications, not only to improve the performance of the application but also it helps to manage memory and other resource efficiently. Basically we can use lazy initialization when a large object is created or the execution of a resource- intensive task in particular when such creation or execution might not occur during the lifetime of the program.

And there are many choices to implement lazy initialization. We can use our own implementation to delay object population or we can use the Lazy<T> class of the .NET library to do it.

To prepare for lazy initialization, you create an instance of Lazy<T>. The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

The Lazy<T> class contains two properties by which we can detect the status of the lazy class.

IsValueCreated

This property will tell us whether or not the value is initializing in a lazy class.

Value

It gets the lazy initialized value of the current Lazy<T> instance.

Fine. We will now implement one simple class and we will see how lazy<T> works with it. Have a look at the following example.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleAPP
{
    public class Test
    {
        private List<string> list = null;
        public Test()
        {
            Console.WriteLine("List Generated:");
            list = new List<string>() { 
                "Sourav","Ram"
            };
        }
        public List<string> Names
        {
            get
            {
                return list;
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Lazy<Test> lazy = new Lazy<Test>();
            Console.WriteLine("Data Loaded : " + lazy.IsValueCreated);
            Test t = lazy.Value;
            foreach (string tmp in t.Names)
            {
                Console.WriteLine(tmp);
            }
            Console.ReadLine();
        }
    }
}