Quels sont les avantages Lazy offre sur standard instanciation paresseux?

Question

Considérez cet exemple, il montre deux manières possibles d'initialisation paresseuse. Sauf pour être thread-safe, sont-il des advantates spécifiques de l'utilisation Lazy ici

class Customer {
    private decimal? _balance2;
    private static decimal GetBalanceOverNetwork() {
        //lengthy network operations
        Thread.Sleep(2000);
        return 99.9M;
    }

    public decimal? GetBalance2Lazily() {
        return _balance2 ?? (_balance2 = GetBalanceOverNetwork());
    }

    private readonly Lazy<decimal> _balance1 = new Lazy<decimal>(GetBalanceOverNetwork);

    public Lazy<decimal> Balance1 {
        get { return _balance1; }
    }
}

Mise à jour:

S'il vous plaît considérer le code ci-dessus comme un exemple simple, les types de données ne sont pas pertinentes, le point est ici pour comparer Lazy sur standard initialisation paresseuse.

Answer 1

Il est sémantiquement plus correct.

Lorsque vous utilisez le Nullable<decimal>, ce que vous dites est que la valeur de null défendraient l'état « non évalué ». Bien que ce soit une conversion commune, il est toujours arbitraire. Il y a des millions d'autres façons d'interpréter null, vous devez donc expliquer probablement quelque part (dans la documentation ou tout au moins un commentaire) quels moyens nuls dans ce cas.

Au contraire, lorsque vous utilisez Lazy<decimal>, vos intentions sont claires.