Olvasás angol nyelven

Megosztás a következőn keresztül:

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ő:

C# 
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

Megjegyzé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.NaN Single.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:

C# 
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 implementált tulajdonságok egyenlők.

C# 
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:

C# 
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:

C# 
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:

C# 
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:

C# 
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:

C# 
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