Egyenlőségi operátorok – annak vizsgálata, hogy két objektum egyenlő-e vagy sem

  • Cikk

Az == (egyenlőség) és != az (egyenlőtlenségi) operátorok ellenőrzik, hogy operandusaik egyenlőek-e vagy sem. Az értéktípusok egyenlők, ha a tartalmaik egyenlőek. A referenciatípusok egyenlők, ha a két változó ugyanarra a tárolóra hivatkozik.

Egyenlőség operátor ==

Az egyenlőség operátor == akkor ad true vissza értéket, ha az operandusai egyenlőek, false ellenkező esetben.

Értéktípusok egyenlősége

A beépített értéktípusok operandusai egyenlők, ha az értékük egyenlő:

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

Feljegyzés

Ha az ==><>=<=operandusok bármelyike nem szám (Double.NaN vagy Single.NaN), akkor a művelet falseeredménye . Ez azt jelenti, hogy az NaN érték nem nagyobb, nem kisebb, mint bármely más double (vagy float) érték, beleértve a NaN. További információkért és példákért tekintse meg vagy tekintse meg a Double.NaNSingle.NaN referenciacikket.

Az azonos számtípusú két operandus egyenlő, ha az alapul szolgáló integráltípus megfelelő értékei egyenlők.

A felhasználó által definiált szerkezettípusok alapértelmezés szerint nem támogatják az == operátort. Az operátor támogatásához a == felhasználó által definiált szerkezetnek túl kell terhelnie azt.

A == C# tuples támogatja az és != az operátorokat. További információkért tekintse meg a Tuple-típusok cikkÉnek Tuple egyenlőségi szakaszát.

Hivatkozástípusok egyenlősége

Alapértelmezés szerint két nem rekord típusú referencia típusú operandus egyenlő, ha ugyanarra az objektumra hivatkoznak:

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

Ahogy a példa is mutatja, a felhasználó által definiált referenciatípusok alapértelmezés szerint támogatják az == operátort. A referenciatípus azonban túlterhelheti az operátort == . Ha egy hivatkozástípus túlterheli az == operátort, a Object.ReferenceEquals módszerrel ellenőrizheti, hogy az adott típus két hivatkozása ugyanarra az objektumra hivatkozik-e.

Rekordtípusok egyenlősége

A rekordtípusok támogatják azokat az == operátorokat, != amelyek alapértelmezés szerint értékegyenlőségi szemantikát biztosítanak. Ez azt jelzi, hogy két rekord operandusa egyenlő, ha mindkettő null vagy az összes mező megfelelő értéke, és az automatikusan megvalósított tulajdonságok értéke egyenlő.

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

Ahogy az előző példa is mutatja, a nem rekord típusú referencia típusú tagok esetében a referenciaértékeket a rendszer összehasonlítja, nem pedig a hivatkozott példányokat.

Sztring egyenlősége

Két sztringoperndus akkor egyenlő, ha mindkettő null azonos hosszúságú, vagy mindkét sztringpéldány azonos hosszúságú, és mindegyik karakterpozícióban azonos karakterekkel rendelkezik:

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

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

A sztringek egyenlőségének összehasonlítása kis- és nagybetűk közötti összehasonlítás. A sztringek összehasonlításáról további információt a Sztringek összehasonlítása C#-ban című témakörben talál.

Egyenlőség delegálása

Két azonos futásidejű delegált operandus egyenlő, ha mindkettő azonos null hosszúságú, vagy a meghívási listák azonos hosszúságúak, és mindegyik pozícióban azonos bejegyzésekkel rendelkeznek:

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

További információ: A C# nyelvi specifikációjának Egyenlőségi operátorok delegálása szakasza.

A szemantikailag azonos lambdakifejezések kiértékelése során előállított delegáltak nem egyenlők , ahogy az alábbi példa is mutatja:

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

Egyenlőtlenség operátor !=

Az egyenlőtlenségi operátor != akkor ad true vissza értéket, ha az operandusai nem egyenlők, false ellenkező esetben. A beépített típusok operandusai esetében a kifejezés x != y ugyanazt az eredményt adja, mint a kifejezés!(x == y). A típusegyenlőségről további információt az Egyenlőség operátor szakaszban talál.

Az alábbi példa az operátor használatát != mutatja be:

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

Operátorok túlterhelése

A felhasználó által definiált típus túlterhelheti az és != az == operátorokat. Ha egy típus túlterheli a két operátor egyikét, a másikat is túl kell terhelnie.

Egy rekordtípus nem tudja explicit módon túlterhelni az és != az == operátorokat. Ha módosítania kell a rekordtípus Tés != az == operátorok viselkedését, implementálja a metódust IEquatable<T>.Equals a következő aláírással:

public virtual bool Equals(T? other);

C# nyelvspecifikáció

További információ: A C# nyelvi specifikációjának relációs és típustesztelő operátorok szakasza.

A rekordtípusok egyenlőségével kapcsolatos további információkért tekintse meg a Rekordok funkció javaslati megjegyzésének Egyenlőség tagok szakaszát.

Lásd még