Laziness in C# 4.0 – Lazy<T>

“Lazy Instantiation” defers creation of an object till the time it is actually accessed.The process of object creation is always expensive as it involves allocation of memory on the heap.So Lazy Instantiation optimizes resources by using them when it is actually required.Till C# 3.0 we needed to some custom coding to implement “Lazy Instantiation” pattern.Now C# 4.0 introduces the Lazy<T> class as part of BCL for this purpose.In this post we will take a detailed look into the behavior and functioning of this class.

Let us refer to the following lines of code:

class Program
{
    static void Main(string[] args)
    {
        Lazy<Foo> f = new Lazy<Foo>( );
        Console.WriteLine("Foo is defined");
        if (!f.IsValueCreated) Console.WriteLine("Foo is not initialized yet..");
        Console.WriteLine("Foo::ID=" + (f.Value as Foo).ID);
        if (f.IsValueCreated) Console.WriteLine("Foo is initialized now..");
        Console.Read(); 

    }
} 

public class Foo
{
    public int ID { get; set; } 

    public Foo()
    {
        Console.WriteLine("Foo:: Constructor is called");
        ID = 1;
    }
}

This program will print the following:

Foo is defined
Foo is not initialized yet..
Foo:: Constructor is called
Foo::ID=1
Foo is initialized now..

Here the object of Foo is created only when f.Value is accessed.The property Value returns the instance of the lazily initialized object.The boolean property IsValueCreated indicates whether the lazy object is initialized or not.We can pass a delegate which returns object of type Foo in the constructor as shown below:

Lazy<Foo> f = new Lazy<Foo>
                (
                    ()=> 
                    { 
                        Foo fobj = new Foo() { ID = 99 }; 
                        return fobj; 
                    }
                );

In this case the program will print

Foo is defined
Foo is not initialized yet..
Foo:: Constructor is called
Foo::ID=99
Foo is initialized now..

The uses of the Lazy<T> class discussed above are all non threadsafe i.e the object will be initialized once even if multiple threads are racing for it.We can make it threadsafe by using the following constructors:

• public Lazy(LazyExecutionMode mode)
• public Lazy(Func<T> valueFactory,LazyExecutionMode mode)

Here we have to pass the System.Threading.LazyExecutionMode enumeration.This enumeration supports the following values:

• NotThreadSafe
• AllowMultipleThreadSafeExecution – This allows the initializer to be executed multiple times and one value is published for all threads to access.
• EnsureSingleThreadSafeExecution – This allows the initializer to be executed once even when multiple threads are trying to access the value and finally the value is published to all the threads.

Let us explore this with some examples.I have written the method Run which accepts a lazy object as shown below:

static void Run(object obj)
 {
     Lazy<Foo> flazy = obj as Lazy<Foo>;
     Foo f = flazy.Value as Foo;
     f.ID++;
     Console.WriteLine("Foo::ID=" + f.ID); 

 }

In the main program I have instantiated the Lazy object with LazyExecutionMode.EnsureSingleThreadSafeExecution as shown below:

static void Main(string[] args)
{
    Lazy<Foo> f = new Lazy<Foo>
        (
            ()=> 
            { 
                Foo fobj = new Foo() { ID = 99 }; 
                return fobj; 
            },LazyExecutionMode.EnsureSingleThreadSafeExecution
        );
    Console.WriteLine("Foo is defined");
    ThreadPool.QueueUserWorkItem(new WaitCallback(Run),f);
    ThreadPool.QueueUserWorkItem(new WaitCallback(Run), f);

    Console.Read(); 

}

The program output is:

Foo is defined
Foo:: Constructor is called
Foo::ID=100
Foo::ID=101

This clearly shows that constructor is called once and then the value is published to the other threads.Now I am making a small change in the Run method as shown below and changing the mode to LazyExecutionMode.AllowMultipleThreadSafeExecution

static void Run(object obj)
 {
     Lazy<Foo> flazy = obj as Lazy<Foo>;
     Foo f = flazy.Value as Foo;
     f.ID++;
     Thread.Sleep(100);
     Console.WriteLine("Foo::ID=" + f.ID); 

 }

The program output is:

Foo is defined
Foo:: Constructor is called
Foo:: Constructor is called
Foo::ID=101
Foo::ID=101

So here the constructor is called twice and then the final value is published to all the threads.