Qual è la differenza tra incapsulare un membro privato come proprietà e definire una proprietà senza un membro privato?

Qual è la differenza (prestazioni, memoria … ecc.) Tra incapsulare un membro privato come questo

private int age; public int Age { get { return age; } set { age = value; } } 

e definire una proprietà come questa

 public int Age { get ; set ; } 

Il codice che il compilatore C # genera per le proprietà auto-implementate è quasi identico al tuo primo esempio (usa un campo privato di backing), quindi non mi preoccuperei troppo di ciò.

L’ unica vera differenza è che decora la proprietà getter e setter con l’attributo [CompilerGenerated] . Questo non dovrebbe avere alcun impatto sulle prestazioni di ottenere e impostare la proprietà. (Come minimo nitpick, questo dovrebbe aumentare la dimensione del file binario dell’assemblaggio anche se leggermente leggermente).

Quello che mi piace delle proprietà auto-implementate, a parte la brevità ovviamente, è che impedisce anche al tipo dichiarante di accedere al backing-field invece della proprietà (il backing-field è anonimo). Ciò apporta chiarezza al codice e in genere facilita anche il refactoring / modifica dell’implementazione della proprietà.

Nel secondo caso, il compilatore C # genererà un campo per te e genererà un getter e un setter per accedervi. In altre parole, non vi è alcuna differenza funzionale tra i due campioni di codice che hai postato. L’unica differenza sarà il nome del campo privato, che verrà generato dal compilatore.

Ho fatto questa domanda qualche tempo fa:

vedi Uso corretto delle proprietà C #

Citando la risposta:

Sono equivalenti nel modulo compilato interno, tranne per il fatto che non è ansible accedere alla variabile privata generata dal compilatore nel secondo modulo.

Dal punto di vista dell’efficienza del codice, sono ugualmente equivalenti, il compilatore just in time normalmente accede direttamente alla variabile privata senza il sovraccarico di chiamare una funzione di accesso (dopo che l’ambiente di runtime ha controllato l’accessibilità, ecc.).

Dal punto di vista del codice, preferisco la seconda versione che è più compatta (meno da scrivere, meno da leggere).

La seconda syntax è stata introdotta in C # 3.0. Quindi la prima variante sarebbe più compatibile con i vecchi compilatori.

La differenza è che hai il controllo su getter e setter.

Con l’implementazione automatica, non puoi fare qualcosa come:

 private int age; public int Age { get { return age; } set { if (age != value) { age = value; OnAgeChanged(EventArgs.Empty); } } } public event EventHandler AgeChanged; protected virtual void OnAgeChanged(EventArgs e) { var handler = AgeChanged; if (handler != null) handler(this, e); } 

Se non ne hai bisogno, l’implementazione automatica dovrebbe essere sufficiente.

Il vantaggio principale rispetto all’utilizzo di un’implementazione di proprietà automatica rispetto a un campo è che quando si utilizza un’implementazione di proprietà automatica e in seguito si desidera modificare l’implementazione, ad esempio in precedenza, l’interfaccia della class non cambia.

nessuna differenza rispetto alle prestazioni nel secondo caso è lo zucchero sintetico per la scrittura di proprietà chiamate Proprietà automatiche.

se vuoi mettere un po ‘di logica nel set o ottenere parte, non sarai in grado di farlo automaticamente.