== vs Object.Equals (objet) dans .NET

Question

Donc, quand j'ai un comparée novice pour le novice que je suis maintenant, j'ai l'habitude de penser que ces deux choses étaient sucre syntaxique pour les uns les autres, c'est à dire. que l'utilisation de l'un sur l'autre était simplement une question de préférence personnelle. Au fil du temps, je suis venu à constater que ces deux ne sont pas la même chose, même un défaut de mise en œuvre (voir ceci et cela). Plus confondre la matière, chacun peut être remplacé/surchargé séparément pour avoir un sens complètement différent.

Est-ce une bonne chose, quelles sont les différences, et quand/pourquoi devriez-vous utiliser un sur l'autre?

Answer 1

string x = "hello";
string y = String.Copy(x);
string z = "hello";

Pour tester si x des points pour le même objet que l' y:

(object)x == (object)y  // false
x.ReferenceEquals(y)    // false
x.ReferenceEquals(z)    // true (because x and z are both constants they
                        //       will point to the same location in memory)

Pour tester si x a la même chaîne de valeur en tant que y:

x == y        // true
x == z        // true
x.Equals(y)   // true
y == "hello"  // true

Notez que ceci est différent de Java. En Java, l' == opérateur n'est pas surchargé donc une erreur commune en Java:

y == "hello"  // false (y is not the same object as "hello")

Pour la comparaison de chaînes de caractères en Java, vous devez toujours utiliser .equals()

y.equals("hello")  // true

Answer 2

MSDN est claire et solide de descriptions de choses.

objet.Méthode Equals

l'opérateur ==

Overloadable Opérateurs

Lignes directrices pour remplacer Equals() et Operator ==

Est-ce une bonne chose, ce sont les les différences, et quand/pourquoi devriez-vous utiliser l'un plutôt que l'autre?

Comment peut-il être "bonne" ou "mauvaise" chose? Une méthode, un autre opérateur. Si la référence à l'égalité n'est pas suffisante, la surcharge, sinon de les laisser comme c'est. Pour les types primitifs ils fonctionnent, tout simplement hors de la boîte.

Answer 3

Compte tenu de Microsoft présente déclaration sur l'égalité des opérateurs == et !=, la conclusion est: == doit être juste sucre syntaxique pour Object.Equals():

FAIRE en sorte que l'Objet.D'égal à égal et les opérateurs d'égalité ont exactement la même sémantique

à partir de http://msdn.microsoft.com/en-us/library/vstudio/7h9bszxx(v=vs. 110).aspx

Qu'ils sont distincts, plutôt que juste un peu de sucre, avec le recul, semble être une erreur dans leur conception.

Si vous voulez être certain que vous obtenez de l'IDENTITÉ de la comparaison (lorsque l'on compare les références), puis utilisez ReferenceEquals à la place.

Malheureusement, la gestion de l' == est si contradictoire, que j'ai l'habitude de l'éviter lors de la manipulation de quelqu'un d'autre classes personnalisées, et il suffit d'utiliser le moins lisible Equals(a, b) ou ReferenceEquals(a, b), selon le sens que je veux.

À mon humble avis, il serait mieux pour les gens de ne pas mettre en oeuvre == et !=' at all. Just let .Net default toÉquivautand! Est égal à, and implementest Égal à, " selon le cas.

Si quelqu'un a une logique différente, j'aimerais l'entendre.

(Et oui, c'est vraiment déroutant, étant donné que Java a existé en premier, et utilise == à la moyenne ReferenceEquals. Mais il est trop tard pour changer .Net pour se comporter de cette façon. Et nous avons de Microsoft déclaration à cet effet, dans le lien donné ci-dessus.)

Answer 4

http://msdn.microsoft.com/en-us/library/ms173147.aspx
a quelques bonnes informations sur les différences

Answer 5

Ma compréhension des utilisations des deux était la suivante: utiliser == pour l'égalité conceptuelle (dans le contexte, ces deux arguments signifient-ils la même chose?), Et .Equals pour une égalité concrète (ces deux arguments sont-ils réellement le même objet? ).

Edit: L'article lié de Kevin Sheffield explique mieux la différence entre valeur et référence…