MSIL'de C # veya VB.NET'te yapamayacağınız şeyler nelerdir? [kapalı]

.NET dillerinde yazılmış tüm kodlar MSIL için derlenir, ancak yalnızca doğrudan MSIL kullanarak yapabileceğiniz belirli görevler / işlemler var mı?

MSIL'de C #, VB.NET, F #, j # veya başka herhangi bir .NET dilinden daha kolay iş yapalım.

Şimdiye kadar buna sahibiz:

1. Kuyruk özyineleme
2. Genel Ortak / Çelişki
3. Sadece dönüş tiplerinde farklılık gösteren aşırı yükler
4. Erişim değiştiricileri geçersiz kıl
5. System.Object öğesinden devralınamayan bir sınıfa sahip olun
6. Filtrelenmiş istisnalar (vb.net adresinde yapılabilir)
7. Geçerli statik sınıf türünde sanal bir yöntem çağırma.
8. Bir değer türünün kutulu sürümünde bir tanıtıcı alın.
9. Bir deneme / hata yapın.
10. Yasak isimlerin kullanımı.
11. Değer türleri için kendi parametresiz kurucularınızı tanımlayın .
12. Bir raiseöğeyle olayları tanımlayın .
13. CLR tarafından izin verilen ancak C # tarafından izin verilmeyen bazı dönüşümler.
14. Olarak main()yöntem olmayan bir yöntem oluşturun .entrypoint.
15. doğrudan yerel intve yerel unsigned inttürlerle çalışın .
16. Geçici işaretçilerle oynayın
17. MethodBodyItem içindeki emitbyte yönergesi
18. System.Exception dışı türleri atın ve yakalayın
19. Numaralandırmayı Devral (Doğrulanmamış)
20. Bir bayt dizisini (4x daha küçük) bir ints dizisi olarak değerlendirebilirsiniz.
21. Alan / yöntem / özellik / etkinliğin tümü aynı ada sahip olabilir (Doğrulanmamış).
22. Kendi catch bloğundan bir try bloğuna geri dönebilirsiniz.
23. Famandassem erişim belirleyicisine erişiminiz var ( protected internalfam veya assem)
24. Genel <Module>fonksiyonları tanımlamak için sınıfa veya modül başlatıcısına doğrudan erişim .

MSIL, yalnızca dönüş tiplerinde farklılık gösteren aşırı yüklere izin verir.

call void [mscorlib]System.Console::Write(string)

veya

callvirt int32 ...

C # ve VB dahil olmak üzere çoğu .Net dili MSIL kodunun kuyruk özyineleme özelliğini kullanmaz.

Kuyruk özyineleme fonksiyonel dillerde yaygın olan bir optimizasyondur. A yöntemi, B yönteminin çağrısı yapıldıktan sonra A yönteminin yığınının yeniden yerleştirilebileceği şekilde B yönteminin değerini döndürerek sona erdiğinde ortaya çıkar.

MSIL kodu kuyruk özyinelemesini açıkça destekler ve bazı algoritmalar için bu önemli bir optimizasyon olabilir. Ancak C # ve VB bunu yapmak için yönergeler oluşturmadığından, manuel olarak (veya F # veya başka bir dil kullanılarak) yapılmalıdır.

İşte kuyruk özyineleme C # el ile nasıl uygulanabilir bir örnek:

private static int RecursiveMethod(int myParameter)
{
    // Body of recursive method
    if (BaseCase(details))
        return result;
    // ...

    return RecursiveMethod(modifiedParameter);
}

// Is transformed into:

private static int RecursiveMethod(int myParameter)
{
    while (true)
    {
        // Body of recursive method
        if (BaseCase(details))
            return result;
        // ...

        myParameter = modifiedParameter;
    }
}

Yerel verileri donanım yığından bir yığınla ayrılmış yığın veri yapısına taşıyarak özyinelemeyi kaldırmak yaygın bir uygulamadır. Yukarıda gösterildiği gibi kuyruk çağrısı özyineleme eliminasyonunda, yığın tamamen ortadan kaldırılır, bu da oldukça iyi bir optimizasyondur. Ayrıca, dönüş değerinin uzun bir çağrı zincirinde yürümesi gerekmez, ancak doğrudan döndürülür.

Ancak, yine de, CIL bu özelliği dilin bir parçası olarak sağlar, ancak C # veya VB ile manuel olarak uygulanması gerekir. (Titreşim de bu optimizasyonu kendi başına yapmakta özgürdür, ancak bu başka bir konudur.)

MSIL'de System.Object öğesinden devralınamayan bir sınıfınız olabilir.

Örnek kod: ilasm.exe ile derleyin GÜNCELLEME: Montajcının otomatik devralmasını önlemek için "/ NOAUTOINHERIT" kullanmalısınız.

// Metadata version: v2.0.50215
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .ver 2:0:0:0
}
.assembly sample
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) 
  .hash algorithm 0x00008004
  .ver 0:0:0:0
}
.module sample.exe
// MVID: {A224F460-A049-4A03-9E71-80A36DBBBCD3}
.imagebase 0x00400000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003       // WINDOWS_CUI
.corflags 0x00000001    //  ILONLY
// Image base: 0x02F20000


// =============== CLASS MEMBERS DECLARATION ===================

.class public auto ansi beforefieldinit Hello
{
  .method public hidebysig static void  Main(string[] args) cil managed
  {
    .entrypoint
    // Code size       13 (0xd)
    .maxstack  8
    IL_0000:  nop
    IL_0001:  ldstr      "Hello World!"
    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
    IL_000b:  nop
    IL_000c:  ret
  } // end of method Hello::Main
} // end of class Hello

Bu birleştirmek mümkün protectedve internalerişim değiştiricileri. C # 'da yazarsanız protected internalderlemeden ve türetilmiş sınıflardan erişilebilir. MSIL ile yalnızca derleme içinde türetilmiş sınıflardan erişilebilen bir üye alabilirsiniz . (Bence bu oldukça faydalı olabilir!)

Ooh, o zaman bunu fark etmedim. (Jon-skeet etiketini eklerseniz, bu daha olasıdır, ancak sık sık kontrol etmiyorum.)

Görünüşe göre çok iyi cevaplarınız var. Ek olarak:

• C # 'daki bir değer türünün kutulu sürümünde tanıtıcı alamazsınız. C ++ / CLI içinde yapabilirsiniz
• C # bir deneme / hata yapamazsınız ("hata" bir "her şeyi yakalamak ve blok sonunda tekrar" veya "sonunda ama sadece başarısızlık" gibi)
• C # ama yasal IL tarafından yasaklanan birçok isim var
• IL, değer türleri için kendi parametresiz kurucularınızı tanımlamanızı sağlar .
• C # 'da "yükselt" öğesiyle olayları tanımlayamazsınız. (VB sen var özel etkinlikler için , ancak "varsayılan" etkinlikler bir tane içermez.)
• Bazı dönüşümlere CLR tarafından izin verilir, ancak C # tarafından izin verilmez. objectC # ile geçerseniz , bunlar bazen işe yarayacaktır. Bir bakınız uint [] / int [] SO soru bir örnek için.

Başka bir şey düşünürsem buna ekleyeceğim ...

CLR zaten genel eş / karşıtlığı destekliyor, ancak C # 4.0'a kadar bu özelliği almıyor

• C # 4.0 Özellikleri
• Co / contravariance

IL'de sadece türetilmiş türleri değil, herhangi bir türü atabilir ve yakalayabilirsiniz System.Exception.

IL, sanal yöntem çağrıları arasında callve callvirtsanal yöntem çağrıları arasında ayrım yapar . Birincisini kullanarak geçerli statik sınıf türünün sanal bir yöntemini çağırmayı zorlayabilirsiniz dinamik sınıf türündeki sanal işlev yerine .

C # bunu yapmanın bir yolu yoktur:

abstract class Foo {
    public void F() {
        Console.WriteLine(ToString()); // Always a virtual call!
    }

    public override string ToString() { System.Diagnostics.Debug.Assert(false); }
};

sealed class Bar : Foo {
    public override string ToString() { return "I'm called!"; }
}

IL gibi VB de MyClass.Method()sözdizimini kullanarak sanal olmayan çağrılar verebilir . Yukarıda, bu olurdu MyClass.ToString().

Bir try / catch'de, try bloğunu kendi catch bloğundan tekrar girebilirsiniz. Yani, bunu yapabilirsiniz:

.try {
    // ...

  MidTry:
    // ...

    leave.s RestOfMethod
}
catch [mscorlib]System.Exception {
    leave.s MidTry  // branching back into try block!
}

RestOfMethod:
    // ...

AFAIK bunu C # veya VB'de yapamazsınız

IL ve VB.NET ile istisnaları yakalarken filtreler ekleyebilirsiniz, ancak C # v3 bu özelliği desteklemez.

Bu VB.NET örneği alınır http://blogs.msdn.com/clrteam/archive/2009/02/05/catch-rethrow-and-filters-why-you-should-care.aspx (not When ShouldCatch(ex) = Trueiçinde Yakalama maddesi):

Try
   Foo()
Catch ex As CustomBaseException When ShouldCatch(ex)
   Console.WriteLine("Caught exception!")
End Try

Bildiğim kadarıyla, doğrudan C # içinde modül başlatıcıları (tüm bir modül için statik yapıcılar) yapmanın bir yolu yoktur:

http://blogs.msdn.com/junfeng/archive/2005/11/19/494914.aspx

Native types
Yerel int ve yerli imzasız int türleriyle doğrudan çalışabilirsiniz (c # 'da yalnızca aynı olmayan bir IntPtr üzerinde çalışabilirsiniz.

Transient Pointers
Yönetilen türlere işaret eden, ancak yönetilen yığında olmadıkları için bellekte hareket etmemeleri garanti edilen geçici işaretçilerle oynayabilirsiniz. Yönetilmeyen kodla uğraşmadan bunu nasıl kullanabileceğinizden tam olarak emin değilim, ancak diğer dillere doğrudan stackalloc gibi şeyler aracılığıyla maruz kalmıyor.

<Module>
Eğer arzu ederseniz sınıfla uğraşabilirsiniz (bunu IL'ye ihtiyaç duymadan yansıma ile yapabilirsiniz)

.emitbyte

15.4.1.1 .emitbyte yönergesi MethodBodyItem :: =… | .emitbyte Int32 Bu yönerge, yönerge göründüğü noktada doğrudan yöntemin CIL akışına işaretsiz bir 8 bit değerinin yayılmasına neden olur. [Not: .emitbyte yönergesi testler oluşturmak için kullanılır. Düzenli programlar üretilmesine gerek yoktur. son not]

.entrypoint
Bu konuda biraz daha esnekliğiniz var, örneğin Ana olarak adlandırılmayan yöntemlere uygulayabilirsiniz.

şartnameyi oku eminim birkaç tane daha bulacaksınız.

C # 'nın izin vermediği co / contra varyans yöntemini geçersiz kılma yöntemini hackleyebilirsiniz (bu, genel varyans ile aynı DEĞİLDİR!). Bunu burada uygulamak hakkında daha fazla bilgiye sahibim ve bölüm 1 ve 2

Bence (tamamen yanlış nedenlerle) dilediğim kişi Enum'da kalıtımdı. SMIL'de yapmak zor bir şey gibi görünmüyor (Enum'lar sadece sınıflar olduğu için), ancak C # sözdiziminin yapmanızı istediği bir şey değil.

İşte biraz daha:

1. Temsilcilerde fazladan örnek yöntemleriniz olabilir.
2. Delegeler arabirimler uygulayabilir.
3. Temsilci ve arabirimlerde statik üyeleriniz olabilir.

20) Bir bayt dizisini (4x daha küçük) bir ints dizisi olarak değerlendirebilirsiniz.

Son zamanlarda hızlı bir XOR uygulaması yapmak için kullandım, çünkü CLR xor işlevi ints üzerinde çalışıyor ve bir bayt akışında XOR yapmam gerekiyordu.

Ortaya çıkan kod, C # 'da yapılan eşdeğerden ~ 10x daha hızlı olarak ölçülmüştür (her baytta XOR yapıyor).

===

Soruyu düzenlemek ve # 20 olarak listeye eklemek için yeterli stackoverflow sokak credzim yok, başka biri olabilirse şişebilir ;-)

Gizleyicilerin kullandığı bir şey - bir alan / yöntem / özellik / etkinlik aynı ada sahip olabilir.

Enum mirası gerçekten mümkün değildir:

Bir Enum sınıfından miras alabilirsiniz. Ancak sonuç özellikle bir Enum gibi davranmaz. Bir değer türü gibi değil, sıradan bir sınıf gibi davranır. Srange şey: IsEnum: True, IsValueType: True, IsClass: False

Ancak bu özellikle yararlı değildir (bir kişiyi veya çalışma zamanının kendisini karıştırmak istemiyorsanız).

IL'de System.Multicast delegesi olan bir sınıf da türetebilirsiniz, ancak bunu C # ile yapamazsınız:

// Aşağıdaki sınıf tanımı yasadışı:

herkese açık sınıf YourCustomDelegate: MulticastDelegate {}

Ayrıca, IL'de modül düzeyinde (küresel olarak da bilinir) yöntemler tanımlayabilirsiniz ve aksine C #, yalnızca en az bir türe bağlı oldukları sürece yöntemleri tanımlamanıza izin verir.