Is Lazy<T> a good solution for a thread safe lazy loaded singleton?

Question

We implemented a lazy loaded singleton using double locking on get to make sure the instance is only initialized once (and not twice due to thread race conditions).

I was wondering if simply using Lazy<T> is a good solution for this problem?

I.E.

private static Lazy<MyClass> _instance = new Lazy<MyClass>(() => return new MyClass());  public static MyClass Instance {     get     {         return _instance.Value;     } } 

Answer 1

I suggest you to read referencede articles from comments:

• Lazy Class
• Implementing the Singleton Pattern in C#

In all cases the Lazy<T> class is thread-safe, but you need to remember that the Value of this type can be thread-unsafe, and can be corrupted in multithreading environment:

private static Lazy<MyClass> _instance = new Lazy<MyClass>(() => return new MyClass());  public static MyClass Instance {    get {       return _instance.Value;    } }  public void MyConsumerMethod() {     lock (Instance)     {         // this is safe usage         Instance.SomeMethod();     }      // this can be unsafe operation     Instance.SomeMethod(); } 

Also you can use any constructor you like depending on the environment of your application.