Gleichheitsoperatoren : Testen, ob zwei Objekte gleich sind oder nicht

Die Operatoren == (Gleichheit) und != (Ungleichheit) überprüfen, ob die Operanden gleich sind oder nicht. Werttypen sind gleich, wenn ihr Inhalt gleich ist. Verweistypen sind gleich, wenn die beiden Variablen auf denselben Speicher verweisen.

Gleichheitsoperator ==

Der Gleichheitsoperator == gibt true zurück, wenn die Operanden gleich sind; andernfalls false.

Gleichheit von Werttypen

Operanden der integrierten Werttypen sind gleich, wenn ihre Werte gleich sind:

int a = 1 + 2 + 3;
int b = 6;
Console.WriteLine(a == b);  // output: True

char c1 = 'a';
char c2 = 'A';
Console.WriteLine(c1 == c2);  // output: False
Console.WriteLine(c1 == char.ToLower(c2));  // output: True

Hinweis

Bei den Operatoren ==, <, >, <= und >= ist das Ergebnis eines Vorgangs false, wenn einer der Operanden keine Zahl ist (Double.NaN oder Single.NaN). Das bedeutet, dass der NaN-Wert weder größer als noch kleiner als noch gleich einem anderen double-Wert (oder float-Wert) ist, einschließlich NaN. Weitere Informationen und Beispiele finden Sie im Double.NaN- oder Single.NaN-Referenzartikel.

Zwei Operanden desselben enum-Typs sind gleich, wenn die entsprechenden Werte des zugrunde liegenden integralen Typs gleich sind.

Benutzerdefinierte Strukturtypen unterstützen den ==-Operator nicht standardmäßig. Eine benutzerdefinierte Struktur muss den ==-Operator überladen, damit er unterstützt wird.

Die == Operatoren und != werden von C#- Tupeln unterstützt. Weitere Informationen finden Sie im Abschnitt Tupelgleichheit im Artikel Tupeltypen.

Gleichheit von Verweistypen

Standardmäßig sind zwei Verweistypoperanden, die keine Datensätze darstellen, gleich, wenn sie auf dasselbe Objekt verweisen:

public class ReferenceTypesEquality
{
    public class MyClass
    {
        private int id;

        public MyClass(int id) => this.id = id;
    }

    public static void Main()
    {
        var a = new MyClass(1);
        var b = new MyClass(1);
        var c = a;
        Console.WriteLine(a == b);  // output: False
        Console.WriteLine(a == c);  // output: True
    }
}

Das Beispiel zeigt, dass benutzerdefinierte Verweistypen den ==-Operator standardmäßig unterstützen. Ein Verweistyp kann den Operator == aber überladen. Wenn ein Verweistyp den ==-Operator überlädt, verwenden Sie die Object.ReferenceEquals-Methode, um zu überprüfen, ob zwei Verweise dieses Typs auf dasselbe Objekt verweisen.

Gleichheit von Datensatztypen

Datensatztypen sind in C# 9.0 und höher verfügbar und unterstützen die Operatoren == und !=, die standardmäßig Semantik für Wertgleichheit ausdrücken. Das bedeutet, dass zwei Datensatzoperanden gleich sind, wenn beide gleich null oder die entsprechenden Werte aller Felder sowie die automatisch implementierten Eigenschaften gleich sind.

public class RecordTypesEquality
{
    public record Point(int X, int Y, string Name);
    public record TaggedNumber(int Number, List<string> Tags);

    public static void Main()
    {
        var p1 = new Point(2, 3, "A");
        var p2 = new Point(1, 3, "B");
        var p3 = new Point(2, 3, "A");

        Console.WriteLine(p1 == p2);  // output: False
        Console.WriteLine(p1 == p3);  // output: True

        var n1 = new TaggedNumber(2, new List<string>() { "A" });
        var n2 = new TaggedNumber(2, new List<string>() { "A" });
        Console.WriteLine(n1 == n2);  // output: False
    }
}

Wie im vorherigen Beispiel gezeigt, werden bei Nicht-Datensatz-Verweistypmember die Verweiswerte verglichen, nicht die Instanzen, auf die verwiesen wird.

Zeichenfolgengleichheit

Zwei Zeichenfolge-Operanden gleich sind, wenn beide gleich null sind oder wenn beide Zeichenfolgeninstanzen dieselbe Länge und identische Zeichen in jeder Zeichenposition haben:

string s1 = "hello!";
string s2 = "HeLLo!";
Console.WriteLine(s1 == s2.ToLower());  // output: True

string s3 = "Hello!";
Console.WriteLine(s1 == s3);  // output: False

Zeichenfolgengleichheitsvergleiche sind Ordnungsvergleiche, bei denen die Groß-/Kleinschreibung beachtet wird. Weitere Informationen zum Zeichenfolgenvergleich finden Sie unter Vergleichen von Zeichenfolgen in C#.

Delegatengleichheit

Zwei delegate-Operanden mit demselben Laufzeittyp sind gleich, wenn beide null sind oder wenn ihre Aufruflisten die gleiche Länge aufweisen und an jeder Position gleiche Einträge enthalten:

Action a = () => Console.WriteLine("a");

Action b = a + a;
Action c = a + a;
Console.WriteLine(object.ReferenceEquals(b, c));  // output: False
Console.WriteLine(b == c);  // output: True

Weitere Informationen finden Sie im Abschnitt Operatoren für Delegatengleichheit der C#-Sprachspezifikation.

Delegaten, die aus der Auswertung semantisch identischer Lambdaausdrücke erstellt werden, sind ungleich, wie im folgenden Beispiel gezeigt:

Action a = () => Console.WriteLine("a");
Action b = () => Console.WriteLine("a");

Console.WriteLine(a == b);  // output: False
Console.WriteLine(a + b == a + b);  // output: True
Console.WriteLine(b + a == a + b);  // output: False

Ungleichheitsoperator !=

Der Ungleichheitsoperator != gibt zurück true , wenn seine Operanden nicht gleich sind, false andernfalls. Für die Operanden der integrierten Typen führt der Ausdruck x != y zum selben Ergebnis wie der Ausdruck !(x == y). Weitere Informationen zur Typengleichheit finden Sie im Abschnitt Gleichheitsoperator.

Im folgenden Beispiel wird die Verwendung des !=-Operators veranschaulicht:

int a = 1 + 1 + 2 + 3;
int b = 6;
Console.WriteLine(a != b);  // output: True

string s1 = "Hello";
string s2 = "Hello";
Console.WriteLine(s1 != s2);  // output: False

object o1 = 1;
object o2 = 1;
Console.WriteLine(o1 != o2);  // output: True

Operatorüberladbarkeit

Ein benutzerdefinierter Typ kann die Operatoren == und !=überladen. Wenn ein Typ einen der zwei Operatoren überlädt, muss er auch den anderen Operator überladen.

Ein Datensatztyp kann die == Operatoren und != nicht explizit überladen. Wenn Sie das Verhalten der Operatoren == und != für den Datensatztyp T ändern müssen, implementieren Sie die Methode IEquatable<T>.Equals mit der folgenden Signatur:

public virtual bool Equals(T? other);

C#-Sprachspezifikation

Weitere Informationen finden Sie im Abschnitt Relationale und Typtestoperatoren in der C#-Sprachspezifikation.

Weitere Informationen zur Gleichheit von Datensatztypen finden Sie im Abschnitt Gleichheitsmember des Artikels Datensätze.

Weitere Informationen