整理贴,NET中的闭包《续》:闭包造成的意外。

你的名字 2022-07-24 09:19 98阅读 0赞

http://blog.csdn.net/yan\_hyz/article/details/7799672

闭包是将一些执行封装，将它像对象一样传递，在传递时,执行依然能够访问到原上下文。访问原来上下文,是闭包的重要特征

代码：

**\[csharp\]**  [view plain][]   [copy][view plain]

1.  **static** **void** Main(**string**\[\] args)  
2.    
3.  \{  
4.    
5.  List<Action> ls = **new** List<Action>();  
6.    
7.  **for** (**int** i = 0; i < 10; i++)  
8.    
9.  \{  
10.   
11. ls.Add(() => Console.WriteLine(i));  
12.   
13. \}  
14.   
15. **foreach** (Action action **in** ls)  
16.   
17. \{  
18.   
19. action();  
20.   
21. \}  
22.   
23. System.Console.Read();  
24.   
25. \}

结果：  
![1343563367_4151.png][]  
原因：

由于只声明了一个i变量

所以所有的Action捕获的都是同一个i变量。结果就是每一行都输出数字10

改进：

**\[csharp\]**  [view plain][]   [copy][view plain]

1.  **static** **void** Main(**string**\[\] args)  
2.    
3.  \{  
4.    
5.  List<Action> ls = **new** List<Action>();  
6.    
7.  **for** (**int** i = 0; i < 10; i++)  
8.    
9.  \{  
10.   
11. **int** tp = i;  
12.   
13. ls.Add(() => Console.WriteLine(tp));  
14.   
15. \}  
16.   
17. **foreach** (Action action **in** ls)  
18.   
19. \{  
20.   
21. action();  
22.   
23. \}  
24.   
25. System.Console.Read();  
26.   
27. \}

与上例代码的唯一不是是在循环体中使用了一个局部变量tp,这种写法在通常看来不通是多用了一个中转变量,对程的执行不会有什么影响,但事实上tp这个变量在被每个Action独立保存.

这样，每次循环体在执行的时候，都会取得一个全新的tp，而且tp不会因为所在声名体的完成而出栈

若匿名方法中如果引用了某个变量，则该局部变量将被提升为实例变量，并储存于一个叫做闭包（closure）的对象中。

提升之后，即使创建该变量的方法执行完毕该变量仍不会消亡。

当指向该匿名函数的所有引用都消失后，该闭包变量即可正常地被垃圾回收器回收

**\[csharp\]**  [view plain][]   [copy][view plain]

1.  **class** Program  
2.    
3.  \{  
4.    
5.  **delegate** **int** wxd(**int** i);  
6.    
7.  **delegate** wxd lzm(**int** ii);  
8.    
9.  **static** **void** Main(**string**\[\] args)  
10.   
11. \{  
12.   
13. lzm obj = **delegate**(**int** ii)  
14.   
15. \{  
16.   
17. **return**  
18.   
19. **delegate**(**int** i)  
20.   
21. \{  
22.   
23. **return** i + ii;  
24.   
25. \};  
26.   
27. \};  
28.   
29. wxd w1 = obj(1);  
30.   
31. wxd w2 = obj(2);  
32.   
33. System.Console.WriteLine(w1(3));  
34.   
35. System.Console.WriteLine(w2(3));  
36.   
37. System.Console.Read();  
38.   
39. \}  
40.   
41. \}

输出的结果是4和5

\[obj\]函数接受一个参数，返回新的函数\[w1,w2\]。新的函数\[w1,w2\]将\[obj\]的参数与自己的参数相加，返回结果

函数\[w1,w2\]在接受相同的参数的时候，产生了不同的结果。

实际上\[obj\]返回的内部函数已经把\[obj\]的参数\[ii\]记录了

在这里,方法已不仅仅是一个函数指针了

\[obj\]的参数\[ii\]是如何记录的:

通常理解，函数的参数是放在栈中的。

如果闭包也将参数放在栈中，那么\[ii\]在\[obj\]运行结束的时候就会消失掉，这个时候\[w1,w2\]再通过栈去搜索\[ii\]显然就是不可能的。

所以闭包中参数或内部变量不能放在栈中.而是放在程序执行过程之中的一张全局表里.

\[\[obj\]在返回内部函数的时候，将全局表,自己的结构表,内部函数的指针一起传递给变量\[w1,w2\].

这时内部函数可以访问\[ii\]，外部却无法访问\[ii\]

[view plain]: http://blog.csdn.net/yan_hyz/article/details/7799672#
[1343563367_4151.png]: https://img-my.csdn.net/uploads/201207/29/1343563367_4151.png