Gleichheitsoperatoren: Testen, ob zwei Objekte gleich oder ungleich sind

Artikel
07.04.2023

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#-Tupel 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 unterstützen die Operatoren == und !=, die standardmäßig Semantik für Wertgleichheit ausdrücken. Das heißt, zwei Datensatzopernden sind gleich, wenn beide werte oder entsprechende Werte aller Felder sind null und automatisch implementierte 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 das vorherige Beispiel zeigt, werden bei Verweistypmembern, die keine Datensätze sind, 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

Bei Vergleichen der Gleichheit von Zeichenfolgen wird Groß-/Kleinschreibung beachtet. 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 durch Auswertung semantisch identischer Lambdaausdrücke erzeugt werden, sind beispielsweise nicht gleich. Dies wird 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 true zurück, wenn die Operanden nicht gleich sind; andernfalls false. 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.

Teilen über