Quelle est la différence entre == et Equals() pour les primitives en C#?

Question

Considérer ce code:

int age = 25;
short newAge = 25;
Console.WriteLine(age == newAge);  //true
Console.WriteLine(newAge.Equals(age)); //false
Console.ReadLine();

Les deux int et short sont des types primitifs, mais une comparaison avec == renvoie la valeur true et une comparaison avec d' Equals renvoie la valeur false.

Pourquoi?

Answer 1

Réponse courte:

L'égalité est compliqué.

Réponse détaillée:

Primitives types de remplacer la base object.Equals(object) et retourne true si le texte de l'encadré object est du même type et de la valeur. (Notez que cela fonctionne également pour les types nullables; non-null types nullables toujours à cocher pour une instance du type sous-jacent.)

Depuis newAge est short, son Equals(object) méthode ne renvoie vrai si vous passez d'une boîte courte avec la même valeur. Vous êtes de passage un coffret int, elle retourne false.

En revanche, l' == opérateur est défini comme la prise de deux ints (ou shorts ou longs).
Lorsque vous appelez avec un int et short, le compilateur va convertir implicitement l' short de int et de comparer l'résultant ints par valeur.

D'autres moyens de faire fonctionner

Les types primitifs ont aussi leur propre Equals() méthode qui accepte du même type.
Si vous écrivez age.Equals(newAge), le compilateur choisira int.Equals(int) comme le meilleur de surcharge et de convertir implicitement short de int. Puis, il retournera true, étant donné que cette méthode compare simplement le ints directement.

short a également un short.Equals(short) méthode, mais int ne peut pas être implicitement converti short, de sorte que vous ne sont pas en l'appelant.

Vous pourraient le forcer à appeler cette méthode avec un plâtre:

Console.WriteLine(newAge.Equals((short)age)); // true

Cela appellera short.Equals(short) directement, sans la boxe. Si age est supérieure à 32767, il va lever une exception de dépassement de capacité.

Vous pouvez aussi appeler l' short.Equals(object) de surcharge, mais explicitement passer un coffret de l'objet afin qu'il soit du même type:

Console.WriteLine(newAge.Equals((object)(short)age)); // true

Comme lors de la visualisation alternative, cela permettra de jeter un dépassement de capacité si elle ne rentre pas dans un short. Contrairement à la solution précédente, il sera de la boîte de l' short dans un objet, de perdre du temps et de la mémoire.

Code Source:

Voici les deux Equals() méthodes du code source:

    public override bool Equals(Object obj) {
        if (!(obj is Int16)) {
            return false;
        }
        return m_value == ((Int16)obj).m_value;
    }

    public bool Equals(Int16 obj)
    {
        return m_value == obj;
    }

Pour En Savoir Plus:

Voir Eric Lippert.

Answer 2

Car il n'y a pas de surcharge pour short.Equals qui accepte un int. Par conséquent, il est appelé:

public override bool Equals(object obj)
{
    return obj is short && this == (short)obj;
}

obj n'est pas un short.. par conséquent, il est faux.

Answer 3

Pour les types de valeur, .Equals exige que les deux objets de même type et ont la même valeur, alors que == seulement des tests, si les deux valeurs sont les mêmes.

Object.Equals
http://msdn.microsoft.com/en-us/library/bsc2ak47(v=vs. 110).aspx

Answer 4

Lorsque vous passez int de shorts'est Égal à vous transmettre object:

Donc, ce pseudo-code s'exécute:

return obj is short && this == (short)obj;

Answer 5

== est utilisé pour la vérification d'une condition d'égalité, il peut être considéré comme un opérateur(opérateur booléen), juste pour comparer 2 choses, et ici, le type de données n'est pas grave car il y aurait une conversion de type de fait et Equals est également utilisé pour la vérification d'égale condition, mais dans ce cas, les types de données doit être la même. N est Égal à est une méthode qui n'est pas un opérateur.

Ci-dessous un petit exemple tiré de celui que vous avez fourni et cela permettra de clarifier la différence en bref,.

int x=1;
short y=1;
x==y;//true
y.Equals(x);//false

dans l'exemple ci-dessus, X et Y ont les mêmes valeurs c'est à dire 1, et lorsque nous utilisons ==, il sera de retour le vrai, comme dans le cas d' ==, le court type est converti en int par le compilateur et le résultat est donné.

et lorsque nous utilisons Equals, la comparaison est faite, mais le type coulée n'est pas fait par le compilateur, alors la fonction retourne false.

Les gars, s'il vous plaît laissez-moi savoir si je me trompe.