quelle est votre approche sur l'écriture de vérification de l'égalité des code> et 1) strong> La vérification de l'égalité "complète" nécessite une grande partie du code de la chaudière (comme 2) strong> Spécifiez-vous explicitement que vos classes modélisent l'interface 3) strong> Est-ce que je comprends correctement, qu'il n'y a pas de moyen réel d'appliquer automatiquement classes code> vous créez? em> p>
de remplacement correspond à code>,
remplace gethascode code>, générique
Égale code>,
opérateur == code>,
opérateur! = Code>)? P>
iéquatif
égale code> remplace, lorsque j'invoque quelque chose comme
a == B code> et je dois toujours mettre en œuvre à la fois le
égal code> et
opérateur == code> membres? p>
4 Réponses :
Vous devez juste avoir besoin d'implémenter l'opérateur == pour A == b. de
Comme j'aime mes données dans des dictionnaires parfois, je remplace GetHashCode.
Suivant I Mettre en œuvre Equals (comme une norme inutilisée ... En effet, il n'ya aucune contrainte pour l'égalité lors de l'utilisation de génériques) et spécifiez la mise en œuvre inégalable. Depuis que je vais faire cela, je pourrais aussi bien pointer mon == et! = Implémentations à égaux. :) p>
Je fais rarement quelque chose de spécial pour les cours; Pour la plupart des objets réguliers, l'égalité référentielle fonctionne bien. P>
i encore plus rarement écrire un La chaudière n'est généralement pas trop problématique, mais les outils IIRC comme Restomer peuvent vous aider ici. P>
Oui, il est conseillé de garder des égaux et == en synchronisation, ce qui doit être fait explicitement. P> struct code>; Mais puisque les structures représentent les valeurs em> il est généralement approprié de fournir l'égalité, etc. Cela impliquerait généralement tout; Equals, ==,! = Et
Iequatable
Equalitalcander
Vous avez raison, c'est beaucoup de code de plaque de chaudière et vous devez tout implémenter séparément.
Je recommanderais: p>
gethashcode code> et Equals (objet) code> - Création de surcharges pour == et implémentation iéquatif code> sans faire cela pourrait entraîner un comportement très inattendu LI>
- Je voudrais toujours implémenter
iéquatif code> si vous remplissez égale (objet) code> et gethascode code> li> li>
- i seulement surchargez l'opérateur == plus rarement li>
- La mise en œuvre correctement sur l'égalité des classes non calendrantes est délicate et peut toujours produire des résultats surprenants / indésirables. Si vous avez besoin d'égalité pour types dans une hiérarchie, implémentez
IequalityComparer code> exprimant la comparaison qui vous intéresse. LI>
- L'égalité des types mutables est généralement une mauvaise idée, car deux objets peuvent être égaux, puis inégal plus tard ... Si un objet est muté (d'une manière égale affectant) après son utilisation comme une clé dans une table de hachage , vous ne pourrez plus le retrouver. Li>
- Une partie de la plaque de chaudière est légèrement différente pour les structures ... mais comme Marc, j'écris très rarement mes propres structures. Li>
ul>
Voici un exemple de mise en œuvre: p> xxx pré> et oui, c'est un diable de beaucoup de chaudras, dont très peu change entre les implémentations: ( p>
La mise en oeuvre de == code> est légèrement em> moins efficace qu'il pourrait être, car il sera appelé à Equals (objet) code> Ce qui doit faire la vérification de type dynamique ... mais l'alternative est encore plus une plaque de chaudière, comme ceci: p> xxx pré> p>
2 suggestions mineures pour le deuxième bloc de code: 1) Ne devriez-vous pas déplacer (objet) gauche == (objet) droit code> à partir de
== code> au générique
est égal à < / code>? Donc, cela donne la vitesse (bien sûr cela dépend, mais en supposant le pire des cas) Vérification de l'égalité de référence Même pour Generic
Equals Code> Méthode? 2) Vous n'avez pas besoin de la deuxième chèque NULL
(objet) droit == null code> dans
== code> comme vous le faites essentiellement en générique
égale code>. Voir mon post ..
@nawfal: Je ne pense pas qu'il y ait beaucoup de choses à le faire dans le générique égale code>, il va être rapide de toute façon dans les cas où il est i> vrai, et pour Les cas où il n'est pas i> vrai, il s'agit d'un contrôle supplémentaire sans avantage. Quant à la partie null - qui nécessiterait la vérification du type dynamique. Oui, vous pourriez discuter pour les deux - mais je suis assez heureux avec ce que j'ai écrit il y a deux ans ...
@nawfal: Euh, tu as raison - il n'y aurait pas de chèque dynamique là-bas. Je vais supprimer la partie "droite" ici ...
@ Jonskeet, c'est si frustrant d'écrire ce code de la batterie sur et plus lorsque vous faites une erreur est si facile dans ces choses. Heureusement, les extraits peuvent aider à cet égard! J'aurais essayé de m'éloigner en écrivant une classe de base abstrait générique qui fait le travail (je connais les dangers potentiels, mais si je peux gérer, c'est correct) à être dérivé par des classes de base, mais cela limite les classes dérivées de héritage d'une autre classe de base .. juste dire ..
voir Quel est le meilleur Pratique "pour comparer deux instances d'un type de référence? p>
Vous pouvez éviter le code de la plaque de chaudière (l'espoir c # / vs équipe apporte quelque chose de facile pour les développeurs dans leur prochaine itération) avec l'aide d'un extrait d'un extrait, Voici un tel .. p>