Domanda

Domanda rapida: quando decidi di usare le proprietà (in C #) e quando decidi di usare i metodi?

Siamo impegnati in questo dibattito e abbiamo trovato alcune aree in cui è discutibile se dovremmo usare una proprietà o un metodo. Un esempio è questo:

public void SetLabel(string text)
{
    Label.Text = text;
}

Nell'esempio, Label è un controllo su una pagina ASPX. Esiste un principio che può governare la decisione (in questo caso) se rendere questo un metodo o una proprietà.

Accetterò la risposta più generale e completa, ma che tocca anche l'esempio che ho fornito.

Altri suggerimenti

Sì, se tutto ciò che stai facendo è ottenere e impostare, usa una proprietà.

Se stai facendo qualcosa di complesso che può influenzare diversi membri dei dati, un metodo è più appropriato. Oppure se il tuo getter accetta parametri o il setter accetta più di un parametro valore.

Al centro c'è un'area grigia in cui la linea può essere leggermente sfocata. Non esiste una regola rigida e veloce e diverse persone a volte non sono d'accordo sul fatto che qualcosa debba essere una proprietà o un metodo. L'importante è essere (relativamente) coerenti con il modo in cui lo fai (o come lo fa il tuo team).

Sono in gran parte intercambiabili ma una proprietà segnala all'utente che l'implementazione è relativamente "semplice". Oh, e la sintassi è un po 'più pulita.

In generale, la mia filosofia è che se inizi a scrivere un nome di metodo che inizia con get o set e accetta zero o un parametro (rispettivamente), allora è un candidato principale per una proprietà.

Se stai impostando una proprietà effettiva del tuo oggetto, allora usi una proprietà.

Se stai eseguendo un'attività / funzionalità, allora usi un metodo.

Nel tuo esempio, è una proprietà definita che viene impostata.

Se tuttavia, la tua funzionalità fosse quella di AppendToLabel, utilizzeresti un metodo.

Le proprietà sono un modo per iniettare o recuperare dati da un oggetto. Creano un'astrazione su variabili o dati all'interno di una classe. Sono analoghi a getter e setter in Java.

I metodi incapsulano un'operazione.

In generale utilizzo le proprietà per esporre singoli bit di dati o piccoli calcoli su una classe, come l'imposta sulle vendite. Che deriva dal numero di articoli e dal loro costo in un carrello.

Uso i metodi quando creo un'operazione, come il recupero di dati dal database. Qualsiasi operazione che abbia parti in movimento è un candidato per un metodo.

Nel tuo esempio di codice lo racchiuderei in una proprietà se dovessi accedervi al di fuori della sua classe contenente:

public Label Title 
{
   get{ return titleLabel;}
   set{ titleLabel = value;}
}

Impostazione del testo:

Title.Text = "Properties vs Methods";

Se stessi solo impostando la proprietà Text dell'etichetta, è così che lo farei:

public string Title 
{
   get{ return titleLabel.Text;}
   set{ titleLabel.Text = value;}
}

Impostazione del testo:

Title = "Properties vs Methods";

Cercando tramite MSDN, ho trovato un riferimento su Proprietà vs metodi che fornisce alcune ottime linee guida per la creazione di metodi:

  
      
  • L'operazione è una conversione, ad esempio Object.ToString .
  •   
  • L'operazione è abbastanza costosa da comunicare con   l'utente che dovrebbe prendere in considerazione la memorizzazione nella cache   il risultato.
  •   
  • Ottenere un valore di proprietà utilizzando l'accessor get avrebbe un valore osservabile   effetto collaterale.
  •   
  • Chiamare il membro due volte in successione produce risultati diversi.
  •   
  • L'ordine di esecuzione è importante. Si noti che le proprietà di un tipo dovrebbero   essere in grado di essere impostato e recuperato in qualsiasi   ordine.
  •   
  • Il membro è statico ma restituisce un valore che può essere modificato.
  •   
  • Il membro restituisce un array. Le proprietà che restituiscono array possono essere   molto fuorviante. Di solito lo è   necessario per restituire una copia del   array interno in modo che l'utente non possa   cambia stato interno. Questo, accoppiato   con il fatto che un utente può facilmente   supponiamo che sia una proprietà indicizzata,   porta a un codice inefficiente.
  •   

Similmente le proprietà sono attributi dei tuoi oggetti. I metodi sono comportamenti del tuo oggetto.

L'etichetta è un attributo e ha più senso renderla una proprietà.

In termini di programmazione orientata agli oggetti, dovresti avere una chiara comprensione di ciò che fa parte del comportamento e di ciò che è semplicemente un attributo.

Auto {Colore, Modello, Marca}

Un'auto ha gli attributi Color, Model e Brand, quindi non ha senso avere un metodo SetColor o SetModel perché in modo sintetico non chiediamo a Car di impostare il proprio colore.

Quindi se mappi il caso proprietà / metodo sull'oggetto reale o lo guardi da un punto di vista simbolico, la tua confusione sparirà davvero.

Devi solo guardare il nome ... " Proprietà " ;. Cosa significa? Il dizionario lo definisce in molti modi, ma in questo caso "un attributo o qualità essenziale o distintivo di una cosa" si adatta meglio.

Pensa allo scopo dell'azione. Stai, infatti, alterando o recuperando "un attributo essenziale o distintivo"? Nel tuo esempio, stai usando una funzione per impostare una proprietà di una casella di testo. Sembra un po 'sciocco, vero?

Le proprietà sono davvero funzioni. Si compilano tutti in getXXX () e setXXX (). Li nasconde solo nello zucchero sintattico, ma è lo zucchero che fornisce un significato semantico al processo.

Pensa a proprietà come gli attributi. Una macchina ha molti attributi. Colore, MPG, modello, ecc. Non tutte le proprietà sono impostabili, alcune sono calcolabili.

Nel frattempo, un metodo è un'azione. GetColor dovrebbe essere una proprietà. GetFile () dovrebbe essere una funzione. Un'altra regola empirica è che, se non cambia lo stato dell'oggetto, dovrebbe essere una funzione. Ad esempio, CalculatePiToNthDigit (n) dovrebbe essere una funzione, perché in realtà non sta cambiando lo stato dell'oggetto Math a cui è collegato.

Questo forse è un po 'sconclusionato, ma si riduce davvero a decidere quali sono i tuoi oggetti e cosa rappresentano. Se non riesci a capire se dovrebbe essere una proprietà o una funzione, forse non importa quale.

Preferisco usare le proprietà per aggiungere / impostare metodi con il parametro 1 . Se i parametri sono maggiori, utilizzare i metodi.

Le proprietà dovrebbero essere semplicemente impostate e ottenere una sola riga. Qualcosa di più e dovrebbe davvero essere spostato su un metodo. Il codice complesso dovrebbe essere sempre nei metodi.

Uso solo le proprietà per l'accesso alle variabili, ovvero ottenere e impostare singole variabili o ottenere e impostare i dati nei controlli. Non appena è necessario / eseguito qualsiasi tipo di manipolazione dei dati, utilizzo i metodi.

Un altro grande vantaggio per Proprietà è che il valore della proprietà può essere visto in Visual Studio durante il debug.

Le proprietà sono davvero belle perché sono accessibili nel visual designer di Visual Studio, a condizione che abbiano accesso.

Usano essere utilizzati se si stanno semplicemente impostando e ottenendo e forse qualche convalida che non accede a una quantità significativa di codice. Fai attenzione perché la creazione di oggetti complessi durante la convalida non è semplice.

Qualsiasi altro metodo è il modo preferito.

Non si tratta solo di semantica. L'uso di proprietà inappropriate inizia a creare stranezze nel visual designer di Visual Studio.

Ad esempio stavo ottenendo un valore di configurazione all'interno di una proprietà di una classe. La classe di configurazione apre effettivamente un file ed esegue una query sql per ottenere il valore di quella configurazione. Ciò ha causato problemi nella mia applicazione in cui il file di configurazione veniva aperto e bloccato da Visual Studio stesso anziché dalla mia applicazione perché non stava solo leggendo ma scrivendo il valore di configurazione (tramite il metodo setter). Per risolvere questo problema, dovevo solo cambiarlo in un metodo.

Per motivi di design, le proprietà rappresentano dati o attributi dell'oggetto di classe, mentre i metodi sono azioni o comportamenti dell'oggetto di classe.

In .Net, nel mondo ci sono altre implicazioni nell'uso di Proprietà:

  • Le proprietà sono utilizzate in Databinding, mentre i metodi get_ / set_ non lo sono.
  • Proprietà dell'utente di serializzazione XML come meccanismo naturale di serilizzazione.
  • Le proprietà sono accessibili da PropertyGrid controllo e stagista ICustomTypeDescriptor , che può essere utilizzato in modo efficace se stai scrivendo una libreria personalizzata.
  • Le proprietà sono controllate da Attributi , si può usare saggiamente per progettare software orientati all'aspetto.

Idee sbagliate (IMHO) sull'uso delle Proprietà:

  • Utilizzato per esporre piccoli calcoli: Il blocco get di ControlDesigner.SelectionRules viene eseguito su 72 righe !!
  • Utilizzato per esporre strutture di dati interne: anche se una proprietà non è mappata a un membro di dati interno, è possibile utilizzarla come proprietà, se è un attributo della tua classe. Viceversa, anche se non è consigliabile un attributo delle proprietà della classe, restituisce array come membri di dati (invece i metodi vengono utilizzati per restituire una copia approfondita dei membri.)

Nell'esempio qui avrebbe potuto essere scritto, con più significato commerciale come:

public String Title
{
    set { Label.Text = text; }
}

Ecco una buona serie di linee guida per quando usare proprietà vs metodi da Bill Wagner

  • Usa una proprietà quando tutte queste sono vere: I getter dovrebbero essere semplici e quindi improbabili che generino eccezioni. Si noti che ciò non implica alcun accesso alla rete (o al database). Entrambi potrebbero fallire, e quindi genererebbero un'eccezione.
  • Non dovrebbero avere dipendenze reciproche. Si noti che ciò include l'impostazione di una proprietà e la sua influenza su un'altra. (Ad esempio, l'impostazione della proprietà FirstName influirebbe su una proprietà FullName di sola lettura che componeva il nome + le proprietà del cognome implica tale dipendenza)
  • Dovrebbero essere configurabili in qualsiasi ordine
  • Il getter non ha un effetto collaterale osservabile Nota che questa linea guida non preclude alcune forme di valutazione pigra in una proprietà.
  • Il metodo deve sempre tornare immediatamente. (Si noti che ciò preclude una proprietà che effettua una chiamata di accesso al database, una chiamata al servizio Web o altre operazioni simili).
  • Utilizza un metodo se il membro restituisce un array.
  • Le chiamate ripetute al getter (senza codice intermedio) dovrebbero restituire lo stesso valore.
  • Le chiamate ripetute al setter (con lo stesso valore) non dovrebbero produrre differenze rispetto a una singola chiamata.

  • Il get non deve restituire un riferimento alle strutture di dati interne (vedere il punto 23). Un metodo potrebbe restituire una copia approfondita e potrebbe evitare questo problema.

* Tratto dalla mia risposta a una domanda duplicata.

Questo è semplice.

1: utilizzare la proprietà quando si desidera che i dati vengano convalidati prima di essere archiviati nel campo. Quindi in questo modo la proprietà fornisce l'incapsulamento per i tuoi campi. Perché se lasci i tuoi campi l'utente finale pubblico può assegnare qualsiasi valore che può essere o non essere valido secondo il tuo requisito aziendale come l'età dovrebbe essere maggiore di 18. Quindi prima che il valore sia archiviare il campo corrispondente dobbiamo verificarne la validità. In questo modo le proprietà rappresentano i dati.

2: Utilizza il metodo quando desideri eseguire un'azione come se stessi fornendo alcuni dati come parametro e il tuo metodo sta eseguendo l'elaborazione sulla base dei valori forniti e restituendo il valore elaborato come output. Oppure vuoi cambiare il valore di alcuni campi con questo calcolo. " In questo modo il metodo rappresenta l'azione " ;.

Vengo da Java e ho usato il metodo get .. set .. per un po '.

Quando scrivo codice, non chiedo a me stesso: "accedere a questi dati è semplice o richiede un processo pesante?" perché le cose possono cambiare (oggi recuperare questa proprietà è semplice, domani può richiedere un processo pesante o pesante).

Oggi ho un metodo SetAge (int age) domani avrò anche un metodo SetAge (data di nascita) che calcola l'età usando la data di nascita.

Sono rimasto molto deluso dal fatto che il compilatore trasformi la proprietà in get e set ma non considero i miei metodi Get ... e Set .. uguali.

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