人们为什么要反汇编 .NET (CLR) 二进制文件？

Question

我对 .NET 有点陌生，但对编程并不陌生，而且我对反汇编已编译的 .NET 代码的趋势和兴奋感到有些困惑。 这似乎毫无意义。

.NET 的高度易用性是我使用它的原因。 我在资源有限的环境中编写了 C 语言和真实的（硬件处理器）汇编。 这就是为什么要花精力在这么多细致的细节上，以提高效率。 在 .NET 领域，如果您浪费时间深入研究实现的最神秘的细节，那么它就违背了高级面向对象语言的目的。 在使用 .NET 的过程中，我调试了常见的性能问题和奇怪的竞争条件，并且这一切都是通过阅读我自己的源代码来完成的，从来没有想过编译器正在生成什么中间语言。 例如，很明显，for(;;) 循环将比数组上的 foreach() 更快，考虑到 foreach() 将使用带有方法的枚举对象调用前进到下一次，而不是简单地递增变量，这很容易通过运行几百万次的紧密循环来证明（无需反汇编）。

真正让反汇编 IL 变得愚蠢的是，它不是真正的机器代码。 这是虚拟机代码。 我听说有些人实际上喜欢移动指令来优化它。 你在开玩笑吧？ 即时编译的虚拟机代码甚至无法以本机编译代码的速度执行简单的紧凑 for(;;) 循环。 如果您想充分利用处理器的每个周期，请使用 C/C++ 并花时间学习真正的汇编。 这样，您花在理解大量底层细节上的时间实际上是值得的。

那么，除了有太多空闲时间之外，人们为什么还要反汇编 .NET (CLR) 二进制文件呢？

Answer 1

当您逐渐掌握特定环境时，了解各种高级语言的编译器实际上对源代码执行的操作是一项重要技能，就像了解数据库引擎将如何计划执行您的各种 SQL 查询一样。可以扔给他们。 以熟练的方式使用一定程度的抽象，熟悉（至少）低于它的水平是一件很好的事情； 请参阅关于我关于该主题的演讲的一些注释抽象和该演讲的幻灯片，以及 Joel Spolsky 的“定律”我在演讲中提到的“泄漏抽象”。

Answer 2

当源代码丢失或特定标记版本中版本控制中的内容似乎与附带的二进制文件不对应时，我就使用了它。

Answer 3

在刚刚完成 4 天的安全软件开发课程后，我想说很多人都会反编译源代码以查找其中的任何漏洞。 了解客户端应用程序的来源有助于规划对服务器的攻击。

当然，很少有公用事业之类的，就不会有这样的问题。

如果我没记错的话，有一个应用程序可以混淆你的 .net 二进制文件。 我相信它被称为 dotfuscator。

Answer 4

了解如何使用文档不完善的界面。

（遗憾的是，在基于 .net 的工具（例如 BizTalk 或 WCF）中，仅生成通用文档的情况太频繁了，因此有时需要反汇编为 C# 来查看方法正在做什么以及在什么上下文中使用它）

Answer 5

每种 .NET 语言都实现自己的 CLR 功能子集。 了解 CLR 能够完成您当前使用的语言所不具备的功能，可以让您就是否更改语言、发出 IL 或寻找其他方法做出明智的决定。

你认为人们做这样的事情的唯一原因是因为他们有太多的时间，这种假设是侮辱性的，也是没有受过教育的。

Answer 6

找到库错误并找出解决方法。

例如：如果没有反射，您就无法远程异常并重新抛出它而不杀死它的回溯。 然而框架可以做到这一点。

Answer 7

从您的问题来看，您似乎不知道 Reflector 将 CLR 程序集反汇编回 C# 或 VB，因此您几乎看到的是原始代码，而不是 IL！

Answer 8

实际上，int[] 上的 foreach 被编译成 for 语句。 如果我们将它转​​换为可枚举的，那么你是对的，它使用一个枚举器。 然而，奇怪的是，由于没有增加 temp int，所以它变得更快。为了证明这一点，我们使用基准测试与反编译器相结合来增加理解......

所以我认为通过问这个问题，你真的你自己回答了。

如果此基准与您的不同，请告诉我。 我用对象数组、空值等进行了尝试...

代码：

    static void Main(string[] args)
    {

        int[] ints = Enumerable.Repeat(1, 50000000).ToArray();

        while (true)
        {
            DateTime now = DateTime.Now;
            for (int i = 0; i < ints.Length; i++)
            {
                //nothing really
            }
            Console.WriteLine("for loop: " + (DateTime.Now - now));

            now = DateTime.Now;
            for (int i = 0; i < ints.Length; i++)
            {
                int nothing = ints[i];
            }
            Console.WriteLine("for loop with assignment: " + (DateTime.Now - now));

            now = DateTime.Now;
            foreach (int i in ints)
            {
                //nothing really
            }
            Console.WriteLine("foreach: " + (DateTime.Now - now));

            now = DateTime.Now;
            foreach (int i in (IEnumerable<int>)ints)
            {
                //nothing really
            }
            Console.WriteLine("foreach casted to IEnumerable<int>: " + (DateTime.Now - now));
        }

    }

结果：

for loop: 00:00:00.0273438
for loop with assignment: 00:00:00.0712890
foreach: 00:00:00.0693359
foreach casted to IEnumerable<int>: 00:00:00.6103516
for loop: 00:00:00.0273437
for loop with assignment: 00:00:00.0683594
foreach: 00:00:00.0703125
foreach casted to IEnumerable<int>: 00:00:00.6250000
for loop: 00:00:00.0273437
for loop with assignment: 00:00:00.0683594
foreach: 00:00:00.0683593
foreach casted to IEnumerable<int>: 00:00:00.6035157
for loop: 00:00:00.0283203
for loop with assignment: 00:00:00.0771484
foreach: 00:00:00.0771484
foreach casted to IEnumerable<int>: 00:00:00.6005859
for loop: 00:00:00.0273438
for loop with assignment: 00:00:00.0722656
foreach: 00:00:00.0712891
foreach casted to IEnumerable<int>: 00:00:00.6210938

反编译（请注意，空 foreach 必须添加变量赋值...我们的空 for 循环没有但显然需要的东西）：

private static void Main(string[] args)
{
    int[] ints = Enumerable.Repeat<int>(1, 0x2faf080).ToArray<int>();
    while (true)
    {
        DateTime now = DateTime.Now;
        for (int i = 0; i < ints.Length; i++)
        {
        }
        Console.WriteLine("for loop: " + ((TimeSpan) (DateTime.Now - now)));
        now = DateTime.Now;
        for (int i = 0; i < ints.Length; i++)
        {
            int num1 = ints[i];
        }
        Console.WriteLine("for loop with assignment: " + ((TimeSpan) (DateTime.Now - now)));
        now = DateTime.Now;
        int[] CS$6$0000 = ints;
        for (int CS$7$0001 = 0; CS$7$0001 < CS$6$0000.Length; CS$7$0001++)
        {
            int num2 = CS$6$0000[CS$7$0001];
        }
        Console.WriteLine("foreach: " + ((TimeSpan) (DateTime.Now - now)));
        now = DateTime.Now;
        using (IEnumerator<int> CS$5$0002 = ((IEnumerable<int>) ints).GetEnumerator())
        {
            while (CS$5$0002.MoveNext())
            {
                int current = CS$5$0002.Current;
            }
        }
        Console.WriteLine("foreach casted to IEnumerable<int>: " + ((TimeSpan) (DateTime.Now - now)));
    }
}

Answer 9

学习。

文章很好，但它们没有提供生产代码。 如果没有.NET Reflector，我需要花费几周的时间才能弄清楚 Microsoft 如何在 FileSystemWatcher 组件中实现事件。 相反，只用了几个小时，我就完成了我的 FileSystemSearcher 组件。

Answer 10

我自己经常想知道这一点...:)

有时需要了解特定的库方法如何工作或者它到底为什么这样工作。 可能存在这种情况：有关此功能的文档含糊不清，或者存在一些需要调查的奇怪行为。 在这种情况下，有些人会去反汇编库来查看某些方法内部进行了哪些调用。

至于优化我从来没有听说过。 我认为尝试优化 MIL 最终是愚蠢的，因为它将被输入到翻译器中，翻译器将以相当高的效率生成真实的机器代码，并且您的“优化”无论如何都可能会丢失。

Answer 11

要了解底层系统是如何实现的，请了解 IL 中的高级代码相当于什么，规避许可......

Answer 12

我在以下更多情况中使用了它：

1. 在我没有源代码的内部程序集上遇到问题。
2. 需要弄清楚特定的第三方控件库如何寻找运行时许可证。
3. 需要了解 .Net 许可证编译器的工作原理。 （刚刚将 lc.exe 放入 Reflector 中）
4. 用它来确保我正确构建了某些库。

Answer 13

人们没有提到的是，如果您使用像 PostSharp 这样的编译时编织 AOP 框架，那么反射器会非常有用。