比较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

答案很简单：

你有List<I>，你比较两个I彼此。因为interface 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]; 

Answer 2

我会设置一个断点在每个类的equals（）方法和==操作符，看看被称为评估每个表达式。这显然不是你所期望的。我的猜测是，因为I不会要求实现者公开==运算符，所以当您比较两个I时，运行时不会寻找重载的运算符，而是使用System.Object ==，执行参考检查。