Suponha que o cenário não permita implementar um tipo imutável. Seguindo essa suposição, gostaria de opiniões / exemplos sobre como projetar corretamente um tipo que, depois de consumido, se torne imutável.

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

QuandoObjectA consomeObjectAConfig:

public ObjectA {

  public ObjectA(ObjectAConfig config) {

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

Eu não estou satisfeito que isso simplesmente funcione, eu gostaria de saber se há um padrão melhor (excluído, como dito, fazendoObjectAConfig imutável pelo design desde o começo).

Por exemplo:

pode fazer sentido definir uma mônada comoOnce<T> que permitem que o valor empacotado seja inicializado apenas uma vez?

pode fazer sentido definir um tipo que retorna o próprio tipo alterando um campo privado?