Freigeben über

Gleichheitsoperatoren: Testen, ob zwei Objekte gleich oder ungleich sind

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.

Sie können den is Musterabgleichsoperator als Alternative zu einem == Test verwenden, wenn Sie einen Konstantenwert testen. Der is Operator verwendet die Standardgleichheitssemantik für alle Wert- und Referenztypen.

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

Für die ==Operatoren ,< , >und , <=>= wenn einer der Operanden keine Zahl (Double.NaN oder Single.NaN) ist, ist falsedas Ergebnis des Vorgangs . Das bedeutet, dass der NaN Wert nicht größer als, kleiner oder gleich einem anderen double (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.

C#- Tupel verfügen über integrierte Unterstützung für die == Und-Operatoren != . Weitere Informationen finden Sie im Abschnitt Tupelgleichheit im Artikel Tupeltypen.

Gleichheit von Verweistypen

Standardmäßig sind Verweistypopernden, mit Ausnahme von Datensätzen, 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 im vorstehenden Beispiel gezeigt, werden für Referenztypmmber ihre Referenzwerte verglichen, nicht die Referenzinstanzen.

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

Von Bedeutung

Gleiche Einträge in einer Aufrufliste enthalten alle festen Parameter im Aufruf, einschließlich des Empfängers. Der Empfänger ist die Instanz eines Objekts, das dargestellt this wird, wenn der Eintrag aufgerufen wird.

var o1 = new object();
var o2 = new object();
var d1 = o1.ToString;
var d2 = o2.ToString;
Console.WriteLine(object.ReferenceEquals(d1, d2));  // output: False
Console.WriteLine(d1 == d2);  // output: False (different receivers)

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 ==!=. 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

  • Last updated on