Mixed vs. classe séparée mutabilité

Question

Dans une classe partiellement mutable, est-il préférable de mélanger les champs mutables avec ses immuables ceux, ou créer une nouvelle classe (ou classes) qui les encapsulent? Voici un exemple en C # de ce dont je parle:

interface IBedroom
{
    int Volume { get; }

    string Color { get; }

    void Paint(string newColor);
}

Voici une mise en œuvre avec mutabilité mixte dans ses domaines:

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

Et avec un mutabilité séparé:

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

et la mise en oeuvre séparée 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 côté personnellement avec le style dernier. Dans mon expérience, les bugs qui découlent de la manipulation de l'État dans les scénarios simultanés sont difficiles à déboguer. Comme la norme devient la concurrence pour les programmes, il semble que localisant mutabilité est un facteur clé pour réduire l'effort de débogage. Dans le second exemple, nous ne devons pas regarder par-dessus pour savoir où l'état est manipulé toute la mise en œuvre de la classe. La totalité de la mutabilité de SeparatedMutabilityBedroom est localisé à RoomColor.

Que pensez-vous? Ai-je oublié quelques points pour examen?

Answer 1

Programmation des structures de données immuables est une technique très utile, mais est difficile à critiquer sur une meilleure pratique ou une suggestion basée sur un exemple simple de l'ensemble. Décider ce qui est le mieux doit tenir compte d'autres facteurs tels que la façon dont cette classe est utilisée et interagi avec.

Cependant, en supposant que vous êtes dans une situation qui a une grande quantité d'écrivains multiples avec la concurrence à cet objet, puis faire un objet ne vais pas vraiment partie immuable que vous achetez beaucoup puisque vous pouvez encore rencontrer des problèmes.

Dans ce cas, soit utiliser une sorte de primitive de synchronisation ou d'utiliser un objet complètement immuable.

réponse parle de certaines techniques d'utilisation des objets complètement immuables.