Як обробляти сетерів на незмінних полях?

У мене є клас з двома 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 і раніше ми стикалися з двома варіантами непорушних полів, відкритих через геттер:

1. Створіть змінну резервної копії лише для читання та поверніть її за допомогою ручного геттера. Ця опція є безпечною (потрібно явно видалити, readonlyщоб знищити незмінність. Однак це створило безліч кодових плит коду.
2. Використовуйте автоматичну власність із приватним налаштуванням. Це створює простіший код, але легше випадково порушити незмінність.

Хоча з C # 6 (доступний у VS2015, який був випущений вчора), ми отримуємо найкраще з обох світів: автоматичні властивості лише для читання. Це дозволяє нам спростити клас ОП до:

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

Два рішення.

Простий:

Не включайте сетерів, як зауважив Девід, для незмінних об'єктів, що читаються тільки.

Як варіант:

Дозволити сеттерам повертати новий незмінний об'єкт, багатослівний порівняно з попереднім, але забезпечує стан у часі для кожного ініціалізованого об'єкта. Цей дизайн є дуже корисним інструментом для безпеки та незмінності нитки, який поширюється на всі необхідні мови 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...
}