Tra le tante piccole e grandi novità del .NET Framework 4.0 ci sono le classi Lazy<T> e LazyVariable<T>. Il concetto è molto semplice: istanziamo un tipo passando un delegate ad una funzione che restituisce un valore; la prima volta che interroghiamo la proprietà Value, il delegate viene chiamato e il valore persistito per le successive interrogazioni.

Ecco un esempio:

static void Main(string[] args)
{
    Lazy<String> v = new Lazy<String>(GetValue);
    Lazy<String> v2 = v;

    Console.WriteLine(v.Value);
    Console.WriteLine(v.Value);
    Console.WriteLine(v2.Value);
}

private static string GetValue()
{
    Console.WriteLine("GetValue called");
    return "ciao";
}

che stampa a video:

GetValue called
ciao
ciao
ciao

La differenza con LazyVariable è che questa è una struct invece che una classe. Perciò il seguente codice:

static void Main(string[] args)
{
    LazyVariable<String> v = new LazyVariable<String>(GetValue);
    LazyVariable<String> v2 = v;

    Console.WriteLine(v.Value);
    Console.WriteLine(v.Value);
    Console.WriteLine(v2.Value);
}

stampa:

GetValue called
ciao
ciao
GetValue called
ciao

Questo perché quando si assegna v a v2, viene copiata l'intera struttura e non mantenuto un riferimento alla classe come avviene con Lazy.
Entrambe le classi sono inoltre serializzabili e accettano nel costruttore un LazyExecutionMode che dispone di tre valori: NotThreadSafe, EnsureSingleThreadSafeExecution, AllowMultipleThreadSafeExecution. In questo modo possiamo decidere se accedere a Value indicando che solo un thread ci accederà, oppure più thread ci possono accedere e solo una volta il delegate viene eseguito (tramite lock), oppure più thread ci accedono e una o più volte il delegate potrebbe essere eseguito (il default). Mi piacerebbe che implementassero anche la conversione implicita verso T così da non dover interrogare Value, ma forse lo faranno :-)