Gleichheitsoperatoren (C#-Referenz)Equality operators (C# reference)

Die Operatoren == (Gleichheit) und != (Ungleichheit) überprüfen, ob die Operanden gleich sind oder nicht.The == (equality) and != (inequality) operators check if their operands are equal or not.

Gleichheitsoperator ==Equality operator ==

Der Gleichheitsoperator == gibt true zurück, wenn die Operanden gleich sind; andernfalls false.The equality operator == returns true if its operands are equal, false otherwise.

Gleichheit von WerttypenValue types equality

Operanden der integrierten Werttypen sind gleich, wenn ihre Werte gleich sind:Operands of the built-in value types are equal if their values are equal:

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 Double.NaN, wenn einer der Operanden keine Zahl ist (Single.NaN oder false).For the ==, <, >, <=, and >= operators, if any of the operands is not a number (Double.NaN or Single.NaN), the result of operation is false. 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.That means that the NaN value is neither greater than, less than, nor equal to any other double (or float) value, including NaN. Weitere Informationen und Beispiele finden Sie im Double.NaN- oder Single.NaN-Referenzartikel.For more information and examples, see the Double.NaN or Single.NaN reference article.

Zwei Operanden desselben enum-Typs sind gleich, wenn die entsprechenden Werte des zugrunde liegenden integralen Typs gleich sind.Two operands of the same enum type are equal if the corresponding values of the underlying integral type are equal.

Benutzerdefinierte Strukturtypen unterstützen den ==-Operator nicht standardmäßig.User-defined struct types don't support the == operator by default. Eine benutzerdefinierte Struktur muss den ==-Operator überladen, damit er unterstützt wird.To support the == operator, a user-defined struct must overload it.

Ab C# 7.3 werden die Operatoren == und != für C#-Tupel unterstützt.Beginning with C# 7.3, the == and != operators are supported by C# tuples. Weitere Informationen finden Sie im Abschnitt Gleichheit und Tupel im Artikel C#-Tupeltypen.For more information, see the Equality and tuples section of the C# tuple types article.

Gleichheit von VerweistypenReference types equality

Standardmäßig sind zwei Verweistypoperanden gleich, wenn sie auf dasselbe Objekt verweisen:By default, two reference-type operands are equal if they refer to the same object:

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.As the example shows, user-defined reference types support the == operator by default. Ein Verweistyp kann den Operator == aber überladen.However, a reference type can overload the == operator. 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.If a reference type overloads the == operator, use the Object.ReferenceEquals method to check if two references of that type refer to the same object.

ZeichenfolgengleichheitString equality

Zwei Zeichenfolge-Operanden gleich sind, wenn beide gleich null sind oder wenn beide Zeichenfolgeninstanzen dieselbe Länge und identische Zeichen in jeder Zeichenposition haben:Two string operands are equal when both of them are null or both string instances are of the same length and have identical characters in each character position:

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

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

Dies ist ein Ordinalvergleich unter Berücksichtigung der Groß-/Kleinschreibung.That is a case-sensitive ordinal comparison. Weitere Informationen zum Zeichenfolgenvergleich finden Sie unter Vergleichen von Zeichenfolgen in C#.For more information about string comparison, see How to compare strings in C#.

DelegatengleichheitDelegate equality

Zwei delegate-Operanden mit demselben Laufzeittyp sind gleich, wenn beide null lauten oder ihre Aufruflisten die gleiche Länge aufweisen und an jeder Position gleiche Einträge umfassen:Two delegate operands of the same runtime type are equal when both of them are null or their invocation lists are of the same length and have equal entries in each position:

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.For more information, see the Delegate equality operators section of the C# language specification.

Delegaten, die durch die Auswertung semantisch identischer Lambdaausdrücke erzeugt werden, sind beispielsweise nicht gleich. Dies wird im folgenden Beispiel gezeigt:Delegates that are produced from evaluation of semantically identical lambda expressions are not equal, as the following example shows:

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 !=Inequality operator !=

Der Ungleichheitsoperator != gibt true zurück, wenn die Operanden nicht gleich sind; andernfalls false.The inequality operator != returns true if its operands are not equal, false otherwise. Für die Operanden der integrierten Typen führt der Ausdruck x != y zum selben Ergebnis wie der Ausdruck !(x == y).For the operands of the built-in types, the expression x != y produces the same result as the expression !(x == y). Weitere Informationen zur Typengleichheit finden Sie im Abschnitt Gleichheitsoperator.For more information about type equality, see the Equality operator section.

Im folgenden Beispiel wird die Verwendung des !=-Operators veranschaulicht:The following example demonstrates the usage of the != operator:

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überladbarkeitOperator overloadability

Ein benutzerdefinierter Typ kann die Operatoren und ==überladen!=.A user-defined type can overload the == and != operators. Wenn ein Typ einen der beiden Operatoren überlädt, muss er auch den anderen Operator überladen.If a type overloads one of the two operators, it must also overload another one.

C#-SprachspezifikationC# language specification

Weitere Informationen finden Sie im Abschnitt Relationale und Typtestoperatoren in der C#-Sprachspezifikation.For more information, see the Relational and type-testing operators section of the C# language specification.

Weitere InformationenSee also