Wie gehe ich mit Setzern auf unveränderlichen Feldern um?

Ich habe eine Klasse mit zwei readonly intFeldern. Sie sind als Eigenschaften ausgesetzt:

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 { } }
}

Dies bedeutet jedoch, dass das Folgende vollkommen legal ist:

Thing iThoughtThisWasMutable = new Thing(1, 42);

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

Die Fehler, die von der Annahme ausgehen, dass dies funktionieren würde, werden mit Sicherheit heimtückisch sein. Sicher, der falsche Entwickler sollte die Dokumentation gelesen haben. Das ändert aber nichts an der Tatsache, dass ihn kein Kompilierungs- oder Laufzeitfehler vor dem Problem gewarnt hat.

Wie sollte die ThingKlasse geändert werden, damit Entwickler mit geringerer Wahrscheinlichkeit den oben genannten Fehler machen?

Eine Ausnahme auslösen? Verwenden Sie eine Get-Methode anstelle einer Eigenschaft?

Warum diesen Code legal machen?
Nehmen Sie das raus, set { }wenn es nichts tut.
So definieren Sie eine schreibgeschützte öffentliche Eigenschaft:

public int Foo { get { return _foo; } }

In C # 5 und früheren Versionen standen uns zwei Optionen für unveränderliche Felder gegenüber, die über einen Getter verfügbar gemacht wurden:

1. Erstellen Sie eine schreibgeschützte Sicherungsvariable und geben Sie diese über einen manuellen Getter zurück. Diese Option ist sicher (man muss die Option explizit entfernen readonly, um die Unveränderlichkeit zu zerstören. Es wurde jedoch viel Code für die Kesselplatte erstellt.
2. Verwenden Sie eine Auto-Eigenschaft mit einem privaten Setter. Dies erzeugt einfacheren Code, es ist jedoch einfacher, die Unveränderlichkeit aus Versehen zu brechen.

Mit C # 6 (verfügbar in VS2015, das gestern veröffentlicht wurde) erhalten wir jetzt das Beste aus beiden Welten: schreibgeschützte automatische Eigenschaften. Dies ermöglicht es uns, die Klasse des OP zu vereinfachen, um:

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; }
}

Die Zeilen Foo = foound Bar = barsind nur im Konstruktor gültig (der die robuste Nur-Lese-Anforderung erfüllt) und das Hintergrundfeld ist impliziert, anstatt explizit definiert zu werden (was den einfacheren Code ermöglicht).

Man könnte die Setter einfach loswerden. Sie tun nichts, sie werden die Benutzer verwirren und zu Fehlern führen. Sie können sie jedoch stattdessen als privat kennzeichnen und so die Sicherungsvariablen entfernen, was Ihren Code vereinfacht:

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; }
}

Zwei Lösungen.

Einfach:

Schließen Sie keine Setter ein, wie von David für unveränderliche schreibgeschützte Objekte angegeben.

Alternative:

Setter können ein neues unveränderliches Objekt zurückgeben, das im Vergleich zum vorherigen ausführlich ist, jedoch für jedes initialisierte Objekt den Status über die Zeit angibt. Dieses Design ist ein sehr nützliches Werkzeug für die Thread-Sicherheit und Unveränderlichkeit, das sich über alle wichtigen OOP-Sprachen erstreckt.

Pseudocode

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...
}

öffentliche statische Fabrik

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...
}