Warum kann C # zwei Objekttypen nicht miteinander vergleichen, VB jedoch nicht?

Ich habe zwei Objekte in C # und weiß nicht, ob es sich um einen Booleschen oder einen anderen Typ handelt. Wenn ich jedoch versuche, diese C # zu vergleichen, kann ich nicht die richtige Antwort geben. Ich habe den gleichen Code mit VB.NET ausprobiert und das hat es geschafft!

Kann mir jemand sagen, wie ich das beheben kann, wenn es eine Lösung gibt?

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 # führt der ==Operator (wenn er auf Referenztypausdrücke angewendet wird) eine Referenzgleichheitsprüfung durch, sofern diese nicht überladen ist . Sie vergleichen zwei Referenzen, die das Ergebnis von Box-Conversions sind. Dies sind also unterschiedliche Referenzen.

BEARBEITEN: Bei Typen, die das überladen ==, können Sie ein anderes Verhalten erzielen - dies basiert jedoch auf dem Typ der Ausdrücke zur Kompilierungszeit . Zum Beispiel stringbietet ==(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

Hier verwendet der erste Vergleich den überladenen Operator, der zweite den "Standard" -Referenzvergleich.

In VB =erledigt der Bediener viel mehr Arbeit - dies ist nicht einmal gleichbedeutend mit der Verwendung object.Equals(x, y), da Dinge wie der Option CompareVergleich von Text Einfluss haben können.

Im Grunde die Betreiber nicht funktionieren auf die gleiche Weise und sind nicht beabsichtigt , auf die gleiche Weise.

Zusätzlich zu Jons Antwort, die die C # -Seite der Dinge erklärt, macht VB Folgendes:

In VB mit prüft Option Strict Onein Vergleich über = immer auf Wertgleichheit und niemals auf Referenzgleichheit. Tatsächlich wird Ihr Code nach dem Wechsel nicht einmal kompiliert, Option Strict Onda er System.Objectkeinen definiert Operator=. Sie sollten diese Option immer aktiviert haben, da sie Fehler effektiver abfängt als eine Venusfliegenfalle (obwohl in Ihrem speziellen Fall dieses nachlässige Verhalten tatsächlich das Richtige tut). ¹

Tatsächlich Option Strict Onverhält sich VB mit noch strenger als C #: In C # wird a == b entweder ein Aufruf von ausgelöst SomeType.operator==(a, b)oder, falls dies nicht vorhanden ist, ein Vergleich der Referenzgleichheit aufgerufen (was dem Aufruf entspricht object.ReferenceEquals(a, b)).

In VB hingegen ruft der Vergleich a = b immer den Gleichheitsoperator auf. ² Wenn Sie den Referenzgleichheitsvergleich verwenden möchten, müssen Sie verwenden a Is b(was wiederum dasselbe ist wie Object.ReferenceEquals(a, b)).

¹⁾ Hier ist ein guter Hinweis darauf, warum die Verwendung Option Strict Offeine schlechte Idee ist: Ich habe VB.NET fast ein Jahrzehnt lang verwendet, von vor der offiziellen Veröffentlichung von .NET bis vor einigen Jahren, und ich habe absolut keine Ahnung, was damit zu a = btun ist Option Strict Off. Es macht eine Art Gleichheitsvergleich, aber was genau passiert und warum, keine Ahnung. Es ist jedoch komplexer als die Funktion von C # dynamic(da dies auf einer gut dokumentierten API beruht). Folgendes sagt der MSDN:

Da Option Strict Oneine starke Typisierung möglich ist , unbeabsichtigte Typkonvertierungen mit Datenverlust verhindert werden, eine späte Bindung nicht möglich ist und die Leistung verbessert wird, wird die Verwendung dringend empfohlen.

²⁾ Jon hat eine Ausnahme erwähnt, Strings, bei denen der Gleichheitsvergleich aus Gründen der Abwärtskompatibilität einige weitere Dinge bewirkt.

Objektinstanzen werden nicht mit dem Operator "==" verglichen. Sie sollten die Methode "equals" verwenden. Mit dem Operator "==" werden Referenzen verglichen, keine Objekte.

Versuche dies:

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

Ergebnisse:

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

Versuchen Sie Folgendes:

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

Ergebnisse:

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

Das Problem ist, dass der Operator == in C # ein Aufruf einer statischen Methode ist (naja, vielleicht nicht technisch, aber es kann auch so sein), basierend auf dem Typ der Kompilierungszeit der beiden Parameter. Was die tatsächlichen Laufzeitarten dieser Objekte sind, spielt keine Rolle.

Basierend auf diesem Kompilierungszeittyp bestimmt der Compiler, welche Implementierung operator ==verwendet werden soll. Es kann die Standardimplementierung verwenden object, es kann eine der numerischen Überladungen verwenden, die von der Sprache bereitgestellt werden, oder es kann eine benutzerdefinierte Implementierung sein.

Dies unterscheidet sich von VB darin, dass VB die Implementierung zur Kompilierungszeit nicht bestimmt. Es wartet bis zur Laufzeit und überprüft die beiden angegebenen Parameter, um festzustellen, welche Implementierung des ==Operators verwendet werden soll.

Ihr Code enthält boolesche Werte, diese befinden sich jedoch in Variablen vom Typ object. Da die Variable vom Typ ist object, verwendet der C # -Compiler die objectImplementierung von ==, die die Referenzen vergleicht , nicht die Objektinstanzen. Da es sich bei den Booleschen Werten um Kästchen handelt, haben sie nicht dieselbe Referenz, obwohl ihre Werte identisch sind.

Dem VB-Code ist es egal, welcher Typ die Variable ist. Es wartet bis zur Laufzeit und überprüft dann die beiden Variablen, um festzustellen, ob sie es sind tatsächlich vom Typ Boolean sind, und verwendet daher die ==Implementierung des Booleschen Operators. Diese Implementierung vergleicht die Werte der Booleschen Werte und nicht ihre Referenzen (und die Booleschen Werte werden vor dem Aufruf dieses Operators entpackt, sodass ein Referenzvergleich nicht einmal mehr Sinn macht). Da die Werte der Booleschen Werte identisch sind, wird true zurückgegeben.