Le novità  del .NET Framework 4.0: Lazy Initialization

Per Lazy Initialization di un oggetto si intende il fatto che la sua creazione venga rimandata fino al momento in cui esso viene effettivamente utilizzato. In questo modo si possono ottenere aumenti di performance anche notevoli. Gli scenari in cui questa tecnica può essere sfruttata sono sostanzialmente due. Nel primo caso possiamo trovarci nella situazione in cui un certo oggetto molto pesante da creare potrebbe anche non essere mai utilizzato in quanto il suo uso presuppone una specifica scelta fatta dall'utente.

Un caso semplice potrebbe essere quello rappresentato da una classe Cliente che contenga al suo interno la collection Ordini. Quest'ultima potrebbe dover accedere al database per l'inizializzazione di tutti gli ordini e richiedere quindi un certo tempo oltre ad un certo consumo di memoria. Se necessario, ovviamente dobbiamo farlo, ma se ad esempio l'utente decide di non visualizzare gli ordini di un certo Cliente avremo speso tempo macchina e memoria inutilmente.

Il secondo scenario vede come protagonisti sempre oggetti onerosi da creare ed inizializzare ma questa volta necessari all'esecuzione dell'applicazione e quindi non rinunciabili. In questo caso ci troviamo dinanzi ad oggetti che vogliamo creare solo dopo che altre operazioni sono state completate. Immaginiamo per esempio un'applicazione che crei diversi oggetti pesanti in fase di caricamento iniziale e vogliamo quindi in qualche modo scaglionare nel tempo la creazione di questi oggetti dando la precedenza di volta in volta a quelli utilizzati effettivamente in un certo momento per evitare di rallentare eccessivamente il tempo di avvio dell'applicazione.

Possiamo quindi risolvere elegantemente questi due scenari utilizzando il nuovo tipo Lazy<T>. Tornando all'esempio sopra possiamo immaginare di avere una classe Ordini che rappresenta gli ordini di un particolare Cliente:

Lazy<Ordini> _ordini = new Lazy<Ordini>();

poi esponiamo _ordini con una proprietà  della classe Cliente:

public class Cliente
{
    private Lazy<Ordini> _ordini = new Lazy<Ordini>();
    public Cliente()
    {
       ...
    }
    public Ordini OrdiniCliente
    {
        get
        {
            return _ordini.Value;
        }
    }
}

Finché non andiamo a leggere la proprietà  OrdiniCliente e quindi la proprietà  Value del nostro nuovo tipo Lazy<Ordini> la classe Ordini non sarà  istanziata e con essa non sarà  effettuato neanche l'accesso al database. Le prestazioni ringraziano!