Değişmez alanlardaki ayarlayıcıları nasıl kullanabilirim?

İki readonly intalanlı bir sınıfım var . Özellikler olarak ortaya çıkarlar:

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

Ancak, bu, aşağıdakilerin tamamen yasal bir kod olduğu anlamına gelir:

Thing iThoughtThisWasMutable = new Thing(1, 42);

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

Bunun işe yarayacağını varsaymaktan kaynaklanan hataların sinsi olacağından emin olabilirsiniz. Elbette, hatalı geliştirici dokümanları okumuş olmalıydı. Ancak bu, derleme veya çalışma zamanı hatasının bir sorun hakkında onu uyarmaması gerçeğini değiştirmez.

Nasıl olmalıdır Thingsınıf Devs yukarıdaki hata yapma olasılığı daha düşük olacak şekilde değiştirilebilir?

Bir istisna atmak? Bir özellik yerine bir alıcı yöntemi kullanın?

Bu kodu neden yasal yapıyorsun?
Çıkarıp set { }hiçbir şey yaparsa.
Salt okunur bir genel özelliği şu şekilde tanımlayabilirsiniz:

public int Foo { get { return _foo; } }

C # 5 ve öncesinde, bir alıcı tarafından maruz bırakılan değişmez alanlar için iki seçenekle karşı karşıya kaldık:

1. Salt okunur bir yedekleme değişkeni oluşturun ve bunu manuel bir alıcı aracılığıyla döndürün. Bu seçenek güvenlidir ( readonlydeğişmezliği imha etmek için açıkça açıkça kaldırılması gerekir . Yine de birçok kazan plakası kodu oluşturuldu).
2. Özel bir ayarlayıcı ile bir otomatik özellik kullanın. Bu, daha basit kod oluşturur, ancak değişmezliği yanlışlıkla kırmak daha kolaydır.

Yine de C # 6 ile (dün piyasaya sürülen VS2015'te mevcut), şimdi her iki dünyanın da en iyisini elde ediyoruz: salt okunur otomatik özellikler. Bu OP'nin sınıfını basitleştirmemizi sağlar:

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 = fooVe Bar = barsatırlar yerine (daha basit kod başarır olan) açıkça tanımlanmalıdır zorunda kalmak yerine, ima (sağlam salt okunur gereksinimi başarır) yapıcı ve destek alanında geçerlidir.

Sadece ayarlayıcılardan kurtulabilirsin. Hiçbir şey yapmazlar, kullanıcıları şaşırtırlar ve hatalara yol açarlar. Ancak, bunun yerine onları özel kılabilir ve böylece kodunuzu basitleştirerek destek değişkenlerinden kurtulabilirsiniz:

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

İki çözüm.

Basit:

Değiştirilebilir salt okunur nesneler için David tarafından belirtilen ayarlayıcıları dahil etmeyin.

Alternatif:

Ayarlayıcıların öncekine göre daha ayrıntılı olan yeni bir değişmez nesne döndürmelerine izin verin, ancak başlatılan her nesne için zaman içinde durum sağlar. Bu tasarım, tüm zorunlu OOP dillerine yayılan İplik güvenliği ve değişmezliği için çok faydalı bir araçtır.

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

kamu statik fabrikası

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