Що ви можете зробити в MSIL, чого не можете зробити в C # або VB.NET? [зачинено]

Весь код, написаний мовами .NET, компілюється в MSIL, але чи існують конкретні завдання / операції, які ви можете виконувати лише безпосередньо за допомогою MSIL?

Дозвольте нам також зробити легше в MSIL, ніж C #, VB.NET, F #, j # або будь-якій іншій мові .NET.

Поки що ми маємо це:

1. Рекурсія хвоста
2. Generic Co / суперечності
3. Перевантаження, які відрізняються лише типом повернення
4. Заміна модифікаторів доступу
5. Майте клас, який не може успадкувати System.Object
6. Відфільтровані винятки (можна зробити на vb.net)
7. Виклик віртуального методу поточного типу статичного класу.
8. Отримайте ручку на коробці у версії типу значення.
9. Зробіть спробу / помилку.
10. Використання заборонених імен.
11. Визначте власні конструктори без параметрів для типів значень .
12. Визначте події за допомогою raiseелемента.
13. Деякі конверсії, дозволені CLR, але не C #.
14. Зробіть не main()метод як .entrypoint.
15. працювати безпосередньо з рідним intта рідним unsigned intтипами.
16. Грайте з перехідними покажчиками
17. директива випромінювання в MethodBodyItem
18. Киньте і ловіть не типи System.Exception
19. Спадкові перерахунки (неперевірені)
20. Ви можете трактувати масив байтів як (на 4 рази менший) масив вкладень.
21. Ви можете мати поле / метод / властивість / подія, всі мають однакове ім’я (Неперевірене).
22. Ви можете відключитися на спробу блоку з власного блоку лову.
23. Ви маєте доступ до специфікатора доступу famandassem ( protected internalє fam або assem)
24. Прямий доступ до <Module>класу для визначення глобальних функцій або ініціалізатор модуля.

MSIL дозволяє виконувати перевантаження, які відрізняються лише типом повернення через

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

або

callvirt int32 ...

Більшість мов .Net, включаючи C # і VB, не використовують функцію хвостової рекурсії MSIL-коду.

Рекурсія хвоста - це оптимізація, яка є загальною для функціональних мов. Це відбувається, коли метод A закінчується поверненням значення методу B таким чином, що стек методу A може бути розміщений після виклику методу B.

MSIL-код чітко підтримує рекурсію хвоста, і для деяких алгоритмів це може бути важливою оптимізацією. Але оскільки C # і VB не генерують інструкцій для цього, це потрібно зробити вручну (або за допомогою F # або іншої мови).

Ось приклад того, як хвостова рекурсія може бути реалізована вручну в C #:

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

Звичайна практика видалення рекурсії шляхом переміщення локальних даних із апаратного стеку на структуру даних, виділених нагромадженням. У разі усунення рекурсійного виклику, як показано вище, стек видаляється повністю, що є досить хорошою оптимізацією. Крім того, значення повернення не повинно проходити по довгому ланцюгу викликів, але воно повертається безпосередньо.

Але, як би там не було, CIL надає цю функцію як частину мови, але за допомогою C # або VB її потрібно реалізувати вручну. (Джиттер також вільний зробити цю оптимізацію самостійно, але це зовсім інше питання.)

У MSIL ви можете мати клас, який не може успадкувати System.Object.

Приклад коду: компілюйте його за допомогою ilasm.exe ОНОВЛЕННЯ: Ви повинні використовувати "/ NOAUTOINHERIT", щоб запобігти автоматичному успадкуванню асемблера.

// 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

Можна комбінувати модифікатори protectedта internalотримати доступ до них. У C #, якщо ви пишете, protected internalчлен доступний із складання та з похідних класів. Via MSIL ви можете отримати елемент , який доступний з похідних класів в збірці тільки . (Я думаю, що це може бути дуже корисно!)

О, я цього часу не помітив. (Якщо ви додасте тег jon-skeet, це швидше, але я не перевіряю це так часто.)

Схоже, ви вже отримали досить хороші відповіді. В додаток:

• Ви не можете отримати ручку для коробкової версії типу значення у C #. Ви можете в C ++ / CLI
• Ви не можете зробити спробу / помилку в C # ("помилка" - це як "зловити все і знову в кінці блоку" або "нарешті, але тільки на помилку")
• Є безліч імен, заборонених C #, але легальними IL
• IL дозволяє визначити власні конструктори без параметрів для типів значень .
• Ви не можете визначити події за допомогою елемента "підвищення" в C #. (У VB ви повинні робити власні події, але події "за замовчуванням" не містять жодної.)
• Деякі перетворення дозволені CLR, але не C #. Якщо ви перейдете через objectC #, вони іноді спрацюють. Для прикладу див. Запитання uint [] / int [] SO .

Я додам до цього, якщо думаю про щось інше ...

CLR вже підтримує спільне / протиріччя, але C # не отримує цю функцію до 4.0

• C # 4.0 Особливості
• Co / протиріччя

В IL ви можете кидати та ловити будь-який тип взагалі, а не лише типи, що походять від них System.Exception.

IL має відмінність між викликами віртуальних методів callта callvirtдля них. Використовуючи перший, ви можете змусити викликати віртуальний метод поточного типу статичного класу замість віртуальної функції в динамічному типі класу.

У C # немає способу зробити це:

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

VB, як і IL, може видавати невірусні дзвінки, використовуючи MyClass.Method()синтаксис. У вищесказаному це було б MyClass.ToString().

У режимі спробу / лову ви можете повторно ввести блок спробу з власного блоку лову. Отже, ви можете це зробити:

.try {
    // ...

  MidTry:
    // ...

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

RestOfMethod:
    // ...

AFAIK, ви не можете цього зробити в C # або VB

За допомогою IL та VB.NET ви можете додавати фільтри під час лову винятків, але C # v3 не підтримує цю функцію.

Цей приклад VB.NET взято з http://blogs.msdn.com/clrteam/archive/2009/02/05/catch-rethrow-and-filters-why-you-should-care.aspx (зверніть увагу When ShouldCatch(ex) = Trueна Застереження про лов):

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

Наскільки я знаю, немає можливості зробити ініціалізатори модулів (статичні конструктори для всього модуля) безпосередньо в C #:

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

Native types
Ви можете працювати безпосередньо з нативними int та нативними типами неподписаних int безпосередньо (у c # ви можете працювати лише над IntPtr, який не є однаковим.

Transient Pointers
Ви можете грати з перехідними покажчиками, які є вказівниками на керовані типи, але гарантовано не рухаються в пам'яті, оскільки вони не знаходяться в керованій купі. Не зовсім впевнений, як ви могли б корисно використовувати це, не возившись з некерованим кодом, але це не піддається впливу інших мов безпосередньо через речі, такі як stackalloc.

<Module>
ви можете зіткнутися з класом, якщо цього хочете (ви можете зробити це за допомогою роздумів, не потребуючи IL)

.emitbyte

15.4.1.1 Директива .emitbyte MethodBodyItem :: =… | .emitbyte Int32 Ця директива спричиняє непідписане 8-бітове значення, яке випромінюється безпосередньо в потік CIL методу, в точці, в якій з'являється директива. [Примітка. Директива .emitbyte використовується для генерації тестів. Це не потрібно при генерації регулярних програм. кінцева примітка]

.entrypoint
Ви маєте трохи більшу гнучкість щодо цього, ви можете застосувати його до методів, які не називаються, наприклад, Main.

прочитайте специфікацію. Я впевнений, що ви знайдете ще кілька.

Ви можете зламати метод переосмислення ко / контра-дисперсії, що C # не дозволяє (це НЕ те саме, що загальна дисперсія!). Я отримав більше інформації про реалізацію цього тут , а також частини 1 і 2

Я думаю, що той, кого я бажав (з цілком неправильних причин), був спадщиною в «Енумс». Здається, це не складно зробити в SMIL (оскільки Enums - це просто класи), але це не те, що синтаксис C # хоче, щоб ти робив.

Ось ще кілька:

1. Ви можете мати додаткові методи екземплярів у делегатах.
2. Делегати можуть реалізовувати інтерфейси.
3. Ви можете мати статичних членів у делегатах та інтерфейсах.

20) Ви можете трактувати масив байтів як (на 4 рази менший) масив внів.

Нещодавно я використав це для швидкої реалізації XOR, оскільки функція xr CLR працює на ints, і мені потрібно було зробити XOR у потоці байтів.

Отриманий код вимірюється на ~ 10x швидше, ніж еквівалент, виконаний в C # (роблячи XOR на кожен байт).

===

У мене не вистачає stackoverflow street kredz, щоб відредагувати питання та додати це до списку як №20, якщо хтось інший міг би це розбухнути ;-)

Щось використовує обфускатор - у вас може бути поле / метод / властивість / подія, всі мають однакову назву.

Успадкування Enum насправді неможливо:

Ви можете успадкувати з класу Enum. Але результат не так поводиться, як Енум. Він поводиться навіть не як тип значення, а як звичайний клас. Дивна річ: IsEnum: True, IsValueType: True, IsClass: False

Але це не особливо корисно (якщо ви не хочете заплутати людину чи сам час виконання).

Ви також можете отримати клас від делегата System.Multicast в IL, але ви не можете цього зробити в C #:

// Наступне визначення класу є незаконним:

публічний клас YourCustomDelegate: MulticastDelegate {}

Ви також можете визначити методи на рівні модуля (він же глобальний) в IL, а C #, навпаки, дозволяє лише визначати методи, якщо вони прикріплені принаймні до одного типу.