Operatory równości (odwołanie w C#)

Operatory == (równość) != i (nierówności) sprawdzają, czy ich operandy są równe, czy nie.

Operator równości ==

Operator równości zwraca == wartość , jeśli jej true operandy są równe, w false przeciwnym razie.

Równość typów wartości

Operandy wbudowanych typów wartości są równe, jeśli ich wartości są równe:

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

Uwaga

W == przypadku operatorów < , , > , <= i >= , jeśli którykolwiek z operandów nie jest liczbą ( lub ), wynikiem Double.NaN operacji jest Single.NaN false . Oznacza to, że wartość nie jest ani większa, mniejsza niż ani równa żadnej innej wartości (lub ), w NaN double tym float NaN . Aby uzyskać więcej informacji i przykładów, zobacz artykuł Double.NaN lub Single.NaN .

Dwa operandy tego samego typu wy enum są równe, jeśli odpowiadające im wartości bazowego typu całkowitego są równe.

Typy struktur zdefiniowane przez użytkownika domyślnie nie == obsługują operatora. Aby można było == obsługiwać operator , struktura zdefiniowana przez użytkownika musi go przeciążyć.

Począwszy od języka C# 7.3, == operatory i != są obsługiwane przez krotki języka C#. Aby uzyskać więcej informacji, zobacz sekcję Tuple equality (Równość krotek) artykułu Tuple types (Typy krotek).

Równość typów odwoływnych

Domyślnie dwa operandy typu odwołania innego niż rekord są równe, jeśli odwołują się do tego samego obiektu:

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
    }
}

Jak pokazano w przykładzie, zdefiniowane przez użytkownika typy referencyjne == domyślnie obsługują operator . Jednak typ referencyjny może przeciążyć == operator. Jeśli typ odwołania przeciąża operator, użyj metody , aby sprawdzić, czy dwa odwołania tego typu odwołują == się do tego samego Object.ReferenceEquals obiektu.

Równość typów rekordów

Dostępne w języku C# 9.0 i nowszych typy rekordów obsługują operatory i , które domyślnie == zapewniają != semantykę równości wartości. Oznacza to, że dwa operandy rekordów są równe, gdy oba z nich są lub odpowiadające im wartości wszystkich pól, a właściwości zaimplementowane automatycznie null są równe.

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
    }
}

Jak pokazano w poprzednim przykładzie, w przypadku nienotowanych elementów członkowskich typu odwołania ich wartości odwołania są porównywane, a nie wystąpienia, do których istnieją odwołania.

Równość ciągów

Dwa operandy ciągów są równe, gdy oba są wystąpieniami ciągu lub oba są o tej samej długości i mają identyczne znaki null w każdej pozycji znaku:

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

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

Jest to porównanie porządkowe z rozróżnianą wielkością liter. Aby uzyskać więcej informacji na temat porównywania ciągów, zobacz How to compare strings in C# (Jak porównywać ciągi w języku C#).

Delegowanie równości

Dwa delegowane operandy tego samego typu czasu działania są równe, gdy oba z nich są lub ich listy wywołania mają taką samą długość i mają takie same wpisy w null każdej pozycji:

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

Aby uzyskać więcej informacji, zobacz sekcję Delegate equality operators (Delegowanie operatorów równości) specyfikacji języka C#.

Delegaty, które są produkowane na podstawie oceny semantycznie identycznych wyrażeń lambda, nie są równe, jak pokazano w poniższym przykładzie:

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

Operator nierówności !=

Operator nierówności zwraca != wartość , jeśli jej true operandy nie są równe, w false przeciwnym razie. Dla operandów typów wbudowanych wyrażenie generuje ten sam wynik co x != y wyrażenie !(x == y) . Aby uzyskać więcej informacji na temat równości typów, zobacz sekcję Operator równości.

W poniższym przykładzie pokazano użycie != operatora :

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

Przeciążanie operatorów

Typ zdefiniowany przez użytkownika może przeciążyć == operatory != i . Jeśli typ przeciąża jeden z dwóch operatorów, musi również przeciążyć drugi.

Typ rekordu nie może jawnie przeciążyć == operatorów != i . Jeśli musisz zmienić zachowanie operatorów i dla typu rekordu , zaim implementuj == != metodę z następującym T IEquatable<T>.Equals podpisem:

public virtual bool Equals(T? other);

specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz sekcję Relational and type-testing operators (Operatory relacyjne i testowania typów) w specyfikacji języka C#.

Aby uzyskać więcej informacji na temat równości typów rekordów, zobacz sekcję Elementy członkowskie równości uwagi dotyczącej propozycji funkcji rekordów.

Zobacz też