La différence entre l'opérateur == et de la méthode Equals() en C#?

Quelle est la différence entre == et Equals() avec exemple? Je sais que == est utilisé pour comparer l'opérateur et Equals() méthode est utilisée pour comparer le contenu de la chaîne.J'ai donc essayé

//first example
string s1 = "a";
string s2 = "a";
Console.Write(a.Equals(s2)); //returns true, but if I assign "b" to s2,
                             //then result will be false

//second example
string s1 ="a";
string s2 ="a";
Console.Write(s1 == s2);     //returns true

Comment est-ce donc? Les deux sont différents des références d'objet. Supposons que nous considérons qu'il s'agit de référence. Mais j'ai essayé de l'utiliser comme ceci

string s1 = new string("ab");
string s2 = new string("ab");

J'obtiens erreur de compilation qui ne peut pas convertir en chaîne de caractères char

La méthode Equals() n'est pas seulement utilisé pour comparer le contenu d'une chaîne de caractères, il peut être utilisé pour comparer deux objets. Le string type en C# qui arrive à contenir une remplacer la méthode pour Equals() qui permettra de comparer leurs valeurs (ce fait est très mal expliqué dans un certain nombre d'articles qui suggèrent que Equals() est pour la comparaison de chaînes uniquement).

InformationsquelleAutor Jui Test | 2012-03-02

c#equals equals-operator string

22

Il y a plusieurs choses qui se passent. Tout d'abord, dans cet exemple:
```
string s1 = "a";
string s2 = "a";
Console.WriteLine(s1 == s2);
```
Vous prétendez que:

Les deux sont différents de l'objet de référence.

Ce n'est pas vrai en raison de chaîne de stage. s1 et s2 sont des références pour le même objet. La spécification C# garantit que - à partir de la section 2.4.4.5 du C# 4 spécification:

Lorsque deux ou plus de deux littéraux de chaîne qui sont l'équivalent selon la chaîne de l'opérateur d'égalité (§7.10.7) apparaissent dans le même programme, ces littéraux de chaîne reportez-vous à la même instance de chaîne.

Donc, dans ce cas particulier, vous obtenez toujours "vrai" même si vous avez imprimé object.ReferenceEquals(s1, s2), ou si vous l'avez fait d'utiliser un véritable de référence de l'identité comparaison avec ==:
```
object s1 = "a";
object s2 = "a";
Console.WriteLine(s1 == s2); //Still prints True due to string literal interning
```
Cependant, même si ces ont été des références à des objets distincts, == est surchargé pour string. La surcharge est un au moment de la compilation de décision la mise en œuvre à utiliser dépend du moment de la compilation des types des opérandes. Ainsi, par exemple:
```
string a = new string('x', 1);
string b = new string('x', 1);
Console.WriteLine(a == b); //Uses string's implementation, prints True

object c = a;
object d = b;
Console.WriteLine(c == d); //Reference identity comparison, prints False
```
Comparer avec object.Equals(object) qui est une méthode virtuelle. Comme il arrive, String surcharges cette méthode ainsi, mais surtout, il la remplace. Donc, si nous modifions notre code:
```
string a = new string('x', 1);
string b = new string('x', 1);
Console.WriteLine(a.Equals((object) b));

object c = a;
object d = b;
Console.WriteLine(c.Equals(d));
```
... puis les deux appels à la méthode dans le code compilé sera simplement de object.Equals(object), mais ils vont encore imprimés Vrai en raison de polymorphisme: la mise en œuvre dans String sera utilisé.

Voici ce qu'un appel à la surchargé méthode ressemblerait à:
```
string a = new string('x', 1);
string b = new string('x', 1);
Console.WriteLine(a.Equals(b)); //Calls string.Equals(string)
```
- Deux questions: pourquoi le casting de d à object, puisque c'est déjà un objet? Aussi, dans le a Equals b partie, je voudrais appeler à la fois l'objet et le correcteur de la chaîne de surcharge, il est donc plus clairement quelle est la différence.
- 1) Oui, je n'ai pas besoin de cast dans ce cas. 2) vous ne savez Pas de quoi vous parlez.
- Je veux dire ceci: voir la dernière réponse. Je n'ai pas d'obtenir directement votre explication à propos de la surcharge/remplacement....
- Ok, je peux le modifier pour que.
- C'est tout. Je n'ai pas vraiment sentir à l'aise modification moi-même...
InformationsquelleAutor Jon Skeet
7

Devis à partir de la documentation de Est égal à:

La valeur par défaut de la mise en œuvre d'égal à Égal supports de référence pour l'égalité
les types de référence, et au niveau du bit pour l'égalité des types de valeur. Référence
l'égalité signifie que l'objet des références par rapport reportez-vous à la
même objet. Bit-à-bit de l'égalité signifie que les objets qui sont contre ont
la même représentation binaire.

Et la opérateur == :

Prédéfinis pour différents types de valeurs, l'opérateur d'égalité (==) retourne vrai si
les valeurs de ses opérandes sont égaux, sinon false. Pour référence
d'autres types de chaîne, == retourne true si les deux opérandes reportez-vous à
le même objet. Pour le type de chaîne, == compare les valeurs de la
les chaînes de caractères.

Maintenant, revenons à votre question: pourquoi ne s1 == s2 retourne vrai? Les chaînes sont spéciaux des bêtes dans .NET. Ils représentent immuable types de référence. Ils sont internés dans .NET. Cela signifie que si vous avez 2 constantes de chaîne avec la même valeur, ils se réfèrent à la même instance de l'objet au moment de l'exécution.

Citation de la la documentation:

Le common language runtime conserve la chaîne de stockage par le maintien d'une
tableau, appelé le stagiaire de la piscine, qui contient une référence unique
chaque littéral de chaîne déclarée ou créé par programmation dans
votre programme. Par conséquent, une instance d'une chaîne littérale avec un
notamment qu'une valeur n'existe qu'une fois dans le système.
- Ce n'est pas uniquement en raison d'un stage. Un stage est pourquoi il faudrait travailler même s'ils ont été déclarés de type object. Mais même les références à différents objets de chaîne avec le même contenu serait de travailler aussi longtemps que le moment de la compilation les types impliqués sont à la fois de la chaîne, en raison de la surcharge d'opérateur. La documentation que vous avez cité est trompeuse, car elle suggère, il y a quelques manutention spéciale juste pour les chaînes de caractères - il n'y en a pas, c'est juste que la chaîne est un type de référence qui surcharge l'opérateur==.
- Notez également que le stage est une langue détail .NET propose les mécanismes, mais il serait tout à fait possible d'avoir un langage Muet# qui est le même que le langage C# dans tous les sens, à l'exception sans constante chaîne de stage.
InformationsquelleAutor Darin Dimitrov
2

Vous êtes en train de penser semble Java-esque. En java, le == opérateur ne peut pas être personnalisé, de sorte que pour les types référence, il est toujours fait référence à l'égalité, même si cela signifie que la valeur de l'égalité pour les types primitifs. D'autre part, Equals est pour vérifier la valeur de l'égalité dans les types de référence.

Les choses sont différentes en C#, cependant. Les deux Equals et == personnalisées peuvent être mises en œuvre. La différence est que Equals est virtuelle (exemple) méthode, tandis que operator== est une méthode statique. A côté de cela, ils peuvent se comporter exactement de la même manière.

Par défaut, les deux Equals et == vérifier la référence à l'égalité pour les types référence, et la valeur de l'égalité pour les types de valeur. Cependant, pour string, les deux sont personnalisés afin de vérifier la valeur de l'égalité.

InformationsquelleAutor Ken Wayne VanderLinde

Vous devez vous connecter pour publier un commentaire.