Lazy<T> Class

It is really a strange thing.

It is not support Invalidation, so it is used really for lazy objects that is not invalidated.

Long ago, I rolled my own functional equivalent to Lazy<T>, $0with one major difference: The object exposed an Invalidate() $0 $0method that causes it to clear the contained value, and reset$0 $0its internal state to what it was when it was created. That in-$0 $0turn causes it to re-initialize the value the next time it is $0 $0accessed.$0 $0 $0$0 $0 $0That allows my home-grown implementation to serve as a $0 $0cache for holding a value with a high initialization cost, and$0 $0simplifying the code logic to manage and refresh the stored$0 $0value if it becomes stale or invalid. I routinely use that object$0 $0as a backing for properties whose values are expensive to$0 $0initialize or compute, so the computed value is cached and$0 $0can also be reinitialized whenever needed.$0 $0$0 $0 $0If Lazy<T> had such a method, it could be used to cache $0 $0values that can become invalid or stale at some point, and$0 $0need to be reinitialized.$0 $0 $0$0 $0 $0Another useful feature would be a way to declare a $0 $0property that is backed by a Lazy<T> (if it supported$0 $0invalidation), without having to write any code other$0 $0than the ValueFactory method.$0 $0$0 $0 $0$0 $0

Regarding the singleton guarantee I found this implementation in the Task Parallel Library samples:

 public sealed class LazySingleton
    {
        private readonly static Lazy<LazySingleton> instance =
            new Lazy<LazySingleton>(() => new LazySingleton() );

        private LazySingleton() { }

        public static LazySingleton Instance
        {
            get { return instance.Value; }
        }
    }

The most important point of Lazy<T> is that it provides a neat implementation of the singleton pattern (only one instance will be created even under race conditions). For more information, see this comprehensive blog post: http://geekswithblogs.net/BlackRabbitCoder/archive/2010/05/19/c-system.lazylttgt-and-the-singleton-design-pattern.aspx

[Igby] No, this is not an implementation of the singleton pattern. This is an implementation of the lazy initiailization pattern. You can still create multiple instances:
Lazy<MyClass> lazy1 = new Lazy<MyClass>();
Lazy<MyClass> lazy2 = new Lazy<MyClass>();

[Glenn] It's true that you can create multiple instances of Lazy<MyClass>, but Luke's statement is still correct: Within a multithreaded program, an instance of Lazy<MyClass> can be used to implement a singleton MyClass that is shared by all threads. The Lazy<MyClass> must be thread safe, and all threads must access the same instance of Lazy<MyClass>.

http://log.medcl.net/item/2010/11/system-lazy-u003ctu003e/