Operátory rovnosti – test, jestli jsou dva objekty stejné nebo ne

  • Článek

Operátory == (rovnost) a!=(nerovnosti) kontrolují, jestli jsou jejich operandy stejné nebo ne. Typy hodnot jsou stejné, pokud se jejich obsah rovná. Odkazové typy jsou stejné, když obě proměnné odkazují na stejné úložiště.

Operátor rovnosti ==

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

Rovnost typů hodnot

Operandy předdefinovaných typů hodnot jsou stejné, pokud jsou jejich hodnoty stejné:

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

Poznámka:

==Pro operátory , ,<> , <=a >= operátory, pokud některý z operandů není číslo (Double.NaN nebo Single.NaN), výsledek operace je .false To znamená, že NaN hodnota není větší než, menší než, ani rovna žádné jiné double (nebo float) hodnotě, včetně NaN. Další informace a příklady najdete v článku nebo Single.NaN v referenčním Double.NaN článku.

Dva operandy stejného typu výčtu jsou stejné, 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 .

== Řazené kolekce členů jazyka C# podporují operátory!=. Další informace najdete v oddílu rovnosti řazené kolekce členů v článku o typech řazených kolekcí členů.

Rovnost typů odkazů

Ve výchozím nastavení jsou dva operandy referenčního typu bez záznamu 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, uživatelem definované odkazové typy podporují == operátor ve výchozím nastavení. Typ odkazu však může přetížit == operátor. Pokud typ odkazu přetíží == operátor, pomocí Object.ReferenceEquals metody zkontrolujte, zda dva odkazy tohoto typu odkazují na stejný objekt.

Rovnost typů záznamů

Typy záznamů podporují operátory == , != které ve výchozím nastavení poskytují sémantiku rovnosti hodnot. To znamená, že dva operandy záznamů jsou stejné, pokud jsou null oba nebo odpovídající hodnoty všech polí a 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, pro členy referenčního typu bez záznamu se porovnávají jejich referenční hodnoty, nikoli odkazované instance.

Rovnost řetězců

Dva řetězcové operandy jsou stejné, pokud jsou null obě nebo obě instance řetězců mají stejnou délku a mají stejné znaky v 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

Porovnání rovnosti řetězců jsou porovnání s rozlišováním malých a velkých písmen. Další informace o porovnání řetězců naleznete v tématu Porovnání řetězců v jazyce C#.

Delegování rovnosti

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

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 naleznete v části Delegovat operátory rovnosti specifikace jazyka C#.

Delegáti vytvořené z vyhodnocení sémanticky identických výrazů lambda se nerovnají, 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í true , pokud jeho operandy nejsou rovny, false jinak. Pro operandy předdefinovaných typů výraz x != y vytvoří stejný výsledek jako výraz !(x == y). Další informace o rovnosti typů naleznete 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 != operátory. Pokud typ přetíží jeden ze dvou operátorů, musí také přetížit druhý z nich.

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

public virtual bool Equals(T? other);

specifikace jazyka C#

Další informace najdete v části Relační a typové operátory specifikace jazyka C#.

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

Viz také