Eric Lippert me dijo que debería "tratar de hacer que los tipos de valores sean siempre inmutables", así que pensé que debería tratar de hacer que los tipos de valor sean siempre inmutables.

Pero, acabo de encontrar esta estructura mutable interna,System.Web.Util.SimpleBitVector32, en elSystem.Web ensamblado, lo que me hace pensar que debe haber una buena razón para tener una estructura mutable. Supongo que la razón por la que lo hicieron de esta manera es porque funcionó mejor bajo pruebas, y lo mantuvieron interno para desalentar su mal uso. Sin embargo, eso es especulación.

He hecho C&P como fuente de esta estructura. ¿Qué es lo que justifica la decisión de diseño de utilizar una estructura mutable? En general, ¿qué tipo de beneficios puede obtener el enfoque y cuándo son lo suficientemente significativos como para justificar los posibles perjuicio

[Serializable, StructLayout(LayoutKind.Sequential)]
internal struct SimpleBitVector32
{
    private int data;
    internal SimpleBitVector32(int data)
    {
        this.data = data;
    }

    internal int IntegerValue
    {
        get { return this.data; }
        set { this.data = value; }
    }

    internal bool this[int bit]
    {
        get { 
            return ((this.data & bit) == bit); 
        }
        set {
            int data = this.data;
            if (value) this.data = data | bit;
            else this.data = data & ~bit;
        }
    }

    internal int this[int mask, int offset]
    {
        get { return ((this.data & mask) >> offset); }
        set { this.data = (this.data & ~mask) | (value << offset); }
    }

    internal void Set(int bit)
    {
        this.data |= bit;
    }

    internal void Clear(int bit)
    {
        this.data &= ~bit;
    }
}