Dela via

Likhetsoperatorer – testa om två objekt är lika med eller inte

  • Artikel

Operatörerna == (likhet) och!=(ojämlikhet) kontrollerar om deras operander är lika med eller inte. Värdetyper är lika med när deras innehåll är lika med. Referenstyper är lika med när de två variablerna refererar till samma lagring.

Likhetsoperator ==

Likhetsoperatorn == returnerar true om dess operander är lika, false annars.

Likhet mellan värdetyper

Operander för de inbyggda värdetyperna är lika med om deras värden är lika med:

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

Kommentar

För operatorerna ==,< , >, <=och >= om någon av operanderna inte är ett tal (Double.NaN eller Single.NaN) är falseresultatet av åtgärden . Det innebär att NaN värdet varken är större än, mindre än eller lika med något annat double (eller float) värde, inklusive NaN. Mer information och exempel finns i referensartikeln Double.NaN eller Single.NaN .

Två operander av samma uppräkningstyp är lika med om motsvarande värden för den underliggande integraltypen är lika.

Användardefinierade structtyper stöder inte operatorn == som standard. För att stödja operatorn == måste en användardefinierad struct överbelasta den.

Operatorerna == och stöds av C#-tupplar!=. Mer information finns i avsnittet Tuple equality i artikeln Tuple types (Tuppelns typer).

Likhet mellan referenstyper

Som standard är två operander av typen icke-post lika om de refererar till samma objekt:

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

Som exemplet visar stöder användardefinierade referenstyper operatorn == som standard. En referenstyp kan dock överbelasta operatorn == . Om en referenstyp överbelastar operatorn == använder du Object.ReferenceEquals metoden för att kontrollera om två referenser av den typen refererar till samma objekt.

Likhet mellan posttyper

Posttyper stöder operatorerna == och != som som standard ger värdejämlikhetssemantik. Det innebär att två postoperor är lika när båda är null eller motsvarande värden för alla fält och automatiskt implementerade egenskaper är lika.

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

Som föregående exempel visar jämförs deras referensvärden för icke-postreferenstypsmedlemmar, inte de refererade instanserna.

Strängjämlikhet

Två strängoperor är lika med varandra när båda är null eller båda stränginstanserna har samma längd och har identiska tecken i varje teckenposition:

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

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

Jämförelse av strängjämlikhet är skiftlägeskänsliga ordningstalsjämförelser. Mer information om strängjämförelse finns i Så här jämför du strängar i C#.

Delegera likhet

Två delegerade operander av samma körningstyp är lika när båda är null eller deras anropslistor har samma längd och har samma poster i varje position:

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

Mer information finns i avsnittet Delegera likhetsoperatorer i C#-språkspecifikationen.

Ombud som skapas från utvärdering av semantiskt identiska lambda-uttryck är inte lika med, vilket visas i följande exempel:

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

Ojämlikhetsoperator !=

Ojämlikhetsoperatorn != returnerar true om dess operander inte är lika med, false annars. För operanderna för de inbyggda typerna ger uttrycket x != y samma resultat som uttrycket !(x == y). Mer information om typjämlikhet finns i avsnittet Likhetsoperator .

I följande exempel visas hur operatorn != används:

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

Överlagring av operator

En användardefinierad typ kan överbelasta operatorerna == och != . Om en typ överbelastar en av de två operatorerna måste den också överbelasta den andra.

En posttyp kan inte uttryckligen överbelasta operatorerna == och != . Om du behöver ändra beteendet för operatorerna == och != för posttypen Timplementerar IEquatable<T>.Equals du metoden med följande signatur:

public virtual bool Equals(T? other);

Språkspecifikation för C#

Mer information finns i avsnittet Relations- och typtestningsoperatorer i C#-språkspecifikationen.

Mer information om likhet mellan posttyper finns i avsnittet Likhetsmedlemmar i anteckningen om funktionsförslag för poster.

Se även