C# 会从聚合结构/类中受益吗？

Question

前言

tl;wr:这是一个讨论。

我知道这个“问题”更多的是一个讨论，因此为什么我将其标记为社区维基。但是，根据 How to Ask 页面，它可能属于此处，因为它与特定的编程相关，而不是讨论经过一小时的研究后，可以在网络上的任何地方找到具体的、与大多数 C# 程序员相关的内容，并且符合主题。此外，问题本身就是为了获得答案，无论我的偏见如何，我都会保持开放的态度：C# 真的会从聚合结构中受益吗？尽管有这个前言，但我会理解这一点关闭，但如果有权限和意图关闭的用户将我重定向到网络上适当的讨论点，我将不胜感激。

---

简介

---

缺乏结构可变性

结构 是 C# 中灵活但有争议的类型。它们提供了堆栈分配的值类型组织范式，但不提供其他值类型的不变性。

有些人说结构应该代表值，并且值不会改变（例如 int i = 5;，5 是不可变的），而有些人则将它们视为带有子字段的 OOP 布局。

关于结构不变性的争论 (1，2，3) ，当前的解决方案似乎是让程序员强制执行不变性，也尚未解决。

例如，当将结构作为引用访问时，C# 编译器将检测可能的数据丢失（此页面的底部< /a>) 并限制分配。此外，由于结构体构造函数、属性和函数能够执行任何操作，（对于构造函数）在返回控件之前分配所有字段的限制，结构体 不能声明为常量，如果它们仅限于数据表示，那么这将是正确的声明。

---

结构体的不可变子集，聚合

聚合类（Wikipedia< /a>）是功能有限的严格数据结构，由于缺乏灵活性而注定要提供语法糖。在 C++ 中，它们“没有用户声明的构造函数，没有私有或受保护的非静态数据成员，没有基类，也没有虚函数”。尽管核心概念保持不变，但 C# 中此类类的理论细节在此仍存在争议。

由于聚合结构严格来说是带有标记访问器的数据持有者，因此可以确保它们的不变性（在可能的 C# 上下文中）。与其他纯值类型一样，聚合也不能为 null，除非指定了 null 运算符 (?)。因此，许多非法的结构操作以及一些语法糖都将成为可能。

---

使用

---

1. 聚合可以声明为 const，因为它们的构造函数将被强制执行除了分配字段之外不执行任何操作。
2. 聚合可以用作方法参数的默认值。
3. 聚合可以是隐式顺序的，从而促进与本机
4. 聚合的交互。聚合将是不可变的，强制引用访问不会丢失数据。编译器对此类子字段修改的检测可能会导致完整的、隐式的重新分配。库。

---

假设语法

---

根据 C++ 语法，我们可以想象如下内容： （请记住，这是一个社区 wiki，欢迎并鼓励改进）

aggregate Size
{
    int Width;
    int Height;
}

aggregate Vector
{
    // Default values for constructor.
    double X = 0, Y = 0, Z = 0;
}

aggregate Color
{
    byte R, G, B, A = 255;
}

aggregate Bar
{
    int X;
    Qux Qux;
}

aggregate Qux
{
    int X, Y;
}

static class Foo
{
    // Constant is possible.
    const Size Big = new Size(200, 100);

    // Inline constructor.
    const Vector Gravity = { 0, -9.8, 0 };

    // Default value / labeled parameter.
    const Color Fuschia = { 255, 0, 255 };
    const Vector Up = { y: 1 };

    // Sub-aggregate initialization
    const Bar Test = { 20, { 4, 3 } };

    static void SetVelocity(Vector velocity = { 0, 1, 0 }) { ... }
    static void SetGravity(Vector gravity = Foo.Gravity) { ... }

    static void Main()
    {
        Vector v = { 1, 2, 3 };

        double y = v.Y; // Valid.

        v.Y = 5; // Invalid, immutable.
    }
}

隐式（重新）赋值

从今天开始，在 C# 4.0 中分配结构的子字段是有效的：

Vector v = new Vector(1, 2, 3);
v.Z = 5; // Legal in current C#.

但是，有时，编译器可以检测到结构何时被错误地访问为参考文献，并将禁止更改子字段。例如，(示例问题)

//(in a Windows.Forms context)
control.Size.Width = 20; // Illegal in current C#.

作为 Size 是一个属性，struct Size 是一个值类型，我们将编辑实际属性的副本/克隆，在这种情况下这将是无用的。作为 C# 用户，我们倾向于假设大多数内容都是通过引用访问的，尤其是在 OOP 设计中，这会让我们认为这样的调用是合法的（如果 struct Size 是 struct Size ，那么它就是合法的）代码>类）。

此外，在访问集合时，编译器还禁止我们修改结构体子字段：(示例问题 ）

List<Vector> vectors = ... // Imagine populated data.
vectors[4].Y = 10; // Illegal in current C#.

关于这些不幸的限制的好消息是，编译器对这种情况做了一半可能的聚合解决方案：检测它们何时发生。另一半是隐式地重新分配具有更改后的值的新聚合。

• 当在局部范围内时，只需重新分配向量即可。
• 在外部作用域中时，找到一个 get，如果可以访问匹配的 set 访问器，则重新分配给该访问器。

为此，为了避免混淆，委托必须标记为隐式：

implicit aggregate Vector { ... }
implicit aggregate Size { ... }


// Example 1
{
    Vector v = new Vector(1, 2, 3);
    v.Z = 5; // Legal with implicit aggregates.

    // What is implicitly done:
    v = new Vector(v.X, v.Y, 5); // Local variable, simply reassign.
}

// Example 2
{
    //(in a Windows.Forms context)
    control.Size.Width = 20; // Legal with implicit aggregates.

    // What is implicitly done:
    Size old = control.Size.__get(); // External, MSIL detects a get.
    // If MSIL can find a matching, accessible __set:
    control.Size.__set({ 20, old.Height });
}

// Example 3
{
    List<Vector> vectors = ... // Imagine populated data.
    vectors[4].Y = 10; // Legal with implicit aggregates.

    // What is implicitly done:
    Vector old = vectors[4].__get(); // External, MSIL detects a get.
    // If MSIL can find a matching, accessible __set:
    vectors[4].__set({ old.X, 10, old.Z });
}

// Example 4
{
    Vector The5thVector(List<Vector> vectors) { return vectors[4]; }
    ...
    List<Vector> vectors = ...;
    The5thVector(vectors).Y = 10; // Illegal with implicit aggregates.

    // This is illegal because the compiler cannot find an implicit
    // "set" to match. as it is a function return, not a property or
    // indexer.
}

当然，最后的隐式重新分配只是一种语法简化，可以或可以不被采纳。我只是建议它，因为编译器似乎能够检测到对结构的此类引用访问，并且如果它是聚合，则可以轻松地为程序员转换代码。

---

摘要

• 聚合可以有字段；
• 聚合是值类型；
• 聚合是不可变的；
• 聚合在堆栈上分配；
• 聚合不能继承；
• 聚合具有顺序布局；
• 聚合有一个顺序的默认构造函数；
• 聚合不能有用户定义的构造函数；
• 聚合可以有默认值和标记结构；
• 聚合可以内联定义；
• 聚合可以声明为常量；
• 聚合可以用作默认参数；
• 除非指定，否则聚合不可为 null (?)；

可能：

• 聚合（可以）被隐式地重新分配；请参阅 Marcelo Cantos 的回复和评论。
• 聚合（可以）有接口；
• 聚合（可以）有方法；

---

缺点

由于聚合不会取代结构，而是另一种组织方案，我找不到太多缺点，但希望 S/O 的 C# 老手能够填充这个 CW 部分。最后一点，请直接回答问题并进行讨论：如本文所述，C# 会对聚合类有利吗？我无论如何都不是 C# 专家，只是 C# 语言的爱好者，并且怀念这个对我来说至关重要的功能。我正在向经验丰富的程序员寻求有关此案例的建议和评论。 我知道存在许多解决方法，并且每天都在积极使用它们，我只是认为它们太常见了，不容忽视。

Answer 1

我希望结构体首先是用类似于您提出的语义的东西来定义的。

然而，我们仍然坚持现有的东西，我认为我们不太可能在 CLR 中引入一种全新的“类型”。引入一种新类型意味着将其引入每种 .NET 语言，而不仅仅是 C#，这是一个很大的变化。

我认为更有可能的是 - 请记住，当我谈论假设的、未宣布的未来产品的假设语言功能时，这些产品不存在且可能永远不存在，我这样做仅用于娱乐目的 ——我们会找到一些方法来对类和结构进行更好的不变性注释和强制执行。无论所讨论的类型是值类型还是引用类型，编译器都可以更好地强制执行不变性并使其更容易以不可变风格进行编程。如果编译器或 CLR 在编译时或 jit 时具有更多已知的不变性保证，那么它也可以更好地优化在多核计算机上运行的代码。

当您苦苦思考您的提案时，您可能需要考虑一个有趣的问题：如果聚合类型具有方法，那么“this”是值还是变量？例如：

aggregate Vector
{
    int x, y, z;
    public void M(Action action)
    {
         Console.WriteLine(this.x);
         action();
         Console.WriteLine(this.x);
    }
}
...
Vector v = new Vector(1, 2, 3);
Action action = ()=>{ v = new Vector(4, 5, 6); };
v.M(action);

发生什么事？ “this”是否通过值传递给M，在这种情况下它会写出两次“1”，或者它是否作为对变量的引用传递，其中如果观察到您所谓的“不可变”类型发生变异？ （因为变异的是变量；根据定义，变量是允许变异的，这就是为什么它们被称为“可变的”。）

Answer 2

这会做什么呢？

List<Vector> vectors = ...;
Vector v = vectors[4];
v.Y = 10;

或者这个？

Vector The5thVector(List<Vector> vectors) { return vectors[4]; }
...
List<Vector> vectors = ...;
The5thVector(vectors).Y = 10;

用隐式赋值替换诊断不会让你走得太远。可变结构如此成问题是有原因的，并且简单地声明一个新概念（聚合）并不能解决任何这些问题。

最好的解决方案是首先禁止语言中存在可变结构。第二个最佳解决方案是表现得好像他们不被允许一样。结构应该很小并且独立，这消除了使它们不可变的任何缺点。

Answer 3

不，它不会受益。无论如何，结构作为可变类型更好。

首先......“隐式重新分配的不变性”实际上只是“低效的可变性”。

给定一个“Point”结构，如果您只想更改 X 的值，为什么要强制重写整个内存结构呢？仅仅单独覆盖 X 比用新值覆盖 X 并用当前值毫无意义地覆盖 Y 更有效。这样的计划不会有任何好处。

老实说，整个可变性主题只是一个视角问题。只有在将复杂对象作为一个整体引用时，讨论可变性才有意义，并询问其各个部分是否会改变值，同时维护对整个对象的引用。

例如，将字符串称为不可变是有意义的，因为您将其称为表示字符集合的特定内存块，从引用它的任何事物的角度来看，其中字符不会更改值。另一方面，int 结构是可变的，因为它的值可以通过简单的赋值来更改，并且对 int 结构的任何引用（指针）都会看到这些更改。

至于结构或聚合方法中的“this”，当然它应该始终引用结构/聚合在堆栈上的内存位置，因此通过匿名方法和委托更改结构值的更新应该被反映并视为可变的。总而言之，可变性在基本变量级别上是一个好主意，而不变性最好在更高级别上处理，其中表示复杂对象并且显式编码“不可变”行为。