Come gestisco i setter su campi immutabili?

Ho una lezione con due readonly intcampi. Sono esposti come proprietà:

public class Thing
{
    private readonly int _foo, _bar;

    /// <summary> I AM IMMUTABLE. </summary>
    public Thing(int foo, int bar)
    {
        _foo = foo;
        _bar = bar;
    }

    public int Foo { get { return _foo; } set { } }

    public int Bar { get { return _bar; } set { } }
}

Tuttavia, ciò significa che quanto segue è un codice perfettamente legale:

Thing iThoughtThisWasMutable = new Thing(1, 42);

iThoughtThisWasMutable.Foo = 99;  // <-- Poor, mistaken developer.
                                  //     He surely has bugs now. :-(

Gli insetti che derivano dal presupporre che funzionerebbe sono sicuramente insidiosi. Certo, lo sviluppatore errato avrebbe dovuto leggere i documenti. Ma ciò non cambia il fatto che nessun errore di compilazione o di runtime lo ha avvertito del problema.

Come dovrebbe Thingessere cambiata la classe in modo che gli sviluppatori abbiano meno probabilità di commettere l'errore di cui sopra?

Generare un'eccezione? Utilizzare un metodo getter anziché una proprietà?

Perché rendere legale quel codice?
Elimina set { }se non fa nulla.
Ecco come definire una proprietà pubblica di sola lettura:

public int Foo { get { return _foo; } }

Con C # 5 e precedenti, ci siamo trovati di fronte a due opzioni per i campi immutabili esposti tramite un getter:

1. Creare una variabile di supporto di sola lettura e restituirla tramite un getter manuale. Questa opzione è sicura (si deve rimuovere esplicitamente il readonlyper distruggere l'immutabilità. Tuttavia, ha creato un sacco di codice della piastra della caldaia.
2. Utilizzare una proprietà automatica, con un setter privato. Questo crea un codice più semplice, ma è più facile interrompere accidentalmente l'immutabilità.

Con C # 6 (disponibile in VS2015, che è stato rilasciato ieri), ora otteniamo il meglio di entrambi i mondi: proprietà auto di sola lettura. Questo ci consente di semplificare la classe del PO per:

public class Thing
{
    /// <summary> I AM IMMUTABLE. </summary>
    public Thing(int foo, int bar)
    {
        Foo = foo;
        Bar = bar;
    }

    public int Foo { get; }
    public int Bar { get; }
}

Le linee Foo = fooe Bar = barsono valide solo nel costruttore (che raggiunge il solido requisito di sola lettura) e il campo di supporto è implicito, piuttosto che dover essere esplicitamente definito (che ottiene il codice più semplice).

Potresti semplicemente sbarazzarti dei setter. Non fanno nulla, confonderanno gli utenti e porteranno a bug. Tuttavia, potresti invece renderli privati ​​e quindi sbarazzarti delle variabili di supporto, semplificando il tuo codice:

public class Thing
{
    public Thing(int foo, int bar)
    {
        Foo = foo;
        Bar = bar;
    }

    public int Foo { get; private set; }

    public int Bar { get; private set; }
}

Due soluzioni.

Semplice:

Non includere setter come notato da David per oggetti di sola lettura immutabili.

In alternativa:

Consenti ai setter di restituire un nuovo oggetto immutabile, dettagliato rispetto al primo ma fornisce uno stato nel tempo per ogni oggetto inizializzato. Questo design è uno strumento molto utile per la sicurezza e l'immutabilità dei thread che si estende a tutti i linguaggi OOP imperativi.

pseudocodice

public class Thing
{

{readonly vars}

    public Thing(int foo, int bar)
    {
        _foo = foo;
        _bar = bar;
    }

    public Thing withFoo(int foo) {
        return new Thing(foo, getBar());
    }

    public Thing withBar(int bar) {
        return new Thing(getFoo(), bar)
    }

    etc...
}

fabbrica statica pubblica

public class Thing
{

{readonly vars}

    private Thing(int foo, int bar)
    {
        _foo = foo;
        _bar = bar;
    }

    public static with(int foo, int bar) {
        return new Thing(foo, bar)
    }

    public Thing withFoo(int foo) {
        return new Thing(foo, getBar());
    }

    public Thing withBar(int bar) {
        return new Thing(getFoo(), bar)
    }

    etc...
}