Question

有人能解释一下这个重载是什么意思吗？

public static bool operator ==(Shop lhs, Shop rhs)
{
    if (Object.ReferenceEquals(lhs, null))
    {
        if (Object.ReferenceEquals(rhs, null))
        {
            return true;
        }
        return false;
    }

    return lhs.Equals(rhs);
}

我从未在重载中看到过Object.ReferenceEquals

Answer 1

此重载旨在比较Shop的两个实例。它使用Object.ReferenceEquals来确定其中一个实例是否为null 它无法使用lhs == null或rhs == null，因为这会再次调用operator ==并创建一个无限递归，从而导致StackOverflowException。

如果两个实例均为null，则返回true（因为它们相等）如果只有一个实例是null，则返回false（因为它们不相等）如果两个实例都不是null，则会返回Equals Shop实施的结果。

Answer 2

operator overload（= {，而不是ReferenceEquals的方法重载）来检查类型Shop的两个实例是否具有相同的引用（即，它们是否引用相同的内存地址）。

bool result = shop1 == shop2; //shop1 and shop2 are of type Shop

声明==运算符时，您还需要重载其匹配（或计数器）运算符!=：

public static bool operator ==(Shop lhs, Shop rhs) {
    if (Object.ReferenceEquals(lhs, null)) { //Check if the left-hand-side Shop is null
        if (Object.ReferenceEquals(rhs, null)) {
            return true; //both are null, equal reference
        }
        return false; //lhs is null, but rhs is not (not equal reference)
    }
    return lhs.Equals(rhs); //lhs is not null, thus can call .Equals, check if it is Equals to rhs
}

public static bool operator !=(Shop lhs, Shop rhs) { //the opposite operator
    if (Object.ReferenceEquals(lhs, null)) {
        if (Object.ReferenceEquals(rhs, null)) {
            return false;
        }
        return true;
    }
    return !lhs.Equals(rhs);
}

还值得注意的是，Object.ReferenceEquals(lhs, null)代替lhs == null，因为第二个会导致另一个重载==被调用，直到infinite recursion导致StackOverflowException }}

它们的用法如下：

Shop shop1 = new Shop();
Shop shop2 = new Shop();
bool result = shop1 == shop2; //this will return false, since lhs and rhs referring to two different memory address
shop2 = shop1;
result = shop1 == shop2; //this will return true, referring to the same memory location
shop1 = null;
shop2 = null;
result = shop1 == shop2; //this will return true, both are null

理解这一点，你甚至可以创建这样的东西：

public struct MyCrazyInt{ //this will reverse the result of + and -
    private int Value { get; set; }
    public MyCrazyInt(int value) :this() {
        Value = value;
    }

    public bool Equals(MyCrazyInt otherCrazy) {
        return this.Value != otherCrazy.Value; //reverse this result
    }

    public static MyCrazyInt operator +(MyCrazyInt lhs, MyCrazyInt rhs) {
        int lhsVal = lhs.Value;
        int rhsVal = rhs.Value;
        return new MyCrazyInt(lhsVal - rhsVal); //note that direct lhs-rhs will cause StackOverflow
    }

    public static MyCrazyInt operator -(MyCrazyInt lhs, MyCrazyInt rhs) {
        int lhsVal = lhs.Value;
        int rhsVal = rhs.Value;
        return new MyCrazyInt(lhsVal + rhsVal); //note that direct lhs+rhs will cause StackOverflow
    }

    public override string ToString() {
        return Value.ToString();
    }
}

然后像这样使用它

MyCrazyInt crazyInt1 = new MyCrazyInt(5);
MyCrazyInt crazyInt2 = new MyCrazyInt(3);
MyCrazyInt crazyInt3 = crazyInt1 - crazyInt2; //this will return 8
crazyInt3 = crazyInt1 + crazyInt2; //this will return 2

Answer 3

这很容易。＆＃34; NULL＆＃34;实际上是一个驻留在内存中并具有引用的对象，可以设置为任何对象，它是Base＆＃34; Object＆＃34;的子类。类。

因此，上面的代码首先检查＆＃34; Shop＆＃34;通过将它们的参考值与＆＃34; null＆＃34;进行比较，对象同样为null。对象引用，如果它们都等于null，则它们相等并返回True。

如果只有第一个对象为空而第二个对象为空，则返回false。

最后，如果第一个Shop对象不为null，则代码假设第二个不为null，并将它们的实例与Shop对象进行比较以检查它们是否相等。

我们必须使用这种方式比较null对象的主要原因是，如果比较null或未实例化的对象，则会出现运行时错误，因此我们需要覆盖默认的＆＃34; ==＆＃34;以这种方式运营。

这个重载是什么意思？

3 个答案: