readonly vs. proprietà private getter-only in C # 6

Se si dà un'occhiata qui , vedrete che il seguente codice:

class Example
{
   private List<LinearLayout> layouts1 { get; } = new List<LinearLayout>();
}

Viene abbassato dal compilatore per:

internal class Example
{
    private readonly List<LinearLayout> <layouts1>k__BackingField = new List<LinearLayout>();

    private List<LinearLayout> layouts1
    {
        get
        {
            return <layouts1>k__BackingField;
        }
    }
}

e la proprietà viene ulteriormente abbassata a un metodo get_layouts1() .

In altre parole, gli inizializzatori della proprietà automatica sono puro zucchero sintattico. Forniscono un mezzo per utilizzare le proprietà automatiche, pur consentendo l'inizializzazione del campo di supporto.

Quindi dal punto di vista della mutevolezza, non c'è alcuna differenza tra loro. Entrambi forniscono accesso in sola lettura a un elenco inizializzato quando viene creata un'istanza della classe.

È possibile che crei una leggera overhead delle prestazioni poiché il metodo deve essere chiamato per ottenere il riferimento all'elenco, ma è probabile che JIT CLR ottimizzi il metodo e acceda direttamente al campo.

L'uso più ovvio per le proprietà private è a scopo di caricamento lento / posticipato . Ci sono altri usi, ma come linea guida, sono spesso "rumore" inutile. Non andrei tanto lontano da dire che l'utilizzo di una proprietà privata è peggio che usare solo un campo, ma consiglio di usare un campo di sola lettura per la maggior parte dei casi.

In questo caso funzionerebbero quasi in modo identico. C'è una sottigliezza che renderebbe la proprietà privata meno che ideale:

• Il bytecode avrebbe accesso a List<LinearLayout> tramite una funzione getter. Tuttavia, non appena il bytecode viene ricompilato per il tuo ambiente (cosa che C # ha fatto per molto tempo), la funzione getter sarebbe stata ottimizzata, quindi non un vero problema.

Se vengono utilizzati in modo identico, non ci saranno differenze pratiche.