== ou .Equals ()

== est le test d’identité. Il retournera true si les deux objects testés sont en fait le même object. Equals() effectue un test d’égalité et renvoie true si les deux objects se considèrent égaux.

Les tests d’identité sont plus rapides, vous pouvez donc les utiliser lorsque vous n’avez pas besoin de tests d’égalité plus coûteux. Par exemple, comparer avec une chaîne vide ou vide.

Il est possible de surcharger l’un ou l’autre pour fournir des tests d’identité de type comportemental pour Equals() -, mais pour que quelqu’un puisse lire votre code, veuillez ne pas le faire.

Ci-dessous: certains types comme Ssortingng ou DateTime fournissent des surcharges pour l’opérateur == qui lui donne une sémantique d’égalité. Le comportement exact dépendra donc des types d’objects que vous comparez.

Voir également:

• http://blogs.msdn.com/csharpfaq/archive/2004/03/29/102224.aspx

@John Millikin:

Ci-dessous: certains types de valeur comme DateTime fournissent des surcharges pour l’opérateur ==> qui lui donnent une sémantique d’égalité. Le comportement exact dépendra donc des types d’objects que vous comparez.

Élaborer:

DateTime est implémenté en tant que struct. Toutes les structures sont des enfants de System.ValueType.

Étant donné que les enfants de System.ValueType vivent sur la stack, il n’y a pas de pointeur de référence sur le tas, et donc aucun moyen d’effectuer une vérification des références, vous devez comparer les objects uniquement par valeur.

System.ValueType remplace .Equals () et == pour utiliser un contrôle d’égalité basé sur la reflection, il utilise la reflection pour comparer chaque valeur de champ.

Comme la reflection est un peu lente, si vous implémentez votre propre structure, il est important de remplacer .Equals () et d’append votre propre code de vérification de valeur, car cela sera beaucoup plus rapide. Ne vous contentez pas d’appeler base.Equals ();

Tout le monde a à peu près tout ce que vous avez couvert, mais j’ai un autre mot à dire. De temps en temps, vous aurez quelqu’un qui jure sur sa vie (et celle de ses proches) que .Equals est plus efficace / meilleur / meilleure pratique ou une autre ligne dogmatique. Je ne peux pas parler d’efficacité (bon, dans certaines circonstances, je peux), mais je peux parler d’un gros problème qui va .Equals : .Equals nécessite un object pour exister. (Cela semble stupide, mais ça détourne les gens.)

Vous ne pouvez pas faire ce qui suit:

 SsortingngBuilder sb = null; if (sb.Equals(null)) { // whatever } 

Il me semble évident, et peut-être la plupart des gens, que vous obtiendrez une NullReferenceException . Cependant, les partisans de .Equals oublient ce petit fait. Certains sont même “rejetés” (désolé, ils n’ont pas pu résister) quand ils ont vu apparaître les NullRefs.

(Et des années avant la publication de DailyWTF , je travaillais en fait avec quelqu’un qui exigeait que tous les contrôles soient .Equals au lieu de == . Même prouver que son inexactitude n’avait pas aidé. Nous nous sums contentés de briser toutes ses autres règles pour que aucune référence renvoyée par une méthode ni une propriété n’a été nulle, et cela a fonctionné à la fin.)

== est généralement le “identité” est égal à signifiant “object a est en fait exactement le même object en mémoire que l’object b”.

equals () signifie que les objects sont logiquement égaux (par exemple d’un sharepoint vue commercial). Donc, si vous comparez des instances d’une classe définie par l’utilisateur, vous devrez généralement utiliser et définir equals () si vous voulez que des choses comme une table de hachage fonctionnent correctement.

Si vous aviez la classe proverbiale Person avec les propriétés “Name” et “Address” et que vous vouliez utiliser cette personne en tant que clé dans une table de hachage contenant plus d’informations à leur sujet, vous devez implémenter equals () (et hash) pourrait créer une instance d’une personne et l’utiliser comme clé dans la table de hachage pour obtenir les informations.

En utilisant == seul, votre nouvelle instance ne serait pas la même.

Selon MSDN :

En C #, il existe deux types d’égalité: l’égalité de référence (également appelée identité) et l’égalité des valeurs. L’égalité des valeurs est la signification généralement comprise de l’égalité: cela signifie que deux objects contiennent les mêmes valeurs. Par exemple, deux entiers de la valeur 2 ont une valeur d’égalité. L’égalité de référence signifie qu’il n’y a pas deux objects à comparer. Au lieu de cela, il y a deux références d’object et les deux font référence au même object.

…

Par défaut, l’opérateur == teste l’égalité de référence en déterminant si deux références indiquent le même object.

L’exemple est dû au fait que la classe DateTime implémente l’interface IEquatable, qui implémente une “méthode spécifique au type pour déterminer l’égalité des instances”. selon MSDN .

Une autre chose à prendre en compte: l’opérateur == peut ne pas être appelable ou avoir une signification différente si vous accédez à l’object depuis une autre langue. En règle générale, il est préférable d’avoir une alternative pouvant être appelée par son nom.

Equals et == peuvent tous deux être surchargés. Les résultats exacts de l’appel varient donc. Notez que == est déterminé au moment de la compilation, alors que l’implémentation réelle pourrait changer, quel == est utilisé est fixé au moment de la compilation, contrairement à Equals qui pourrait utiliser une implémentation différente basée sur le type d’exécution du côté gauche.

Par exemple, la ssortingng effectue un test d’égalité pour == .

Notez également que la sémantique des deux peut être complexe .

La meilleure pratique consiste à mettre en œuvre l’égalité comme cet exemple. Notez que vous pouvez simplifier ou exclure tout cela en fonction de la manière dont vous prévoyez d’utiliser votre classe, et que cette struct est déjà la plus utilisée.

 class ClassName { public bool Equals(ClassName other) { if (other == null) { return false; } else { //Do your equality test here. } } public override bool Equals(object obj) { ClassName other = obj as null; //Null and non-ClassName objects will both become null if (obj == null) { return false; } else { return Equals(other); } } public bool operator ==(ClassName left, ClassName right) { if (left == null) { return right == null; } else { return left.Equals(right); } } public bool operator !=(ClassName left, ClassName right) { if (left == null) { return right != null; } else { return !left.Equals(right); } } public override int GetHashCode() { //Return something useful here, typically all members shifted or XORed together works } } 

use égal si vous voulez exprimer le contenu des objects comparés doit être égal. utilisez == pour les valeurs primitives ou si vous voulez vérifier que les objects comparés sont un seul et même object. Pour les objects == vérifie si le pointeur d’adresse des objects est le même.

J’ai vu Object.ReferenceEquals () utilisé dans les cas où l’on veut savoir si deux références se réfèrent au même object

Si vous démontez (par dotPeek par exemple) de Object, alors

 public virtual bool Equals(Object obj) 

décrit comme:

 // Returns a boolean indicating if the passed in object obj is // Equal to this. Equality is defined as object equality for reference // types and bitwise equality for value types using a loader sortingck to // replace Equals with EqualsValue for value types). // 

Donc, dépend du type. Par exemple:

  Object o1 = "vvv"; Object o2 = "vvv"; bool b = o1.Equals(o2); o1 = 555; o2 = 555; b = o1.Equals(o2); o1 = new List { 1, 2, 3 }; o2 = new List { 1, 2, 3 }; b = o1.Equals(o2); 

La première fois que b est vraie (égale sur les types de valeur), la deuxième fois b est vraie (égale sur les types de valeur), la troisième fois b est fausse (égale sur les types de référence).

Dans la plupart des cas, ils sont identiques, vous devez donc utiliser == pour plus de clarté. Selon les directives de conception de Microsoft Framework:

“Assurez-vous que les opérateurs Object.Equals et les opérateurs d’égalité ont exactement la même sémantique et les mêmes caractéristiques de performance.” https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/equality-operators

Mais parfois, quelqu’un va substituer Object.Equals sans fournir des opérateurs d’égalité. Dans ce cas, vous devez utiliser Equals pour tester l’égalité de valeur et Object.ReferenceEquals pour tester l’égalité de référence.