Comment remplacer l'opérateur == lorsque vous utilisez des interfaces plutôt que des types réels?

Question

J'ai un code comme ceci:

Comment dois-je mettre en œuvre l'opérateur == pour qu'il sera appelé lorsque les variables sont des IMyClass d'interface?

public class MyClass : IMyClass 
{ 
    public static bool operator ==(MyClass a, MyClass b) 
    { 
     if (ReferenceEquals(a, b)) 
      return true; 

     if ((Object)a == null || (Object)b == null) 
      return false; 

     return false; 
    } 

    public static bool operator !=(MyClass a, MyClass b) 
    { 
     return !(a == b); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     IMyClass m1 = new MyClass(); 
     IMyClass m2 = new MyClass(); 

     MyClass m3 = new MyClass(); 
     MyClass m4 = new MyClass(); 

     Console.WriteLine(m1 == m2); // does not go into custom == function. why not? 
     Console.WriteLine(m3 == m4); // DOES go into custom == function 
    } 
} 

Answer 1

La clé est que vous n'êtes pas primordial un opérateur - vous la surcharge il.

Il n'y a pas opérateur défini pour

operator ==(IMyClass x, IMyClass y) 

de sorte que le compilateur n'a rien pourrait appeler. Il ne peut pas appeler

operator ==(MyClass x, MyClass y) 

car il ne sait pas que m1 et m2 se fait référence à instance de MyClass. Autant que je sache, il n'y a aucun moyen de mettre en œuvre un opérateur à utiliser pour les interfaces - après tout, plusieurs implémentations pourraient fournir leur propre, juste pour un point d'ambiguïté possible.

Personnellement, je suis un peu méfiant d'essayer de parler de l'égalité par rapport aux types non-scellés pour commencer - l'égalité et l'héritage ne se mélangent pas très bien. Cela va doublement pour les interfaces, bien sûr :) Vous pourriez être le mieux à mettre en œuvre un IEqualityComparer<IMyClass> approprié et en utilisant à la place.

Answer 2

Essayez de rendre l'opérateur == fonction virtuelle.

Answer 3

Regardez dans la réponse acceptée pour cette question: == vs. Object.Equals(object) in .NET

La différence est de l'égalité d'identité contre l'égalité sémantique. La substitution == est destinée à des structures qui sont supposées être «identiques» parce qu'elles ont les mêmes valeurs, puisque les structures sont copiées par valeur et ne sont donc jamais des références au même objet. Equals est utilisé pour un contrôle sémantique de l'égalité des valeurs pour les types Reference. Par défaut, les deux opérations sont les mêmes.