Co możesz zrobić w MSIL, czego nie możesz zrobić w C # lub VB.NET? [Zamknięte]

Cały kod napisany w językach .NET kompiluje się do MSIL, ale czy istnieją określone zadania / operacje, które można wykonać tylko bezpośrednio przy użyciu MSIL?

Zróbmy też rzeczy łatwiejsze w MSIL niż C #, VB.NET, F #, j # czy jakikolwiek inny język .NET.

Jak dotąd mamy to:

1. Rekursja ogona
2. Ogólna współ / kontrawariancja
3. Przeciążenia, które różnią się tylko typami zwracanymi
4. Zastąp modyfikatory dostępu
5. Mieć klasę, która nie może dziedziczyć po System.Object
6. Filtrowane wyjątki (można to zrobić w vb.net)
7. Wywołanie metody wirtualnej bieżącego typu klasy statycznej.
8. Zapoznaj się z pudełkową wersją typu wartości.
9. Spróbuj / błąd.
10. Używanie zabronionych nazw.
11. Zdefiniuj własne konstruktory bez parametrów dla typów wartości .
12. Zdefiniuj zdarzenia za pomocą raiseelementu.
13. Niektóre konwersje dozwolone przez środowisko CLR, ale nie przez C #.
14. Utwórz main()metodę inną niż .entrypoint.
15. pracować bezpośrednio z typami natywnymi inti natywnymi unsigned int.
16. Graj z przejściowymi wskaźnikami
17. emitbyte w MethodBodyItem
18. Wyrzuć i złap typy inne niż System.Exception
19. Dziedzicz wyliczenia (niezweryfikowane)
20. Tablicę bajtów można traktować jako (4x mniejszą) tablicę liczb całkowitych.
21. Możesz mieć wszystkie pola / metody / właściwości / zdarzenia o tej samej nazwie (niezweryfikowane).
22. Możesz rozgałęzić się z powrotem do bloku try z własnego bloku catch.
23. Masz dostęp do specyfikatora dostępu famandassem ( protected internalto fam lub assem)
24. Bezpośredni dostęp do <Module>klasy w celu zdefiniowania funkcji globalnych lub inicjatora modułu.

MSIL zezwala na przeciążenia, które różnią się tylko typami zwracanymi z powodu

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

lub

callvirt int32 ...

Większość języków .Net, w tym C # i VB, nie korzysta z funkcji rekurencji ogonowej kodu MSIL.

Rekursja ogona to optymalizacja, która jest powszechna w językach funkcjonalnych. Występuje, gdy metoda A kończy się zwracaniem wartości metody B, tak że stos metody A może zostać cofnięty po wywołaniu metody B.

Kod MSIL wyraźnie obsługuje rekurencję ogonową, a dla niektórych algorytmów może to być ważna optymalizacja do wykonania. Ale ponieważ C # i VB nie generują instrukcji, aby to zrobić, należy to zrobić ręcznie (lub za pomocą F # lub innego języka).

Oto przykład, jak rekurencja ogona może być implementowana ręcznie w 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;
    }
}

Powszechną praktyką jest usuwanie rekursji przez przenoszenie danych lokalnych ze stosu sprzętowego do struktury danych stosu z alokacją sterty. W eliminacji rekurencji tail-call, jak pokazano powyżej, stos jest całkowicie eliminowany, co jest całkiem dobrą optymalizacją. Ponadto wartość zwracana nie musi przechodzić przez długi łańcuch wywołań, ale jest zwracana bezpośrednio.

W każdym razie CIL udostępnia tę funkcję jako część języka, ale w przypadku C # lub VB musi być ona zaimplementowana ręcznie. (Jitter może również samodzielnie przeprowadzić tę optymalizację, ale to zupełnie inna kwestia).

W MSIL możesz mieć klasę, która nie może dziedziczyć po System.Object.

Przykładowy kod: skompiluj go za pomocą ilasm.exe AKTUALIZACJA: Musisz użyć "/ NOAUTOINHERIT", aby zapobiec automatycznemu dziedziczeniu asemblera.

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

Możliwe jest łączenie modyfikatorów protectedi internaldostępu. W C #, jeśli napiszesz, protected internalelement członkowski jest dostępny z zestawu iz klas pochodnych. Via MSIL można uzyskać członka, który jest dostępny z klas pochodnych w zespole tylko . (Myślę, że to może być całkiem przydatne!)

Och, wtedy tego nie zauważyłem. (Jeśli dodasz tag jon-skeet, jest to bardziej prawdopodobne, ale nie sprawdzam go tak często).

Wygląda na to, że masz już całkiem dobre odpowiedzi. Dodatkowo:

• Nie można uzyskać dojścia do pudełkowej wersji typu wartości w C #. Możesz w C ++ / CLI
• Nie można wykonać próby / błędu w C # („błąd” to coś w rodzaju „złap wszystko i wyrzuć ponownie na końcu bloku” lub „ostatecznie, ale tylko w przypadku niepowodzenia”)
• Istnieje wiele nazw, które są zabronione przez C #, ale prawna IL
• IL umożliwia definiowanie własnych konstruktorów bez parametrów dla typów wartości .
• Nie można definiować zdarzeń za pomocą elementu „raise” w C #. (W VB ty masz do niestandardowych zdarzeń, ale „default” wydarzenia nie obejmować jeden).
• Niektóre konwersje są dozwolone przez środowisko CLR, ale nie przez C #. Jeśli przejdziesz przez objectC #, te czasami będą działać. Zobacz przykład pytania uint [] / int [] SO .

Dodam do tego, jeśli pomyślę o czymś innym ...

Środowisko CLR obsługuje już ogólną współbieżność / kontrawariancję, ale C # nie otrzymuje tej funkcji do 4,0

• Funkcje języka C # 4.0
• Współ / sprzeczność

W IL możesz wrzucić i złapać dowolny typ, nie tylko typy pochodzące od System.Exception.

IL ma rozróżnienie między calli callvirtdla wywołań metod wirtualnych. Używając tego pierwszego, możesz wymusić wywołanie metody wirtualnej bieżącego typu klasy statycznej zamiast funkcji wirtualnej w typie klasy dynamicznej.

C # nie ma na to sposobu:

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, podobnie jak IL, może wywoływać nie wirtualne wywołania, używając MyClass.Method()składni. W powyższym byłoby to MyClass.ToString().

W trybie try / catch możesz ponownie wprowadzić blok try z jego własnego bloku catch. Więc możesz to zrobić:

.try {
    // ...

  MidTry:
    // ...

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

RestOfMethod:
    // ...

AFAIK, nie możesz tego zrobić w C # lub VB

Dzięki IL i VB.NET można dodawać filtry podczas przechwytywania wyjątków, ale C # v3 nie obsługuje tej funkcji.

Ten przykład VB.NET pochodzi z http://blogs.msdn.com/clrteam/archive/2009/02/05/catch-rethrow-and-filters-why-you-should-care.aspx (zwróć uwagę When ShouldCatch(ex) = Truena Klauzula połowowa):

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

O ile wiem, nie ma możliwości tworzenia inicjalizatorów modułów (statycznych konstruktorów dla całego modułu) bezpośrednio w C #:

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

Native types
Możesz bezpośrednio pracować z natywnymi typami int i natywnymi unsigned int (w języku C # można pracować tylko na IntPtr, który nie jest taki sam.

Transient Pointers
Możesz grać z przejściowymi wskaźnikami, które są wskaźnikami zarządzanych typów, ale gwarantuje, że nie będą poruszać się w pamięci, ponieważ nie znajdują się na zarządzanej stercie. Nie jestem do końca pewien, jak pożytecznie można go używać bez mieszania się z niezarządzanym kodem, ale nie jest to bezpośrednio ujawniane w innych językach tylko za pośrednictwem rzeczy takich jak stackalloc.

<Module>
możesz zadzierać z klasą, jeśli chcesz (możesz to zrobić przez refleksję bez konieczności posiadania IL)

.emitbyte

15.4.1.1 Dyrektywa .emitbyte MethodBodyItem :: =… | .emitbyte Int32 Ta dyrektywa powoduje emisję 8-bitowej wartości bez znaku bezpośrednio do strumienia CIL metody w miejscu, w którym pojawia się dyrektywa. [Uwaga: Dyrektywa .emitbyte służy do generowania testów. Nie jest to wymagane przy generowaniu zwykłych programów. notatka końcowa]

.entrypoint
Masz w tym trochę większą elastyczność, możesz zastosować to na przykład do metod innych niż Main.

przeczytaj specyfikację Jestem pewien, że znajdziesz jeszcze kilka.

Możesz zhakować metodę przesłaniającą co / contra-variance, na co C # nie zezwala (to NIE jest to samo, co wariancja ogólna!). Mam więcej informacji na temat implementacji tego tutaj oraz części 1 i 2

Myślę, że jedynym, o którym marzyłem (z całkowicie niewłaściwych powodów) było dziedziczenie w Enums. Wydaje się, że nie jest to trudne zadanie w SMIL (ponieważ wyliczenia to tylko klasy), ale nie jest to coś, czego wymaga składnia C #.

Oto więcej:

1. Możesz mieć dodatkowe metody instancji w delegatach.
2. Delegaci mogą implementować interfejsy.
3. Możesz mieć statyczne elementy członkowskie w delegatach i interfejsach.

20) Tablicę bajtów można traktować jako (4x mniejszą) tablicę liczb całkowitych.

Użyłem tego ostatnio do wykonania szybkiej implementacji XOR, ponieważ funkcja CLR xor działa na ints i musiałem zrobić XOR na strumieniu bajtów.

Wynikowy kod był ~ 10x szybszy niż jego odpowiednik w C # (wykonując XOR na każdym bajcie).

===

Nie mam dość stackoverflow street credz, aby edytować pytanie i dodać to do listy jako # 20, jeśli ktoś inny mógłby to być super ;-)

Coś używanego przez obfuskatorów - możesz mieć pole / metodę / właściwość / zdarzenie, wszystkie mają tę samą nazwę.

Dziedziczenie wyliczenia nie jest naprawdę możliwe:

Możesz dziedziczyć z klasy Enum. Ale wynik nie zachowuje się szczególnie jak Enum. Zachowuje się nawet nie jak typ wartości, ale jak zwykła klasa. Rzecz w tym, że: IsEnum: True, IsValueType: True, IsClass: False

Ale to nie jest szczególnie przydatne (chyba że chcesz zmylić osobę lub samo środowisko wykonawcze).

Możesz również wyprowadzić klasę z delegata System.Multicast w IL, ale nie możesz tego zrobić w C #:

// Następująca definicja klasy jest niedozwolona:

klasa publiczna YourCustomDelegate: MulticastDelegate {}

Możesz również zdefiniować metody na poziomie modułu (aka globalne) w języku IL, a C # z kolei umożliwia definiowanie metod tylko, o ile są one dołączone do co najmniej jednego typu.