Différence C # entre == et Equals ()

J'ai une condition dans une application Silverlight qui compare 2 chaînes, pour une raison quelconque, lorsque je l'utilise, ==elle renvoie false tandis que .Equals()renvoie true .

Voici le code:

if (((ListBoxItem)lstBaseMenu.SelectedItem).Content.Equals("Energy Attack"))
{
    // Execute code
}

if (((ListBoxItem)lstBaseMenu.SelectedItem).Content == "Energy Attack")
{
    // Execute code
}

Une raison pour laquelle cela se produit?

Lorsque ==est utilisé sur une expression de type object, il sera résolu en System.Object.ReferenceEquals.

Equalsest juste une virtualméthode et se comporte comme telle, donc la version surchargée sera utilisée (qui, pour le stringtype, compare le contenu).

Lors de la comparaison d'une référence d'objet à une chaîne (même si la référence d'objet fait référence à une chaîne), le comportement spécial de l' ==opérateur spécifique à la classe de chaîne est ignoré.

Normalement (lorsqu'il ne s'agit pas de chaînes, c'est-à-dire), Equalscompare les valeurs , tout en ==comparant les références d'objet . Si deux objets que vous comparez se réfèrent à la même instance exacte d'un objet, alors les deux renverront true, mais si l'un a le même contenu et provient d'une source différente (est une instance distincte avec les mêmes données), seul Equals sera retourner vrai. Cependant, comme indiqué dans les commentaires, la chaîne est un cas particulier car elle remplace l' ==opérateur de sorte que lorsqu'il s'agit uniquement de références de chaîne (et non de références d'objet), seules les valeurs sont comparées même s'il s'agit d'instances distinctes. Le code suivant illustre les différences subtiles de comportements:

string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s3), s1 == s3, s1.Equals(s3));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s4), s1 == s4, s1.Equals(s4));

La sortie est:

True True True
False True True
False False True

==et .Equalsdépendent tous deux du comportement défini dans le type réel et le type réel sur le site d'appel. Les deux ne sont que des méthodes / opérateurs qui peuvent être remplacés sur n'importe quel type et compte tenu du comportement souhaité par l'auteur. D'après mon expérience, je trouve qu'il est courant pour les gens d'implémenter .Equalssur un objet mais néglige d'implémenter l'opérateur ==. Cela signifie que .Equalsva réellement mesurer l'égalité des valeurs tout ==en mesurant si elles sont ou non la même référence.

Lorsque je travaille avec un nouveau type dont la définition est en flux ou que j'écris des algorithmes génériques, je trouve que la meilleure pratique est la suivante

• Si je veux comparer des références en C #, j'utilise Object.ReferenceEqualsdirectement (pas nécessaire dans le cas générique)
• Si je veux comparer les valeurs que j'utilise EqualityComparer<T>.Default

Dans certains cas, lorsque je pense que l'utilisation de ==est ambigu, j'utiliserai explicitement Object.Referenceégal dans le code pour supprimer l'ambiguïté.

Eric Lippert a récemment publié un article sur le blog expliquant pourquoi il existe 2 méthodes d'égalité dans le CLR. Ça vaut le coup d'être lu

• http://blogs.msdn.com/ericlippert/archive/2009/04/09/double-your-dispatch-double-your-fun.aspx

== Opérateur

1. Si les opérandes sont des types de valeur et que leurs valeurs sont égales, elle renvoie vrai sinon faux.
2. Si les opérandes sont des types de référence à l'exception de la chaîne et que les deux font référence à la même instance (même objet), elle renvoie true sinon false.
3. Si les opérandes sont de type chaîne et que leurs valeurs sont égales, elle renvoie vrai sinon faux.

.Équivaut à

1. Si les opérandes sont des types de référence , il exécute l' égalité de référence, c'est-à-dire que si les deux font référence à la même instance (même objet), il renvoie vrai sinon faux.
2. Si les opérandes sont des types de valeur, contrairement à l'opérateur ==, il vérifie d'abord leur type et si leurs types sont identiques, il exécute l'opérateur ==, sinon il renvoie false.

Premièrement, il y a une différence. Pour les chiffres

> 2 == 2.0
True

> 2.Equals(2.0)
False

Et pour les cordes

> string x = null;
> x == null
True

> x.Equals(null)
NullReferenceException

Dans les deux cas, ==se comporte plus utilement que.Equals

Pour autant que je le comprends, la réponse est simple:

1. == compare les références d'objet.
2. .Equals compare le contenu de l'objet.
3. String les types de données agissent toujours comme une comparaison de contenu.

J'espère que j'ai raison et qu'il a répondu à votre question.

J'ajouterais que si vous transformez votre objet en chaîne, cela fonctionnera correctement. C'est pourquoi le compilateur vous donnera un avertissement disant:

Comparaison de référence involontaire possible; pour obtenir une comparaison de valeurs, placez le côté gauche pour taper 'chaîne'

Étant donné que la version statique de la .Equalméthode n'a pas été mentionnée jusqu'à présent, je voudrais l'ajouter ici pour résumer et comparer les 3 variantes.

MyString.Equals("Somestring"))          //Method 1
MyString == "Somestring"                //Method 2
String.Equals("Somestring", MyString);  //Method 3 (static String.Equals method) - better

où MyStringest une variable qui vient d'ailleurs dans le code.

Informations de fond et pour résumer:

En Java, utiliser ==pour comparer les chaînes ne doit pas être utilisé. Je mentionne cela au cas où vous auriez besoin d'utiliser les deux langues et aussi pour vous faire savoir que l'utilisation ==peut également être remplacée par quelque chose de mieux en C #.

En C #, il n'y a pas de différence pratique pour comparer des chaînes en utilisant la méthode 1 ou la méthode 2 tant que les deux sont de type chaîne. Cependant, si l'un est nul, l'un est d'un autre type (comme un entier), ou l'un représente un objet qui a une référence différente, alors, comme le montre la question initiale, vous pouvez rencontrer que la comparaison du contenu pour l'égalité peut ne pas retourner ce que vous vous attendez.

Solution suggérée:

Étant donné que l'utilisation ==n'est pas exactement la même chose que .Equalslors de la comparaison, vous pouvez utiliser la méthode statique String.Equals à la place. De cette façon, si les deux côtés ne sont pas du même type, vous comparerez toujours le contenu et si l'un est nul, vous éviterez l'exception.

   bool areEqual = String.Equals("Somestring", MyString);  

C'est un peu plus à écrire, mais à mon avis, plus sûr à utiliser.

Voici quelques informations copiées de Microsoft:

public static bool Equals (string a, string b);

Paramètres

a Chaîne

La première chaîne à comparer, ou null.

b Chaîne

La deuxième chaîne à comparer, ou null.

Retour Boolean

truesi la valeur de aest la même que la valeur de b; autrement, false. Si les deux aet le bsont null, la méthode retourne true.

Tout comme un ajout aux réponses déjà bonnes: ce comportement n'est PAS limité aux chaînes ou à la comparaison de différents types de chiffres. Même si les deux éléments sont de type objet du même type sous-jacent. "==" ne fonctionnera pas.

La capture d'écran suivante montre les résultats de la comparaison de deux valeurs d'objet {int} -

Je suis un peu confus ici. Si le type d'exécution de Content est de type chaîne, alors == et Equals doivent renvoyer true. Cependant, étant donné que cela ne semble pas être le cas, le type d'exécution du contenu n'est pas une chaîne et appeler Equals dessus fait une égalité référentielle et cela explique pourquoi Equals ("Energy Attack") échoue. Cependant, dans le second cas, la décision quant à l'opérateur statique == surchargé à appeler est prise au moment de la compilation et cette décision semble être == (chaîne, chaîne). cela me suggère que le contenu fournit une conversion implicite en chaîne.

Il y a une autre dimension à une réponse antérieure de @BlueMonkMN. La dimension supplémentaire est que la réponse à la question du titre de @ Drahcir telle qu'elle est énoncée dépend également de la façon dont nous sommes arrivés à la stringvaleur. Pour illustrer:

string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;
string s5 = "te" + "st";
object s6 = s5;
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2));

Console.WriteLine("\n  Case1 - A method changes the value:");
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s3), s1 == s3, s1.Equals(s3));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s4), s1 == s4, s1.Equals(s4));

Console.WriteLine("\n  Case2 - Having only literals allows to arrive at a literal:");
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s5), s1 == s5, s1.Equals(s5));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s6), s1 == s6, s1.Equals(s6));

La sortie est:

True True True

  Case1 - A method changes the value:
False True True
False False True

  Case2 - Having only literals allows to arrive at a literal:
True True True
True True True

Ajout d'un point de plus à la réponse.

.EqualsTo() La méthode vous permet de comparer la culture et la casse.

Le ==jeton en C # est utilisé pour deux opérateurs de vérification d'égalité différents. Lorsque le compilateur rencontre ce jeton, il vérifie si l'un des types comparés a implémenté une surcharge d'opérateur d'égalité pour les types de combinaison spécifiques comparés (*) ou pour une combinaison de types vers lesquels les deux types peuvent être convertis. Si le compilateur trouve une telle surcharge, il l'utilisera. Sinon, si les deux types sont tous les deux des types de référence et qu'ils ne sont pas des classes non liées (soit il peut s'agir d'une interface, soit de classes liées), le compilateur considérera ==comme un opérateur de comparaison de référence. Si aucune des conditions ne s'applique, la compilation échouera.

Notez que certaines autres langues utilisent des jetons distincts pour les deux opérateurs de vérification d'égalité. Dans VB.NET, par exemple, le =jeton est utilisé dans les expressions uniquement pour l'opérateur de vérification d'égalité surchargeable et Isest utilisé comme opérateur de test de référence ou de test nul. Un à utiliser =sur un type qui ne remplace pas l'opérateur de vérification d'égalité échouera, de même que la tentative d'utilisation Isà d'autres fins que le test d'égalité ou de nullité de référence.

(*) Les types ne surchargent généralement l'égalité que pour la comparaison avec eux-mêmes, mais il peut être utile pour les types de surcharger l'opérateur d'égalité pour la comparaison avec d'autres types particuliers; par exemple, intaurait pu (et floatà mon humble avis aurait dû mais pas) défini un opérateur d'égalité à comparer , de sorte que 16777217 ne se rapporterait pas égal à 16777216f. En l'état, étant donné qu'aucun opérateur de ce type n'est défini, C # promeut le intto floaten l'arrondissant à 16777216f avant que l'opérateur de vérification d'égalité ne le voit; cet opérateur voit alors deux nombres à virgule flottante égaux et les signale comme égaux, ignorant l'arrondi qui a eu lieu.

Des réponses et des exemples vraiment géniaux!

Je voudrais juste ajouter la différence fondamentale entre les deux,

Les opérateurs tels que ==ne sont pas polymorphes, tout Equalsest

Avec ce concept à l'esprit, si vous travaillez sur un exemple (en regardant le type de référence à gauche et à droite, et en vérifiant / sachant si le type a effectivement == opérateur surchargé et égal à étant remplacé), vous êtes certain d'obtenir la bonne réponse .

Lorsque nous créons un objet, l'objet est divisé en deux parties, l'une est le contenu et l'autre fait référence à ce contenu. ==compare à la fois le contenu et la référence; equals()compare uniquement le contenu

http://www.codeproject.com/Articles/584128/What-is-the-difference-between-equalsequals-and-Eq

==

L'opérateur == peut être utilisé pour comparer deux variables de toute nature, et il compare simplement les bits .

int a = 3;
byte b = 3;
if (a == b) { // true }

Remarque: il y a plus de zéros sur le côté gauche de l'int, mais nous ne nous en soucions pas ici.

int a (00000011) == octet b (00000011)

Rappelez-vous que l'opérateur == ne se soucie que du modèle des bits de la variable.

Utilisez == si deux références (primitives) font référence au même objet sur le tas.

Les règles sont les mêmes que la variable soit une référence ou une primitive.

Foo a = new Foo();
Foo b = new Foo();
Foo c = a;

if (a == b) { // false }
if (a == c) { // true }
if (b == c) { // false }

a == c est vrai a == b est faux

le motif binaire est le même pour a et c, ils sont donc égaux en utilisant ==.

Égal():

Utilisez la méthode equals () pour voir si deux objets différents sont égaux .

Tels que deux objets String différents qui représentent tous les deux les personnages de "Jane"

La seule différence entre Equal et == réside dans la comparaison des types d'objets. dans d'autres cas, tels que les types de référence et les types de valeurs, ils sont presque identiques (les deux sont une égalité bit à bit ou les deux une égalité de référence).

objet: égal à: égalité bit à bit ==: égalité de référence

chaîne: (égal et == sont les mêmes pour la chaîne, mais si l'une des chaînes a changé en objet, le résultat de la comparaison sera différent) Égale: égalité bit à bit ==: égalité bit à bit

Voir ici pour plus d'explications.