vs misto di classe separata mutevolezza

Question

In una classe parzialmente mutevole, è meglio mescolare i campi mutabili con i suoi quelli immutabili, o di creare una nuova classe (o le classi) che li incapsulare? Ecco un esempio in C # di quello che sto parlando:

interface IBedroom
{
    int Volume { get; }

    string Color { get; }

    void Paint(string newColor);
}

Ecco un'implementazione con mutevolezza mista nei suoi campi:

class MixedMutabilityBedroom : IBedroom
{
    readonly int volume;
    string color;

    public MixedMutabilityBedroom(int volume, string color = "")
    {
        this.volume = volume;
        this.color = color;
    }

    public int Volume
    {
        get { return volume; }
    }

    public string Color
    {
        get { return color; }
    }

    public void Paint(string newColor)
    {
        color = newColor;
    }
}

E uno con mutevolezza separata:

// first, a fully mutable helper class
class RoomColor
{
    string value;

    public RoomColor(string value)
    {
        this.value = value;
    }

    public string Value
    {
        get { return value; }
    }

    public void Change(string newValue)
    {
        value = newValue;
    }
}

e l'attuazione separati-mutabilità:

class SeparatedMutabilityBedroom : IBedroom
{
    readonly int volume;
    readonly RoomColor color;

    public SeparatedMutabilityBedroom(int volume, RoomColor color)
    {
        this.volume = volume;
        this.color = color;
    }

    public int Volume
    {
        get { return volume; }
    }

    public string Color
    {
        get { return color.Value; }
    }

    public void Paint(string newColor)
    {
        color.Change(newColor);
    }
}

I parteggiare personalmente con quest'ultimo stile. Nella mia esperienza, gli insetti che nascono dalla manipolazione dello Stato in scenari simultanei sono difficili da eseguire il debug. Come la concorrenza diventa la norma per i programmi, sembra che la localizzazione mutevolezza è un fattore chiave per ridurre lo sforzo di debug. Nel secondo esempio non abbiamo di guardare oltre l'intera implementazione della classe per scoprire dove lo stato è manipolato. L'insieme di mutevolezza del SeparatedMutabilityBedroom è localizzato a RoomColor.

Cosa ne pensi? Ho dimenticato alcuni punti di riflessione?

Answer 1

Programmazione con strutture di dati immutabili è una tecnica molto utile, ma è difficile da criticare su un complesso migliori pratiche o suggerimento sulla base di un semplice esempio. Decidere ciò che è meglio deve tener conto di altri fattori come il modo questa classe viene utilizzato e interagito con.

Tuttavia, supponendo che si sono in una situazione che ha una grande quantità di concorrenza con più autori a questo oggetto, poi facendo un oggetto parzialmente immutabile davvero wont comprarti molto da quando è ancora possibile incorrere in problemi.

In questo caso entrambi utilizzare una sorta di primitiva di sincronizzazione o utilizzare un oggetto completamente immutabile.

Questa risposta parla di alcune tecniche di utilizzo di oggetti completamente immutabili.