匿名方法中的捕获变量

　　乍一接触"匿名方法中的捕获变量"这一术语可能会优点蒙，那什么是"匿名方法中的捕获变量"呢？在章节未开始之前，我们先定义一个委托：public delegate void methodinvoke();

1、闭包和不同类型的变量：

　　首先，大家应该都知道"闭包"，它的概念是：一个函数除了能通过提供给它的参数交互之外，还能同环境进行更大程度的互动。但这个定义过于抽象，还需要理解两个术语：

　　1）外部变量（outer variable）指作用域内包括匿名方法的局部变量或参数（不包括ref和out参数）。在类的实例成员内部的匿名方法中，this引用也被认为是一个外部变量。

　　2）捕获的外部变量（captured outer variable）通常简称捕获变量（captured variable），它是在匿名方法内部使用的外部变量。

　　这些定义看起来云里雾里的，那接下来以一个例子来说明： 

 1 public void enclosingmethod()
 2 {
 3     int outervariable = 5; // 外部变量
 4     string capturevariable = "captured"; // 被匿名方法捕获的外部变量
 5     if (datetime.now.hour == 23)
 6     {
 7         int normallocalvariable = datetime.now.minute; // 普通方法的局部变量
 8         console.writeline(normallocalvariable);
 9     }
10     methodinvoke x = delegate ()
11     {
12         string anonlocal = "local to anonymous method"; // 匿名方法的局部变量
13         console.writeline(capturevariable + anonlocal); // 捕获外部变量capturevariable
14     };
15     console.writeline(outervariable);
16     x();
17 }

2、捕获变量的行为：

　　如果你运行了上述代码，你会发现匿名方法捕捉到的确实是变量，而不是创建委托实例时该变量的值。通俗的说就是只有在匿名方法被调用时才会被使用。 

 1 string captured = "before x is created";
 2 methodinvoke x = delegate
 3 {
 4     console.writeline(captured);
 5     captured = "change by x";
 6 };
 7 captured = "directly before x is invoked";
 8 x();
 9 console.writeline(captured);
10 captured = "before second invocation";
11 x();

　　上述代码的执行顺序是这样子的(可以debug)：定义变量captured => 声明匿名方法methodinvoke x => 将captured的值修改为"directly before x is invoked" => 紧接着调用委托x()，这个时候会进入匿名方法 => 首先输出captured的值"directly before x is invoked"，然后修改为"change by x" => 匿名方法调用结束，来到第9行，输出captured的值"change by x" => 第10行重新给captured赋值"before second invocation" => 调用x()

3、捕获变量到底有什么用处：

　　捕获变量能简化避免专门创建一些类来存储一个委托需要处理的信息。

1 list<people> findallyoungerthan(list<people> people, int limit)
2 {
3     return people.where(person => person.age < limit).tolist();
4 }

　　我们在委托实例内部捕获了limit参数——如果仅有匿名方法而没有捕获变量，就只能在匿名方法中使用一个"硬编码"的限制年龄，而不能使用作为参数传递的limit。这样的设计能够准备描述我们的"目的"，而不是将大量的精力放在"过程"上。

4、捕获变量的延长生存期：

　　到目前为止，我么一直在创建委托实例的方法内部使用委托实例。在这种情况下，你对捕获变量的生存期（lifetime）不会又太大的疑问。但是，假如委托实例"逃"到另一个黑暗的世界(big bad world)，那会发生什么？假如创建它的那个方法结束了，它将何以应对？

　　在理解这种问题时，最简单的办法就是指定一个规则，给出一个例子，然后思考假如没有那个规则，会发生什么：对于一个捕获变量，只要还有任何委托实例在引用它，它就会一直存在。

 1 private static void main(string[] args)
 2 {
 3     methodinvoke x = createdelegateinstance();
 4     x();
 5     x();
 6 }
 7 
 8 private static methodinvoke createdelegateinstance()
 9 {
10     int counter = 5;
11 
12     methodinvoke ret = delegate
13     {
14         console.writeline(counter);
15         counter++;
16     };
17 
18     ret();
19     return ret;
20 }

　　输出的结果：

　　我们一般认为counter在栈上，所以只要与createdelegateinstance对应的栈帧被销毁，counter随之消失，但是从结果来看，显然我们的认知是有问题的。事实上，编译器创建了一个额外的类容纳变量。createdelegateinstance方法拥有对该类的一个实例的引用，所以它能使用counter。另外，委托也对该实例的一个引用，这个实例和其他实例一样都在堆上。除非委托准备好垃圾回收，否则那个实例是不会被回收的。

5、局部变量实例化：

　　下面将展示一个例子。

1 int single;
2 for (int i = 0; i < 10; i++)
3 {
4     single = 5;
5     console.writeline(single + i);
6 }

1 for (int i = 0; i < 10; i++)
2 {
3     int multiple = 5;
4     console.writeline(multiple + i);
5 }

　　上述两段代码在语义和功能上是一样的，但在内存开销上显然第一种写法比第二种占用较小的内存。single变量只实例化一次，而multiple变量将实例化10次。当一个变量被捕获时，捕捉的是变量的"实例"。如果在循环内捕捉multiple，第一次循环迭代时捕获的变量与第二次循环时捕获的变量是不同的。

 1 list<methodinvoke> list = new list<methodinvoke>();
 2 for (int index = 0; index < 5; index++)
 3 {
 4     int counter = index * 10;
 5     list.add(delegate
 6     {
 7         console.writeline(counter);
 8         counter++;
 9     });
10 }
11 foreach (methodinvoke t in list)
12 {
13     t();
14 }
15 
16 list[0]();
17 list[0]();
18 list[0]();
19 
20 list[1]();

　　输出结果：

　　上述代码首先创建了5个不同的委托实例，调用委托时，会先打印counter值，再对它进行递增。由于counter变量是在循环内部声明的，所以每次循环迭代，它都会被实例化。这样一来，每个委托捕捉到的都是不同的变量。

6、共享和非共享的变量混合使用：

 1 methodinvoke[] delegates = new methodinvoke[2];
 2 int outside = 0;
 3 
 4 for (int i = 0; i < 2; i++)
 5 {
 6     int inside = 0;
 7     delegates[i] = delegate
 8     {
 9         console.writeline($"{outside},{inside}");
10         outside++;
11         inside++;
12     };
13 }
14 
15 methodinvoke first = delegates[0];
16 methodinvoke second = delegates[1];
17 
18 first();
19 first();
20 first();
21 
22 second();
23 second();

　　输出结果：

　　首先outside变量只声明了一次，但inside变量每次循环迭代，都会实例化一个新的inside变量。这意味着当我们创建委托实例时，outside变量将由委托实例共享，但每个委托实例都有它们自己的inside变量。

7、总结：

　　如何合理使用捕获变量？

　　　　1）如果用或不用捕获变量的代码同样简单，那就不要用。

　　　　2）捕获由for或foreach语句声明的变量之前，思考你的委托是否需要再循环迭代结束之后延续，以及是否想让它看到那个变量的后续值。如果不是，就在循环内另建一个变量，用来复制你想要的值。

　　　　3）如果创建多个委托实例，而且捕获了变量，思考下是否希望它们捕获同一变量。

　　　　4）如果捕获的变量不会发生变化，就不需要担心。

　　　　5）如果你创建的委托实例永远不会存储别的地方，不会返回，也不会启动线程。

　　　　6）从垃圾回收的角度，思考任何捕获变量被延长的生存期。这个问题一般都不大，但假如捕获的对象会产生昂贵的内存开销，问题就会凸显出来。

参考：深入理解c#_第三版