एक म्यूटेबल क्लास डिज़ाइन करें जो इसके उपभोग के बाद अपरिवर्तनीय हो जाता है

Question

मान लीजिए कि परिदृश्य एक अपरिवर्तनीय प्रकार को लागू करने की अनुमति नहीं देता है। उस धारणा के बाद, मैं राय/उदाहरणों को सही तरीके से डिजाइन करने के तरीके पर विचार करना चाहता हूं कि इसका उपभोग करने के बाद, अपरिवर्तनीय हो जाता है।

public class ObjectAConfig { 

    private int _valueB; 
    private string _valueA; 
    internal bool Consumed { get; set; } 

    public int ValueB { 
    get { return _valueB; } 
    set 
    { 
     if (Consumed) throw new InvalidOperationException(); 
     _valueB = value; 
    } 
    } 

    public string ValueA { 
    get { return _valueA; } 
    set 
    { 
     if (Consumed) throw new InvalidOperationException(); 
     _valueA = value; 
    } 
    } 
} 

जब ObjectA खपत ObjectAConfig:

public ObjectA { 

    public ObjectA(ObjectAConfig config) { 

    _config = config; 
    _config.Consumed = true; 
    } 
} 

मैं संतुष्ट है कि इस बस काम करता है नहीं कर रहा हूँ, मैं, के रूप में कहा एक बेहतर पैटर्न (बाहर रखा गया हो, तो जानना चाहते हैं, ObjectAConfig द्वारा अपरिवर्तनीय बना शुरुआत से डिजाइन)।

• भावना Once<T> की तरह एक इकाई है कि अनुमति देते हैं लिपटे मूल्य केवल एक बार प्रारंभ करने के लिए परिभाषित कर सकते हैं:

  उदाहरण के लिए

  ?

• एक ऐसे प्रकार को परिभाषित कर सकता है जो प्रकार को एक निजी क्षेत्र में बदल देता है? अर्थात आप इसे रोक सकते हैं -

Answer 1

क्या आप कभी कभी कार्यान्वित कर रहे हैं नाम "popsicle immutability" के अंतर्गत चला जाता है। आपका वर्तमान दृष्टिकोण काम करेगा - वास्तव में मैं उस पैटर्न को कई स्थानों पर स्वयं उपयोग करता हूं।

private void SetField<T>(ref T field, T value) { 
    if (Consumed) throw new InvalidOperationException(); 
    field = value; 
} 
public int ValueB { 
    get { return _valueB; } 
    set { SetField(ref _valueB, value); } 
}  
public string ValueA { 
    get { return _valueA; } 
    set { SetField(ref _valueA, value); } 
} 

एक और संबंधित दृष्टिकोण है, हालांकि: एक बिल्डर

आप शायद कुछ दोहराव की तरह कुछ के माध्यम से कम कर सकते हैं।

public interface IConfig 
{ 
    string ValueA { get; } 
    int ValueB { get; } 
} 
public class ObjectAConfig : IConfig 
{ 
    private class ImmutableConfig : IConfig { 
     private readonly string valueA; 
     private readonly int valueB; 
     public ImmutableConfig(string valueA, int valueB) 
     { 
      this.valueA = valueA; 
      this.valueB = valueB; 
     } 
    } 
    public IConfig Build() 
    { 
     return new ImmutableConfig(ValueA, ValueB); 
    } 
    ... snip: implementation of ObjectAConfig 
} 

यहाँ IConfig की वास्तव में एक अपरिवर्तनीय कार्यान्वयन है, और अपने मूल कार्यान्वयन: उदाहरण के लिए, अपने मौजूदा कक्षा लेने। यदि आप जमे हुए संस्करण चाहते हैं, तो Build() पर कॉल करें।