Pourquoi voudriez-vous utiliser String.Equals == plus ?

Question

J’ai été récemment introduit à une grande base de code et remarqué toutes les comparaisons de chaînes sont effectuées à l’aide au lieu de

Quelle est la raison pour cela, pensez-vous ? Pourquoi voudriez-vous utiliser String.Equals plus == ?

Answer 1

Il est tout à fait probable qu’une grande partie de la base de développeur provient d’un Java où l’utilisation de fond `` pour comparer des chaînes est faux et ne fonctionne pas.

En c#, il n’y a aucune différence (pratique) (pour cordes) tant qu’ils sont de type string.

Si elles sont tapées comme ou alors voir ici les autres réponses qui parlent de méthodes génériques ou de surcharge des opérateurs car il vous certainement à utiliser la méthode Equals.

Answer 2

Il est pratique, la différence entre string.Equals et ==

bool result = false;

        object obj = "String";
        string str2 = "String";
        string str3 = typeof(string).Name;
        string str4 = "String";
        object obj2 = str3;

        // Comparision between object obj and string str2 -- Com 1
        result = string.Equals(obj, str2);// true
        result = String.ReferenceEquals(obj, str2); // true
        result = (obj == str2);// true

        // Comparision between object obj and string str3 -- Com 2
        result = string.Equals(obj, str3);// true
        result = String.ReferenceEquals(obj, str3); // false
        result = (obj == str3);// false

        // Comparision between object obj and string str4 -- Com 3
        result = string.Equals(obj, str4);// true
        result = String.ReferenceEquals(obj, str4); // true
        result = (obj == str4);// true

        // Comparision between string str2 and string str3 -- Com 4
        result = string.Equals(str2, str3);// true
        result = String.ReferenceEquals(str2, str3); // false
        result = (str2 == str3);// true

        // Comparision between string str2 and string str4 -- Com 5
        result = string.Equals(str2, str4);// true
        result = String.ReferenceEquals(str2, str4); // true
        result = (str2 == str4);// true

        // Comparision between string str3 and string str4 -- Com 6
        result = string.Equals(str3, str4);// true
        result = String.ReferenceEquals(str3, str4); // false
        result = (str3 == str4);// true

        // Comparision between object obj and object obj2 -- Com 7
        result = String.Equals(obj, obj2);// true
        result = String.ReferenceEquals(obj, obj2); // false
        result = (obj == obj2);// false

L'Ajout De Regarder

    obj     "String" {1#}   object {string}
    str2    "String" {1#}   string
    str3    "String" {5#}   string
    str4    "String" {1#}   string
    obj2    "String" {5#}   object {string}

Maintenant, regardez {1#} et {5#}

obj, str2, str4 et obj2 références sont les mêmes.

obj et obj2 sont object type et d'autres sont string type

Conclusion:

1. com1: résultat = (obj == str2);// true
   • compare object et string donc effectue une référence de contrôle d'égalité
   • obj et str2 point à la même référence, de sorte que le résultat est vrai
2. com2: résultat = (obj == str3);// false
   • compare object et string donc effectue une référence de contrôle d'égalité
   • obj et de la str3 point pour les différentes références de sorte que le résultat est faux
3. com3: résultat = (obj == str4);// true
   • compare object et string donc effectue une référence de contrôle d'égalité
   • obj et de la str4 point à la même référence, de sorte que le résultat est vrai
4. com4: résultat = (str2 == str3);// true
   • compare string et string donc effectue une valeur de chaîne de vérifier
   • str2 et str3 sont à la fois "Chaîne" de sorte que le résultat est vrai
5. com5: résultat = (str2 == str4);// true
   • compare string et string donc effectue une valeur de chaîne de vérifier
   • str2 et str4 sont à la fois "Chaîne" de sorte que le résultat est vrai
6. com6: résultat = (str3 == str4);// true
   • compare string et string donc effectue une valeur de chaîne de vérifier
   • str3 et str4 sont à la fois "Chaîne" de sorte que le résultat est vrai
7. com7: résultat = (obj == obj2);// false - compare object et object donc effectue une référence de contrôle d'égalité - obj et obj2 point pour les différentes références de sorte que le résultat est faux

Answer 3

Il y a une subtile mais très importante différence entre == et la Chaîne.Est égal méthodes:

class Program
{
    static void Main(string[] args)
    {
        CheckEquality("a", "a");
        Console.WriteLine("----------");
        CheckEquality("a", "ba".Substring(1));
    }

    static void CheckEquality<T>(T value1, T value2) where T : class
    {
        Console.WriteLine("value1: {0}", value1);
        Console.WriteLine("value2: {0}", value2);

        Console.WriteLine("value1 == value2:      {0}", value1 == value2);
        Console.WriteLine("value1.Equals(value2): {0}", value1.Equals(value2));

        if (typeof(T).IsEquivalentTo(typeof(string)))
        {
            string string1 = (string)(object)value1;
            string string2 = (string)(object)value2;
            Console.WriteLine("string1 == string2:    {0}", string1 == string2);
        }
    }
}

Produit de cette sortie:

value1: a
value2: a
value1 == value2:      True
value1.Equals(value2): True
string1 == string2:    True
----------
value1: a
value2: a
value1 == value2:      False
value1.Equals(value2): True
string1 == string2:    True

Vous pouvez voir que l'opérateur == est de retour faux à deux, évidemment, l'égalité des chaînes de caractères. Pourquoi? Parce que l'opérateur == en cours d'utilisation dans le générique de la méthode est résolu à l'op_equal méthode telle que définie par le Système.Objet (la seule garantie de T la méthode a au moment de la compilation), ce qui signifie que c'est la référence à l'égalité au lieu de la valeur de l'égalité.

Lorsque vous avez deux valeurs saisies en tant que Système.Chaîne explicitement, alors == a la valeur de l'égalité sémantique, car le compilateur résout l' == pour le Système.Chaîne de caractères.op_equal au lieu de Système.Objet.op_equal.

Donc, pour jouer la sécurité, j'ai presque toujours utiliser des chaînes de caractères.Est égal à la place de qui je reçois toujours la valeur de l'égalité sémantique que je veux.

Et pour éviter d'exception nullreferenceexceptions si une des valeurs est nulle, je l'utilise toujours la statique de la Chaîne.Méthode Equals:

bool true = String.Equals("a", "ba".Substring(1));

Answer 4

``offre-t-elle des surcharges pour gérer les corps et culture prenant en charge la comparaison. Si votre code ne fait pas usage de celles-ci, les devs peuvent juste servir à Java, où (comme Matthew dit), vous devez utiliser le. Equals, méthode pour des comparaisons de contenu.

Answer 5

Il y a un texte sur cet article que vous trouverez peut-être intéressant, avec quelques citations de Jon Skeet. Il semble que l’utilisation est à peu près les mêmes.

Jon Skeet affirme que l’exécution de l’instance est égale à « est un peu mieux lorsque les chaînes sont courtes-comme les chaînes augmentent de longueur, cette différence devient complètement insignifiante. »