在MSIL中可以做什么，而在C＃或VB.NET中不能做什么？[关闭]

用.NET语言编写的所有代码都可以编译为MSIL，但是是否存在只能直接使用MSIL才能执行的特定任务/操作？

让我们在MSIL中也比C＃，VB.NET，F＃，j＃或任何其他.NET语言更轻松地完成工作。

到目前为止，我们有：

1. 尾递归
2. 通用协/反方差
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. 您可以将字节数组视为int数组（小4倍）。
21. 您可以将字段/方法/属性/事件都具有相同的名称（未验证）。
22. 您可以从其自己的catch块分支回try块。
23. 您可以访问famandassem访问说明符（protected internal是fam 或 assem）
24. 直接访问<Module>用于定义全局函数的类或模块初始化器。

MSIL允许的重载仅在返回类型上有所不同，因为

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

要么

callvirt int32 ...

包括C＃和VB在内的大多数.Net语言都不使用MSIL代码的尾部递归功能。

尾递归是功能语言中常见的优化。当方法A通过返回方法B的值而结束时，发生这种情况，以便一旦对方法B进行调用，就可以释放方法A的堆栈。

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成员，则可以从程序集和派生类访问成员。通过MSIL你可以得到一个部件，其内装配从派生类访问只。（我认为这可能非常有用！）

哦，当时我没发现。（如果您添加了jon-skeet标签，则可能性更大，但我不经常检查它。）

看来您已经有了不错的答案。此外：

• 您无法获得C＃中值类型的盒装版本的句柄。您可以在C ++ / CLI中
• 您无法在C＃中进行尝试/错误（“错误”就像“捕获所有内容并在块末尾重新抛出”或“最终但仅在失败时一样”）
• C＃禁止使用很多名称，但合法的IL
• IL允许您为值类型定义自己的无参数构造函数。
• 您不能在C＃中使用“ raise”元素定义事件。（在VB中，您必须进行自定义事件，但“默认”事件不包含一个。）
• CLR允许某些转换，但C＃不允许。如果您使用objectC＃进行浏览，这些有时会起作用。有关示例，请参见uint [] / int [] SO问题。

如果我有其他想法的话，我会加...

CLR已经支持通用协方差/协方差，但是C＃直到4.0才获得此功能。

• C＃4.0功能
• 协方差

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

与IL一样，VB可以使用MyClass.Method()语法发出非虚拟调用。在上面，应为MyClass.ToString()。

在try / catch中，您可以从其自己的catch块中重新输入try块。因此，您可以执行以下操作：

.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在Catch子句）：

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的方法。

阅读规格说明，我相信您还会发现更多。

您可以修改方法覆盖co / contra-variance，这是C＃不允许的（这与常规方差不一样！）。我在此处以及第1部分和第2部分中获得了有关实现此方法的更多信息。

我认为我一直希望（完全错误的理由）的是Enums中的继承。在SMIL中似乎并不难（因为Enums只是类），但这不是C＃语法要您完成的事情。

还有更多：

1. 您可以在委托中拥有额外的实例方法。
2. 代表可以实现接口。
3. 您可以在委托和接口中具有静态成员。

20）您可以将字节数组视为int数组（小4倍）。

我最近使用它来执行快速的XOR实现，因为CLR xor函数在ints上运行，并且我需要对字节流进行XOR。

测得的代码比在C＃中完成的代码快10倍（在每个字节上执行XOR）。

===

我没有足够的stackoverflow street credz来编辑问题，并将其添加为20号列表，如果其他人可以将其膨胀;-)

混淆器使用的东西-您可以使字段/方法/属性/事件都具有相同的名称。

枚举继承实际上是不可能的：

您可以从Enum类继承。但是结果的表现并不特别像枚举。它的行为甚至不像值类型，而是像普通的类。奇怪的是：IsEnum：True，IsValueType：True，IsClass：False

但这并不是特别有用（除非您想混淆人员或运行时本身。）

您还可以从IL中的System.Multicast委托派生一个类，但不能在C＃中做到这一点：

//以下类定义是非法的：

公共类YourCustomDelegate：MulticastDelegate {}

您还可以在IL和C＃中定义模块级（aka全局）方法，相反，仅允许您定义方法，只要它们附加到至少一种类型即可。