Operadores de igualdad (referencia de C#)Equality operators (C# Reference)

Los operadores == (igualdad) y != (desigualdad) comprueban si los operandos son iguales.The == (equality) and != (inequality) operators check if their operands are equal or not.

Operador de igualdad ==Equality operator ==

El operador de igualdad == devuelve true si sus operandos son iguales; en caso contrario, devuelve false.The equality operator == returns true if its operands are equal, false otherwise.

Igualdad entre tipos de valorValue types equality

Los operandos de los tipos de valor integrados son iguales si sus valores son iguales:Operands of the built-in value types are equal if their values are equal:

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

Nota

Para los operadores ==, <, >, <= y >=, si cualquier operando no es un número (Double.NaN o Single.NaN), el resultado del operador será false.For the ==, <, >, <=, and >= operators, if any of the operands is not a number (Double.NaN or Single.NaN), the result of operation is false. Esto significa que el valor NaN no es mayor, inferior ni igual que cualquier otro valor double o float, incluido NaN.That means that the NaN value is neither greater than, less than, nor equal to any other double (or float) value, including NaN. Para obtener más información y ejemplos, vea el artículo de referencia Double.NaN o Single.NaN.For more information and examples, see the Double.NaN or Single.NaN reference article.

Dos operandos del mismo tipo enum son iguales si los valores correspondientes del tipo entero subyacente son iguales.Two operands of the same enum type are equal if the corresponding values of the underlying integral type are equal.

Los tipos struct definidos por el usuario no son compatibles con el operador == de forma predeterminada.User-defined struct types don't support the == operator by default. Para admitir el operador ==, un elemento struct definido por el usuario debe sobrecargarlo.To support the == operator, a user-defined struct must overload it.

A partir de C# 7.3, los operadores == y != son compatibles con las tuplas de C#.Beginning with C# 7.3, the == and != operators are supported by C# tuples. Para obtener más información, vea la sección Igualdad y tuplas del artículo Tipos de tupla de C#.For more information, see the Equality and tuples section of the C# tuple types article.

Igualdad entre cadenasString equality

Dos operandos string son iguales si ambos son null, o bien si las instancias de ambas cadenas tienen la misma longitud y los mismos caracteres en cada posición de caracteres:Two string operands are equal when both of them are null or both string instances are of the same length and have identical characters in each character position:

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

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

Es la comparación de ordinales que distingue entre mayúsculas de minúsculas.That is case-sensitive ordinal comparison. Para obtener más información sobre la comparación de cadenas, vea Cómo comparar cadenas en C# .For more information about string comparison, see How to compare strings in C#.

Igualdad entre tipos de referenciaReference types equality

Dos operandos de tipos de referencia (excepto string) son iguales si hacen referencia al mismo objeto:Two other than string reference type operands are equal when they refer to the same object:

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

Como se muestra en el ejemplo, el operador == es compatible de forma predeterminada con los tipos de referencia definidos por el usuario.As the example shows, user-defined reference types support the == operator by default. Sin embargo, un tipo de referencia definido por el usuario puede sobrecargar el operador ==.However, a user-defined reference type can overload the == operator. Si un tipo de referencia sobrecarga el operador ==, use el método Object.ReferenceEquals para comprobar si dos referencias de ese tipo hacen referencia al mismo objeto.If a reference type overloads the == operator, use the Object.ReferenceEquals method to check if two references of that type refer to the same object.

Operador de desigualdad !=Inequality operator !=

El operador de desigualdad (!=) devuelve true si sus operandos son iguales; en caso contrario, devuelve false.The inequality operator != returns true if its operands are not equal, false otherwise. Para los operandos de los tipos integrados, la expresión x != y genera el mismo resultado que la expresión !(x == y).For the operands of the built-in types, the expression x != y produces the same result as the expression !(x == y). Para obtener más información sobre la igualdad de tipos, vea la sección Operador de igualdad.For more information about type equality, see the Equality operator section.

En el siguiente ejemplo se muestra el uso del operador !=:The following example demonstrates the usage of the != 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

Posibilidad de sobrecarga del operadorOperator overloadability

Un tipo definido por el usuario puede sobrecargar los operadores == y !=.A user-defined type can overload the == and != operators. Si un tipo sobrecarga uno de los dos operadores, también debe sobrecargar el otro.If a type overloads one of the two operators, it must also overload another one.

Especificación del lenguaje C#C# language specification

Para obtener más información, vea la sección Operadores de comprobación de tipos y relacionales de la Especificación del lenguaje de C#.For more information, see the Relational and type-testing operators section of the C# language specification.

Vea tambiénSee also