Operátory rovnosti (referenční informace jazyka C#)

Operátory == (rovnost) a != (nerovnost) kontrolují, jestli jsou jejich operandy stejné nebo ne.

Operátor rovnosti ==

Operátor rovnosti vrátí == hodnotu , pokud jsou jeho true operandy stejné, false jinak.

Rovnost typů hodnot

Operandy předdefinových hodnotových typů jsou shodné, pokud se jejich hodnoty rovnají:

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

Dva operandy stejného typu výčtu jsou shodné, pokud jsou odpovídající hodnoty základního celočíselného typu stejné.

Uživatelem definované typy struktur ve výchozím nastavení operátor == nepodporují. Pro podporu == operátoru musí uživatelem definovaná struktura přetížit.

Počínaje jazykem C# 7.3 jsou operátory a podporovány řazenou kolekcemi členů == != jazyka C#. Další informace najdete v části Rovnost řazené kolekce členů v článku Typy řazené kolekce členů.

Rovnost typů odkazů

Ve výchozím nastavení jsou dva ne record operandy odkazového typu stejné, pokud odkazují na stejný 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
    }
}

Jak ukazuje příklad, odkazové typy definované uživatelem ve výchozím nastavení == podporují operátor . Odkazový typ však může přetížit == operátor . Pokud odkazový typ přetíží operátor, pomocí metody zkontrolujte, jestli dva odkazy tohoto typu == Object.ReferenceEquals odkazují na stejný objekt.

Rovnost typů záznamů

Typy záznamů dostupné v jazyce C# 9.0 a novějším podporují operátory a , které ve výchozím nastavení poskytují == != sémantiku rovnosti hodnot. To znamená, že dva operandy záznamů jsou shodné, pokud jsou oba dva nebo odpovídající hodnoty všech polí a null automaticky implementované vlastnosti jsou stejné.

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

Jak ukazuje předchozí příklad, v případě členů referenčního typu bez záznamu se porovnávají jejich referenční hodnoty, nikoli odkazované instance.

Rovnost řetězce

Dva řetězcové operandy jsou shodné, pokud jsou oba nebo obě instance řetězce mají stejnou délku a mají identické null znaky na každé pozici znaku:

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

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

To je ordinální porovnání rozlišují malá a velká písmena. Další informace o porovnání řetězců najdete v tématu Porovnání řetězců v jazyce C#.

Delegování rovnosti

Dva operandy delegáta stejného typu za běhu jsou shodné, pokud jsou oba dva nebo jejich seznamy volání mají stejnou délku a mají na každé pozici stejné null položky:

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

Další informace najdete v části Delegování operátorů rovnosti specifikace jazyka C#.

Delegáti, kteří jsou vytvořeni vyhodnocením sémanticky identických výrazů lambda, nejsou si rovni, jak ukazuje následující příklad:

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

Operátor nerovnosti !=

Operátor nerovnosti vrátí != hodnotu , pokud se jeho true operandy nerovnají, false jinak. Pro operandy předdefinových typůvytvoří výraz stejný x != y výsledek jako výraz !(x == y) . Další informace o rovnosti typů najdete v části Operátor rovnosti.

Následující příklad ukazuje použití != operátoru :

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

Přetížení operátoru

Uživatelem definovaný typ může přetížit == operátory != a . Pokud typ přetíží jeden ze dvou operátorů, musí také přetížit druhý.

Typ záznamu nemůže explicitně přetížit == operátory != a . Pokud potřebujete změnit chování operátorů a pro == != typ záznamu , T implementujte IEquatable<T>.Equals metodu s následujícím podpisem:

public virtual bool Equals(T? other);

specifikace jazyka C#

Další informace najdete v části Relační operátory a operátory pro testování typů specifikace jazyka C#.

Další informace o rovnosti typů záznamů najdete v části Členové rovnosti v poznámce k návrhu záznamů.

Viz také

• Referenční dokumentace k jazyku C#
• Operátory a výrazy v C#
• System.IEquatable<T>
• Object.Equals
• Object.ReferenceEquals
• Porovnání rovnosti
• Relační operátory