Zaprojektuj klasę zmienną, która po jej zużyciu stanie się niezmienna.

Question

Załóżmy, że scenariusz nie pozwala na implementację typu niezmiennego. Podążając za tym założeniem, chciałbym uzyskać opinie/przykłady, jak poprawnie zaprojektować typ, który po jego zużyciu staje się niezmienny.

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

Kiedy ObjectA zużywa ObjectAConfig:

public ObjectA { 

    public ObjectA(ObjectAConfig config) { 

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

nie jestem zadowolony, że to po prostu działa, chciałbym wiedzieć, czy istnieje lepszy wzór (wyłączone, jak powiedział, co ObjectAConfig niezmienna przez projekt od początku).

Na przykład:

• może sensu definiować monady jak Once<T> które pozwalają owinięty wartość zostać zainicjowany tylko raz?

• może w sensie zdefiniować typ, który zwraca sam typ zmieniający prywatne pole?

Answer 1

Co wdrażają czasami idzie pod nazwą „popsicle immutability” - to znaczy można go zamrażać. Twoje obecne podejście zadziała - w rzeczywistości używam tego wzoru w wielu miejscach.

Prawdopodobnie można zmniejszyć niektóre powielania poprzez coś takiego:

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

istnieje inny, powiązany podejście, choć: wypełniacz. Na przykład, biorąc istniejącą klasę:

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 
} 

Tu jest naprawdę niezmienne realizacja IConfig i oryginalne wykonanie. Jeśli chcesz zamrożoną wersję, zadzwoń pod numer Build().