ฉันจะจัดการ setters ในฟิลด์ที่ไม่เปลี่ยนรูปแบบได้อย่างไร

ฉันมีชั้นเรียนสอง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คลาสอย่างไรเพื่อให้ devs มีโอกาสทำผิดพลาดน้อยกว่า

โยนข้อยกเว้นหรือไม่ ใช้วิธี getter แทนคุณสมบัติหรือไม่

ทำไมต้องทำให้รหัสนั้นถูกกฎหมาย?
เอาออกset { }ถ้ามันไม่ทำอะไรเลย
นี่คือวิธีที่คุณกำหนดคุณสมบัติสาธารณะแบบอ่านอย่างเดียว:

public int Foo { get { return _foo; } }

ด้วย C # 5 และก่อนหน้านี้เราต้องเผชิญกับสองตัวเลือกสำหรับฟิลด์ที่ไม่เปลี่ยนรูปที่เปิดเผยผ่านทะเยอทะยาน:

1. สร้างตัวแปรสำรองแบบอ่านอย่างเดียวและส่งคืนผ่านทาง getter แบบแมนนวล ตัวเลือกนี้มีความปลอดภัย (หนึ่งจะต้องลบอย่างชัดเจนreadonlyเพื่อทำลาย immutability มันสร้างรหัสจานหม้อไอน้ำจำนวนมากแม้ว่า
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เส้นเท่านั้นที่ถูกต้องในคอนสตรัค (ซึ่งประสบความสำเร็จในความต้องการอ่านอย่างเดียวที่แข็งแกร่ง) และเขตการสนับสนุนเป็นนัยมากกว่าที่มีการกำหนดไว้อย่างชัดเจน (ซึ่งประสบความสำเร็จในรหัสง่าย)

คุณสามารถกำจัด setters ได้ พวกเขาไม่ทำอะไรเลยพวกเขาจะสับสนผู้ใช้และพวกเขาจะนำไปสู่ข้อบกพร่อง อย่างไรก็ตามคุณสามารถทำให้พวกเขาเป็นส่วนตัวและกำจัดตัวแปรสำรองโดยทำให้โค้ดของคุณง่ายขึ้น:

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 ที่จำเป็นทั้งหมด

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

โรงงานสาธารณะ

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