如何处理不可变字段上的setter？

我有一堂课有两个readonly int领域。它们作为属性公开：

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

但是，这意味着以下代码完全合法：

Thing iThoughtThisWasMutable = new Thing(1, 42);

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

假设可以奏效的错误肯定是隐蔽的。当然，错误的开发人员应该已经阅读了文档。但这并不能改变没有编译或运行时错误就此问题警告过他的事实。

应该如何Thing更改类，以使开发人员不太可能犯上述错误？

抛出异常？使用getter方法而不是属性？

为什么要使该代码合法？如果不采取任何措施，
请取出set { }。
这是您定义只读公共属性的方式：

public int Foo { get { return _foo; } }

在C＃5及更低版本中，对于通过getter公开的不可变字段，我们面临着两种选择：

1. 创建一个只读的后备变量，然后通过手动获取器将其返回。此选项是安全的（必须明确删除readonly来破坏不变性。尽管如此，它却创建了许多样板代码。
2. 使用带有私有设置器的自动属性。这样可以创建更简单的代码，但是更容易意外破坏不变性。

但是，使用C＃6（在昨天发布的VS2015中可用），我们现在可以两全其美：只读自动属性。这使我们可以将OP的类简化为：

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

的Foo = foo和Bar = bar线仅在构造（其实现了鲁棒只读要求）和背场是隐含的，而不是必须明确定义（其实现了更简单的代码）有效。

您可以摆脱二传手。他们什么都不做，会迷惑用户，并导致错误。但是，您可以改为将它们设为私有，从而摆脱后备变量，从而简化代码：

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

两种解决方案。

简单：

请勿包含David指出的不可变只读对象的设置器。

或者：

允许设置者返回一个新的不可变对象，该对象比前一个更为冗长，但会为每个初始化的对象提供一段时间的状态。对于线程安全和不变性而言，此设计是非常有用的工具，它扩展到所有命令式OOP语言。

伪码

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

公共静态工厂

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