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

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

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.

A mintamegfeleltetési operátort a teszt alternatívájaként is használhatja==, ha állandó értéken tesztel. Az is operátor az alapértelmezett egyenlőségi szemantikát használja az összes érték- és referenciatípushoz.

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 egyike nem szám (Double.NaN vagy Single.NaN), akkor a művelet falseeredménye . Ez azt jelenti, hogy az NaN érték nem nagyobb, 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 beépített támogatást nyújt az és == az != operátorok számára. 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 a hivatkozás típusú operandusok, a rekordok kivételével, egyenlőek, 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 implementált tulajdonságok egyenlők.

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

Fontos

A meghívási lista egyenlő bejegyzései tartalmazzák a hívásban szereplő összes rögzített paramétert, beleértve a fogadót is. A fogadó egy objektum példánya, amelyet this a bejegyzés meghívása jelöl.

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)

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 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 ==és != az T 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

  • Last updated on