Definition des Operators "==" für Double

Aus irgendeinem Grund habe ich mich in die .NET Framework-Quelle für die Klasse geschlichen Doubleund festgestellt, dass die Deklaration von ==:

public static bool operator ==(Double left, Double right) {
    return left == right;
}

Die gleiche Logik gilt für jeden Bediener.

• Was ist der Sinn einer solchen Definition?
• Wie funktioniert es?
• Warum erzeugt es keine unendliche Rekursion?

In Wirklichkeit verwandelt der Compiler den ==Operator in einen ceqIL-Code, und der von Ihnen erwähnte Operator wird nicht aufgerufen.

Der Grund für den Operator im Quellcode ist wahrscheinlich, dass er aus anderen Sprachen als C # aufgerufen werden kann, die ihn nicht CEQdirekt (oder durch Reflexion) in einen Aufruf übersetzen . Der Code innerhalb des Operators wird zu a kompiliert CEQ, sodass es keine unendliche Rekursion gibt.

Wenn Sie den Operator über Reflection aufrufen, können Sie tatsächlich sehen, dass der Operator aufgerufen wird (und nicht eine CEQAnweisung) und offensichtlich nicht unendlich rekursiv ist (da das Programm wie erwartet beendet wird):

double d1 = 1.1;
double d2 = 2.2;

MethodInfo mi = typeof(Double).GetMethod("op_Equality", BindingFlags.Static | BindingFlags.Public );

bool b = (bool)(mi.Invoke(null, new object[] {d1,d2}));

Resultierende IL (zusammengestellt von LinqPad 4):

IL_0000:  nop         
IL_0001:  ldc.r8      9A 99 99 99 99 99 F1 3F 
IL_000A:  stloc.0     // d1
IL_000B:  ldc.r8      9A 99 99 99 99 99 01 40 
IL_0014:  stloc.1     // d2
IL_0015:  ldtoken     System.Double
IL_001A:  call        System.Type.GetTypeFromHandle
IL_001F:  ldstr       "op_Equality"
IL_0024:  ldc.i4.s    18 
IL_0026:  call        System.Type.GetMethod
IL_002B:  stloc.2     // mi
IL_002C:  ldloc.2     // mi
IL_002D:  ldnull      
IL_002E:  ldc.i4.2    
IL_002F:  newarr      System.Object
IL_0034:  stloc.s     04 // CS$0$0000
IL_0036:  ldloc.s     04 // CS$0$0000
IL_0038:  ldc.i4.0    
IL_0039:  ldloc.0     // d1
IL_003A:  box         System.Double
IL_003F:  stelem.ref  
IL_0040:  ldloc.s     04 // CS$0$0000
IL_0042:  ldc.i4.1    
IL_0043:  ldloc.1     // d2
IL_0044:  box         System.Double
IL_0049:  stelem.ref  
IL_004A:  ldloc.s     04 // CS$0$0000
IL_004C:  callvirt    System.Reflection.MethodBase.Invoke
IL_0051:  unbox.any   System.Boolean
IL_0056:  stloc.3     // b
IL_0057:  ret 

Interessanterweise - die gleichen Betreiber nicht existieren (entweder in der Referenzquelle oder über Reflexion) für integrale Typen, nur Single, Double, Decimal, String, und DateTime, die widerlegt meine Theorie , dass sie aus anderen Sprachen aufgerufen werden , existieren. Natürlich können Sie ohne diese Operatoren zwei Ganzzahlen in anderen Sprachen gleichsetzen. Wir kehren also zu der Frage zurück, warum sie existieren double.

Die Hauptverwirrung besteht darin, dass Sie davon ausgehen, dass alle .NET-Bibliotheken (in diesem Fall die Extended Numerics Library, die nicht Teil der BCL ist) in Standard-C # geschrieben sind. Dies ist nicht immer der Fall und verschiedene Sprachen haben unterschiedliche Regeln.

In Standard-C # würde der angezeigte Code aufgrund der Funktionsweise der Operatorüberlastungsauflösung zu einem Stapelüberlauf führen. Der Code befindet sich jedoch nicht in Standard-C # - er verwendet grundsätzlich undokumentierte Funktionen des C # -Compilers. Anstatt den Operator aufzurufen, wird der folgende Code ausgegeben:

ldarg.0
ldarg.1
ceq
ret

Das war's :) Es gibt keinen 100% äquivalenten C # -Code - dies ist in C # mit Ihrem eigenen Typ einfach nicht möglich .

Selbst dann wird der eigentliche Operator beim Kompilieren von C # -Code nicht verwendet - der Compiler führt eine Reihe von Optimierungen durch, wie in diesem Fall, bei denen der op_EqualityAufruf nur durch den einfachen ersetzt wird ceq. Auch hier können Sie dies nicht in Ihrer eigenen DoubleExStruktur replizieren - es ist Compiler-Magie.

Dies ist sicherlich keine einzigartige Situation in .NET - es gibt viele ungültige Codes, Standard-C #. Die Gründe sind normalerweise (a) Compiler-Hacks und (b) eine andere Sprache mit den ungeraden (c) Laufzeit-Hacks (ich sehe dich an Nullable!).

Da der Roslyn C # -Compiler eine Oepn-Quelle ist, kann ich Sie tatsächlich auf den Ort verweisen, an dem die Überlastungsauflösung entschieden wird:

Der Ort, an dem alle Binäroperatoren aufgelöst werden

Die "Verknüpfungen" für intrinsische Operatoren

Wenn Sie sich die Verknüpfungen ansehen, werden Sie feststellen, dass die Gleichheit zwischen double und double zu dem intrinsischen double-Operator führt, niemals zu dem tatsächlichen ==Operator, der für den Typ definiert ist. Das .NET-Typsystem muss so tun, als wäre Doublees ein Typ wie jeder andere, aber C # nicht - doubleist ein Grundelement in C #.

Die Quelle der primitiven Typen kann verwirrend sein. Hast du die allererste Zeile der DoubleStruktur gesehen?

Normalerweise können Sie eine rekursive Struktur wie folgt nicht definieren:

public struct Double : IComparable, IFormattable, IConvertible
        , IComparable<Double>, IEquatable<Double>
{
    internal double m_value; // Self-recursion with endless loop?
    // ...
}

Primitive Typen haben ihre native Unterstützung auch in CIL. Normalerweise werden sie nicht wie objektorientierte Typen behandelt. Ein Double ist nur ein 64-Bit-Wert, wenn es wie float64in CIL verwendet wird. Wenn es jedoch als normaler .NET-Typ behandelt wird, enthält es einen tatsächlichen Wert und Methoden wie alle anderen Typen.

Was Sie hier sehen, ist die gleiche Situation für die Bediener. Wenn Sie den Typ mit doppeltem Typ direkt verwenden, wird er normalerweise nie aufgerufen. Übrigens sieht die Quelle in CIL folgendermaßen aus:

.method public hidebysig specialname static bool op_Equality(float64 left, float64 right) cil managed
{
    .custom instance void System.Runtime.Versioning.NonVersionableAttribute::.ctor()
    .custom instance void __DynamicallyInvokableAttribute::.ctor()
    .maxstack 8
    L_0000: ldarg.0
    L_0001: ldarg.1
    L_0002: ceq
    L_0004: ret
}

Wie Sie sehen können, gibt es keine Endlosschleife (das ceqInstrument wird verwendet, anstatt das aufzurufen System.Double::op_Equality). Wenn also ein Double wie ein Objekt behandelt wird, wird die Operatormethode aufgerufen, die es schließlich als float64primitiven Typ auf CIL-Ebene behandelt.

Ich habe mir die CIL mit JustDecompile angesehen. Das Innere ==wird in den CIL- Ceq- Op-Code übersetzt. Mit anderen Worten, es ist primitive CLR-Gleichheit.

Ich war gespannt, ob der C # -Compiler darauf verweisen würde ceq== beim Vergleich zweier Doppelwerte auf den Operator . In dem trivialen Beispiel, das ich mir (unten) ausgedacht habe, wurde es verwendet ceq.

Dieses Programm:

void Main()
{
    double x = 1;
    double y = 2;

    if (x == y)
        Console.WriteLine("Something bad happened!");
    else
        Console.WriteLine("All is right with the world");
}

generiert die folgende CIL (beachten Sie die Anweisung mit dem Label IL_0017):

IL_0000:  nop
IL_0001:  ldc.r8      00 00 00 00 00 00 F0 3F
IL_000A:  stloc.0     // x
IL_000B:  ldc.r8      00 00 00 00 00 00 00 40
IL_0014:  stloc.1     // y
IL_0015:  ldloc.0     // x
IL_0016:  ldloc.1     // y
IL_0017:  ceq
IL_0019:  stloc.2
IL_001A:  ldloc.2
IL_001B:  brfalse.s   IL_002A
IL_001D:  ldstr       "Something bad happened!"
IL_0022:  call        System.Console.WriteLine
IL_0027:  nop
IL_0028:  br.s        IL_0035
IL_002A:  ldstr       "All is right with the world"
IL_002F:  call        System.Console.WriteLine
IL_0034:  nop
IL_0035:  ret

Wie in der Microsoft-Dokumentation für den System.Runtime.Versioning-Namespace angegeben: Die in diesem Namespace gefundenen Typen sind für die Verwendung in .NET Framework und nicht für Benutzeranwendungen vorgesehen. Der System.Runtime.Versioning-Namespace enthält erweiterte Typen, die die Versionierung unterstützen Side-by-Side-Implementierungen von .NET Framework.