Double için "==" operatörünün tanımı

Bazı nedenlerden dolayı sınıf için .NET Framework kaynağına gizlice giriyordum Doubleve beyanının şöyle olduğunu öğrendim ==:

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

Aynı mantık her operatör için geçerlidir .

• Böyle bir tanımın amacı nedir?
• O nasıl çalışır?
• Neden sonsuz bir özyineleme yaratmıyor?

Gerçekte, derleyici ==operatörü bir ceqIL koduna çevirecek ve bahsettiğiniz operatör çağrılmayacaktır.

Operatörün kaynak kodundaki nedeni büyük olasılıkla, C # dışındaki dillerden, onu CEQdoğrudan bir çağrıya (veya yansıtma yoluyla) çevirmeyen dillerden çağrılabilir . Kod içinde operatör olacak bir şekilde toplanabilir, CEQböylece sonsuz Yinelemesiz yoktur.

Aslında, operatörü yansıtma yoluyla çağırırsanız, operatörün çağrıldığını (bir CEQtalimat yerine ) ve açıkça sonsuz özyinelemeli olmadığını görebilirsiniz (çünkü program beklendiği gibi sona erer):

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

Ortaya çıkan IL (LinqPad 4 tarafından derlenmiştir):

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 

İlginçtir - Aynı operatörleri ayrılmaz türleri için (her iki yansıma referans kaynağı veya üzeri) mevcut OLMAYAN, sadece Single, Double, Decimal, String, ve DateTimebunlar diğer dillerden çağrılacak var olduğunu benim tezini çürütüyor hangi. Açıkçası, bu operatörler olmadan diğer dillerde iki tamsayıyı eşitleyebilirsiniz, bu yüzden "neden varlar" sorusuna geri dönüyoruz double?

Buradaki ana kafa karışıklığı, tüm .NET kitaplıklarının (bu durumda, BCL'nin bir parçası olmayan Genişletilmiş Sayısal Kitaplığı ) standart C # ile yazıldığını varsaymanızdır . Bu her zaman böyle değildir ve farklı dillerin farklı kuralları vardır.

Standart C # 'da, gördüğünüz kod parçası, operatör aşırı yük çözümünün çalışma şekli nedeniyle yığın taşmasına neden olur. Bununla birlikte, kod aslında standart C #'da değildir - temelde C # derleyicisinin belgelenmemiş özelliklerini kullanır. Operatörü aramak yerine şu kodu verir:

ldarg.0
ldarg.1
ceq
ret

İşte bu :)% 100 eşdeğer bir C # kodu yoktur - bu kendi türünüzle C #'da mümkün değildir .

O zaman bile, C # kodunu derlerken gerçek operatör kullanılmaz - derleyici, bu durumda olduğu gibi, op_Equalityaramayı sadece basit olanla değiştirdiği bir dizi optimizasyon yapar ceq. Yine, bunu kendi DoubleExyapınızda kopyalayamazsınız - bu derleyici sihridir.

Bu kesinlikle .NET'te benzersiz bir durum değildir - geçerli olmayan birçok kod vardır, standart C #. Sebepler genellikle (a) derleyici hackleri ve (b) tuhaf (c) çalışma zamanı hackleriyle farklı bir dildir (sana bakıyorum Nullable!).

Roslyn C # derleyicisi oepn kaynağı olduğundan, aslında sizi aşırı yük çözümünün kararlaştırıldığı yere yönlendirebilirim:

Tüm ikili operatörlerin çözümlendiği yer

İç operatörler için "kısayollar"

Kısayollara baktığınızda, çift ve çift arasındaki eşitliğin içsel çift operatörde olduğunu, asla== tipte tanımlanan gerçek operatörde olmadığını göreceksiniz . .NET türü sistem, bunun Doublediğerleri gibi bir tür olduğunu varsaymak zorundadır , ancak C # yoktur - doubleC # 'da ilkeldir.

İlkel türlerin kaynağı kafa karıştırıcı olabilir. Yapının ilk satırını gördünüz mü Double?

Normalde şöyle bir özyinelemeli yapı tanımlayamazsınız:

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

İlkel türlerin CIL'de de yerel desteği vardır. Normalde nesne yönelimli türler gibi ele alınmazlar. Bir double, float64CIL'deki gibi kullanılırsa sadece 64 bitlik bir değerdir . Ancak, normal bir .NET türü olarak ele alınırsa, gerçek bir değer içerir ve diğer türler gibi yöntemler içerir.

Yani burada gördüğünüz şey operatörler için aynı durum. Normalde, doğrudan çift türü kullanırsanız, asla çağrılmaz. BTW, kaynağı CIL'de şöyle görünür:

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

Gördüğünüz gibi sonsuz döngü yok ( ceqenstrüman çağırmak yerine kullanılır System.Double::op_Equality). Bu nedenle, bir double bir nesne gibi ele alındığında, operatör yöntemi çağrılacak ve bu da sonunda onu float64CIL düzeyinde ilkel tür olarak ele alacaktır .

Ben bir göz attım CIL JustDecompile ile. İç kısım ==CIL ceq işlem koduna çevrilir . Başka bir deyişle, ilkel CLR eşitliği.

İki çift değeri karşılaştırırken C # derleyicisinin ceqmi yoksa ==operatöre mi başvuracağını merak ediyordum . Bulduğum önemsiz örnekte (aşağıda), kullanıldı ceq.

Bu program:

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

aşağıdaki CIL'yi oluşturur (etiketli ifadeye dikkat edin 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

System.Runtime.Versioning Ad Alanı için Microsoft belgelerinde belirtildiği gibi: Bu ad alanında bulunan türlerin kullanıcı uygulamaları için değil, .NET Framework içinde kullanılması amaçlanmıştır. System.Runtime.Versioning ad alanı, sürüm oluşturmayı destekleyen gelişmiş türleri içerir. .NET Framework'ün yan yana uygulamaları.