Hello World
Spiga

人肉反编译使用yield关键字的方法

2010-01-26 00:06 by 老赵, 8365 visits

我认为这是一个真命题:“没有用.NET Reflector反编译并阅读过代码的程序员不是专业的.NET程序员”。.NET Reflector强大的地方就在于可以把IL代码反编译成可读性颇高的高级语言代码,并且能够支持相当多的“模式”,根据这些模式它可以在一定程度上把某些语法糖给还原,甚至可以支持简单的Lambda表达式和LINQ。只可惜,.NET Reflector还是无法做到极致,某些情况下生成的代码还是无法还原到易于理解——yield关键字便是这样一个典型的情况。不过还行,对于不复杂的逻辑,我们可以通过人肉来“整理”个大概。

简单yield方法编译结果分析

yeild的作用是简化枚举器,也就是IEnumerator<T>或IEnumerable<T>的实现。“人肉”反编译的关键在于发现编译器的规律,因此我们先来观察编译器的处理结果。值得注意的是,我们这里所谈的“分析”,都采用的是微软目前的C# 3.0编译器。从理论上来说,这些结果或是规律,都有可能无法运用在Mono和微软之前或今后的C#编译器上。首先我们准备一段使用yield的代码:

static IEnumerator<int> GetSimpleEnumerator()
{
    Console.WriteLine("Creating Enumerator");

    yield return 0;
    yield return 1;
    yield return 2;

    Console.WriteLine("Enumerator Created");
}

为了简化问题,我们在这里采用IEnumerator<T>。自动生成的IEnumerable<T>和IEnumerator<T>区别不大,您可以自己观察一下,有机会我会单独讨论和分析其中的区别。经过编译之后再使用.NET Reflector进行反编译,得到的结果是:

private static IEnumerator<int> GetSimpleEnumerator()
{
    return new <GetSimpleEnumerator>d__0(0);
}

[CompilerGenerated]
private sealed class <GetSimpleEnumerator>d__0 : IEnumerator<int>, ...
{
    // Fields
    private int <>1__state;
    private int <>2__current;

    // Methods
    [DebuggerHidden]
    public <GetSimpleEnumerator>d__0(int <>1__state)
    {
        this.<>1__state = <>1__state;
    }

    private bool MoveNext()
    {
        switch (this.<>1__state)
        {
            case 0:
                this.<>1__state = -1;
                Console.WriteLine("Creating Enumerator");
                this.<>2__current = 0;
                this.<>1__state = 1;
                return true;

            case 1:
                this.<>1__state = -1;
                this.<>2__current = 1;
                this.<>1__state = 2;
                return true;

            case 2:
                this.<>1__state = -1;
                this.<>2__current = 2;
                this.<>1__state = 3;
                return true;

            case 3:
                this.<>1__state = -1;
                Console.WriteLine("Enumerator Created");
                break;
        }

        return false;
    }

    ...
}

以上便是编译器生成的逻辑,它将yield关键字这个语法糖转化为普通的.NET结构(再次强调,这只是微软目前的C# 3.0编译器所产生的结果)。从中我们可以得出一些结论:

  • 原本GetSimpleEnumerator方法中包含yield的逻辑不复存在,取而代之的是一个由编译器自动生成的IEnumerator类的实例。
  • 原本GetSimpleEnumerator方法中包含yield的逻辑,被编译器自动转化为对应IEnumerator类中的MoveNext方法的逻辑。
  • 编译器将包含yield逻辑转化为一个状态机,并使用自动生成的state字段保存当前状态。
  • 每次调用MoveNext方法时,都通过switch语句判断state的值,直接进入特定的逻辑片断,并指定下一个状态。

因为从yield关键字的作用便是“中断”一个方法的逻辑,使它在下次执行MoveNext方法的时候继续执行。这就意味着自动生成的MoveNext代码必须通过某一个手段来保留上次调用结束之后的“状态”,并根据这个状态决定下次调用的“入口”——这是个典型的状态机的“思路”。由此看来,编译器如此实现,其“设计”意图也是比较直观的,相信您理解起来也不会有太大问题。

较为复杂的yield方法

上一个例子非常简单,因为GetSimpleEnumerator的逻辑非常简单(只有“顺序”,而没有“循环”和“选择”)。此外,这个方法也没有使用局部变量及参数,于是我们这里不妨再准备一个相对复杂的方法:
private static IEnumerator<int> GetComplexEnumerator(int[] array)
{
    <GetComplexEnumerator>d__2 d__ = new <GetComplexEnumerator>d__2(0);
    d__.array = array;
    return d__;
}

[CompilerGenerated]
private sealed class <GetComplexEnumerator>d__2 : IEnumerator<int>, ...
{
    // Fields
    private int <>1__state;
    private int <>2__current;
    public int <i>5__4;
    public int <i>5__6;
    public int <sumEven>5__3;
    public int <sumOdd>5__5;
    public int[] array;

    // Methods
    [DebuggerHidden]
    public <GetComplexEnumerator>d__2(int <>1__state)
    {
        this.<>1__state = <>1__state;
    }

    private bool MoveNext()
    {
        // 第一部分
        switch (this.<>1__state)
        {
            case 0:
                this.<>1__state = -1;
                Console.WriteLine("Creating Enumerator");
                this.<sumEven>5__3 = 0;
                this.<i>5__4 = 0;
                goto Label_0094;

            case 1:
                this.<>1__state = -1;
                goto Label_0086;

            case 2:
                goto Label_00F4;

            default:
                goto Label_0123;
        }

        // 第二部分
    Label_0086:
        this.<i>5__4++;
    Label_0094:
        if (this.<i>5__4 < this.array.Length)
        {
            if ((this.array[this.<i>5__4] % 2) == 0)
            {
                this.<sumEven>5__3 += this.array[this.<i>5__4];
                this.<>2__current = this.<sumEven>5__3;
                this.<>1__state = 1;
                return true;
            }
            goto Label_0086;
        }
        this.<sumOdd>5__5 = 0;
        this.<i>5__6 = 0;
        while (this.<i>5__6 < this.array.Length)
        {
            if ((this.array[this.<i>5__6] % 2) == 0)
            {
                goto Label_00FB;
            }
            this.<sumOdd>5__5 += this.array[this.<i>5__6];
            this.<>2__current = this.<sumOdd>5__5;
            this.<>1__state = 2;
            return true;
        Label_00F4:
            this.<>1__state = -1;
        Label_00FB:
            this.<i>5__6++;
        }
        Console.WriteLine("Enumerator Created.");
    Label_0123:
        return false;
    }

    ...
}

这下MoveNext的逻辑便一下子复杂了很多。我认为,这是由于编译器期望生成体积小的代码,于是它使用了goto来进行自由的跳转。其实从理论上说,把这个方法分为N个阶段之后,便可以让它们完全独立地分开,只不过此时各状态间便会出现许多重复的逻辑。不过,这段代码看似复杂,其实您仔细分析便会发现,它其实也只是将代码拆成了上下两部分(如代码注释所示):

  • 第一部分:状态机的控制逻辑,即根据当前状态进行跳转。
  • 第二部分:主体逻辑,只不过使用goto代替了普通语句中由for/if组成的逻辑,这么做的目的是为了插入Label,可以让第一部分的代码直接跳转到合适的地方——换句话说,由第一部分跳转到的Label便是yield return出现的地方

从上面的代码中我们还可以看出方法的“参数”及“局部变量”的转化规则:

  • 参数被转化为IEnumerator类的公开字段,命名方式不变,原本的array参数直接变成array字段。
  • 局部变量被转化为IEnumerator类的公开字段,并运用一定的命名规则改名(主要是为了避免和自动生成的current及state字段产生冲突)。对于局部变量localVar,将被转化为<localVar>X__Y的形式。
  • 其他需要自动生成的字段为<>1__state及<>2__current,它们只是进行辅助逻辑,不再赘述。

至此,我们已经掌握了编译器基本的转化规律,可以将其运用到“人肉反编译”的过程中去。

试验:人肉反编译OrderedEnumerable

事实上,.NET框架中的System.Linq.OrderedEnumerable类便是一个包含yield方法的逻辑,使用.NET Reflector得到的相关代码如下:

internal abstract class OrderedEnumerable<TElement> : IOrderedEnumerable<TElement>, ...
{
    internal IEnumerable<TElement> source;

    internal abstract EnumerableSorter<TElement> GetEnumerableSorter(EnumerableSorter<TElement> next);

    public IEnumerator<TElement> GetEnumerator()
    {
        <GetEnumerator>d__0<TElement> d__ = new <GetEnumerator>d__0<TElement>(0);
        d__.<>4__this = (OrderedEnumerable<TElement>) this;
        return d__;
    }

    [CompilerGenerated]
    private sealed class <GetEnumerator>d__0 : IEnumerator<TElement>, ...
    {
        // Fields
        private int <>1__state;
        private TElement <>2__current;
        public OrderedEnumerable<TElement> <>4__this;
        public Buffer<TElement> <buffer>5__1;
        public int <i>5__4;
        public int[] <map>5__3;
        public EnumerableSorter<TElement> <sorter>5__2;

        [DebuggerHidden]
        public <GetEnumerator>d__0(int <>1__state)
        {
            this.<>1__state = <>1__state;
        }

        private bool MoveNext()
        {
            switch (this.<>1__state)
            {
                case 0:
                    this.<>1__state = -1;
                    this.<buffer>5__1 = new Buffer<TElement>(this.<>4__this.source);
                    if (this.<buffer>5__1.count <= 0)
                    {
                        goto Label_00EA;
                    }
                    this.<sorter>5__2 = this.<>4__this.GetEnumerableSorter(null);
                    this.<map>5__3 = this.<sorter>5__2.Sort(this.<buffer>5__1.items, this.<buffer>5__1.count);
                    this.<sorter>5__2 = null;
                    this.<i>5__4 = 0;
                    break;

                case 1:
                    this.<>1__state = -1;
                    this.<i>5__4++;
                    break;

                default:
                    goto Label_00EA;
            }
            if (this.<i>5__4 < this.<buffer>5__1.count)
            {
                this.<>2__current = this.<buffer>5__1.items[this.<map>5__3[this.<i>5__4]];
                this.<>1__state = 1;
                return true;
            }
        Label_00EA:
            return false;
        }

        ...
    }
}

很自然,我们需要“人肉反编译”的便是OrderedEnumerable类的GetEnumerator方法。首先,为了便于理解代码,我们首先还原各名称。既然我们已经知道了局部变量及current/state的命名规则,因此这个工作其实并不困难:

private bool MoveNext()
{
    switch (__state)
    {
        case 0:
            __state = -1;
            var buffer = new Buffer<TElement>(this.source);
            if (buffer.count <= 0)
            {
                goto Label_00EA;
            }

            var sorter = this.GetEnumerableSorter(null);
            var map = sorter.Sort(buffer.items, buffer.count);
            sorter = null;
            var i = 0;
            break;

        case 1:
            __state = -1;
            i++;
            break;

        default:
            goto Label_00EA;
    }

    if (i < buffer.count)
    {
        __current = buffer.items[map[i]];
        __state = 1;
        return true;
    }

Label_00EA:
    return false;
}

值得注意的是,在上面的方法中,this是由原来的<>4__this字段还原而来,它表示的是OrderedEnumerable类型(而不是自动生成的IEnumerator类)的实例。此外,其中的局部变量您需要将其理解为“自动在多次MoveNext调用中保持状态的变量”——这和C语言中的静态局部变量有些接近。自然,__state和__current变量都是自动生成用于保存状态的变量,我们姑且保留它们。

接下来,我们将要还原state等于0时的逻辑。因为我们知道,它其实是yield方法中“第一个yield return”之前的逻辑:

private IEnumerator<TElement> GetEnumerator()
{
    var buffer = new Buffer<TElement>(this.source);
    if (buffer.count <= 0) yield break;
    
    var sorter = this.GetEnumerableSorter(null);
    var map = sorter.Sort(buffer.items, buffer.count);
    // 省略sorter = null(为什么?:P)
    
    var i = 0;
    if (i < buffer.count)
    {
        yield return buffer.items[map[i]];
    }
    
    ...
}

我们发现,在buffer.count小于等于0的时候MoveNext直接返回false了,于是在GetEnumerator方法中我们便使用yield break直接退出。在上面的代码中我们已经还原至第一个yield return,那么当调用下一个MoveNext时(即state为1)逻辑又该如何进行呢?我们再“机械”地还原一下:

private IEnumerator<TElement> GetEnumerator()
{
    ...

    i++;
    if (i < buffer.count)
    {
        yield return buffer.items[map[i]];
    }
    else
    {
        yield break;
    }

    ...
}

接着,我们会发现代码会不断重复上面这段逻辑,因此我们可以使用一个“死循环”将其包装起来。至此,GetEnumerator便还原成功了:

private IEnumerator<TElement> GetEnumerator()
{
    var buffer = new Buffer<TElement>(this.source);
    if (buffer.count <= 0) yield break;
    
    var sorter = this.GetEnumerableSorter(null);
    var map = sorter.Sort(buffer.items, buffer.count);
    
    var i = 0;
    if (i < buffer.count)
    {
        yield return buffer.items[map[i]];
    }

    while (true)
    {
        i++;
        if (i < buffer.count)
        {
            yield return buffer.items[map[i]];
        }
        else
        {
            yield break;
        }
    }
}

不过,又有多少人会写这样的代码呢?的确,这段代码是我们“机械翻译”的结果。不过经过观察,事实上这段代码可以被修改成如下写法:

private IEnumerator<TElement> GetEnumerator()
{
    var buffer = new Buffer<TElement>(this.source);
    if (buffer.count <= 0) yield break;

    var sorter = this.GetEnumerableSorter(null);
    var map = sorter.Sort(buffer.items, buffer.count);

    for (var i = 0; i < buffer.count; i++)
    {
        yield return buffer.items[map[i]];
    }
}

至此就完美了。最后这步转换我们利用了人脑的优越性,这样“看出”一种优雅的模式也并非难事——不过这也并非只能靠“感觉”,因为我在上面谈到,编译器会尽可能生成紧凑的代码,这意味着它和“源代码”相比不会有太多的重复。但经由我们“机械还原”之后,会发现这样一段代码其实是重复出现的:

if (i < buffer.count)
{
    yield return buffer.items[map[i]];
}

于是我们便可以朝着“合并代码片断”的方向去思考,得到最终的结果还是有规律可循的。

总结

如果您关注我最近的文章,并且在看到OrderedEnumerable这个类型之后应该会有所察觉:这篇文章只是我在“分析Array和LINQ排序实现”过程中的一个插曲。没错,这是LINQ排序实现的一小部分。OrderedEnumerable利用了yield关键字,这样我们使用.NET反编译之后代码的可读性很差。为此,我便特地研究了一下对yield进行“人肉反编译”的做法。不过在一开始,我原本其实是想仔细分析一下yield相关的“编译规律”,但是我发现在《C# in Depth》一书中已经对这个话题有了非常详尽的描述,只得作罢。之后我又看了这本书网站上公开的样张,感觉非常不错。

事实上,自从ASP.NET 2.0开始,我似乎就没有看过任何一本ASP.NET 2.0/3.0或是C# 2.0/3.0/4.0的书了,因为我认为这些书中的所有内容都可以从MSDN文档,互联网(如博客)以及自己使用、分析的过程中了解到。不过现在,《C# in Depth》似乎让我对此类技术图书的“偏见”有所动摇了——但只此一本而已,估计我还是不会去买这样的书。:)

对了,昨天我向“有关部门”了解到,《C# in Depth》已经由图灵出版社引进,翻译完毕,只等审校和出版了。

Creative Commons License

本文基于署名 2.5 中国大陆许可协议发布,欢迎转载,演绎或用于商业目的,但是必须保留本文的署名赵劼(包含链接),具体操作方式可参考此处。如您有任何疑问或者授权方面的协商,请给我留言

Add your comment

28 条回复

  1. 老赵
    admin
    链接

    老赵 2010-01-26 00:09:00

    其实还是挺麻烦的,尤其是如果遇到try...catch这种,呵呵。

  2. Fred_Xu
    *.*.*.*
    链接

    Fred_Xu 2010-01-26 00:09:00

    板凳留给我自己吧,明天上班的时候认真看。

  3. RednaxelaFX
    *.*.*.*
    链接

    RednaxelaFX 2010-01-26 00:14:00

    再来个带有using的generator反编译分析也会很有趣……

  4. 麒麟.NET
    *.*.*.*
    链接

    麒麟.NET 2010-01-26 00:21:00

    我怎么感觉C# in Depth早就出中文版了呢?

  5. Scott Guthrie Liu
    *.*.*.*
    链接

    Scott Guthrie Liu 2010-01-26 00:33:00

    “老赵书托”还有吧?
    C# in Depth 这书是第二版了,中文的没的

  6. Leon Weng
    *.*.*.*
    链接

    Leon Weng 2010-01-26 01:10:00

    看的还真不太多,有空研究一下。

  7. 老赵
    admin
    链接

    老赵 2010-01-26 01:32:00

    @Scott Guthrie Liu
    老赵书托会有的,看我心情想啥时写了,hoho。

  8. lsp
    *.*.*.*
    链接

    lsp 2010-01-26 01:38:00

    老赵请教个问题,你博客用的什么编辑器,代码部分又是用什么格式化的。代码部分的格式化令我很头疼。cnblogs自带的编辑器简直是梦魇(对我来说)。

  9. LeoXing
    *.*.*.*
    链接

    LeoXing 2010-01-26 09:02:00

    老赵都和“有关部门”有关系了啊~!

  10. 老赵
    admin
    链接

    老赵 2010-01-26 09:05:00

    @lsp
    在我的博客上搜索“浅谈代码着色”。

  11. 老赵
    admin
    链接

    老赵 2010-01-26 09:06:00

    RednaxelaFX:再来个带有using的generator反编译分析也会很有趣……


    感觉using不如纯粹的try...catch麻烦啊,using不就是try...finally嘛。

  12. 温景良(Jason)
    *.*.*.*
    链接

    温景良(Jason) 2010-01-26 09:17:00

    “没有用.NET Reflector反编译并阅读过代码的程序员不是专业的.NET程序员”。看到这句话我赶紧去更新下Reflector,发现晚了一个版本

  13. RednaxelaFX
    *.*.*.*
    链接

    RednaxelaFX 2010-01-26 09:26:00

    Jeffrey Zhao:
    感觉using不如纯粹的try...catch麻烦啊,using不就是try...finally嘛。


    嗯那同理离散case的switch也只是连串的if...else而后者也只是一些goto,问题是要还原到高级结构比只还原一半到中间结构要麻烦

  14. Allen Lee
    *.*.*.*
    链接

    Allen Lee 2010-01-26 10:01:00

    呵,原来C# in depth被图灵拿走了,哎~

  15. 韦恩卑鄙 alias:v-zhewg
    *.*.*.*
    链接

    韦恩卑鄙 alias:v-zhewg 2010-01-26 10:38:00

    读不懂 使劲读 就懂了

  16. Aaron Lu
    *.*.*.*
    链接

    Aaron Lu 2010-01-26 12:15:00

    先Mark,在慢慢看。
    老赵去做游戏了?

  17. 侯德军
    *.*.*.*
    链接

    侯德军 2010-01-26 12:46:00

    Aaron Lu:
    先Mark,在慢慢看。
    老赵去做游戏了?



    是啊,到盛大了?

  18. 老赵
    admin
    链接

    老赵 2010-01-26 13:17:00

    @侯德军
    谁说盛大就是做游戏的啊……

  19. Yunanw
    *.*.*.*
    链接

    Yunanw 2010-01-26 16:29:00

    老赵换工作了。。

  20. Ivony...
    *.*.*.*
    链接

    Ivony... 2010-01-26 17:09:00

    很好很强大。。。。。

  21. 韦恩卑鄙 alias:v-zhewg
    *.*.*.*
    链接

    韦恩卑鄙 alias:v-zhewg 2010-01-26 18:31:00

    我老婆正在盛大旗下的晋江文学网写BL文写得不亦乐乎。。。

  22. 老赵
    admin
    链接

    老赵 2010-01-26 19:48:00

    @韦恩卑鄙 alias:v-zhewg:
    我老婆正在盛大旗下的晋江文学网写BL文写得不亦乐乎。。。


    可怜啊……那么她晚上有没有提过分要求?

  23. 韦恩卑鄙 alias:v-zhewg
    *.*.*.*
    链接

    韦恩卑鄙 alias:v-zhewg 2010-01-26 19:54:00

    Jeffrey Zhao:
    @韦恩卑鄙 alias:v-zhewg
    可怜啊……那么她晚上有没有提过分要求?


    有阿有阿 比如说一写H部分就要我交公粮 搞得我基本上知道她写到什么情节了。。。。

  24. 老赵
    admin
    链接

    老赵 2010-01-26 20:12:00

    韦恩卑鄙 alias:v-zhewg:
    有阿有阿 比如说一写H部分就要我交公粮 搞得我基本上知道她写到什么情节了。。。。


    牛啊,求帐号

  25. 干拔三分
    *.*.*.*
    链接

    干拔三分 2010-01-26 20:33:00

    老赵推荐一本介绍.net框架的书来吧,最好最好是中文

  26. 老赵
    admin
    链接

    老赵 2010-01-26 20:48:00

    @干拔三分
    CLR via C#有翻译版的。

  27. ouzi
    *.*.*.*
    链接

    ouzi 2010-01-28 23:26:00

    唉,这篇文章终于让我比较清楚的知道yield这个keyword了,以前都一直比较模糊

  28. 横刀天笑
    *.*.*.*
    链接

    横刀天笑 2010-01-29 20:57:00

    经常用Reflector反编译代码,然后想把反编译后的东东加入到项目中,然后再一路的debug进去,可惜就是这些yield啥的生成出来的变态东西,round-trip不了,每次都手工,那个痛苦啊~~

发表回复

登录 / 登录并记住我 ,登陆后便可删除或修改已发表的评论 (请注意保留评论内容)

昵称:(必填)

邮箱:(必填,仅用于Gavatar

主页:(可选)

评论内容(大于5个字符):

  1. Your Name yyyy-MM-dd HH:mm:ss

使用Live Messenger联系我