Operadores de igualdad: prueban si dos objetos son iguales o no

  • Artículo

Los operadores == (igualdad) y != (desigualdad) comprueban si los operandos son iguales. Los tipos de valor son iguales cuando su contenido es igual. Los tipos de referencia son iguales cuando las dos variables hacen referencia al mismo almacenamiento.

Operador de igualdad ==

El operador de igualdad == devuelve true si sus operandos son iguales; en caso contrario, devuelve false.

Igualdad entre tipos de valor

Los operandos de los tipos de valor integrados son iguales si sus valores son iguales:

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. Esto significa que el valor NaN no es mayor, inferior ni igual que cualquier otro valor double o float, incluido NaN. Para obtener más información y ejemplos, vea el artículo de referencia Double.NaN o Single.NaN.

Dos operandos del mismo tipo enum son iguales si los valores correspondientes del tipo entero subyacente son iguales.

Los tipos struct definidos por el usuario no son compatibles con el operador == de forma predeterminada. Para admitir el operador ==, un elemento struct definido por el usuario debe sobrecargarlo.

Los operadores == y != son compatibles con las tuplas de C#. Si desea más información, consulte la sección Igualdad de tupla del artículo Tipos de tupla.

Igualdad entre tipos de referencia

De forma predeterminada, dos operandos de tipo de referencia que no son registros son iguales si hacen referencia al mismo objeto:

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. Sin embargo, un tipo de referencia puede sobrecargar el operador ==. 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.

Igualdad entre tipos de registro

Los tipos de registro admiten los operadores de == y != que, de forma predeterminada, proporcionan semántica de igualdad de valores. Es decir, dos operandos de registro son iguales cuando ambos son null o los valores correspondientes de todos los campos y las propiedades implementadas de forma automática son iguales.

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

Como se muestra en el ejemplo anterior, para miembros de tipo de referencia que no son de registro, se comparan sus valores de referencia, no las instancias a las que se hace referencia.

Igualdad entre cadenas

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:

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

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

Las comparaciones de igualdad de cadenas son comparaciones ordinales que distinguen mayúsculas de minúsculas. Para obtener más información sobre la comparación de cadenas, vea Cómo comparar cadenas en C# .

Igualdad entre delegados

Dos operandos de delegado con el mismo tipo de entorno de ejecución son iguales cuando ambos son null, o bien cuando sus listas de invocación tienen la misma longitud y las mismas entradas en cada posición:

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

Para obtener más información, vea la sección sobre los operadores de igualdad entre delegados de la Especificación del lenguaje C#.

Los delegados que se producen mediante la evaluación de expresiones lambda semánticamente idénticas no son iguales, como se muestra en el ejemplo siguiente:

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

Operador de desigualdad !=

El operador de desigualdad (!=) devuelve true si sus operandos no son iguales; en caso contrario, devuelve false. Para los operandos de los tipos integrados, la expresión x != y genera el mismo resultado que la expresión !(x == y). Para obtener más información sobre la igualdad de tipos, vea la sección Operador de igualdad.

En el siguiente ejemplo se muestra el uso del operador !=:

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 operador

Un tipo definido por el usuario puede sobrecargar los operadores == y !=. Si un tipo sobrecarga uno de los dos operadores, también debe sobrecargar el otro.

Un tipo de registro no puede sobrecargar de forma explícita los operadores == y !=. Si tiene que cambiar el comportamiento de los operadores == y != para el tipo de registro T, implemente el método IEquatable<T>.Equals con la signatura siguiente:

public virtual bool Equals(T? other);

Especificación del lenguaje C#

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#.

Para obtener más información sobre la igualdad de los tipos de registro, vea la sección Miembros de igualdad de la nota de propuesta de características de registros.

Consulte también