Méthodes de Lazy Initialisation avec des propriétés

Question

Je suis actuellement modifier une classe largement utilisée pour déplacer autant de l'initialisation coûteuse du constructeur de la classe dans les propriétés Lazy initialisés. Voici un exemple (en C #):

Avant:

public class ClassA
{
    public readonly ClassB B;

    public void ClassA()
    {
        B = new ClassB();
    }
}

Après:

public class ClassA
{
    private ClassB _b;

    public ClassB B
    {
        get
        {
            if (_b == null)
            {
                _b = new ClassB();
            }

            return _b;
        }
    }
}

Il y a juste quelques plus de ces propriétés dans la classe que je suis altérant, et certains ne sont pas utilisés dans certains contextes (d'où le Paresse), mais s'ils sont utilisés, ils sont susceptibles d'être appelé à plusieurs reprises.

Malheureusement, les propriétés sont aussi souvent utilisés à l'intérieur de la classe. Cela signifie qu'il ya un potentiel pour la variable privée (_b) pour être utilisé directement par une méthode sans être initialisé.

Y at-il un moyen de faire que la propriété publique (B) disponible à l'intérieur de la classe, ou même une autre méthode avec le même initialisé-quand nécessaire?

Ceci est réaffiché des programmeurs (pas assez subjective apparemment): https://softwareengineering.stackexchange.com/questions/34270/best- procédés à des fins de-initialisation-de-paresseux propriétés

Answer 1

Vous pourriez envisager de pousser les propriétés paresseux dans une classe de base pour éviter un accès direct à la variable de support. Je sais pas idéal. Je l'ai toujours pensé que cela était quelque chose qui manque en C # à savoir un soutien direct aux propriétés paresseux.

Answer 2

Eh bien, ma solution recommandée serait de dire à votre collègue de travail à utiliser la propriété, et non pas sur le terrain. Mais vous pourriez idiot preuve à un certain degré comme ceci:

public class ClassA
{
    private Lazy<ClassB> _b = new Lazy<ClassB>(() => new ClassB());

    public ClassB B
    {
        get
        {
            return _b.Value;
        }
    }
}

Maintenant, il est assez difficile de bousiller.

Answer 3

@chibacity affiché (et par la suite) supprimé [et plus tard annulation de la suppression: P] une option alternative à l'aide d'une classe de base abstraite. Bien qu'il ne peut pas être idéal en termes de distribution de code, il fournit une encapsulation agréable suppression d'un grand nombre de prise de l'encombrement de code pour un produit de nettoyage et ClassA plus succinct. Par exemple, vous pourriez envisager de combiner les techniques pour atteindre les deux objectifs:

public class ClassB { /* Class to be lazily instantiated */ }

public abstract class BaseA
{
    private Lazy<ClassB> _b = new Lazy<ClassB>(() => new ClassB());
    public virtual ClassB B { get { return _b.Value; } }
}

public class ClassA : BaseA
{
    public override ClassB B { get { return base.B; } }
}

À première vue, il semble que cela est plus longue haleine, mais si l'on considère que ClassA qui est la classe que vous travaillerez et avec cela maintenant signifie que toutes vos références passent par la même propriété - il y a aucun champ inutile étrangers qui sème la confusion potentielle, il n'y a pas sans passer par la propriété à _b de référence directement et il n'y a pas besoin de dire à votre collègue de travail qui à utiliser ... il n'y a qu'un seul.

ne dis pas cela est la bonne façon de le faire ou que ce soit un modèle qui devrait ou ne devrait pas être suivi, je signale simplement les avantages de ce @chibacity a suggéré que peut autrement passer inaperçu.

Ce serait bien si vous pouviez avoir des propriétés chargées paresseux implicites sans avoir à se référer à B.Value ... par exemple:

[Lazy]
public ClassB B { get; }

ou pour des objets sans constructeurs sans paramètre

[Lazy(() => new ClassB("Hello", "World"))]
public ClassB B { get; }

ou peut-être @chibacity suggéré dans un commentaire

public ClassB B { lazyget; }

ou

public ClassB B { lazyget : new ClassB(); }

Hélas, je ne pense pas que l'une de ces solutions sont actuellement disponibles sous quelque forme que ...