Compartir a través de

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

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.

La documentación de referencia del lenguaje C# cubre la versión más reciente publicada del lenguaje C#. También contiene documentación inicial sobre las características de las versiones preliminares públicas de la próxima versión del lenguaje.

La documentación identifica cualquier característica introducida por primera vez en las últimas tres versiones del idioma o en las versiones preliminares públicas actuales.

Sugerencia

Para buscar cuándo se introdujo por primera vez una característica en C#, consulte el artículo sobre el historial de versiones del lenguaje C#.

Puede usar el is operador de coincidencia de patrones como alternativa a una == prueba al probar con un valor constante. El is operador usa la semántica de igualdad predeterminada para todos los tipos de valor y referencia.

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 alguno de los operandos no es un número (Double.NaN o Single.NaN), el resultado de la operación es false. Esa condición significa que el NaN valor no es mayor que, menor o igual que cualquier otro double valor (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.

Las tuplas de C# tienen compatibilidad integrada con los == operadores y != . 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, los operandos de tipo de referencia, excepto los 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 automáticamente 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 los miembros de tipo de referencia 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 delegados del mismo tipo en tiempo de ejecución son iguales cuando ambas son null o sus listas de invocación tienen la misma longitud y tienen entradas iguales 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

Importante

Las entradas iguales de una lista de invocación incluyen todos los parámetros fijos de la invocación, incluido el receptor. El receptor es la instancia de un objeto representado por this cuando se invoca la entrada.

var o1 = new object();
var o2 = new object();
var d1 = o1.ToString;
var d2 = o2.ToString;
Console.WriteLine(object.ReferenceEquals(d1, d2));  // output: False
Console.WriteLine(d1 == d2);  // output: False (different receivers)

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 proceden de evaluar 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 y false , de lo contrario, . 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 ejemplo siguiente se muestra cómo usar el != 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

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

No se pueden sobrecargar explícitamente los == operadores y != en un tipo de registro. Para cambiar el comportamiento de los == operadores y != para el tipo Tde registro , implemente el IEquatable<T>.Equals método con la firma 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

  • Last updated on