C'è un modo migliore di usare getter e setter su membri privati di una classe?

Utilizzo delle proprietà

Un getter e setter appropriati dovrebbe apparire come questo:

public class Carrots
{
    private string name;

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

( Fai clic qui se non comprendi il ruolo della parola chiave value in questo esempio).

Utilizzo delle proprietà automatiche

Nel c # 3.0 e versioni successive, puoi anche utilizzare proprietà automatiche , rendendolo uniforme più facile.

public class Carrots
{
    public string Name { get; set; }
}

Se vuoi che la proprietà pubblica sia di sola lettura (ma vuoi comunque un setter privato) puoi usare:

public class Carrots
{
    public string Name { get; private set; }
}

Come chiamarlo

In entrambi i casi, lo chiameresti in questo modo:

var c = new Carrots();
c.Name = "This is a test!";
Console.WriteLine(c.Name); //outputs "This is a test!"

Più breve e più facile da leggere sarebbe qualcosa di simile a:

public class Carrots
{
    public string Name { get; set; }
}

Utilizza una variabile privata interna che viene utilizzata quando si accede alla proprietà. Equivalente a:

public class Carrots
{
    private string _name;

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

(come ha dimostrato @John Wu.)

Tuttavia, dipenderà da ciò a cui desideri che il codice esterno sia in grado di accedere.

Se vuoi solo un 'Nome' per essere istantaneamente modificabile e non ha alcuna relazione con l'applicazione quando lo è, la stringa pubblica sopra Nome {get; impostato; } è tutto ciò di cui hai bisogno.

Ma se stai monitorando / usando / controllando il valore di una proprietà all'interno della tua classe e non vuoi che il codice esterno lo cambi, allora il secondo esempio è quello da seguire.

Ad esempio:

Hai una classe creata con un valore noto. Vuoi che quel valore sia cambiato, ma sotto il tuo controllo.

Forse un conto in banca? O la velocità di una macchina?

Consente di andare con la velocità di una macchina:

public class Car
{
    private string _speed;

    public string Speed
    {
        get { return _speed; }
    // Notice no setter in this case.
    }

    public void IncreaseSpeed()
    {
        if(_speed + 1 <= 100)
        {
            _speed++;
        }
    }

    public void Brake()
    {
        if(_speed-- >= 0)
        {
            _speed--;
        }
    }
}

Ciò consente alla chiamata del codice chiamante di aumentare la velocità o di rallentare tenendo premuto il freno tutte le volte che vogliono. Ma ora puoi mettere un limite realistico a quella velocità: l'utente non può violare le regole che hai nel "mondo" dell'applicazione.

Ecco un altro esempio, ma il codice esterno può impostare immediatamente il valore:

public class Car
{
    private string _speed;

    public string Speed
    {
        get { return _speed; }
        set {
                if (value >= 0 && value <= 100)
                {
                    _speed = value;
                }
            }
    }
}

Questo ora consente al codice chiamante di gestire l'accelerazione e la frenata, aggiornando l'oggetto Car quando lo desidera. Ma hai ancora il controllo generale su quale possa essere quel valore, piuttosto che controllare come viene modificato.

Utilizzo:

public class Carrots
{
    public string name;
}

come @Charles Merriam ha dimostrato è tutto buono e buono se non ti interessa quando, ea quale valore, il codice esterno imposterà questa proprietà. È sempre pubblico e mai controllato se modificato.

Non dovrebbe mai essere utilizzato dai metodi interni della tua classe se richiede dei limiti su quale stato dovrebbe essere o richiede un intervallo particolare. Dovresti utilizzare la logica di controllo dei confini ovunque che la acceda (quindi gestire eventuali errori se i controlli non riescono), piuttosto che impedire l'immissione di dati non validi del tutto.

Solo alcune piccole cose:

• Stai utilizzando getter e setter nel costrutto a causa delle limitazioni nella tua lingua e della sua incapacità di inibire l'operatore "indirizzo di" sui membri.
• Stai utilizzando getter e setter perché potrebbe esserci un futuro in cui sostituisci gli elementi di dati con funzioni complesse e il linguaggio non supporta l'override di "." operatore correttamente.
• Stai utilizzando getter e setter perché tutti gli altri lo fanno, diventa parte della tradizione e parte della pianificazione dello sviluppo e della velocità dell'eseguibile gonfia.

Se lavori in una squadra, un approccio alternativo è quello di scaricare getter e setter, usare l'accesso diretto ai campi e fare una chat con lo sviluppatore facendo qualcosa di stupido sul campo.

Quindi scrivi:

public class Carrots
{
    public string name;
}

e accedi come myCarrot.name