Definisi operator "==" untuk Double

Untuk beberapa alasan saya menyelinap ke sumber .NET Framework untuk kelas Doubledan menemukan bahwa deklarasi ==adalah:

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

Logika yang sama berlaku untuk setiap operator.

• Apa gunanya definisi seperti itu?
• Bagaimana cara kerjanya?
• Mengapa itu tidak menciptakan rekursi yang tak terbatas?

Pada kenyataannya, kompiler akan mengubah ==operator menjadi ceqkode IL, dan operator yang Anda sebutkan tidak akan dipanggil.

Alasan untuk operator dalam kode sumber kemungkinan sehingga dapat dipanggil dari bahasa selain C # yang tidak menerjemahkannya menjadi CEQpanggilan langsung (atau melalui refleksi). Kode dalam operator akan dikompilasi menjadi a CEQ, sehingga tidak ada rekursi yang tak terbatas.

Bahkan, jika Anda memanggil operator melalui refleksi, Anda dapat melihat bahwa operator dipanggil (bukan CEQinstruksi), dan jelas tidak rekursif tanpa batas (karena program berakhir seperti yang diharapkan):

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

IL yang dihasilkan (dikompilasi oleh 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 

Menariknya - operator yang sama TIDAK ada (baik dalam sumber referensi atau melalui refleksi) untuk jenis yang tidak terpisahkan, hanya Single, Double, Decimal, String, dan DateTime, yang menyangkal teori saya bahwa mereka ada untuk dipanggil dari bahasa lain. Jelas Anda dapat menyamakan dua bilangan bulat dalam bahasa lain tanpa operator ini, jadi kami kembali ke pertanyaan "mengapa mereka ada untuk double"?

Kebingungan utama di sini adalah Anda berasumsi bahwa semua .NET libraries (dalam hal ini, Extended Numerics Library, yang bukan merupakan bagian dari BCL) ditulis dalam standar C #. Ini tidak selalu terjadi, dan berbagai bahasa memiliki aturan yang berbeda.

Dalam standar C #, potongan kode yang Anda lihat akan menghasilkan stack overflow, karena cara kerja resolusi kelebihan operator. Namun, kode tersebut sebenarnya tidak dalam standar C # - pada dasarnya menggunakan fitur tidak terdaftar dari kompiler C #. Alih-alih memanggil operator, ia memancarkan kode ini:

ldarg.0
ldarg.1
ceq
ret

Itu saja :) Tidak ada 100% kode C # yang setara - ini tidak mungkin dilakukan dalam C # dengan tipe Anda sendiri .

Bahkan kemudian, operator yang sebenarnya tidak digunakan ketika mengkompilasi kode C # - kompiler melakukan banyak optimasi, seperti dalam kasus ini, di mana ia menggantikan op_Equalitypanggilan hanya dengan sederhana ceq. Sekali lagi, Anda tidak dapat meniru ini di DoubleExstruct Anda sendiri - itu adalah kompiler ajaib.

Ini tentu saja bukan situasi yang unik di .NET - ada banyak kode yang tidak valid, standar C #. Alasannya biasanya (a) hack kompiler dan (b) bahasa yang berbeda, dengan hack runtime aneh (c) (Saya sedang melihat Anda Nullable,!).

Karena kompiler Roslyn C # adalah sumber oepn, saya benar-benar dapat mengarahkan Anda ke tempat resolusi overload ditentukan:

Tempat di mana semua operator biner diselesaikan

"Pintasan" untuk operator intrinsik

Ketika Anda melihat pintasan, Anda akan melihat bahwa kesetaraan antara hasil ganda dan ganda di operator ganda intrinsik, tidak pernah di ==operator yang sebenarnya ditentukan pada jenis. Sistem tipe .NET harus berpura-pura bahwa itu Doubleadalah tipe seperti yang lain, tetapi C # tidak - doubleadalah primitif dalam C #.

Sumber tipe primitif bisa membingungkan. Pernahkah Anda melihat baris pertama dari Doublestruct?

Biasanya Anda tidak dapat mendefinisikan struct rekursif seperti ini:

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

Tipe primitif memiliki dukungan asli mereka di CIL juga. Biasanya mereka tidak diperlakukan seperti tipe berorientasi objek. Double adalah nilai 64-bit jika digunakan seperti float64pada CIL. Namun, jika ditangani sebagai tipe .NET biasa, ini berisi nilai aktual dan berisi metode seperti jenis lainnya.

Jadi yang Anda lihat di sini adalah situasi yang sama untuk operator. Biasanya jika Anda menggunakan tipe tipe ganda secara langsung, itu tidak akan pernah dipanggil. BTW, sumbernya terlihat seperti ini di CIL:

.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
}

Seperti yang Anda lihat, tidak ada loop tanpa akhir ( ceqinstrumen digunakan alih-alih memanggil System.Double::op_Equality). Jadi ketika ganda diperlakukan seperti objek, metode operator akan dipanggil, yang pada akhirnya akan menanganinya sebagai float64tipe primitif pada level CIL.

Saya melihat CIL dengan JustDecompile. Bagian dalam ==akan diterjemahkan ke kode ce ce CIL . Dengan kata lain, ini adalah persamaan CLR primitif.

Saya ingin tahu apakah kompiler C # akan referensi ceqatau ==operator ketika membandingkan dua nilai ganda. Dalam contoh sepele saya datang dengan (di bawah), itu digunakan ceq.

Program ini:

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

menghasilkan CIL berikut (perhatikan pernyataan dengan 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

Seperti yang ditunjukkan dalam dokumentasi Microsoft untuk System.Runtime.Versioning Namespace: Jenis yang ditemukan di namespace ini dimaksudkan untuk digunakan dalam .NET Framework dan bukan untuk aplikasi pengguna. System.Runtime.Nersioning namespace berisi tipe canggih yang mendukung versi di implementasi berdampingan dari .NET Framework.