Gelijkheidsoperators: testen of twee objecten gelijk zijn of niet

  • Artikel

De == operators (gelijkheid) en!=(ongelijkheid) controleren of hun operanden gelijk zijn of niet. Waardetypen zijn gelijk wanneer de inhoud gelijk is. Verwijzingstypen zijn gelijk wanneer de twee variabelen naar dezelfde opslag verwijzen.

Gelijkheidsoperator ==

De gelijkheidsoperator retourneert ==true als de operanden gelijk zijn, false anders.

Gelijkheid van waardetypen

Operanden van de ingebouwde waardetypen zijn gelijk als de waarden gelijk zijn:

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

Notitie

Als een van de operanden geen getal (of) is, is falsehet resultaat van de bewerking voor de ><=<>===operatoren , en operatoren .Single.NaNDouble.NaN Dit betekent dat de NaN waarde niet groter is dan, kleiner dan, noch gelijk is aan een andere double (of float) waarde, met inbegrip NaNvan . Zie het Double.NaN artikel of Single.NaN naslaginformatie voor meer informatie en voorbeelden.

Twee operanden van hetzelfde enumtype zijn gelijk als de bijbehorende waarden van het onderliggende integrale type gelijk zijn.

Door de gebruiker gedefinieerde structtypen ondersteunen de == operator niet standaard. Om de operator te ondersteunen, moet een door de == gebruiker gedefinieerde struct deze overbelasten.

De == en != operators worden ondersteund door C# -tuples. Zie de sectie Tuple-gelijkheid van het artikel Tuple-typen voor meer informatie.

Gelijkheid van verwijzingstypen

Standaard zijn twee niet-recordverwijzingstype operanden gelijk als ze naar hetzelfde object verwijzen:

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

Zoals in het voorbeeld wordt weergegeven, ondersteunen door de gebruiker gedefinieerde referentietypen de == operator standaard. Een verwijzingstype kan de == operator echter overbelasten. Als een verwijzingstype de == operator overbelast, gebruikt u de Object.ReferenceEquals methode om te controleren of twee verwijzingen van dat type naar hetzelfde object verwijzen.

Gelijkheid van recordtypen

Recordtypen ondersteunen de == en != operators die standaard semantiek voor gelijkheid van waarden bieden. Dat wil gezegd: twee recordoperanden zijn gelijk wanneer beide waarden zijn null of overeenkomende waarden van alle velden en automatisch geïmplementeerde eigenschappen gelijk zijn.

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

Zoals in het voorgaande voorbeeld wordt weergegeven, worden voor niet-recordverwijzingstypeleden hun referentiewaarden vergeleken, niet de exemplaren waarnaar wordt verwezen.

Gelijkheid van tekenreeksen

Twee tekenreeksoperanden zijn gelijk wanneer beide tekenreeksexemplaren of null beide tekenreeksexemplaren dezelfde lengte hebben en identieke tekens hebben in elke tekenpositie:

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

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

Vergelijkingen voor gelijkheid van tekenreeksen zijn hoofdlettergevoelige ordinale vergelijkingen. Zie Tekenreeksen vergelijken in C# voor meer informatie over tekenreeksvergelijking.

Gelijkheid delegeren

Twee operanden van hetzelfde uitvoeringstype zijn gelijk wanneer beide of null hun aanroeplijsten dezelfde lengte hebben en gelijke vermeldingen hebben op elke positie:

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

Zie de sectie Gelijkheidsoperatoren delegeren van de C#-taalspecificatie voor meer informatie.

Gemachtigden die zijn geproduceerd door de evaluatie van semantisch identieke lambda-expressies zijn niet gelijk, zoals in het volgende voorbeeld wordt weergegeven:

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

Ongelijkheidsoperator !=

De ongelijkheidsoperator != retourneert true als de operanden niet gelijk zijn, false anders. Voor de operanden van de ingebouwde typen produceert de expressie x != y hetzelfde resultaat als de expressie !(x == y). Zie de sectie Gelijkheidsoperator voor meer informatie over type gelijkheid.

In het volgende voorbeeld ziet u het gebruik van de != operator:

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

Overbelasting van operatoren

Een door de gebruiker gedefinieerd type kan de == en != operators overbelasten. Als een type een van de twee operators overbelast, moet het ook de andere overbelasting.

Een recordtype kan de == en != operators niet expliciet overbelasten. Als u het gedrag van het == recordtype en != de operators voor recordtype Twilt wijzigen, implementeert u de IEquatable<T>.Equals methode met de volgende handtekening:

public virtual bool Equals(T? other);

C#-taalspecificatie

Zie de sectie Relationele operators en typetests van de C#-taalspecificatie voor meer informatie.

Zie de sectie Gelijkheidsleden van de notitie voor het voorstel voor records voor meer informatie over gelijkheid van recordtypen.

Zie ook