根据定义，值类型是不可变的吗？

Question

我经常读到structs 应该是不可变的——它们不是根据定义吗？

你认为int 是不可变的吗？

int i = 0;
i = i + 123;

似乎没问题 - 我们得到一个新的 int 并将其分配回 i。这个呢？

i++;

好吧，我们可以把它当成一个捷径。

i = i + 1;

structPoint 呢？

Point p = new Point(1, 2);
p.Offset(3, 4);

这真的改变了(1, 2)的观点吗？难道我们不应该把它看作是Point.Offset()返回一个新点的快捷方式吗？

p = p.Offset(3, 4);

这个想法的背景是这样的——一个没有标识的值类型怎么可能是可变的？您必须至少查看两次才能确定它是否发生了变化。但是没有身份怎么能做到呢？

我不想通过考虑ref 参数和装箱来使推理复杂化。我也知道p = p.Offset(3, 4); 比p.Offset(3, 4); 更能表达不变性。但问题仍然存在 - 值类型在定义上不是不可变的吗？

更新

我认为至少涉及两个概念——变量或字段的可变性和变量值的可变性。

public class Foo
{
    private Point point;
    private readonly Point readOnlyPoint;

    public Foo()
    {
        this.point = new Point(1, 2);
        this.readOnlyPoint = new Point(1, 2);
    }

    public void Bar()
    {
        this.point = new Point(1, 2);
        this.readOnlyPoint = new Point(1, 2); // Does not compile.

        this.point.Offset(3, 4); // Is now (4, 6).
        this.readOnlyPoint.Offset(3, 4); // Is still (1, 2).
    }
}

在示例中，我们必须使用字段 - 一个可变字段和一个不可变字段。因为值类型字段包含整个值，所以存储在不可变字段中的值类型也必须是不可变的。我仍然对结果感到非常惊讶 - 我没有期望 readonly 字段保持不变。

变量（除了常量）总是可变的，因此它们对值类型的可变性没有任何限制。

---

答案似乎不是那么直截了当，所以我将重新表述这个问题。

鉴于以下情况。

public struct Foo
{
    public void DoStuff(whatEverArgumentsYouLike)
    {
        // Do what ever you like to do.
    }

    // Put in everything you like - fields, constants, methods, properties ...
}

你能否给出一个完整版本的Foo 和一个用法示例——可能包括ref 参数和装箱——这样就不可能重写所有出现的

foo.DoStuff(whatEverArgumentsYouLike);

与

foo = foo.DoStuff(whatEverArgumentsYouLike);

Answer 1

您可以编写可变结构，但最佳实践是使值类型不可变。

例如 DateTime 在执行任何操作时总是会创建新实例。点是可变的，可以更改。

回答您的问题：不，根据定义，它们不是不可变的，这取决于它们是否应该是可变的。例如，如果它们应该用作字典键，它们应该是不可变的。

Answer 2

可变性和值类型是两个不同的东西。

将类型定义为值类型，表示运行时将复制值而不是对运行时的引用。另一方面，可变性取决于实现，每个类都可以根据需要实现。

Answer 3

我不想让推理复杂化 关于这个考虑ref 参数和装箱。我也知道 p = p.Offset(3, 4); 表示 不变性比 p.Offset(3, 4); 确实如此。但是 问题仍然存在 - 不是值类型 根据定义是不可变的？

那么，你并没有真正在现实世界中运作，是吗？在实践中，值类型在函数之间移动时复制自身的倾向与不可变性很好地吻合，但除非您使它们不可变，否则它们实际上并不是不可变的，因为正如您所指出的，您可以使用对它们的引用像其他任何东西一样。

Answer 4

值类型在定义上不是不可变的吗？

不，它们不是：例如，如果您查看 System.Drawing.Point 结构体，它的 X 属性上有一个 setter 和一个 getter。

但是，可以说所有值类型应该使用不可变的 API 定义。

Answer 5

对象/结构在以数据无法更改的方式传递给函数时是不可变的，并且返回的结构是new 结构。经典的例子是

String s = "abc";

s.toLower();

如果编写了toLower 函数，因此返回一个替换“s”的新字符串，它是不可变的，但如果函数逐个字母替换“s”中的字母并且从不声明“新字符串” ，它是可变的。

Answer 6

如果您的逻辑足够深入，那么 所有 类型都是不可变的。当您修改引用类型时，您可能会争辩说您实际上是在将新对象写入同一地址，而不是修改任何内容。

或者您可以争辩说，在任何语言中，一切都是可变的，因为以前用于一件事的内存有时会被另一件事覆盖。

有了足够多的抽象，而忽略了足够多的语言特性，你就可以得出任何你喜欢的结论。

这没有抓住重点。根据 .NET 规范，值类型是可变的。你可以修改它。

int i = 0;
Console.WriteLine(i); // will print 0, so here, i is 0
++i;
Console.WriteLine(i); // will print 1, so here, i is 1

但它仍然是相同的。变量i 只声明一次。在此声明之后发生的任何事情都是修改。

在类似具有不可变变量的函数式语言中，这是不合法的。 ++i 是不可能的。一旦声明了一个变量，它就有一个固定的值。

在 .NET 中，情况并非如此，没有什么可以阻止我在声明 i 后对其进行修改。

再想一想，下面是另一个可能更好的例子：

struct S {
  public S(int i) { this.i = i == 43 ? 0 : i; }
  private int i;
  public void set(int i) { 
    Console.WriteLine("Hello World");
    this.i = i;
  }
}

void Foo {
  var s = new S(42); // Create an instance of S, internally storing the value 42
  s.set(43); // What happens here?
}

在最后一行，根据您的逻辑，我们可以说我们实际上构造了一个新对象，并用该值覆盖旧对象。 但那是不可能的！要构造一个新对象，编译器必须将i 变量设置为42。但它是私有的！它只能通过用户定义的构造函数访问，该构造函数明确禁止值 43（改为将其设置为 0），然后通过我们的 set 方法访问，该方法具有令人讨厌的副作用。编译器无法只是使用它喜欢的值创建一个新对象。将s.i 设置为43 的唯一方法是通过调用set()修改当前对象。编译器不能这样做，因为它会改变程序的行为（它会打印到控制台）

因此，要使所有结构不可变，编译器就必须作弊并破坏语言规则。当然，如果我们愿意打破规则，我们可以证明任何事情。我可以证明所有整数也是相等的，或者定义一个新类会导致你的计算机着火。 只要我们遵守语言规则，结构就是可变的。

Answer 7

不，他们不是。示例：

Point p = new Point (3,4);
Point p2 = p;
p.moveTo (5,7);

在此示例中，moveTo() 是 就地 操作。它改变了隐藏在引用 p 后面的结构。您可以通过查看p2 看到：它的位置也将发生变化。对于不可变结构，moveTo() 必须返回一个新结构：

p = p.moveTo (5,7);

现在，Point 是不可变的，当您在代码中的任何位置创建对它的引用时，您不会有任何意外。来看看i：

int i = 5;
int j = i;
i = 1;

这是不同的。 i 不是一成不变的，5 是。第二个赋值不会复制对包含i 的结构的引用，而是复制i 的内容。所以在幕后，发生了完全不同的事情：你得到了变量的完整副本，而不是内存中地址（引用）的副本。

与对象等效的是复制构造函数：

Point p = new Point (3,4);
Point p2 = new Point (p);

这里，p 的内部结构被复制到一个新的对象/结构中，p2 将包含对它的引用。但这是一个非常昂贵的操作（与上面的整数赋值不同），这就是为什么大多数编程语言都会做出区分。

随着计算机变得更强大并获得更多内存，这种区别将会消失，因为它会导致大量错误和问题。在下一代中，将只有不可变对象，任何操作都将受到事务的保护，甚至int 将是一个完整的对象。就像垃圾收集一样，它将在程序稳定性方面向前迈出一大步，在最初的几年里会引起很多痛苦，但它将允许编写可靠的软件。今天，计算机的速度还不够快。

Answer 8

我认为令人困惑的是，如果您有一个应该像值类型一样工作的引用类型，那么让它不可变是个好主意。值类型和引用类型之间的主要区别之一是通过引用类型上的一个名称所做的更改可以显示在另一个名称中。值类型不会发生这种情况：

public class foo
{
    public int x;
}

public struct bar
{
    public int x;
}


public class MyClass
{
    public static void Main()
    {
        foo a = new foo();
        bar b = new bar();

        a.x = 1;
        b.x = 1;

        foo a2 = a;
        bar b2 = b;

        a.x = 2;
        b.x = 2;

        Console.WriteLine( "a2.x == {0}", a2.x);
        Console.WriteLine( "b2.x == {0}", b2.x);
    }
}

生产：

a2.x == 2
b2.x == 1

现在，如果您希望有一个类型具有值语义，但又不想真正将其设为值类型 - 可能是因为它需要的存储太多或其他原因，您应该考虑不可变性是设计的一部分。对于不可变的 ref 类型，对现有引用所做的任何更改都会生成一个新对象，而不是更改现有对象，因此您会获得值类型的行为，即您持有的任何值都不能通过其他名称进行更改。

当然，System.String 类就是这种行为的典型例子。

Answer 9

一个对象是不可变的，如果它的状态 一旦对象有就不会改变 已创建。

简短回答：不，值类型在定义上不是不可变的。 结构和类都可以是可变的或不可变的。 这四种组合都是可能的。如果结构或类具有非只读的公共字段、带有 setter 的公共属性或设置私有字段的方法，则它是可变的，因为您可以更改其状态而无需创建该类型的新实例。

---

长答案：首先，不变性问题仅适用于具有字段或属性的结构或类。最基本的类型（数字、字符串和 null）本质上是不可变的，因为它们没有任何东西（字段/属性）可以改变。 5 就是 5 就是 5。对 5 的任何操作都只会返回另一个不可变的值。

您可以创建可变结构，例如System.Drawing.Point。 X 和 Y 都有修改结构字段的设置器：

Point p = new Point(0, 0);
p.X = 5;
// we modify the struct through property setter X
// still the same Point instance, but its state has changed
// it's property X is now 5

有些人似乎将不可变性与值类型通过值（因此得名）而不是通过引用传递这一事实相混淆。

void Main()
{
    Point p1 = new Point(0, 0);
    SetX(p1, 5);
    Console.WriteLine(p1.ToString());
}

void SetX(Point p2, int value)
{
    p2.X = value;
}

在这种情况下，Console.WriteLine() 写入“{X=0,Y=0}”。这里p1 未被修改，因为SetX() 修改了p2，这是p1 的副本。这是因为p1 是一个值类型，而不是因为它是不可变的（它不是）。

为什么应该值类型是不可变的？很多原因...见this question。主要是因为可变值类型会导致各种不那么明显的错误。在上面的例子中，程序员可能在调用SetX() 之后期望p1 是(5, 0)。或者想象一下按一个以后可以更改的值进行排序。然后您的排序集合将不再按预期排序。字典和哈希也是如此。 Fabulous Eric Lippert (blog) 写了一个 whole series about immutability 以及为什么他认为这是 C# 的未来。 Here's one of his examples 可让您“修改”只读变量。

---

更新：您的示例：

this.readOnlyPoint.Offset(3, 4); // Is still (1, 2).

正是 Lippert 在他的帖子中提到的关于修改只读变量的内容。 Offset(3,4) 实际上修改了一个Point，但它是readOnlyPoint 的副本，它从未分配给任何东西，所以它丢失了。

而那就是为什么可变值类型是邪恶的：它们让你认为你正在修改某些东西，而有时你实际上是在修改一个副本，这会导致意想不到的错误.如果Point 是不可变的，Offset() 将不得不返回一个新的Point，而您将无法将其分配给readOnlyPoint。然后你去“哦，对了，它是只读的是有原因的。我为什么要尝试更改它？幸好编译器现在阻止了我。”

---

更新：关于您改写的请求...我想我知道您的意思。在某种程度上，您可以“认为”结构是内部不可变的，修改结构与用修改后的副本替换它是一样的。据我所知，它甚至可能是 CLR 在内存中内部所做的事情。 （这就是闪存的工作原理。你不能只编辑几个字节，你需要将整个千字节块读入内存，修改你想要的少数，然后将整个块写回。）然而，即使它们“内部不可变” "，这是一个实现细节，对于我们作为结构用户的开发人员（他们的接口或 API，如果你愿意的话），它们可以被更改。我们不能忽视这一事实并“认为它们是不可变的”。

您在评论中说“您不能引用字段或变量的值”。您假设每个结构变量都有不同的副本，这样修改一个副本不会影响其他副本。这并不完全正确。以下标记的行不可替换，如果...

interface IFoo { DoStuff(); }
struct Foo : IFoo { /* ... */ }

IFoo otherFoo = new Foo();
IFoo foo = otherFoo;
foo.DoStuff(whatEverArgumentsYouLike); // line #1
foo = foo.DoStuff(whatEverArgumentsYouLike); // line #2

第 1 行和第 2 行的结果不同...为什么？因为foo 和otherFoo 指的是Foo 的同一个盒装实例。第 1 行中 foo 中的任何更改都会反映在 otherFoo 中。第 2 行将 foo 替换为一个新值，并且对 otherFoo 没有任何作用（假设 DoStuff() 返回一个新的 IFoo 实例并且不修改 foo 本身）。

Foo foo1 = new Foo(); // creates first instance
Foo foo2 = foo1; // create a copy (2nd instance)
IFoo foo3 = foo2; // no copy here! foo2 and foo3 refer to same instance

修改foo1 不会影响foo2 或foo3。修改foo2 将反映在foo3 中，但不会反映在foo1 中。修改 foo3 将反映在 foo2 中，但不会反映在 foo1 中。

令人困惑？坚持使用不可变的值类型，您就可以消除修改它们的冲动。

---

更新：修复了第一个代码示例中的错字

Answer 10

不，值类型不是根据定义是不可变的。

首先，我应该问“值类型是否表现得像不可变类型？”这个问题。而不是询问它们是否是不可变的 - 我认为这会引起很多混乱。

struct MutableStruct
{
    private int state;

    public MutableStruct(int state) { this.state = state; }

    public void ChangeState() { this.state++; }
}

struct ImmutableStruct
{
    private readonly int state;

    public MutableStruct(int state) { this.state = state; }

    public ImmutableStruct ChangeState()
    {
        return new ImmutableStruct(this.state + 1);
    }
}

[待续...]

Answer 11

去年我写了一篇关于不制作结构可能遇到的问题的博客文章 不可变。

The full post can be read here

这是一个可怕的错误的例子：

//Struct declaration:

struct MyStruct
{
  public int Value = 0;

  public void Update(int i) { Value = i; }
}

代码示例：

MyStruct[] list = new MyStruct[5];

for (int i=0;i<5;i++)
  Console.Write(list[i].Value + " ");
Console.WriteLine();

for (int i=0;i<5;i++)
  list[i].Update(i+1);

for (int i=0;i<5;i++)
  Console.Write(list[i].Value + " ");
Console.WriteLine();

这段代码的输出是：

0 0 0 0 0
1 2 3 4 5

现在让我们做同样的事情，但将数组替换为通用 List<>：

List<MyStruct> list = new List<MyStruct>(new MyStruct[5]); 

for (int i=0;i<5;i++)
  Console.Write(list[i].Value + " ");
Console.WriteLine();

for (int i=0;i<5;i++)
  list[i].Update(i+1);

for (int i=0;i<5;i++)
  Console.Write(list[i].Value + " ");
Console.WriteLine();

输出是：

0 0 0 0 0
0 0 0 0 0

解释很简单。不，这不是装箱/拆箱...

从数组中访问元素时，运行时会直接获取数组元素，因此Update() 方法对数组项本身起作用。这意味着数组中的结构本身已更新。

在第二个示例中，我们使用了通用的List<>。当我们访问特定元素时会发生什么？好吧，indexer 属性被调用，这是一个方法。值类型在方法返回时总是被复制，所以这正是发生的情况：列表的索引器方法从内部数组中检索结构并将其返回给调用者。因为涉及到一个值类型，所以会做一个拷贝，在拷贝上调用Update()方法，当然对列表的原始项没有影响。

换句话说，始终确保您的结构是不可变的，因为您永远无法确定何时会制作副本。大多数时候它是显而易见的，但在某些情况下它真的会让你大吃一惊......

Answer 12

要定义一种类型是可变的还是不可变的，必须定义该“类型”所指的内容。当声明引用类型的存储位置时，声明只是分配空间来保存对存储在其他地方的对象的引用；该声明不会创建有问题的实际对象。尽管如此，在谈论特定引用类型的大多数上下文中，人们不会谈论包含引用的存储位置，而是由该引用标识的对象。可以写入保存对象引用的存储位置这一事实绝不意味着对象本身是可变的。

相比之下，当声明值类型的存储位置时，系统将在该存储位置内为该值类型持有的每个公共或私有字段分配嵌套存储位置。有关值类型的所有内容都保存在该存储位置中。如果定义了Point 类型的变量foo 及其两个字段X 和Y，则分别保持3 和6。如果将foo 中的Point 的“实例”定义为一对字段，则当且仅当foo 是可变的时，该实例才是可变的。如果将Point 的实例定义为这些字段中保存的值（例如“3,6”），那么根据定义，这样的实例是不可变的，因为更改其中一个字段会导致Point 持有不同的实例。

我认为将值类型“实例”视为字段而不是它们所持有的值更有帮助。根据该定义，存储在可变存储位置的任何值类型以及存在任何非默认值的值类型将始终是可变的，无论它是如何声明的。语句MyPoint = new Point(5,8) 构造Point 的新实例，其中包含字段X=5 和Y=8，然后通过将其字段中的值替换为新创建的Point 的值来改变MyPoint。即使 struct 无法在其构造函数之外修改其任何字段，但 struct 类型也无法保护实例的所有字段不被另一个实例的内容覆盖。

顺便说一下，一个可变结构可以实现通过其他方式无法实现的语义的简单示例：假设myPoints[] 是一个可被多个线程访问的单元素数组，让二十个线程同时执行代码：

Threading.Interlocked.Increment(myPoints[0].X);

如果myPoints[0].X 开始时等于 0，并且有 20 个线程执行上述代码，无论是否同时，myPoints[0].X 将等于 20。如果有人试图模仿上面的代码：

myPoints[0] = new Point(myPoints[0].X + 1, myPoints[0].Y);

那么如果任何线程在另一个线程读取它并写回修改后的值之间读取myPoints[0].X，则增量的结果将丢失（结果myPoints[0].X可以任意结束在1之间的任何值和 20。