Qu'est-ce qui doit être remplacé dans une structure pour garantir le bon fonctionnement de l'égalité?

Question

Comme l'indique le titre: dois-je remplacer l'opérateur ==? que diriez-vous de la méthode .Equals()? Quelque chose que je manque?

Answer 1

Un exemple de msdn

public struct Complex 
{ 
    double re, im; 
    public override bool Equals(Object obj) 
    { 
     return obj is Complex && this == (Complex)obj; 
    } 
    public override int GetHashCode() 
    { 
     return re.GetHashCode()^im.GetHashCode(); 
    } 
    public static bool operator ==(Complex x, Complex y) 
    { 
     return x.re == y.re && x.im == y.im; 
    } 
    public static bool operator !=(Complex x, Complex y) 
    { 
     return !(x == y); 
    } 
} 

Answer 2

La différence fondamentale entre les deux est que l'opérateur == est statique, à savoir la méthode appropriée pour appeler est déterminée au moment de la compilation, tandis que la méthode Equals est appelée dinamically sur un exemple.
Définir les deux est probablement la meilleure chose à faire, même si cela importe moins dans le cas des structures, puisque les structures ne peuvent pas être étendues (une structure ne peut pas hériter d'une autre structure).

Answer 3

Vous devez également implémenter IEquatable < T>. Voici un extrait des directives de conception de cadre:

Implémenter IEquatable sur les types de valeurs. La méthode Object.Equals sur les types de valeur entraîne la mise en boîte, et son implémentation par défaut n'est pas très effcace car elle utilise la refection. IEquatable.Equals peut offrir de meilleures performances et peut être mis en œuvre afin qu'il ne provoque pas de boxe.

public struct Int32 : IEquatable<Int32> { 
    public bool Equals(Int32 other){ ... } 
} 

DO suivre les mêmes directives que pour Object.Equals prépondérants lorsque de IEquatable.Equals de mise en œuvre. Voir la section 8.7.1 pour directives détaillées sur Object.Equals prépondérants

Answer 4

Unfortunetely Je n'ai pas assez réputation pour commenter d'autres entrées. Donc, je poste l'amélioration possible de la meilleure solution ici.

me corriger si je me trompe, mais la mise en œuvre mentionné ci-dessus

public struct Complex 
{ 
    double re, im; 
    public override bool Equals(Object obj) 
    { 
     return obj is Complex && this == (Complex)obj; 
    } 
    public override int GetHashCode() 
    { 
     return re.GetHashCode()^im.GetHashCode(); 
    } 
    public static bool operator ==(Complex x, Complex y) 
    { 
     return x.re == y.re && x.im == y.im; 
    } 
    public static bool operator !=(Complex x, Complex y) 
    { 
     return !(x == y); 
    } 
} 

a-défaut majeur. Je référant à

public override int GetHashCode() 
    { 
     return re.GetHashCode()^im.GetHashCode(); 
    } 

XOR est symétrique, si complexe (2,1) et complexe (1,2) donnerait même hashCode.

Nous devrions probablement faire quelque chose comme:

public override int GetHashCode() 
    { 
     return re.GetHashCode() * 17^im.GetHashCode(); 
    } 

Answer 5

Juste pour complétude Je conseille également à une surcharge méthode Equals:

public bool Equals(Complex other) 
{ 
    return other.re == re && other.im == im; 
} 

c'est une réelle amélioration de spead car il n'y a pas survenant de boxe de l'argument en entrée de Equals(Object obj) méthode

Quelques bonnes pratiques pour utiliser les types de valeur:

• les rendre immuable
• override Égal (celle qui prend un objet comme argument); Surcharge
• surcharge Equivaut à prendre une autre instance du même type de valeur (par exemple * Equals (Complex other));
• opérateurs de surcharge == et! =;
• override GetHashCode

Cela vient de ce poste: http://theburningmonk.com/2015/07/beware-of-implicit-boxing-of-value-types/

Answer 6

La plupart du temps, vous pouvez éviter la mise en œuvre Equals et GetHashCode dans struct - parce qu'il ya une mise en oeuvre automatique par le compilateur pour les types de valeur à l'aide au niveau du bit contenu + réflexion pour les membres de référence.

Jetez un oeil à ce poste: Which is best for data store Struct/Classes?

Donc, pour la facilité d'utilisation, vous pouvez toujours mettre en œuvre == et =.

Mais la plupart du temps, vous pouvez éviter d'implémenter Equals et GetHashcode.
Un cas où vous devez implémenter Equals et GetHashCode est pour un champ que vous ne voulez pas prendre en compte.
Par exemple un champ qui varie au fil du temps comme Age of a Person ou instantSpeed ​​d'une voiture (l'identité de l'objet ne doit pas changer si vous voulez le retrouver dans le dictionnaire au même endroit)

Cordialement, meilleur code