Làm thế nào để tôi xử lý setters trên các lĩnh vực bất biến?

Tôi có một lớp học với hai readonly intlĩnh vực. Chúng được phơi bày như là tài sản:

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

Tuy nhiên, điều đó có nghĩa là sau đây là mã hợp pháp hoàn hảo:

Thing iThoughtThisWasMutable = new Thing(1, 42);

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

Các lỗi xuất phát từ giả định rằng sẽ hoạt động chắc chắn là ngấm ngầm. Chắc chắn, nhà phát triển nhầm lẫn nên đọc tài liệu. Nhưng điều đó không thay đổi thực tế rằng không có lỗi biên dịch hoặc thời gian chạy nào cảnh báo anh ta về vấn đề này.

Làm thế nào để Thingthay đổi lớp để các nhà phát triển ít có khả năng mắc lỗi ở trên?

Ném một ngoại lệ? Sử dụng một phương thức getter thay vì một tài sản?

Tại sao làm cho mã đó hợp pháp?
Lấy ra set { }nếu nó không làm gì.
Đây là cách bạn xác định một tài sản công cộng chỉ đọc:

public int Foo { get { return _foo; } }

Với C # 5 trở về trước, chúng tôi đã phải đối mặt với hai tùy chọn cho các trường không thay đổi được hiển thị thông qua một getter:

1. Tạo một biến sao lưu chỉ đọc và trả về biến đó thông qua một getter thủ công. Tùy chọn này là an toàn (người ta phải loại bỏ rõ ràng readonlyđể phá hủy tính bất biến. Mặc dù vậy, nó đã tạo ra rất nhiều mã nồi hơi.
2. Sử dụng một thuộc tính tự động, với một setter riêng. Điều này tạo ra mã đơn giản hơn, nhưng dễ dàng hơn để vô tình phá vỡ tính bất biến.

Mặc dù với C # 6 (có sẵn trong VS2015, được phát hành ngày hôm qua), giờ đây chúng ta đã có được thứ tốt nhất của cả hai thế giới: thuộc tính tự động chỉ đọc. Điều này cho phép chúng tôi đơn giản hóa lớp 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; }
}

Các dòng Foo = foovà Bar = barchỉ hợp lệ trong hàm tạo (đạt được yêu cầu chỉ đọc mạnh mẽ) và trường sao lưu được ngụ ý, thay vì phải được xác định rõ ràng (đạt được mã đơn giản hơn).

Bạn chỉ có thể thoát khỏi các setters. Họ không làm gì cả, họ sẽ gây nhầm lẫn cho người dùng và họ sẽ dẫn đến lỗi. Tuy nhiên, thay vào đó, bạn có thể đặt chúng ở chế độ riêng tư và do đó loại bỏ các biến sao lưu, đơn giản hóa mã của bạn:

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

Hai giải pháp.

Đơn giản:

Đừng bao gồm các setters như David lưu ý cho các đối tượng chỉ đọc bất biến.

Cách khác:

Cho phép setters trả về một đối tượng bất biến mới, dài dòng so với trước đây nhưng cung cấp trạng thái theo thời gian cho từng đối tượng được khởi tạo. Thiết kế này là một công cụ rất hữu ích cho sự an toàn và bất biến của Thread, trải rộng trên tất cả các ngôn ngữ OOP bắt buộc.

Mã giả

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

nhà máy tĩnh công cộng

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