Informazioni sulle proprietà implementate automaticamente

Question

Ho la classe semplice che usa le proprietà implementate automaticamente:

Public Class foo
{
    public foo() { }  

    public string BarName {get; set;}
}

Ovviamente uso la variabile BarName in tutta la mia classe e ora ho bisogno di aggiungere logica quando il valore della proprietà è impostato (deve essere tutto in maiuscolo, vai in figura). Questo significa che ora devo creare una variabile privata per BarName, ad es. _BarName e modificare l'attuale variabile BarName utilizzata in tutta la mia classe in _BarName?

Public Class foo
{
    public foo() {}  

    private string _BarName = "";
    public string BarName 
    { 
        get {return _BarName;}
        set {_BarName = Value.ToString().ToUpper();}
    }
}

Sto cercando di assicurarmi di comprendere le implicazioni dell'utilizzo delle proprietà implementate automaticamente e cosa comporterà lungo la strada quando / se dovrò cambiare qualcosa. Presumo che il refactoring, come mostrato sopra, non sia un cambiare perché la proprietà rimane sostanzialmente la stessa; ci è voluto solo un po 'di lavoro all'interno della classe per mantenerlo in quel modo e aggiungere la logica necessaria.

Un altro esempio, che potrebbe essere più significativo, è che ho bisogno di chiamare un metodo quando si usa un setter o getter; più che cambiare il valore.

Questo sembra un equo scambio tra le righe e le righe di codice per impostare le proprietà.

Answer 1

  

Significa che ora devo farlo   creare una variabile privata per BarName

Si

  

e cambia l'attuale NomeBar   variabile utilizzata in tutta la mia classe

Non modificare il resto del codice nella classe per utilizzare la nuova variabile privata creata. BarName , come proprietà, ha lo scopo di nascondere la variabile privata (tra le altre cose), allo scopo di evitare i cambiamenti radicali che contempli al resto del tuo codice.

  

Suppongo che il refactoring, come   mostrato sopra, non è un cambiamento di rottura   perché la proprietà è fondamentalmente   rimanere lo stesso; ci sono voluti solo a   poco lavoro per mantenerlo così e   aggiungi la logica necessaria.

Una corretta.

Answer 2

Non è necessario modificare nulla. Le proprietà implementate automaticamente sono solo zucchero sintattico. Il compilatore sta generando la variabile privata e ottiene / imposta la logica per te, dietro le quinte. Se aggiungi la tua logica getter / setter, il compilatore utilizzerà il tuo codice anziché il suo codice generato automaticamente, ma per quanto riguarda gli utenti di quella proprietà, nulla è cambiato; qualsiasi codice che fa riferimento alla tua proprietà continuerà a funzionare.

Answer 3

Quando si utilizzano le proprietà automatiche non si ottiene l'accesso diretto al "supporto" sottostante variabile e non si ottiene l'accesso alla logica effettiva che viene implementata nel getter e nel setter di proprietà. Hai accesso solo alla proprietà (quindi utilizzando BarName in tutto il codice).

Se ora devi implementare una logica specifica nel setter, non puoi più utilizzare le proprietà automatiche e devi implementare la proprietà nel "vecchio stile" modo. In questo caso, è necessario implementare la propria variabile di supporto privata (il metodo preferito, almeno per me, è di nominare la variabile di supporto privato con lo stesso nome della proprietà, ma con una minuscola iniziale (in questo caso, il supporto La variabile si chiamerà barName). Quindi implementare la logica appropriata nel getter / setter.

Nel tuo esempio, hai ragione nel dire che non si tratta di un cambiamento di rottura. Questo tipo di refactoring (passando dalle proprietà automatiche alle proprietà "normali" non dovrebbe mai essere una modifica in quanto non stai modificando l'interfaccia pubblica (il nome o l'accessibilità della proprietà pubblica).

Answer 4

Non usare le proprietà automatiche se sai che stai per convalidare quell'oggetto. Questi oggetti possono essere oggetti di dominio ecc. Ad esempio, se si dispone di una classe Customer, utilizzare le variabili private perché potrebbe essere necessario convalidare il nome, la data di nascita, ecc. Ma se si utilizza una classe Rss, sarà possibile utilizzare solo le proprietà automatiche poiché non viene eseguita alcuna convalida e la classe viene utilizzata solo per contenere alcuni dati.

Answer 5

Hai ragione sul refactoring e in realtà non dovrebbe rompere nulla.

La necessità o meno di passare effettivamente attraverso i riferimenti all'interno della classe al nome della proprietà e modificarli per fare riferimento al campo privato dipende dal fatto che il codice interno sia necessario per accedere alla rappresentazione sottostante dei dati piuttosto che da come è stato presentato ai consumatori della classe. Nella maggior parte dei casi potresti lasciarti abbastanza bene da solo.

Nel tuo semplice esempio sarebbe saggio lasciare abbastanza da solo e assicurarsi che nessun codice interno alla classe possa sovvertire la conversione / formattazione eseguita nel setter.

Se invece il getter stava facendo un po 'di magia per cambiare la rappresentazione interna del campo nel modo in cui i consumatori avevano bisogno di visualizzare i dati, forse (in alcuni casi) il codice interno all'interno della classe avrebbe bisogno di accedere al campo .

Dovresti esaminare ogni ricorrenza dell'accesso alla proprietà automatica nella classe e decidere se toccare il campo o usare la proprietà.

Answer 6

Le proprietà automatiche sono solo zucchero sintattico, il compilatore infatti crea il membro privato per esso, ma poiché è generato in fase di compilazione, non è possibile accedervi.

E in seguito, se si desidera implementare getter e setter per la proprietà, solo allora si crea un membro privato esplicito per esso e si aggiunge la logica.