¿Por qué C # no puede comparar dos tipos de objetos entre sí, pero VB no?

Tengo dos objetos en C # y no sé si es booleano o de cualquier otro tipo. Sin embargo, cuando trato de comparar esos C # no puede dar la respuesta correcta. He intentado el mismo código con VB.NET y ¡lo hice!

¿Alguien puede decirme cómo solucionar esto si hay una solución?

C#:

object a = true;
object b = true;
object c = false;
if (a == b) c = true;
MessageBox.Show(c.ToString()); //Outputs False !!

VB.NET:

Dim a As Object = True
Dim b As Object = True
Dim c As Object = False
If (a = b) Then c = True
MessageBox.Show(c.ToString()) '// Outputs True

En C #, el ==operador (cuando se aplica a expresiones de tipo de referencia) realiza una verificación de igualdad de referencia a menos que esté sobrecargado . Estás comparando dos referencias que son el resultado de conversiones de boxeo, por lo que esas son referencias distintas.

EDITAR: con tipos que sobrecargan ==, puede obtener un comportamiento diferente, pero eso se basa en el tipo de tiempo de compilación de las expresiones. Por ejemplo, stringproporciona ==(string, string):

string x = new string("foo".ToCharArray());
string y = new string("foo".ToCharArray());
Console.WriteLine(x == y); // True
Console.WriteLine((object) x == (object) y); // False

Aquí, la primera comparación usa el operador sobrecargado, pero la segunda usa la comparación de referencia "predeterminada".

En VB, el =operador hace mucho más trabajo: ni siquiera es equivalente al uso object.Equals(x, y), ya que cosas como Option Comparepueden afectar la forma en que se compara el texto.

Básicamente, los operadores no funcionan de la misma manera y no están destinados a funcionar de la misma manera.

Además de la respuesta de Jon que explica el lado C # de las cosas, esto es lo que hace VB:

En VB con Option Strict On, una comparación a través de = siempre prueba la igualdad de valores y nunca la igualdad de referencia. De hecho, su código ni siquiera se compila una vez que cambia Option Strict Onporque System.Objectno define un Operator=. Usted debe siempre tener esta opción, atrapa insectos con más eficacia que una venus atrapamoscas (aunque en su caso particular, este comportamiento laxa en realidad hace lo correcto). ¹

De hecho, con Option Strict On, VB se comporta aún más estricto que C #: en C #, a == b ya sea activa una llamada a SomeType.operator==(a, b)o, si esto no existe, invoca comparación de igualdad de referencia (que es equivalente a llamarobject.ReferenceEquals(a, b) ).

En VB, por otro lado, la comparación a = b siempre invoca al operador de igualdad. ² Si desea utilizar la comparación de igualdad de referencia, debe utilizarla a Is b(que, una vez más, es lo mismo que Object.ReferenceEquals(a, b))

¹⁾ Aquí hay una buena indicación de por qué usar Option Strict Offes una mala idea: he usado VB.NET durante casi una década, desde antes del lanzamiento oficial de .NET hasta hace unos años, y no tengo ni idea de qué a = bhace Option Strict Off. Hace algún tipo de comparación de igualdad, pero qué sucede exactamente y por qué, ni idea. Sin dynamicembargo, es más complejo que la función de C # (porque se basa en una API bien documentada). Esto es lo que dice el MSDN:

Debido a que Option Strict Onproporciona un tipeo fuerte , evita conversiones de tipos no deseadas con pérdida de datos, no permite el enlace tardío y mejora el rendimiento, se recomienda encarecidamente su uso.

²⁾ Jon ha mencionado una excepción, cadenas, donde la comparación de igualdad hace algunas cosas más por razones de compatibilidad con versiones anteriores.

Las instancias de objeto no se comparan con el operador "==". Debe usar el método "igual". Con el operador "==" se comparan referencias, no objetos.

Prueba esto:

public class MyObject
{
    public MyObject(String v)
    {
        Value = v;
    }
    public String Value { get; set; }
}

MyObject a = new MyObject("a");
MyObject b = new MyObject("a");
if(a==b){
    Debug.WriteLine("a reference is equal to b reference");
}else{
    Debug.WriteLine("a reference is not equal to b reference");
}
if (a.Equals(b)) {
    Debug.WriteLine("a object is equal to b object");
} else {
    Debug.WriteLine("a object is not equal to b object");
}

Resultados:

a reference is not equal to b reference
a object is not equal to b object

Ahora, intenta esto:

public class MyObject
{
    public MyObject(String v)
    {
        Value = v;
    }
    public String Value { get; set; }

    public bool Equals(MyObject o)
    {
        return (Value.CompareTo(o.Value)==0);
    }
}
MyObject a = new MyObject("a");
MyObject b = new MyObject("a");
if(a==b){
    Debug.WriteLine("a reference is equal to b reference");
}else{
    Debug.WriteLine("a reference is not equal to b reference");
}
if (a.Equals(b)) {
    Debug.WriteLine("a object is equal to b object");
} else {
    Debug.WriteLine("a object is not equal to b object");
}

Resultados:

a reference is not equal to b reference
a object is equal to b object

El problema es que el operador == en C # es una llamada a un método estático (bueno, tal vez no técnicamente, pero puede considerarse como tal) según el tipo de tiempo de compilación de los dos parámetros. Los tipos de tiempo de ejecución reales de esos objetos no importan.

Basado en ese tipo de tiempo de compilación, el compilador determinará qué implementación operator ==usar. Puede usar el predeterminadoobject implementación , podría usar una de las sobrecargas numéricas proporcionadas por el lenguaje, o podría ser una implementación definida por el usuario.

Esto es diferente de VB en que VB no determina la implementación en tiempo de compilación. Espera hasta el tiempo de ejecución e inspecciona los dos parámetros que se le dan para determinar qué implementación del ==operador debe usar.

Su código contiene valores booleanos, pero están en variables que son de tipo object. Porque la variable es de tipo object, el compilador de C # usa la objectimplementación de ==, que compara las referencias , no las instancias de objeto. Como los valores booleanos son cuadros, no tienen la misma referencia, aunque sus valores sean los mismos.

Al código VB no le importa de qué tipo es la variable. Espera hasta el tiempo de ejecución y luego verifica las dos variables, ve que en realidad son del tipo booleano y, por lo tanto, usa la ==implementación del operador booleano . Esa implementación compara los valores de los booleanos, no sus referencias (y los booleanos se desempaquetarán antes de llamar a ese operador, por lo que una comparación de referencia ya no tiene sentido). Debido a que los valores de los booleanos son los mismos, devuelve verdadero.