为什么可以'=' 在C#中不能重载？

Question

我想知道，为什么我不能在 C# 中重载 '=' ？ 我能得到更好的解释吗？

Answer 1

能够为赋值操作定义特殊语义将是有用的，但前提是这种语义可以应用于将给定类型的一个存储位置复制到另一存储位置的所有情况。 尽管标准 C++ 实现了此类赋值规则，但它要求在编译时定义所有类型。 当反射和泛型添加到列表中时，事情会变得更加复杂。

目前，.net 中的规则指定可以通过将所有字节清零来将存储位置设置为其类型的默认值（无论该类型是什么）。 它们进一步指定可以通过复制所有字节将任何存储位置复制到相同类型的另一个存储位置。 这些规则适用于所有类型，包括泛型。 给定两个 KeyValuePair 类型的变量，系统可以将一个变量复制到另一个变量，而无需知道该类型的大小和对齐要求之外的任何信息。 如果 t1、t2 或这些类型中的任何字段的类型都可以实现复制构造函数，则编写以下代码：将一个结构体实例复制到另一个结构体实例必须要复杂得多。

这并不是说这种能力提供了一些显着的好处——如果设计一个新的框架，自定义赋值运算符和默认构造函数的好处可能会超过成本。 然而，在新框架中实施成本将是巨大的，并且对于现有框架来说可能难以克服。

Answer 2

这段代码对我有用：

public class Class1
{

    ...

    public static implicit operator Class1(Class2 value)
    {
        Class1 result = new Class1();

        result.property = value.prop;

        return result;

    }

}

Answer 3

覆盖分配的类型

覆盖分配有两种类型：

1. 当您觉得用户可能会错过某些内容，并且您希望强制用户使用“强制转换”时
   就像浮点数到整数一样，当你丢失浮点值时

int a = (int)5.4f;

2. 当你希望用户这样做时甚至没有注意到他/她改变了对象类型

float f = 5;

如何覆盖赋值

对于 1，使用 explicit 关键字：

public static explicit override ToType(FromType from){
    ToType to = new ToType();
    to.FillFrom(from);
    return to;
}

对于 2，使用 implicit 关键字：

public static implicit override ToType(FromType from){
    ToType to = new ToType();
    to.FillFrom(from);
    return to;
}

更新：

注意：此实现可以在 FromType 或 ToType 类中进行，具体取决于您的需要，没有限制，您的类之一可以保存所有转换，并且另一个没有为此实现任何代码。

Answer 4

内存管理语言通常使用引用而不是对象。 当您定义类及其成员时，您正在定义对象行为，但是当您创建变量时，您正在使用对这些对象的引用。

现在，运算符 = 应用于引用，而不是对象。 当您将一个引用分配给另一个引用时，您实际上使接收引用指向另一个引用所在的同一对象。

Type var1 = new Type();
Type var2 = new Type();

var2 = var1;

在上面的代码中，在堆上创建了两个对象，一个由 var1 引用，另一个由 var2 引用。 现在最后一条语句使 var2 引用指向 var1 所引用的同一个对象。 在该行之后，垃圾收集器可以释放第二个对象，并且内存中只有一个对象。 整个过程中，没有对对象本身进行任何操作。

回到为什么=不能被重载，系统实现是你可以用引用做的唯一明智的事情。 您可以重载应用于对象的操作，但不能重载应用于引用的操作。

Answer 5

如果重载“=”，则在创建对象引用后将永远无法更改该对象引用。
...想一想 - 任何对 theObjectWithOverloadedOperator= 重载运算符内的内容的调用都会导致对重载运算符的另一次调用...那么重载运算符到底在做什么？ 也许设置一些其他属性 - 或者将值设置为新对象（不变性）？
通常不是“=”所暗示的意思。

但是，您可以覆盖隐式的 & 。 显式转换运算符：
http://www.blackwasp.co.uk/CSharpConversionOverload.aspx

Answer 6

因为这样做实际上没有意义。

在 C# 中，= 将对象引用分配给变量。 因此它对变量和对象引用进行操作，而不是对对象本身进行操作。 根据对象类型来重载它是没有意义的。

在C++中，定义operator=对于可以在堆栈上创建实例的类是有意义的，因为对象本身存储在变量中，而不是对它们的引用。 因此定义如何执行此类任务是有意义的。 但即使在 C++ 中，如果您有一组通常通过指针或引用使用的多态类，您通常会通过将 operator= 和复制构造函数声明为私有（或从 boost::noncopyable 继承）来显式禁止像这样复制它们，因为与在 C# 中不重新定义 = 的原因完全相同。 简单地说，如果你有 A 类的引用或指针，你并不真正知道它是否指向 A 类的实例或 A 的子类 B 类的实例。那么你真的知道在这种情况下如何执行 = 吗？

Answer 7

实际上，如果您可以定义具有值语义的类并在堆栈中分配这些类的对象，则重载operator = 是有意义的。 但是，在 C# 中，你不能。

Answer 8

一种可能的解释是，如果重载赋值运算符，则无法进行正确的引用更新。 它实际上会搞砸语义，因为当人们期望引用更新时，您的 = 运算符可能会完全做其他事情。 对程序员不太友好。

您可以使用隐式和显式的 to/from 转换运算符来减轻无法重载赋值的一些看似缺点。

Answer 9

我认为没有任何特别的理由可以指出。 一般来说，我认为这个想法是这样的：

• 如果您的对象是一个大而复杂的对象，则执行不使用 = 运算符进行赋值的操作可能会产生误导。

• 如果您的对象是一个小对象，您也可以使其不可变并在对其执行操作时返回新副本，以便赋值运算符按您期望的开箱即用方式工作（如 System.String 确实如此。）

Answer 10

您可以在 C# 中重载赋值。 只是不是在整个对象上，而是在它的成员上。 您使用 setter 声明属性：

class Complex
{
    public double Real
    {
        get { ... }
        set { /* do something with value */ }
    }

    // more members
}

现在，当您分配给 Real 时，您自己的代码就会运行。

对对象的赋值不可替换的原因是因为它已经被语言定义为意味着非常重要的东西。

Answer 11

它在 C++ 中是允许的，如果不小心，可能会导致很多混乱和错误查找。

本文对此进行了非常详细的解释。

http://www.relisoft.com/book/lang/project/14value。 html

Answer 12

因为搬起石头砸自己的脚是不被允许的。

更严肃地说，人们只能希望你的意思是比较而不是分配。 该框架对干扰平等/等价评估做出了详细规定，请在帮助中或在线使用 msdn 查找“比较”。