Quando dovresti usare un campo anziché una proprietà?

StackOverflow https://stackoverflow.com/questions/641619

  •  22-07-2019
  •  | 
  •  

Domanda

Qualcuno può chiaramente articolare quando si utilizza un campo e quando utilizzare una proprietà nel design di classe?

Si consideri: 

public string Name;

o 

private string _Name;
public string Name
{
   get { return _Name; }
   set { _Name = value; }
}

Mi rendo conto che il secondo metodo è più corretto e flessibile, quindi è quello che cerco di usare, in generale.

Ma allora perché vedo le persone usare il primo metodo? Sono solo pigri o c'è qualche situazione specifica in cui è la scelta giusta? È solo una questione di preferenza?

È stato utile?

Soluzione

Beh, in C # 3.0 puoi effettivamente scrivere: 

public string Name {get; set;}

Che ti permette di essere corretto e pigro.

In generale, con le proprietà, si ottiene l'incapsulamento corretto. Puoi scegliere se consentire l'impostazione di un valore, ottenerlo o entrambi. Utilizzando un membro pubblico, non hai questa opzione.

Probabilmente è una preferenza in una parte e in una parte il modo in cui il tuo team decide di gestire definizioni di classe rapide e sporche, ma direi che usa le proprietà per get / sets.

Per rispondere

  

Qualcuno può chiaramente articolare quando si utilizza un attributo e quando utilizzare una proprietà nel design di classe?

Non dovresti mai usare un attributo pubblico. Si dovrebbe sempre usare una proprietà invece. È più sicuro e più flessibile. Detto questo, le persone saranno pigre e useranno solo un membro pubblico. Tuttavia, con C # 3.0 puoi usare una sintassi più concisa per definire le proprietà, che dovrebbero soddisfare la tua pigrizia interiore.

Basta digitare prop e premere <tab> per accelerare la pigrizia nell'aggiunta di una proprietà.

Altri suggerimenti

Solo alcune informazioni aggiuntive alla risposta di Alan: 

public string Name {get; set;}

è uguale a 

private string _Name;

public string Name{   
get { return _Name; }   
set { _Name = value; }
}

Se si desidera non consentire la funzione impostata di Nome, è possibile avere

nome stringa pubblica {get; privato impostato;}

Le proprietà sono più gestibili dei campi, puoi incapsulare la logica nei setter / getter, permettendoti di nascondere l'implementazione.

Inoltre facilitano il refactoring.

Ulteriori informazioni:

Usando le proprietà puoi controllarne la sicurezza: 

public string Foo { protected get; private set; }

Proprietà offre un modo semplice per generare eventi: 

public string Foo
{
  get { return _foo; }
}
set
{
  bool cancel = false;
  if(BeforeEvent != null) // EventHandler<CancelEventArgs> BeforeEvent
  {
    CancelEventArgs e = new CancelEventArgs();
    BeforeEvent(this, e);
    cancel = e.Cancel;
  }
  if(!cancel)
  {
    _foo = value;
    if(AfterEvent != null) // EventHandler<EventArgs> AfterEvent
    {
      AfterEvent(this, new EventArgs());
    }
  }
}

Inoltre uso spesso codice come questo: 

string Foo
{
  set
  {
    IsFooSet = value != null;
  }
}

bool IsFooSet
{
  get { return _isFoo; }
  set
  { 
   _isFoo = value;
   if(value) // some event raise or controls on form change
  }
}

Quando rendi pubblico il campo, consenti all'utente di fare qualsiasi cosa vogliano fare sul campo. Possono assegnare valori imprevisti, valori non validi, valori che possono causare overflow, ecc.

Con la proprietà, puoi controllare se consentire l'impostazione di nuovi valori sul campo, massaggiando il valore prima di memorizzarlo, avvisando le parti interessate della modifica del valore del campo, ecc. E la stessa idea per restituire valore attraverso il getter. Per .NET framework dalla 2.0 in poi, è possibile impostare l'accessor per il getter, setter. Ad esempio, desideri solo che l'utente abbia accesso in lettura al campo, quindi rendi pubblico il getter, ma il setter è privato o protetto.

Oltre ai motivi già indicati per preferire le proprietà, ci sono anche molte cose interessanti in System.ComponentModel che hanno a che fare con l'associazione dei dati e le notifiche di modifica che funzionano solo con le proprietà piuttosto che con i campi. Ad esempio, guarda la documentazione relativa a PropertyChangedHandler.

Una proprietà come definita sopra agisce come un getter e setter. L'unico vantaggio dell'utilizzo di una proprietà è che puoi trattarla come una variabile con restrizione di accesso. 

public string Name { get; private set; }

Questa proprietà è accessibile pubblicamente, ma può essere impostata solo privatamente. (Non vorresti che qualcuno cambiasse il tuo nome senza il tuo consenso adesso!;))

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top