如果“== 运算符未定义”会发生什么？

Question

如果“== 运算符未定义”会发生什么？

示例：

class a
{
    int variable = 0;
}
class b
{
    void proc()
    {
        a ref1 = new a();
        a ref2 = new a();
        bool cmp1 = ref1 == ref2;//?
        bool cmp2 = ref1 == ref1;//?
    }
}

使用结构时有什么不同吗？

封送 (System.Runtime.Remoting.*) 对象（单例）怎么样？

Answer 1

对于用户定义的值类型，您的代码将无法编译。

具体来说，它会因以下错误而编译失败：“运算符 '==' 无法应用于类型 'a' 和 'a' 的操作数”。

"== 和 != 运算符无法对结构进行操作，除非该结构显式重载它们。"

您必须重载两者。您很可能不想在您的方法中使用默认的 Equals()，因为
“...对于结构，Object.Equals(Object)（这是 System.ValueType 中的重写版本）的默认实现通过使用反射来比较类型中每个字段的值来执行值相等检查。当实现者重写结构中的虚拟 Equals 方法时，目的是提供一种更有效的方法来执行值相等检查，并可选择将比较基于结构的字段或属性的某些子集。”

对于用户定义的引用类型（简化的情况，如OP的示例）：

“即使类没有重载 == 和 != 运算符，但默认行为是在类中执行引用相等性检查。应该重载 == 和 != 运算符，但这不是必需的。”

如果不重载运算符，则很可能只有引用相等测试。

“简化的情况”，因为运算符重载解析可能会选择其他实现而不是默认。

//Minimal example, for demonstration only.
//No Equals(), GetHaschode() overload, no IEquatable<T>, null checks, etc..
class Program
{
    static void Main()
    {

        MyMoreDerived a = new MyMoreDerived() { fbase = 1, fderived = 3 };
        MyMoreDerived b = new MyMoreDerived() { fbase = 2, fderived = 3 };

        //Even though MyMoreDerived does not overload the operators, this
        //will succeed - the definition in MyDerived will be used.
        if (a == b)
        {
            //Reached, because the operator in MyDerived is used.
            Console.WriteLine("MyDerived operator used: a == b");
        }

        a.fderived = 2;
        b.fbase = 1;
        //a => {1, 2} 
        //b => {1, 3}
        //Since 2 != 3, the operator in MyDerived would return false.
        //However only the operator in MyBase will be used.
        if ((MyBase)a == (MyBase)b)
        {
            //Reached, because the operator in MyBase is used.
            Console.WriteLine("MyBase operator used: a == b");
        }

        b.fderived = 2;
        //a => {1, 2} 
        //b => {1, 2}
        //Now both operator definitions would compare equal,
        //however they are not used.
        if ((object)a != (object)b)
        {
            //Reached, because the default implementation is used
            //and the references are not equal.
            Console.WriteLine("Default operator used: a != b");
        }

    }

    class MyBase
    {
        public int fbase;

        public static bool operator ==(MyBase x, MyBase y)
        {
            return x.fbase == y.fbase;
        }

        public static bool operator !=(MyBase x, MyBase y)
        {
            return x.fbase != y.fbase;
        }

    }

    class MyDerived : MyBase
    {
        public int fderived;

        public static bool operator ==(MyDerived x, MyDerived y)
        {
            return x.fderived == y.fderived;
        }

        public static bool operator !=(MyDerived x, MyDerived y)
        {
            return x.fderived != y.fderived;
        }

    }

    class MyMoreDerived : MyDerived
    {
    }

}

单例在引用类型的上下文中最有意义，它们的目的是返回一个特定的实例。我无法想象引用相同但对象不“等于”自身的合理情况。

即使使用远程处理，最佳实践也是将操作合同与数据合同分开。
前者通常由服务器端的 MarshalByRefObject 实现 - 实现由接口定义的操作 - 而后者则使用按值编组并可能由客户端和服务器共享的数据/消息类。如果您重载数据类中的运算符，这可能不是一个大问题。然而，我相信这些不应该引用/调用远程对象。

即使您提供了一个使运算符重载的自定义客户端代理，恕我直言，将远程调用隐藏在 == 和 != 运算符后面也是一种非常糟糕的做法，也是调试的噩梦。
（如果我理解你的意图，我不确定。）

Answer 2

它可能会比较指针“a”和“b”，看它们是否指向内存中的同一对象。

如果您需要比较这些对象的字段，则必须定义比较器函数。

您需要继承 IComparable 接口并定义 CompareTo 方法。

看这里：IComparable 接口

Answer 3

当 == 没有被重写时，我相信它会比较引用，检查它们是否是同一个对象。

示例：

MyClass a = new MyClass(1);
MyClass b = new MyClass(1);
MyClass c = a;

if (a == b) // false
    ...
if (a == c) // true
    ...

因此，在上面的代码中，cmp1 将为 false，但 cmp2 将为 true

对于用户定义的值类型，但是，它会比较该类型的实际值。

Answer 4

来自 MSDN：

对于预定义值类型，相等运算符 (==) 如果其操作数的值相等则返回 true，否则返回 false。 对于字符串以外的引用类型，如果两个操作数引用同一个对象，则 == 返回 true。对于字符串类型，== 比较字符串的值。