Pourquoi les expressions suivantes sont-elles différentes ?
En fait, je peux comprendre totalement [1], car le runtime .NET sera probablement `` l’entier et démarrer en comparant les références à la place. Mais pourquoi est [2] différents ?
Réponses
Trop de publicités?
JaredPar
Points
333733
La raison pour laquelle les appels se comporter différents, c'est qu'ils se lient à des méthodes très différentes.
L' == de cas vont se lier à la statique de référence de l'opérateur d'égalité. Il y a 2 indépendant en coffret int des valeurs créées par conséquent, ils ne sont pas de la même référence.
Dans le second cas, vous lier à la méthode d'instance Object.Equals. C'est une méthode virtuelle qui filtre Int32.Equals et ce vérifications pour un coffret entier. Les deux valeurs entières de 0 donc ils sont égaux
Thomas Levesque
Points
141081
Lorsque vous lancez la valeur int 0 (ou tout autre type de valeur) object, la valeur est en boîte. Chaque fonte d' object produit une case (c'est à dire une autre instance de l'objet). L' == de l'opérateur pour l' object type effectue une référence de comparaison, de sorte qu'il renvoie faux depuis le côté gauche et le côté droit ne sont pas de la même instance.
D'autre part, lorsque vous utilisez Equals, ce qui est une méthode virtuelle, il utilise la mise en œuvre de la réelle boxed de type, c'est à dire Int32.Equals, ce qui renvoie vrai car les deux objets ont la même valeur.
Servy
Points
93720
L' == opérateur, étant statique, n'est pas virtuel. Il va exécuter le code exact que l' object classe définit (`objet est le moment de la compilation du type des opérandes), qui fera une référence de comparaison, quel que soit le runtime type de l'objet.
L' Equals méthode est une instance virtuelle de la méthode. Il sera exécuté le code défini dans le réel de type à l'exécution de la (première) de l'objet, pas le code de la object classe. Dans ce cas, l'objet est un int, alors il va effectuer une comparaison de la valeur, c'est ce que l' int type définit pour son Equals méthode.
SLaks
Points
391154
supercat
Points
25534
Le C# opérateur utilise le jeton == pour représenter deux opérateurs différents: une manière statique overloadable opérateur de comparaison et d'un non-overloadable de référence-opérateur de comparaison. Lorsqu'il rencontre l' == jeton, il vérifie d'abord s'il existe une égalité-test de surcharge qui est applicable à l'opérande types. Si oui, il va invoquer la surcharge. Sinon, il va vérifier si les types sont applicables à la référence-opérateur de comparaison. Si oui, il va utiliser l'opérateur. Si aucun opérateur n'est applicable à l'opérande types, la compilation échoue.
Le code (Object)0 ne se contente pas de sortie d'un Int32 de Object: Int32, comme tous les types de valeur, représente en fait deux types, l'un des qui décrit les valeurs et les emplacements de stockage (tels que la traduction littérale de zéro), mais ne prend pas en tirer de quoi que ce soit, et l'un des qui décrit tas d'objets et provient Object; parce que seul ce dernier type peut être sortie à l' Object, le compilateur doit créer un nouveau segment de mémoire de l'objet de ce dernier type. Chaque invocation d' (Object)0 crée un nouveau segment de mémoire de l'objet, de sorte que les deux opérandes == sont des objets différents, dont chacun, de manière indépendante, encapsule l' Int32 de la valeur 0.
La classe Object n'ont pas toutes utilisables pour des surcharges de défini pour l'opérateur=. Par conséquent, le compilateur ne sera pas en mesure d'utiliser la surcharge de l'égalité-opérateur de test, et de retour à l'aide de la référence de test d'égalité. Parce que les deux opérandes == se réfèrent à des objets distincts, il fera rapport false.
La deuxième comparaison réussit, parce qu'elle pose un tas instance d'objet Int32 si elle est égale à l'autre. Parce que cette instance ne sait ce que signifie être égal à l'autre des cas distincts, il peut répondre à true.
