比较2个接口

Question

interface I //: IEquatable<I>
{ }

class A : I
{
    static public bool operator !=(A a, I i)
    {
        return !(a == i);
    }

    static public bool operator ==(A a, I i)
    {
        return true;
    }

    public override bool Equals(object obj)
    {
        if (obj is I)
            return this == (I)obj;
        else
            return base.Equals(obj);
    }

    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
}

class B : I
{
    static public bool operator !=(B b, I i)
    {
        return !(b == i);
    }

    static public bool operator ==(B b, I i)
    {
        return false;
    }

    public override bool Equals(object obj)
    {
        if (obj is I)
            return this == (I)obj;
        else
            return base.Equals(obj);
    }

    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
}
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        List<I> iss = new List<I>();
        A a = new A();
        B b = new B();
        iss.Add(a);
        iss.Add(b);

        if (iss[0] == iss[1])
            Console.WriteLine("a == b");
        else
            Console.WriteLine("a != b");

        if (iss[1] == iss[0])
            Console.WriteLine("b == a");
        else
            Console.WriteLine("b != a");
    }
}

输出是

a != b
b != a

我预期的

a == b
b != a

有人可以解释一下吗？

Answer 1

我会在每个类的 Equals() 方法和 == 运算符中设置一个断点，并查看调用什么来计算每个表达式。这显然不是你所期望的。我的猜测是，因为 I 不会也不可能要求实现者公开 == 运算符，因此当您比较两个 I 时这样做时，运行时不会费心寻找重载的运算符，而是求助于 System.Object ==，它执行引用检查。

Answer 2

简单的答案：

您有一个 List，并且您将两个 I 相互比较。因为接口 I 没有（也不能）实现比较运算符，所以对象是通过引用进行比较的。

相反，您可以使用抽象基类：

public interface I
{
}

public abstract class AbstractI : I
{
    public static bool operator ==(AbstractI left, I right)
    {
        return left.equals(right); //TODO can be null
    }
    public static bool operator !=(AbstractI left, I right)
    {
        return !left.equals(right);
    }

    protected abstract bool equals(I other);
}

public class A : AbstractI
{
    protected override bool equals(I other)
    {
        //TODO your compare code here
        throw new NotImplementedException();
    }
}

public class B : AbstractI
{
    protected override bool equals(I other)
    {
        //TODO your compare code here
        throw new NotImplementedException();
    }
}


List<AbstractI> l = new List<AbstractI>(){
    new A(),
    new B()
};

var x = l[0] == l[1];