反编译C#代码来看看闭包到底是什么

原文地址：https://zhuanlan.zhihu.com/p/3161634

C#的闭包，是一个语法糖。

它实质上是将匿名函数转换成一个类，函数作为其中的类方法，并调整外部调用代码来实现的。既然是对象，自然就有自己的堆内存分配。

但它并不是无脑地每次创建委托就生成一个新的对象，而是做了编译期间优化，实际程序中生成的对象是少于我们的预期的。

下面就是通过反编译来查看C#是如何编译匿名函数的。

首先是这个经典闭包示例，认为结果是0,1,2,3,4,5,6,7,8,9的统统出去抽自己10个耳光，不解释。

public class Test : MonoBehaviour
{
    Action[] actions = new Action[10];
    void Awake()
    {
        for (int i = 0;i < 10;i++)
        {
            actions[i] = () =>
            {
                Debug.Log(i);
            };
        }

        foreach (var action in actions)
        {
            action();
        }
    }
}

反编译的结果是这样的：

public class Test : MonoBehaviour
{
    private Action[] actions = new Action[10];

    private void Awake()
    {
        <>c__DisplayClass1_0 CS$<>8__locals0 = new <>c__DisplayClass1_0();
        CS$<>8__locals0.i = 0;
        while (CS$<>8__locals0.i < 10)
        {
            this.actions[CS$<>8__locals0.i] = new Action(CS$<>8__locals0.<Awake>b__0);
            int i = CS$<>8__locals0.i;
            CS$<>8__locals0.i = i + 1;
        }
        foreach (Action action in this.actions)
        {
            action();
        }
    }
}

private sealed class <>c__DisplayClass1_0
{
    public int i;

    internal void <Awake>b__0()
    {
        Debug.Log(this.i);
    }
}

估计你们看得都很费劲，我把里面的名字改一下再看吧（之后的代码都是如此）

public class Test : MonoBehaviour
{
    private Action[] actions = new Action[10];

    private void Awake()
    {
//生成一个闭包对象（产生额外堆内存分配）
        AnonymousClass anonymous = new AnonymousClass();
//闭包里使用到的外部变量全部替换成这个闭包对象的属性，这就是一般说的值对象装箱
        anonymous.i = 0;
        while (anonymous.i < 10)
        {
            this.actions[anonymous.i] = new Action(anonymous.Action);
            int i = anonymous.i;
            anonymous.i = i + 1;
        }
        foreach (Action action in this.actions)
        {
            action();
        }
    }
}

private sealed class AnonymousClass
{
    public int i;

    internal void Action()
    {
        Debug.Log(this.i);
    }
}

所以，闭包产生的堆内存有两个，一个是闭包本身的这个对象AnonymousClass，另一个就是它所用到的外部变量i。外部变量越多，堆内存自然也就越多。但外部变量没有，闭包本身还是会占用一个空对象的内存（大概17B？）

光这么看，似乎引用点外部变量也没事？并非如此。

下面是能够正常输出0,1,2,3,4,5,6,7,8,9的经典写法

public class Test : MonoBehaviour
{
    Action[] actions = new Action[10];
    void Awake()
    {
        for (int i = 0;i < 10;i++)
        {
            int j = i;//不同之处就是将i先存到另一个变量中，再在闭包引用这个值
            actions[i] = () =>
            {
                Debug.Log(j);
            };
        }

        foreach (var action in actions)
        {
            action();
        }
    }
}

结果是：

using System;
using UnityEngine;

public class Test : MonoBehaviour
{
    private Action[] actions = new Action[10];

    private void Awake()
    {
        for (int i = 0; i < 10; i++)
        {
            AnonymousClass anonymous = new AnonymousClass();
//闭包对象每个循环都创建了一次
            anonymous.j = i;
            this.actions[i] = new Action(anonymous.Action);
        }
        foreach (Action action in this.actions)
        {
            action();
        }
    }
}

private sealed class AnonymousClass
{
    public int j;

    internal void Action()
    {
        Debug.Log(this.j);
    }
}

虽然闭包对象还是以前的样子，但是却一共创建了10个，GC也就变成了10倍。当然，也因为这个原因能够打印出正确的结果了。

这是理所当然的，因为你需要让它打印出10个不同的结果，它就得保持10个不同的状态嘛。所以你看，并不是只要用循环就一定会产生循环次数的闭包，关键还要看使用的属性是循环内的还是循环外的。其实只要别引用循环内的数据，循环内多次生成闭包函数是没关系的。

然后下一步自然就是，如果我闭包里什么变量都不引用，会是什么样呢？

public class Test : MonoBehaviour
{
    Action[] actions = new Action[10];
    void Awake()
    {
        for (int i = 0;i < 10;i++)
        {
            actions[i] = () =>
            {
                Debug.Log("");//不再引用i
            };
        }

        foreach (var action in actions)
        {
            action();
        }
    }
}

结果是：

public class Test : MonoBehaviour
{
    private Action[] actions = new Action[10];

    private void Awake()
    {
        for (int i = 0; i < 10; i++)
        {
            this.actions[i] = (AnonymousClass.action != null) ?
AnonymousClass.action  :
AnonymousClass.action  = new Action(AnonymousClass.instance.Funtion);
        }
        foreach (Action action in this.actions)
        {
            action();
        }
    }

    private sealed class AnonymousClass
    {
        public static readonly Test.AnonymousClass instance =
new Test.AnonymousClass();
        public static Action action ;

        internal void Funtion()
        {
            Debug.Log("");
        }
    }
}

虽然有很多操作的样子，其实就是将这个匿名函数变成了一个静态单例。不过C#生成的这代码并不是很smart，有不少多余的处理，但反正都是个静态类，也无所谓了。

静态类只会实例化一次，所以可以认为没有引用外部变量的闭包函数都没有GC。

那么引用成员属性呢？

public class Test : MonoBehaviour
{
    Action[] actions = new Action[10];
    void Awake()
    {
        for (int i = 0;i < 10;i++)
        {
            actions[i] = () =>
            {
                Debug.Log(actions.Length);
            };
        }

        foreach (var action in actions)
        {
            action();
        }
    }
}

结果是：

public class Test : MonoBehaviour
{
    private Action[] actions = new Action[10];

    private void Awake()
    {
        for (int i = 0; i < 10; i++)
        {
            this.actions[i] = new Action(this.Function);
        }
        foreach (Action action in this.actions)
        {
            action();
        }
    }

    private void Function()
    {
        Debug.Log(this.actions.Length);
    }
}

只引用成员属性的闭包函数，等效于成员方法

那，如果是引入的是方法内的临时引用对象呢？

public class Test : MonoBehaviour
{
    Action[] actions = new Action[10];
    void Awake()
    {
        for (int i = 0;i < 10;i++)
        {
            Action[] v = actions;//只是简单换个变量保存一下
            actions[i] = () =>
            {
                Debug.Log(v.Length);
            };
        }

        foreach (var action in actions)
        {
            action();
        }
    }
}

结果是：

public class Test : MonoBehaviour
{
    private Action[] actions = new Action[10];

    private void Awake()
    {
        for (int i = 0; i < 10; i++)
        {
            AnonymousClass anonymous = new AnonymousClass();
            anonymous.v = this.actions;
            this.actions[i] = new Action(anonymous.Action);
        }
        foreach (Action action in this.actions)
        {
            action();
        }
    }
}

private sealed class AnonymousClass
{
    public Action[] v;

    internal void Action()
    {
        Debug.Log(this.v.Length);
    }
}

龟龟，这也太蠢了吧？和第二个使用循环内值类型的情况一模一样（10个匿名对象），就不知道优化成上一个的结果么？（0个匿名对象）。也就是说即使是引用对象，在循环里建个临时变量放在闭包里引用也会导致严重的GC问题。

再试试一个方法内多个引用对象的情况

public class Test : MonoBehaviour
{
    Action[] actions = new Action[10];
    void Awake()
    {
        int x = 1;
        int y = 1;
        int z = 1;
        for (int i = 0;i < 5;i++)
        {
            actions[i] = () =>
            {
                Debug.Log(x + y);
            };
        }
        for (int i = 5; i < 10; i++)
        {
            actions[i] = () =>
            {
                Debug.Log(y + z);
            };
        }

        foreach (var action in actions)
        {
            action();
        }
    }
}

结果是：

using System;
using UnityEngine;

public class Test : MonoBehaviour
{
    private Action[] actions = new Action[10];

    private void Awake()
    {
        AnonymousClass anonymous = new <>c__DisplayClass1_0();
        anonymous.x = 1;
        anonymous.y = 1;
        anonymous.z = 1;
        for (int i = 0; i < 5; i++)
        {
            this.actions[i] = anonymous.action1 ?? (anonymous.Action1 = new Action(anonymous.Action1));
        }
        for (int i = 5; i < 10; i++)
        {
            this.actions[i] = anonymous.action2 ?? (anonymous.Action2 = new Action(anonymous.Action2));
        }
        foreach (Action action in this.actions)
        {
            action();
        }
    }
}

private sealed class AnonymousClass
{
    public Action action1;
    public Action action2;
    public int x;
    public int y;
    public int z;

    internal void Action1()
    {
        Debug.Log(this.x + this.y);
    }

    internal void Action2()
    {
        Debug.Log(this.y + this.z);
    }
}

当你一个方法内用到多个闭包函数，而它们引用的是不同的临时变量的话，匿名对象会保存全部的变量的总和。

但这样做的目的是为了只生成一个匿名对象，实际上是一种优化。

当它没得优化的时候：

public class Test : MonoBehaviour
{
    Action[] actions = new Action[10];
    void Awake()
    {
        int x = 1;
        int y = 1;
        for (int i = 0;i < 5;i++)
        {
            actions[i] = () =>
            {
                Debug.Log(x + y);
            };
        }
        for (int i = 5; i < 10; i++)
        {
            int z = 1;
            actions[i] = () =>
            {
                Debug.Log(y + z);
            };
        }

        foreach (var action in actions)
        {
            action();
        }
    }
}

结果是：

public class Test : MonoBehaviour
{
    private Action[] actions = new Action[10];

    private void Awake()
    {
        AnonymousClass1 anonymous1 = new AnonymousClass1();
        anonymous1.x = 1;
        anonymous1.y = 1;
        for (int i = 0; i < 5; i++)
        {
            this.actions[i] = anonymous1.action1 ?? (anonymous1.action1 = new Action(anonymous1.Action1));
        }
        for (int i = 5; i < 10; i++)
        {
            AnonymousClass2 anonymous2 = new AnonymousClass2();
            anonymous2.anonymous1 = anonymous1;//把另一个匿名对象存过来取y值
            anonymous2.z = 1;
            this.actions[i] = new Action(anonymous2.Action2);
        }
        foreach (Action action in this.actions)
        {
            action();
        }
    }
}
private sealed class AnonymousClass1
{
    public Action action1;
    public int x;
    public int y;

    internal void Action1()
    {
        Debug.Log(this.x + this.y);
    }
}
private sealed class AnonymousClass2
{
    public Test.AnonymousClass1 anonymous1;
    public int z;

    internal void Action2()
    {
        Debug.Log(this.anonymous1.y + this.z);
    }
}

总之，就是和我们手写这种情况的时候，差不多的处理。

结论就是多闭包函数同时出现没问题。

好，最后我们总结一遍：

1. 闭包对象的生成次数和引用的临时变量的应用域有关，如果引用循环内的临时变量，每个循环都会生成一份。引用方法里的临时变量，每次调用方法都会生成一份。所以，尽量引用应用域靠外，也就是生命周期更长的变量，不要贪图方便转存对象到临时变量。而且，这个规则和那个变量是值类型还是引用类型无关，只要是临时变量，管你是不是值对象都会触发装箱导致GC。
2. 单个闭包对象的内存占用和引用到的变量的数量有关，但毕竟这些对象都不大，更重要的还是控制闭包对象的生成数量，也就是1所说的内容。
3. 一个方法内有多个闭包函数是没关系的，不需要拆解到多个方法内。
4. 如果闭包函数没有引用任何临时变量，可以认为，它和成员方法等效。

我知道有很多人都排斥使用闭包函数，认为它容易导致“问题”（好多人说的都是“内存泄露”这种无稽之谈，不过GC问题确实还是存在的）

闭包在不同应用域传递变量的方法是创建额外对象，而手写代码则可以选择利用成员属性来代替，这确实会导致闭包产生更多的GC。但在上面的那些用例里，闭包会造成的大量额外GC，也只有“明明可以把变量放在外侧，却非要转存一份在内部”这一种情况，而多出来的GC其实也就是一个空对象，不在逐帧事件里使用并没有什么问题。

闭包毕竟会让代码变得简洁，而低GC写法往往都很丑陋。这种可读性和效能的矛盾一直都存在，适当的权衡是需要的。