C# Unterschied zwischen == und Equals()

Question

Ich habe eine Bedingung in einer Silverlight-Anwendung, die 2 Zeichenfolgen vergleicht, aus irgendeinem Grund, wenn ich verwenden == er gibt zurück falsch während .Equals() gibt zurück. wahr .

Hier ist der Code:

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

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

Gibt es einen Grund, warum dies geschieht?

Answer 1

Ich füge der Antwort einen weiteren Punkt hinzu.

.EqualsTo() Methode gibt Ihnen die Möglichkeit, mit der Kultur zu vergleichen und Groß- und Kleinschreibung zu berücksichtigen.

Answer 2

Dies liegt an der Gleichheit der Werte (Methode equal) und der referenziellen Gleichheit (Operator ==), da die Methode equal die Werte prüft, während der Operator == die Referenz prüft.

\== Operator-Überschreibungscode, der innerhalb der String-Klasse auf https://referencesource.microsoft.com/

so jetzt ist es einfacher zu verstehen, die gleiche Methode hat auch 2 Implementierungen eine von der String-Klasse selbst und eine von der Objektklasse. seine Auswirkungen auf die Leistung als auch ich auch einige grundlegende Code ausführen und versuchen, die Benchmarks zu verstehen.

Ich teile die Ergebnisse unten Bitte korrigieren oder beraten, wenn ich irgendwo falsch bin. es gibt 3 Fälle, und ich habe den gleichen Code für alle Fälle ausgeführt und dies ist das Ergebnis.

Fall 1: Hier verwende ich die Methode string. equal für den Vergleich von 2 Strings und beide Strings haben die gleichen Werte. string.equals(a,b)

1. Durchlauf:5608195 Ticks

2. Durchlauf:5529387 Ticks

3. Lauf:5622569 Ticks

Zecken insgesamt: 16760151

Fall 2: Hier verwende ich die Methode string. equal() (überladen) zum Vergleichen von 2 Strings und beide Strings haben die gleichen Werte. a.equals(b)

1. Lauf: 6738583 Zecken

2. Lauf: 6452927 Zecken

3. Lauf: 7168897 Zecken

Ticks insgesamt=20360407

Fall 3: Hier verwende ich den == Operator für den Vergleich von 2 Strings und beide Strings haben die gleichen Werte. a==b

1. Lauf: 6652151 Zecken

2. Lauf: 7514300 Ticks

3. Lauf: 7634606 Zecken

Zecken insgesamt=21801057

class Program
{
    private static int count;
    static string a = "abcdef";
    static string b = "abcdef";
    static void Main(string[] args)
    {            

        for (int j = 1; j <= 3; j++)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 1; i <= 1000; i++)
            {
                checkString();
            }
            sw.Stop();
            Console.WriteLine(sw.ElapsedTicks);
        }
        Console.ReadLine();

    }
    public static void checkString()
    {
        for (int i = 1; i <= 100000; i++)
        {
            if (a==b)
                count++;
        }
    }
}

Answer 3

Es gibt noch eine weitere Dimension zu einer früheren Antwort von @BlueMonkMN. Die zusätzliche Dimension besteht darin, dass die Antwort auf die von @Drahcir gestellte Titelfrage auch davon abhängt wie erreichten wir die string Wert. Zur Veranschaulichung:

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));

Die Ausgabe ist:

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

Answer 4

Wirklich tolle Antworten und Beispiele!

Ich möchte nur den grundlegenden Unterschied zwischen den beiden hinzufügen,

Operatoren wie == nicht polymorph sind, während Equals es

Mit diesem Konzept im Hinterkopf können Sie jedes beliebige Beispiel ausarbeiten (indem Sie den linken und den rechten Referenztyp betrachten und überprüfen, ob der Typ tatsächlich einen überladenen ==-Operator und eine Überschreibung von Equals hat), um die richtige Antwort zu erhalten.

Answer 5

Ob Equals() y == sind identisch hängt von der Implementierung ab . Da C# den Benutzern die Möglichkeit gibt, verschiedene Verhaltensweisen für Equals() y == beziehungsweise.

    class CompareTest
    {
        public readonly int val;

        public CompareTest(int val)
        {
            this.val = val;
        }

        public override bool Equals(object obj)
        {
            return obj is CompareTest test && this.val == test.val;
        }

        public override int GetHashCode()
        {
            return val;
        }

        public static bool operator == (CompareTest a, object b)
        {
            return Equals(a, b);
        }

        public static bool operator != (CompareTest a, object b)
        {
            return !(a == b);
        }
    }

In diesem Beispiel habe ich Equals() y == haben das gleiche Verhalten. Was aber, wenn ich sie unterschiedlich gestalte? Zum Beispiel:

        public static bool operator == (CompareTest a, object b)
        {
            return false;
        }

Equals() funktioniert normal, aber == wird niemals funktionieren.

Außerdem habe ich zwar dafür gesorgt, dass sie sich gleich verhalten, aber es gibt noch einen Unterschied: welche == Funktion aufgerufen wird, hängt von dem linken Wert ab:

        Compare Test a = new CompareTest(1);
        object b = new CompareTest(1);
        CompareTest c = new CompareTest(1);
        Debug.Log("AB " + (a == b)); // true
        Debug.Log("BA " + (b == a)); // false! because it calls object's == function 
        Debug.Log("AC " + (a == c)); // true
        Debug.Log("CA " + (c == a)); // true