setter omesso vs setter privato?

Question

Qual è la differenza tra una proprietà con un setter omesso e una proprietà con un setter privato?

public string Foo { get; private set; } 

vs

public string Foo { get; } 

Answer 1

In C# 6, get; solo le proprietà sono impostabili solo dal costruttore. Da qualsiasi altra parte, è di sola lettura.

Una proprietà con un private set; può essere impostata ovunque all'interno di tale classe.

Answer 2

dall'esterno della classe, ma non cambierà nulla se si utilizza questa sintassi:

public string Foo { get; } 

ma non sarà in grado di aggiornare Foo all'interno la classe, ad eccezione del costruttore, per farlo, è necessario il setter privato:

public string Foo { get; private set; } 

Answer 3

Una proprietà con un setter omesso viene letta solo ovunque tranne il costruttore della classe, incluso all'interno della classe.

Una proprietà con un setter privato viene letta solo esternamente (anche in sottoclassi), ma scrivibile internamente.

Answer 4

Il setter private è - beh - un metodo set privato che è possibile utilizzare solo all'interno della classe.

Il omesso setter rende la proprietà readonly. Quindi puoi solo impostare il valore di questa proprietà nei tuoi costruttori o tramite un'inizializzazione statica.

Answer 5

La differenza è che il codice generato produrrà un campo di sola lettura nel secondo caso e ovviamente la proprietà non avrà un setter.

Facciamo un esempio reale:

public class Test 
{ 
    public Test(string name) { Name = name; } 
    public string Name { get; private set; } 
} 

il compilatore compilare questo in questo modo:

public class Test 
{ 
    private string <Name>k__BackingField; 
    public Test(string name) 
    { 
     <Name>k__BackingField = name; 
    } 
    public string Name 
    { 
     get { return <Name>k__BackingField; } 
     private set { <Name>k__BackingField = value; } 
    } 
} 

Come si può vedere il compilatore ha automagicamente riscritto il codice per avere un campo di supporto per la proprietà. Il nome del campo sarà quel nome criptico, che è legale .NET ma non C#, il che significa che non puoi mai scrivere codice C# in conflitto con tale membro generato automaticamente.

Fondamentalmente, le proprietà automatiche in C# sono solo zucchero sintattico per una proprietà con un campo di supporto, la proprietà effettiva che si sta compilando ha ancora un campo di supporto, non è necessario scriverlo esplicitamente.

Come si può vedere, inoltre, ha riscritto automaticamente il costruttore per scrivere direttamente nel campo. Nota che questo verrà fatto ovunque all'interno di questa classe in cui la proprietà è scritta, dal momento che non vi è alcuna possibilità che ogni codice personalizzato sia comunque intromesso.

Ora cerchiamo di rimuovere il setter dalla proprietà e vediamo cosa succede:

public class Test 
{ 
    private readonly string <Name>k__BackingField; 
    public Test(string name) 
    { 
     <Name>k__BackingField = name; 
    } 
    public string Name 
    { 
     get { return <Name>k__BackingField; } 
    } 
} 

Si noti che il campo è ora di sola lettura, e di nuovo, ovviamente, il setter è passato dalla proprietà pure.

Quindi questo è in realtà il modo migliore ora per creare tipi semplici con veri proprietà di sola lettura, non solo è la struttura in sé non scrivibile, ma il campo di supporto viene anche in sola lettura che significa che stai ora meglio attrezzata per scrivere facilmente tipi immutabili.