Learn how to use the Lazy class to implement lazy initialization in C# in a thread-safe manner. Handle exceptions, change values, and compare instances.

It's okay to use Lazy for singleton like objects, but due to added memory overhead, avoid using Lazy when there could be huge number of instances.

Last updated on Aug 6, 2024

How do you use the Lazy<T> class to implement lazy initialization in a thread-safe manner in C#?

Lazy initialization is a technique that delays the creation of an object or a value until it is first accessed or needed. This can improve performance and memory usage, especially for expensive or rarely used resources. However, lazy initialization can also introduce concurrency issues, such as race conditions or stale data, if multiple threads access the same lazy instance. How do you use the Lazy<T> class to implement lazy initialization in a thread-safe manner in C#?

1 What is Lazy<T>?

The Lazy<T> class is a generic wrapper that provides a simple and convenient way to implement lazy initialization in C#. It encapsulates a value of type T and a factory method that creates the value when it is first requested. The Lazy<T> class also supports various modes of thread safety, which determine how the value is initialized and cached in a multithreaded environment.

Add your perspective

Gokul Jayavel

Software Engineer @ Philips | Graduate Student, Teaching Assistant @ Northeastern University| Masters in Software Engineering | Ex-Specialist Programmer at Infosys|Full-Stack Developer|SDE|DevOps
Report contribution
The Lazy<T> class in C# provides a way to implement lazy initialization in a thread-safe manner, delaying the creation of an object until it is accessed. To use it, create an instance of 'Lazy<T>', optionally passing a delegate or lambda expression for initialization. Access the value using the 'Value' property, which triggers the creation if it hasn't occurred. By default, 'Lazy<T>' ensures only one thread initializes the object, but you can specify different thread-safety modes like 'None', 'PublicationOnly', or 'ExecutionAndPublication' for custom behaviour. This approach is ideal for resource-intensive objects that may not always be needed.

Like

2 How to use Lazy<T>?

To use Lazy<T>, you need to create an instance of the class and pass a delegate that defines how to create the value of type T. The delegate can be a lambda expression, an anonymous method, or a named method. You can also optionally specify a LazyThreadSafetyMode enum value that indicates the desired level of thread safety. The default mode is LazyThreadSafetyMode.ExecutionAndPublication, which ensures that only one thread can initialize the value and that all threads see the same cached value.

Add your perspective

Gokul Jayavel

Software Engineer @ Philips | Graduate Student, Teaching Assistant @ Northeastern University| Masters in Software Engineering | Ex-Specialist Programmer at Infosys|Full-Stack Developer|SDE|DevOps
Report contribution
To use Lazy<T> in C#, create an instance by specifying the type and a delegate or lambda for initialization. For example, Lazy<MyClass> lazyInstance = new Lazy<MyClass>(() => new MyClass()); defers the creation of MyClass until the Value property is accessed. Accessing lazyInstance.Value triggers the initialization if it hasn't occurred yet. By default, Lazy<T> is thread-safe, ensuring that only one thread initializes the value, and different thread-safety modes can be specified using the LazyThreadSafetyMode enumeration.

Like

3 How to access the value of Lazy<T>?

To access the value of Lazy<T>, you simply use the Value property of the instance. The first time you access the Value property, the Lazy<T> instance invokes the factory method and stores the result in a private field. Subsequent accesses to the Value property return the cached value without invoking the factory method again. If the factory method throws an exception, the Lazy<T> instance caches the exception and rethrows it on every access to the Value property.

Add your perspective

Gokul Jayavel

Software Engineer @ Philips | Graduate Student, Teaching Assistant @ Northeastern University| Masters in Software Engineering | Ex-Specialist Programmer at Infosys|Full-Stack Developer|SDE|DevOps
Report contribution
To access the value of Lazy<T>, use the Value property. This property will trigger the creation of the object if it hasn't already been instantiated. For example, if you have Lazy<MyClass> lazyInstance = new Lazy<MyClass>(() => new MyClass()); you can access the value by calling MyClass myObject = lazyInstance.Value; This ensures that the object is only created when it's first accessed, providing a lazy initialization mechanism.

Like

4 How to handle exceptions with Lazy<T>?

As mentioned above, if the factory method of Lazy<T> throws an exception, the Lazy<T> instance caches the exception and rethrows it on every access to the Value property. This means that you need to handle the exception either in the factory method or in the code that accesses the Value property. You can also use the IsValueCreated property of Lazy<T> to check whether the value has been successfully initialized or not.

Add your perspective

Gokul Jayavel

Software Engineer @ Philips | Graduate Student, Teaching Assistant @ Northeastern University| Masters in Software Engineering | Ex-Specialist Programmer at Infosys|Full-Stack Developer|SDE|DevOps
Report contribution
When dealing with exceptions in Lazy<T>, you have the option to handle the exceptions directly within the factory method used for initialization. This can be done by encapsulating the initialization logic in a try-catch block within the factory method itself. This approach allows you to handle the exception immediately and potentially return a fallback value or log the error. Another strategy is to check the 'IsValueCreated' property before accessing the 'Value' property, allowing you to determine if the value was successfully initialized or if an exception occurred during initialization.

Like

5 How to change the value of Lazy<T>?

The Lazy<T> class does not provide a way to change the value of the instance once it has been initialized. However, you can create a new Lazy<T> instance with a different factory method and assign it to the same variable. This effectively resets the lazy initialization and allows you to create a new value when you access the Value property. Note that this approach is not thread-safe and may cause inconsistent results if multiple threads access the same variable.

Add your perspective

6 How to compare Lazy<T> instances?

The Lazy<T> class implements the IEquatable<Lazy<T>> interface, which means that you can use the Equals method or the == operator to compare two Lazy<T> instances for equality. However, this comparison only checks whether the two instances have the same factory method and thread safety mode, not whether they have the same value. To compare the values of two Lazy<T> instances, you need to access their Value properties and compare them using the Equals method or the == operator of type T.

Add your perspective

7 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

Add your perspective

Feng Yuan
Report contribution
It's okay to use Lazy<T> for singleton like objects, but due to added memory overhead, avoid using Lazy<T> when there could be huge number of instances.

Like

How do you use the Lazy<T> class to implement lazy initialization in a thread-safe manner in C#?

1

2

3

4

5

6

7

1 What is Lazy<T>?

2 How to use Lazy<T>?

3 How to access the value of Lazy<T>?

4 How to handle exceptions with Lazy<T>?

5 How to change the value of Lazy<T>?

6 How to compare Lazy<T> instances?

7 Here’s what else to consider

Multithreading

Rate this article

Thanks for your feedback

More articles on Multithreading

More relevant reading