Perché C # non riesce a confrontare due tipi di oggetti tra loro ma VB no?

Ho due oggetti in C # e non so se è booleano o qualsiasi altro tipo. Tuttavia, quando provo a confrontare quei C # non riesce a dare la risposta giusta. Ho provato lo stesso codice con VB.NET e lo ha fatto!

Qualcuno può dirmi come risolvere questo problema se esiste una soluzione?

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

In C #, l' ==operatore (quando applicato alle espressioni del tipo di riferimento) esegue un controllo dell'uguaglianza di riferimento a meno che non sia sovraccarico . Stai confrontando due riferimenti che sono il risultato di conversioni di boxe, quindi quelli sono riferimenti distinti.

EDIT: con tipi che sovraccaricano il ==, è possibile ottenere un comportamento diverso, ma che si basa sul tipo di espressioni in fase di compilazione . Ad esempio, stringfornisce ==(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

Qui il primo confronto utilizza l'operatore sovraccarico, ma il secondo utilizza il confronto di riferimento "predefinito".

In VB, l' =operatore fa molto più lavoro - non è nemmeno equivalente all'utilizzo object.Equals(x, y), in quanto cose come Option Comparepossono influenzare il modo in cui il testo viene confrontato.

Fondamentalmente gli operatori non lavorano allo stesso modo e non sono destinati a lavorare allo stesso modo.

Oltre alla risposta di Jon che spiega il lato C # delle cose, ecco cosa fa VB:

In VB con Option Strict On, un confronto tramite verifica = sempre l' uguaglianza di valore e mai l'uguaglianza di riferimento. In effetti, il tuo codice non si compila nemmeno una volta che cambi Option Strict Onperché System.Objectnon definisce un Operator=. Dovresti sempre avere questa opzione attiva, cattura i bug in modo più efficace rispetto a un acchiappamosche di Venere (anche se nel tuo caso particolare questo comportamento rilassato fa davvero la cosa giusta). ¹

In effetti, con Option Strict OnVB si comporta anche più rigorosamente di C #: in C #, a == b o avvia una chiamata SomeType.operator==(a, b)o, se non esiste, invoca il confronto di uguaglianza di riferimento (che equivale a chiamare object.ReferenceEquals(a, b)).

In VB, invece, il confronto invoca a = b sempre l'operatore di uguaglianza. ² Se si desidera utilizzare il confronto di uguaglianza di riferimento, è necessario utilizzare a Is b(che è, ancora una volta, lo stesso di Object.ReferenceEquals(a, b)).

¹⁾ Ecco una buona indicazione del perché l'utilizzo Option Strict Offsia una cattiva idea: ho usato VB.NET per quasi un decennio, da prima della versione ufficiale di .NET fino a qualche anno fa, e non ho assolutamente idea di cosa a = bfaccia Option Strict Off. Fa una sorta di confronto sull'uguaglianza, ma cosa succede esattamente e perché, nessuna idea. dynamicTuttavia, è più complesso della funzionalità di C # (perché si basa su un'API ben documentata). Ecco cosa dice MSDN:

Poiché Option Strict Onfornisce una digitazione forte , impedisce conversioni di tipo non intenzionali con perdita di dati, non consente l'associazione tardiva e migliora le prestazioni, è fortemente consigliato l'utilizzo.

²⁾ Jon ha menzionato un'eccezione, le stringhe, in cui il confronto di uguaglianza fa alcune cose in più per ragioni di retrocompatibilità.

Le istanze dell'oggetto non vengono confrontate con l'operatore "==". Dovresti usare il metodo "uguale a". Con "==" l'operatore confronta i riferimenti, non gli oggetti.

Prova questo:

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");
}

risultati:

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

Ora prova questo:

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");
}

risultati:

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

Il problema è che l'operatore == in C # è una chiamata a un metodo statico (beh, forse non tecnicamente, ma può essere considerato come tale) in base al tipo di tempo di compilazione dei due parametri. Non importa quali siano i tipi di runtime effettivi di tali oggetti.

In base a quel tipo di tempo di compilazione, il compilatore determinerà quale implementazione operator ==utilizzare. Potrebbe utilizzare l' objectimplementazione predefinita , potrebbe utilizzare uno dei sovraccarichi numerici forniti dalla lingua o potrebbe essere un'implementazione definita dall'utente.

Ciò è diverso da VB in quanto VB non determina l'implementazione in fase di compilazione. Attende fino al runtime e ispeziona i due parametri forniti per determinare quale implementazione ==dell'operatore deve utilizzare.

Il codice contiene valori booleani, ma si trovano in variabili di tipo object. Poiché la variabile è di tipo object, il compilatore C # utilizza l' objectimplementazione di ==, che confronta i riferimenti , non le istanze dell'oggetto. Poiché i valori booleani sono caselle, non hanno lo stesso riferimento, anche se i loro valori sono gli stessi.

Il codice VB non si preoccupa del tipo di variabile. Aspetta fino al runtime e quindi controlla le due variabili, vede che sono effettivamente entrambi di tipo booleano e quindi utilizza l' ==implementazione dell'operatore booleano . Tale implementazione confronta i valori dei booleani, non i loro riferimenti (e i booleani verranno decompressi prima di chiamare l'operatore, quindi un confronto di riferimento non ha più senso). Poiché i valori dei booleani sono gli stessi, restituisce true.