Pourquoi (objet) 0 == (objet) 0 est-il différent de ((objet) 0) .Equals ((objet) 0)?

Pourquoi les expressions suivantes sont-elles différentes?

[1]  (object)0 == (object)0 //false
[2]  ((object)0).Equals((object)0) // true

En fait, je peux totalement comprendre [1] parce que probablement le runtime .NET sera boxl'entier et commencera à comparer les références à la place. Mais pourquoi est [2] différent?

La raison pour laquelle les appels se comportent différemment est qu'ils se lient à des méthodes très différentes.

Le ==cas sera lié à l'opérateur d'égalité de référence statique. Il y a 2 box indépendantsint valeurs créées, elles ne sont donc pas la même référence.

Dans le second cas, vous vous liez à la méthode d'instance Object.Equals. C'est une méthode virtuelle qui filtrera jusqu'à Int32.Equalset qui vérifie un entier encadré. Les deux valeurs entières sont 0 et sont donc égales

Lorsque vous transtypez la valeur int 0(ou tout autre type de valeur) en object, la valeur est encadrée . Chaque objectconversion en produit une boîte différente (c'est-à-dire une instance d'objet différente). L' ==opérateur duobject type effectue une comparaison de référence, il renvoie donc false car le côté gauche et le côté droit ne sont pas la même instance.

D'autre part, lorsque vous utilisez Equals, qui est une méthode virtuelle, il utilise l'implémentation du type boxed réel, c'est Int32.Equals-à- dire , qui renvoie true puisque les deux objets ont la même valeur.

L' ==opérateur, étant statique, n'est pas virtuel. Il exécutera le code exact que leobject défini par classe (`objet étant le type à la compilation des opérandes), qui effectuera une comparaison de référence, quel que soit le type d'exécution de l'un ou l'autre objet.

La Equalsméthode est une méthode d'instance virtuelle. Il exécutera le code défini dans le type d'exécution réel du (premier) objet, pas le code de la objectclasse. Dans ce cas, l'objet est un int, donc il effectuera une comparaison de valeurs, car c'est ce que le inttype définit pour sa Equalsméthode.

La Equals()méthode est virtuelle.
Par conséquent, il appelle toujours l'implémentation concrète, même lorsque le site d'appel est converti object. intremplace Equals()pour comparer par valeur, vous obtenez donc une comparaison de valeur.

== Utilisation: Object.ReferenceEquals

Object.Equals compare la valeur.

le object.ReferenceEquals méthode compare les références. Lorsque vous allouez un objet, vous recevez une référence contenant une valeur indiquant son emplacement mémoire en plus des données de l'objet sur le tas de mémoire.

La object.Equalsméthode compare le contenu des objets. Il vérifie d'abord si les références sont égales, tout comme object.ReferenceEquals. Mais ensuite, il fait appel aux méthodes Equals dérivées pour tester davantage l'égalité. Regarde ça:

   System.Object a = new System.Object();
System.Object b = a;
System.Object.ReferenceEquals(a, b);  //returns true

L'opérateur C # utilise le jeton ==pour représenter deux opérateurs différents: un opérateur de comparaison statiquement surchargeable et un opérateur de comparaison de référence non surchargeable. Lorsqu'il rencontre le ==jeton, il vérifie d'abord s'il existe une surcharge de test d'égalité applicable aux types d'opérande. Si tel est le cas, il invoquera cette surcharge. Sinon, il vérifiera si les types sont applicables à l'opérateur de comparaison de références. Si tel est le cas, il utilisera cet opérateur. Si aucun opérateur n'est applicable aux types d'opérande, la compilation échouera.

Le code (Object)0ne se contente pas upcast un Int32à Object: Int32, comme tous les types de valeur, représente en fait deux types, l' un qui décrit les valeurs et les lieux de stockage (tels que le zéro littéral), mais ne tire pas de quoi que ce soit, et l' un qui décrit tas d'objets et dérive de Object; car seul ce dernier type peut être converti Object, le compilateur doit créer un nouvel objet de tas de ce dernier type. Chaque appel de (Object)0crée un nouvel objet de tas, de sorte que les deux opérandes à ==sont des objets différents, chacun desquels, indépendamment, encapsule la Int32valeur 0.

La classe Objectn'a aucune surcharge utilisable définie pour l'opérateur égal. Par conséquent, le compilateur ne pourra pas utiliser l'opérateur de test d'égalité surchargé et reviendra à l'utilisation du test d'égalité de référence. Parce que les deux opérandes ==font référence à des objets distincts, il sera signalé false. La deuxième comparaison réussit car elle demande à une instance d'objet de tas Int32si elle est égale à l'autre. Parce que cette instance sait ce que signifie être égale à une autre instance distincte, elle peut répondre true.

Les deux contrôles sont différents. Le premier vérifie l' identité , le second l' égalité . En général, deux termes sont identiques s'ils font référence au même objet. Cela implique qu'ils sont égaux. Deux termes sont égaux, si leurs valeurs sont identiques.

En termes de programmation, l'identité est généralement définie par l'égalité de référence. Si le pointeur vers les deux termes est égal (!), L'objet sur lequel il pointe est exactement le même. Cependant, si les pointeurs sont différents, la valeur des objets sur lesquels ils pointent peut toujours être égale. En C #, l'identité peut être vérifiée à l'aide du Object.ReferenceEqualsmembre statique , tandis que l'égalité est vérifiée à l'aide du Object.Equalsmembre non statique . Puisque vous transtypez deux entiers en objets (ce qui est appelé "boxing", btw), l'opérateur ==de objecteffectue la première vérification, qui est par défaut mappée Object.ReferenceEqualset vérifie l'identité. Si vous appelez explicitement le membre non statique Equals, la répartition dynamique entraîne un appel à Int32.Equals, qui vérifie l'égalité.

Les deux concepts sont similaires, mais pas identiques. Ils peuvent sembler déroutants pour le premier, mais la petite différence est très importante! Imaginez deux personnes, à savoir «Alice» et «Bob». Ils vivent tous les deux dans une maison jaune. Sur la base de l'hypothèse, qu'Alice et Bob vivent dans un quartier, où les maisons ne diffèrent que par leur couleur, ils pourraient tous deux vivre dans des maisons jaunes différentes. Si vous comparez les deux maisons, vous reconnaîtrez qu'elles sont absolument identiques, car elles sont toutes les deux jaunes! Cependant, ils ne partagent pas la même maison et donc leurs maisons sont égales , mais pas identiques . L'identité impliquerait qu'ils vivent dans la même maison.

Remarque : certaines langues définissent l' ===opérateur pour vérifier l'identité.