可变数据有许多优点和缺点。最大的缺点就是别名。如果相同的值在多个地方使用，其中一个地方更改了它，那么它将神奇地更改到正在使用它的其他地方。这与竞态条件有关，但并不完全相同。

有时候，价值百万美元的优势是模块化。可变状态允许您向代码隐藏更改的信息，而代码不需要知道这些信息。

《解释器的艺术》详细讨论了这些权衡，并给出了一些例子。

我不会说可变性是邪恶的，但可变性通常是程序员急于提供最大功能的标志。在现实中，这通常是不需要的，反过来，使界面更小，更容易使用，更难使用错误(=更健壮)。

其中一个例子就是竞态条件中的读/写和写/写冲突。这些在不可变结构中根本不可能发生，因为写操作不是有效的操作。

另外，我认为可变性几乎从来都不是真正需要的，程序员只是认为它在未来可能会出现。例如，改变日期是没有意义的。相反，在旧日期的基础上创建一个新的日期。这是一个廉价的操作，所以性能不是一个考虑因素。

李柏特先生举的例子有几个问题。它是为了说明结构是复制的，以及如果你不小心的话，这可能是一个问题。看看这个例子，我认为这是一个坏的编程习惯的结果，而不是结构或类的问题。

结构应该只有公共成员，不需要任何封装。如果是这样，那么它真的应该是一个类型/类。你真的不需要两个构念来表达同一件事。 如果有一个类包含一个结构，则可以调用该类中的一个方法来更改成员结构。我认为这是一个良好的编程习惯。

正确的实现如下所示。

struct Mutable {
public int x;
}

class Test {
    private Mutable m = new Mutable();
    public int mutate()
    { 
        m.x = m.x + 1;
        return m.x;
    }
  }
  static void Main(string[] args) {
        Test t = new Test();
        System.Console.WriteLine(t.mutate());
        System.Console.WriteLine(t.mutate());
        System.Console.WriteLine(t.mutate());
    }

看起来这是编程习惯的问题，而不是结构本身的问题。结构体应该是可变的，这是它的思想和意图。

更改的结果voila表现如预期:

1 2 3. 按任意键继续…

从程序员的角度来看，还有一些其他的极端情况可能导致不可预测的行为。

不可变值类型和只读字段

    // Simple mutable structure. 
    // Method IncrementI mutates current state.
    struct Mutable
    {
        public Mutable(int i) : this() 
        {
            I = i;
        }

        public void IncrementI() { I++; }

        public int I { get; private set; }
    }

    // Simple class that contains Mutable structure
    // as readonly field
    class SomeClass 
    {
        public readonly Mutable mutable = new Mutable(5);
    }

    // Simple class that contains Mutable structure
    // as ordinary (non-readonly) field
    class AnotherClass 
    {
        public Mutable mutable = new Mutable(5);
    }

    class Program
    {
        void Main()
        {
            // Case 1. Mutable readonly field
            var someClass = new SomeClass();
            someClass.mutable.IncrementI();
            // still 5, not 6, because SomeClass.mutable field is readonly
            // and compiler creates temporary copy every time when you trying to
            // access this field
            Console.WriteLine(someClass.mutable.I);

            // Case 2. Mutable ordinary field
            var anotherClass = new AnotherClass();
            anotherClass.mutable.IncrementI();

            // Prints 6, because AnotherClass.mutable field is not readonly
            Console.WriteLine(anotherClass.mutable.I);
        }
    }

可变值类型和数组

假设我们有一个可变结构的数组，我们为该数组的第一个元素调用IncrementI方法。你希望从这个电话中得到什么行为?它应该改变数组的值还是只改变一个副本?

    Mutable[] arrayOfMutables = new Mutable[1];
    arrayOfMutables[0] = new Mutable(5);

    // Now we actually accessing reference to the first element
    // without making any additional copy
    arrayOfMutables[0].IncrementI();

    // Prints 6!!
    Console.WriteLine(arrayOfMutables[0].I);

    // Every array implements IList<T> interface
    IList<Mutable> listOfMutables = arrayOfMutables;

    // But accessing values through this interface lead
    // to different behavior: IList indexer returns a copy
    // instead of an managed reference
    listOfMutables[0].IncrementI(); // Should change I to 7

    // Nope! we still have 6, because previous line of code
    // mutate a copy instead of a list value
    Console.WriteLine(listOfMutables[0].I);

因此，只要您和团队的其他成员清楚地了解您在做什么，可变结构就不是邪恶的。但是有太多的极端情况，当程序行为与预期不同时，这可能会导致微妙的难以产生和难以理解的错误。

可变数据有许多优点和缺点。最大的缺点就是别名。如果相同的值在多个地方使用，其中一个地方更改了它，那么它将神奇地更改到正在使用它的其他地方。这与竞态条件有关，但并不完全相同。

有时候，价值百万美元的优势是模块化。可变状态允许您向代码隐藏更改的信息，而代码不需要知道这些信息。

《解释器的艺术》详细讨论了这些权衡，并给出了一些例子。

从哪里开始;-p

埃里克·利珀特的博客总是很适合引用:

这是可变的另一个原因 值类型是邪恶的。试着总是 使值类型不可变。

首先，您很容易丢失更改……例如，从列表中获取内容:

Foo foo = list[0];
foo.Name = "abc";

这改变了什么?没有什么有用的…

属性也是一样:

myObj.SomeProperty.Size = 22; // the compiler spots this one

强迫你做:

Bar bar = myObj.SomeProperty;
bar.Size = 22;
myObj.SomeProperty = bar;

不那么关键的是规模问题;可变对象往往有多个属性;然而，如果你有一个包含两个int型，一个string型，一个DateTime型和一个bool型的结构体，你会很快消耗大量内存。使用类，多个调用方可以共享对同一个实例的引用(引用很小)。