Une brève analyse de l'exemple de code de "==" et Equals en C#

La plupart des internautes ont résumé « == » et Equals comme ceci :

1. "==" compare les valeurs de deux variables pour l'égalité.

3. Equals compare si deux variables pointent vers le même objet.

Par exemple : cet article, et prenez les exemples de cet article comme exemple.

public class Person
{
     public Person(string name)
     {
         this.Name = name;
     }

     public string Name { get; set; }
}

 static void Main(string[] args)
 {
     string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
     string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
     Console.WriteLine(a == b);         //true
     Console.WriteLine(a.Equals(b));    //true

     object g = a;
     object h = b;
     Console.WriteLine(g == h);         //false
     Console.WriteLine(g.Equals(h));    //true

     Person p1 = new Person("jia");
     Person p2 = new Person("jia");
     Console.WriteLine(p1 == p2);       //false
     Console.WriteLine(p1.Equals(p2));  //false
     Person p3 = new Person("jia");
     Person p4 = p3;
     Console.WriteLine(p3 == p4);       //true
     Console.WriteLine(p3.Equals(p4));  //true

     Console.ReadKey();
 }

Si la conclusion ci-dessus est correcte et que "==" compare les valeurs de deux variables pour être égales, alors le code suivant ne devrait pas être vrai.

Console.WriteLine(a == b);         //true

Évidemment, les deux variables chaîne ci-dessus : a et b pointent vers deux objets différents, c'est-à-dire que les adresses mémoire qu'elles stockent dans l'espace de pile sont également différentes. Mais pourquoi sont-ils égaux ?

2. Qu'est-ce que la surcharge de l'opérateur ?

La surcharge d'opérateur consiste à redéfinir un opérateur existant et à lui donner une autre fonction pour s'adapter à différents types de données. Pour donner une analogie simple : " " opérateur, en " " deux

Lorsque toutes les arêtes sont des variables de type numérique, l'opérateur " " représente la signification mathématique de " ". Si l'un des côtés de l'opérateur " " est de type chaîne, alors l'opérateur " " représente la connexion

La signification de la chaîne. Il existe de nombreux exemples d’une telle surcharge d’opérateurs, cela a-t-il donc quelque chose à voir avec le sujet de cet article ? Ce que je veux dire, c'est que les variables de chaîne ci-dessus : a, b sont dues à la classe String

Opérateur surchargé "==", voir le code source suivant :

public static bool operator == (String a, String b)
{
    return String.Equals(a, b);
}
 public static bool operator != (String a, String b)
{
    return !String.Equals(a, b);
}

Il est évident que l'opérateur "==" est vraiment surchargé dans la classe String, et pas seulement "==" mais aussi "!=". Et appelez directement la méthode Equals dans la classe String à l'intérieur de la méthode opérateur surchargée,

Le code source est le suivant :

public static bool Equals(String a, String b)
{
         if ((Object)a==(Object)b)
         {
             return true;
         }

         if ((Object)a==null || (Object)b==null)
         {
             return false;
         }

         if (a.Length != b.Length)
             return false;

         return EqualsHelper(a, b);
 }

De ce qui précède, nous pouvons conclure que l'opérateur "==" ne compare pas nécessairement si les valeurs stockées dans deux variables sont égales. Cela dépend si l'opérateur actuel est surchargé dans le type actuel.

3. Réécriture de Equals

Toujours l'exemple ci-dessus :

string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
Console.WriteLine(a == b);         //true
Console.WriteLine(a.Equals(b));    //true

On peut voir de ce qui précède que : a et b sont deux objets différents. Mais si Equals est True, la conclusion ci-dessus : « Equals compare si deux variables pointent vers le même objet » n'est pas valide. Raison

Regardez la méthode Equals dans la classe String :

public override bool Equals(Object obj) <br>       {
    if (this == null)                        //this is necessary to guard against reverse-pinvokes and
        throw new NullReferenceException();  //other callers who do not use the callvirt instruction

    String str = obj as String;
    if (str == null)
        return false;

    if (Object.ReferenceEquals(this, obj))
        return true;

    if (this.Length != str.Length)
        return false;

    return EqualsHelper(this, str);
}

public bool Equals(String value) <br>       {
    if (this == null)                        //this is necessary to guard against reverse-pinvokes and
        throw new NullReferenceException();  //other callers who do not use the callvirt instruction

    if (value == null)
        return false;

    if (Object.ReferenceEquals(this, value))
        return true;

    if (this.Length != value.Length)
        return false;

    return EqualsHelper(this, value);
}

Comme le montre ce qui précède, la classe String non seulement réécrit les Equals dans Object, mais possède également sa propre méthode Equals, mais le code d'implémentation est presque le même. Type de comparaison, adresse mémoire,

Valeur réelle pour obtenir le résultat final. Equals n'est donc pas nécessairement une comparaison unique pour savoir si les adresses de référence sont identiques, sans compter que nous pouvons également le réécrire et le personnaliser. Mais réécris

Equals nécessite également une attention particulière, c'est-à-dire que si vous devez utiliser HashMap, HashSet, Hashtable, vous devez également réécrire GetHashCode().

4. Pourquoi avons-nous besoin d'Equals alors que nous avons "==" ?

Il y a un dicton en Chine : « L'existence de quelque chose doit avoir sa propre raison et sa propre valeur. » Il en va de même pour « ==" et Equals. L'implémentation la plus basique de "==" dans les types référence consiste à comparer

Comparez si les adresses mémoire des deux objets sont cohérentes, si elles sont cohérentes, elles sont égales, sinon elles ne sont pas égales. Une telle implémentation est évidemment pensée d'un point de vue matériel. Si deux objets sont égaux, ce sont le même objet,

Ensuite, leurs adresses en mémoire doivent être égales. Mais bien souvent, le « comportement (méthode) » dépend de la perspective à partir de laquelle nous observons le monde. Par exemple : Type String on déclare un caractère

Les chaînes se soucient davantage de la valeur réelle de la chaîne que de savoir si les deux objets sont créés une ou deux fois en mémoire (c'est-à-dire si les adresses mémoire sont égales), tant qu'ils ont

Si les valeurs réelles sont égales, alors nous les considérons comme égales. Cela s’entend du point de vue de la logique commerciale de la vie plutôt que du point de vue de la machine. Bien sûr la même chaîne déclarée ci-dessus

Que les variables soient créées une ou deux fois, je pense : « Pool constant (ou pool de détention de chaînes) » nous a donné la meilleure solution.

5. Quelle est la relation entre "==" et Equals ?

L'opérateur "==" et Equals sont en fait complémentaires. Parce que : La forme principale d'implémentation de l'opérateur "==" est implémentée du "point de vue informatique (ou point de vue matériel)",

Equals est mis en œuvre sur la base de scénarios commerciaux courants ou de scénarios commerciaux spécifiques. Il n'y a pas de lien inévitable entre les deux. Vous choisissez simplement différentes méthodes en fonction de vos propres besoins commerciaux.

Donc Equals in Object est visuel. Il a été réécrit dans de nombreuses classes et atteint véritablement le comportement spécifique requis dans le type actuel, à savoir : le polymorphisme. Ce n'est donc pas difficile d'expliquer ce qui précède :

object g = a;
object h = b;
Console.WriteLine(g == h);         //false
Console.WriteLine(g.Equals(h));    //true

Étant donné que l'opérateur surchargé "==" n'est pas implémenté dans Object, la méthode de comparaison actuelle de "==" consiste à comparer si les adresses mémoire stockées dans l'espace de pile des deux variables sont les mêmes. Et Equals est

Appelez Equals dans la classe String car la variable g pointe en fait vers un objet chaîne pendant le fonctionnement, et le type Object actuel est simplement le comportement de Visual Studio et du compilateur, c'est-à-dire qu'il est toujours polymorphe.

En fin de compte, tout a ses règles : "==" et Equals ne font pas exception. Pour plus de détails, veuillez cliquer sur : Aller à MSDN.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!