.Net 4.0 framework is shipped with many new features considering all aspects of development. To increase the performance and reduce the memory consumption a new feature was introduced known as “Lazy Instantiation”. With earlier versions of .Net it could be implemented using some custom designing of class but now you don’t need to worry about it just focus on the business logic, the framework will take care of your objects. Lazy initialization or lazy loading, is the idea that the object will not be constructed, created, initialized or loaded until it is absolutely needed. In this post we’ll see what are different ways to use the Lazy feature.
The Lazy initialization can be seen in designing the singleton pattern where we can have static readonly property in a nested class that initializes the singleton object in a Lazy way.
Lazy<T> wrapper introduced to provide the support for Lazy initialization with its several overloads. The Lazy<T> may or may not ensures the thread safe initialization as it consider the performance and if required removes the thread safe environment with locking & synchronization that can result in little affect on performance. But if you want to ensure that initialization should be thread safe then you can use its overloads.
There are six overloads of Lazy<T>:
Initializes a new instance of the Lazy<T> class. When lazy initialization occurs, the default constructor of the target type is used.
When lazy initialization occurs, the default constructor of the target type and the specified initialization mode are used. i.e. considering the isThreadSafe
When lazy initialization occurs, the specified initialization function is used. Means you can the parameterized constructor to the Lazy<T>
Initializes a new instance of the Lazy<T> class. When lazy initialization occurs, the specified initialization function and initialization mode are used by providing the value to isThreadSafe argument.
Initializes a new instance of the Lazy<T> class that uses the default constructor of T and the specified thread-safety mode. The LazyThreadSafetlyMode is the enumeration provided in System.Threading namespace it can have below values
[For more details about LazyThreadSafetyMode enum visit the below link:
Initializes a new instance of the Lazy<T> class that uses the specified initialization function and thread-safety mode. Similar to above initialization you can pass the special type of thread safe mode with generic delegate.
The Lazy<T> class may or may not be threadsafe but to ensure the thread safe Initialization there’s an alternative of Lazy<T>
Alternative of LazyInitialization System.Threading.LazyInitializer
This is static implementation of Lazy initializer which eliminates the overhead of creation of Lazy objects. The methods of LazyInitializer are thread-safe and may be called from multiple threads concurrently. The routines of LazyInitializer avoid needing to allocate a dedicated, lazy-initialization instance, instead using references to ensure targets have been initialized as they are accessed.
Another way of LazyInitialization System.Threading.ThreadLocal
It is the same as
Lazy<t>, but the only difference is that it stores data on Thread Local basis. So the values on the each Thread would be a different copy of the Initialized object.
you can also pass generic delegate to pass values for parametric constructor.
I hope this post helped you somehow understanding the all support provided in .Net 4.0. So its now up to you which approach to use and where to implement the Lazy behavior in your program or application.