I metodi per pigro inizializzazione con proprietà

Question

Al momento sto alterando una classe ampiamente utilizzato per spostare il maggior numero di inizializzazione costoso dal costruttore della classe nella proprietà Pigro inizializzato. Di seguito è riportato un esempio (in C #):

Prima:

public class ClassA
{
    public readonly ClassB B;

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

Dopo:

public class ClassA
{
    private ClassB _b;

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

            return _b;
        }
    }
}

Ci sono un bel po 'di più di queste proprietà nella classe Sono alterazione, e alcuni non sono utilizzati in alcuni contesti (da qui il Pigrizia), ma se sono usati sono suscettibili di essere chiamati più volte.

Purtroppo, le proprietà sono spesso utilizzati anche all'interno della classe. Ciò significa che c'è un potenziale per la variabile privata (_b) da utilizzare direttamente da un metodo che non è inizializzato.

C'è un modo per fare solo la proprietà pubblica (B) disponibile all'interno della classe, o anche un metodo alternativo con lo stesso inizializzato, quando necessaria?

Questa viene ripubblicato da programmatori (non abbastanza soggettivo apparentemente): https://softwareengineering.stackexchange.com/questions/34270/best- metodi-per-lazy-inizializzazione-con-proprietà

Answer 1

Si potrebbe prendere in considerazione che spinge le proprietà pigri in una classe di base per evitare l'accesso diretto alla variabile supporto. Non è l'ideale, lo so. Ho sempre pensato che questo era qualcosa che manca in C # vale a dire il supporto diretto per le proprietà pigri.

Answer 2

Bene, la mia soluzione consigliata sarebbe quella di dire al vostro collega di utilizzare la proprietà, non il campo. Ma ad un certo grado in questo modo si potrebbe prova di idiota-:

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

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

Ora è piuttosto difficile da rovinare.

Answer 3

@chibacity pubblicato (e successivamente) soppresso [e poi non eliminato: P] un'opzione alternativa utilizzando una classe base astratta. Mentre non può essere l'ideale in termini di distribuzione del codice che fornisce un bel incapsulamento rimozione di un sacco di codice fare disordine per una più pulito e più succinta ClassA. Per esempio, si potrebbe prendere in considerazione che unisce le tecniche per raggiungere entrambi gli obiettivi:

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; } }
}

A prima vista, sembra che questo è più lungo senza fiato, ma se si considera che ClassA che è la classe si sarebbe lavorare in e con, questo significa che ora tutti i riferimenti stanno attraversando la stessa proprietà - non c'è campo inutili senza estranei causando potenziale confusione, non c'è bypassando la proprietà di _b riferimento direttamente e non c'è bisogno di dire al vostro collega quale usare ... un solo c'è.

Non dicendo che questo è il modo giusto per fare questo o che si tratta di un modello che dovrebbe o non dovrebbe essere seguita, sto solo sottolineando i vantaggi di quello che @chibacity ha suggerito che potrebbero altrimenti passare inosservati.

Sarebbe bello se si potesse avere implicite proprietà caricati pigri, senza dover fare riferimento a B.Value ... per esempio:

[Lazy]
public ClassB B { get; }

o per gli oggetti senza costruttori senza parametri

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

o forse come @chibacity suggerito in un commento

public ClassB B { lazyget; }

o

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

Ahimè, io non credo che nessuno di questi sono soluzioni attualmente disponibili in qualsiasi forma ...