Оператор перегрузки C# == и! =

Question

У меня возникают проблемы с получением желаемого поведения из этих нескольких классов и интерфейсов.

Вот моя проблема,

//Inside a Unit Test that has access to internal methods and properties 

INode firstNode, secondNode; 

INodeId id = new NodeId (4); 

first = new Node (id, "node"); 
second = new Node (id, "node"); 

Assert.IsTrue (first == second); 

утверждают выше неудачу, потому что, кажется, идет к объектному классу равняется методу вместо перегруженного оператора в узле и классов NodeId.

Если у вас есть предложения о том, как я могу получить желаемое поведение, это было бы замечательно.

Вот часть Рамок я работаю:

public interface IIdentifier<T> where T : class 
{ 
    TKeyDataType GetKey<TKeyDataType>(); 

    bool Equals (IIdentifier<T> obj; 
} 

public interface INode 
{ 
    string name 
    { 
     get; 
    } 

    INodeId id 
    { 
     get; 
    } 
} 

public interface INodeId : IIdentifier<INode> 
{ 
} 

public class Node : INode 
{ 
    internal Node(INodeId id, string name) 
    { 
     //Work 
    } 

    public static bool operator == (Node n1, Node n2) 
    { 
     return n1.equals(n2); 
    } 

    public static bool operator != (Node n1, Node n2) 
    { 
     return !n1.equals(n2); 
    } 

    public bool Equals (INode node) 
    { 
     return this.name == node.name && 
       this.id = node.id; 
    } 

    #region INode Properties 

    } 

public class NodeId : INodeId 
{ 

    internal NodeId(int id) 
    { 
     //Work 
    } 

    public static bool operator == (NodeId n1, NodeId n2) 
    { 
     return n1.equals(n2); 
    } 

    public static bool operator != (NodeId n1, NodeId n2) 
    { 
     return !n1.equals(n2); 
    } 

    public override bool Equals (object obj) 
    { 
     return this.Equals ((IIdentifier<INode>) obj); 
    } 

    public bool Equals (IIdentifier<INode> obj) 
    { 
     return obj.GetKey<int>() == this.GetKey<int>(); 
    } 

    public TKeyDataType GetKey<TKeyDataType>() 
    { 
     return (TKeyDataType) Convert.ChangeType (
      m_id, 
      typeof (TKeyDataType), 
      CultureInfo.InvariantCulture); 
    } 


    private int m_id; 

} 

Answer 1

перегруженных оператора разрешаются во время компиляции на основе объявленных типов операндов, а не от фактического типа объектов во время выполнения. Альтернативный способ сказать это то, что перегрузки операторов не являются виртуальными. Таким образом, сравнение, которое вы делаете выше, это INode.operator==, а не Node.operator==. Поскольку INode.operator== не определен, перегрузка разрешается до Object.operator==, которая просто сравнивает ссылки.

Существует не очень хороший способ обойти это. Наиболее правильная вещь - использовать Equals(), а не == в любом месте, где операнды могут быть объектами. Если вам действительно нужна настоящая перегрузка виртуального оператора, вы должны определить operator == в корневом базовом классе, на который наследуются ваши объекты, и иметь этот вызов перегрузки Equals. Обратите внимание, однако, что это не будет работать для интерфейсов, что и есть у вас.

Answer 2

.Equals может быть злом, если не сделано правильно.

Вот лучшие методы для осуществления этого:

http://msdn.microsoft.com/en-us/library/ms173147(VS.80).aspx

Answer 3

Я думаю, вам может потребоваться переопределить Equals (object) в узле, как в NodeId. Итак:

public override bool Equals (object obj) 
{ 
    if (obj is Node) 
    { 
     return this.Equals(obj as Node); 
    } 
    return false; 
} 

// your code (modified to take a Node instead of an INode) 
public bool Equals (Node node) 
{ 
    return this.name == node.name && 
      this.id = node.id; 
} 

Answer 4

это с помощью == от объекта, поскольку firstNode и secondNode не типа Node, они типа INode. Компилятор не распознает базовые типы.

Поскольку вы не можете перегружать оператора в интерфейсе, лучше всего переписать код, чтобы он не использовал интерфейс INode.