解析C#与NET闭包对比示例.docx
《解析C#与NET闭包对比示例.docx》由会员分享，可在线阅读，更多相关《解析C#与NET闭包对比示例.docx（10页珍藏版）》请在冰豆网上搜索。
解析C#与NET闭包对比示例
[解析]C#与.NET闭包对比示例
文章分析了C#与闭包用法，C#中，闭包其实和类中其他属性、方法是一样的，它们的原则都是下一层可以畅快的调用上一层定义的各种设定，但上一层则不具备访问下一层设定的能力。
首先想说明一点,虽然有这样那样的不好的心态（比如中文技术书），但总体来说，国内的技术人员还是喜欢分享和教导别人的，这点我的个人感受和之前在园子里看到的朋友的感受恰恰相反。
个人认为其实国内很多技术网友都是很热心的，可能因为语言问题同一个技术热点会稍稍落后国外一些，但有些成熟的或者基础的概念都可以找到很细致的中文介绍，特别是关于闭包，因为它的字面解释确实很绕，所以基本所有试图解释这一名词的同学都是尽量用自己认为最通俗易懂的方式来进行讲解。
闲话扯远了，这里我就用C#语言来给大家解释下闭包吧。
其实要提到闭包，我们还得先提下变量作用域和变量的生命周期。
在C#里面，变量作用域有三种，一种是属于类的，我们常称之为field，第二种则属于函数的，我们通常称之为局部变量，还有一种，其实也是属于函数的，不过它的作用范围更小，它只属于函数局部的代码片段，这种同样称之为局部变量。
这三种变量的生命周期基本都可以用一句话来说明，每个变量都属于它所寄存的对象，即变量随着其寄存对象生而生和消亡。
对应三种作用域我们可以这样说，类里面的变量是随着类的实例化而生，同时伴随着类对象的资源回收而消亡（当然这里不包括非实例化的static和const对象）。
而函数（或代码片段）的变量也随着函数（或代码片段）调用开始而生，伴随函数（或代码片段）调用结束而自动由GC释放，它内部变量生命周期满足先进后出的特性。
那么这里有没有例外呢？
答案是有的，不过在提这点之前，我还需要给各位另外一个名词。
都说c#就是MS版本的java，这话在.net1.0可能可以这么说，但自2.0之后C#就可以自豪的说它绝非java了，这里面委托有很大的功劳，如果用过java和C#的人并且尝试过写winform程序时全部手写实现代码的人就会有这样一个感受，同样的click事件在java中必须要无端的套个匿名类，但在c#中，你是可以直接将函数名+=到事件之后而不需要显示写上匿名委托的对象类型的，因为编译器会帮你做这部分工作，在3.0和以后的版本之中，微软将委托的用法更是发挥的淋漓精致，无论是简洁的Lamda还是通俗易懂的LINQ，都是源自委托的。
你可能要问,委托和我们今天要讲的闭包又有什么关系呢?
我们知道，c#,java和javascript,ruby,python这些语言不同，在c#和java的世界里面，原子对象就是类（当然还有struct和基本变量），而不是很多动态语言中的函数，我们可以实例化一个类，实例化一个变量，但不可以直接new一个函数。
也就是表面上看，我们是没办法像js那样将函数进行实例化和传递的。
这也是为什么直到Java7闭包才被姗姗来迟的加入java特性中。
但对C#来说这些只是表象，我刚学c#的时候，看到最多的解释委托的话就是：
委托啊，就相当于c++里面的函数指针啦。
这句话虽然笼统，但确实有一定道理，通过委托特别是匿名委托这层对象的包装，我们就可以突破无法将函数当做对象传递的限制了。
好像这里还是没讲到闭包和委托的关系，好吧，我太啰嗦了，下面从概念开始讲。
闭包其实就是使用的变量已经脱离其作用域，却由于和作用域存在上下文关系，从而可以在当前环境中继续使用其上文环境中所定义的一种函数对象。
好拗口，程序员，还是用示例来说明更好理解。
首先来个最简单的javascript中常常见到的关于闭包的例子：
1.publicclassTCloser
2.
3.{
4.
5.publicFuncT1（）
6.
7.{
8.
9.varn=999;
10.
11.return（）=>
12.
13.{
14.
15.Console.WriteLine（n）;
16.
17.returnn;
18.
19.};
20.
21.}
22.
23.}
24.
25.
26.
27.classProgram{
28.
29.staticvoidMain（）{
30.
31.vara=newTCloser（）;
32.
33.varb=a.T1（）;
34.
35.Console.WriteLine（b（））;
36.
37.}
38.
39.}
从上面的代码我们不难看到，变量n实际上是属于函数T1的局部变量，它本来生命周期应该是伴随着函数T1的调用结束而被释放掉的，但这里我们却在返回的委托b中仍然能调用它，这里正是闭包所展示出来的威力，因为T1调用返回的匿名委托的代码片段中我们用到了n，而在编译器看来，这些都是合法的，因为返回的委托b和函数T1存在上下文关系，也就是说匿名委托b是允许使用它所在的函数或者类里面的局部变量的，于是编译器通过一系列动作（具体动作我们后面再说）使b中调用的函数T1的局部变量自动闭合，从而使该局部变量满足新的作用范围。
因此如果你看到.net中的闭包，你就可以像js中那样理解它，由于返回的匿名函数对象是在函数T1中生成的，因此相当于它是属于T1的一个属性。
如果你把T1的对象级别往上提升一个层次就很好理解了，这里就相当于T1是一个类，而返回的匿名对象则是T1的一个属性，对属性而言，它可以调用它所寄存的对象T1的任何其他属性或者方法，包括T1寄存的对象TCloser内部的其他属性。
如果这个匿名函数会被返回给其他对象调用，那么编译器会自动将匿名函数所用到的方法T1中的局部变量的生命周转期自动提升并与匿名函数的生命周期相同，这样就称之为闭合。
也许你会说，这个返回的委托包含的变量n只是编译器通过某种方式隐藏的对这个委托对象的一个同样对象的赋值吧，那么我们再对比下面两个方法：
1.publicclassTCloser{
2.
3.publicFuncT1（）
4.
5.{
6.
7.varn=999;
8.
9.Funcresult=（）=>
10.
11.{
12.
13.returnn;
14.
15.};
16.
17.
18.
19.n=10;
20.
21.returnresult;
22.
23.}
24.
25.
26.
27.publicdynamicT2（）
28.
29.{
30.
31.varn=999;
32.
33.dynamicresult=new{A=n};
34.
35.n=10;
36.
37.returnresult;
38.
39.}
40.
41.staticvoidMain（）{
42.
43.vara=newTCloser（）;
44.
45.varb=a.T1（）;
46.
47.varc=a.T2（）;
48.
49.Console.WriteLine（b（））;
50.
51.Console.WriteLine（c.A）;
52.
53.}
54.
55.}
最后输出结果是什么呢？
答案是10和999，因为闭包的特性，这里匿名函数中所使用的变量就是实际T1中的变量，与之相反的是，匿名对象result里面的A只是初始化时被赋予了变量n的值，它并不是n，所以后面n改变之后A并未随之而改变。
这正是闭包的魔力所在。
你可能会好奇.net本身并不支持函数对象，那么这样的特性又是从何而来呢？
答案是编译器，我们一看IL代码便会明白了。
首先我给出c#代码：
1.publicclassTCloser{
2.
3.publicFuncT1（）{
4.
5.varn=10;
6.
7.return（）=>
8.
9.{
10.
11.returnn;
12.
13.};
14.
15.}
16.
17.
18.
19.publicFuncT4（）{
20.
21.return（）=>
22.
23.{
24.
25.varn=10;
26.
27.returnn;
28.
29.};
30.
31.}
32.
33.}
这两个返回的匿名函数的唯一区别就是返回的委托中变量n的作用域不一样而已，T1中变量n是属于T1的，而在T4中，n则是属于匿名函数本身的。
但我们看看IL代码就会发现这里面的大不同了：
1..methodpublichidebysiginstanceclass[mscorlib]System.Func`1T1（）cilmanaged{
2.
3..maxstack3
4.
5..localsinit（
6.
7.[0]classConsoleApplication1.TCloser/<>c__DisplayClass1CS$<>8__locals2,
8.
9.[1]class[mscorlib]System.Func`1CS$1$0000）
10.
11.L_0000:
newobjinstancevoidConsoleApplication1.TCloser/<>c__DisplayClass1:
:
.ctor（）
12.
13.L_0005:
stloc.0
14.
15.L_0006:
nop
16.
17.L_0007:
ldloc.0
18.
19.L_0008:
ldc.i4.s10
20.
21.L_000a:
stfldint32ConsoleApplication1.TCloser/<>c__DisplayClass1:
:
n
22.
23.L_000f:
ldloc.0
24.
25.L_0010:
ldftninstanceint32ConsoleApplication1.TCloser/<>c__DisplayClass1:
:
b__0（）
26.
27.L_0016:
newobjinstancevoid[mscorlib]System.Func`1:
:
.ctor（object,nativeint）
28.
29.L_001b:
stloc.1
30.
31.L_001c:
br.sL_001e
32.
33.L_001e:
ldloc.1
34.
35.L_001f:
ret
36.
37.}
38.
39.
40.
41..methodpublichidebysiginstanceclass[mscorlib]System.Func`1T4（）cilmanaged
42.
43.{
44.
45..maxstack3
46.
47..localsinit（
48.
49.[0]class[mscorlib]System.Func`1CS$1$0000）
50.
51.L_0000:
nop
52.
53.L_0001:
ldsfldclass[mscorlib]System.Func`1ConsoleApplication1.TCloser:
:
CS$<>9__CachedAnonymousMethodDelegate4
54.
55.L_0006:
brtrue.sL_001b
56.
57.L_0008:
ldnull
58.
59.L_0009:
ldftnint32ConsoleApplication1.TCloser:
:
b__3（）
60.
61.L_000f:
newobjinstancevoid[mscorlib]System.Func`1:
:
.ctor（object,nativeint）
62.
63.L_0014:
stsfldclass[mscorlib]System.Func`1ConsoleApplication1.TCloser:
:
CS$<>9__CachedAnonymousMethodDelegate4
64.
65.L_0019:
br.sL_001b
66.
67.L_001b:
ldsfldclass[mscorlib]System.Func`1ConsoleApplication1.TCloser:
:
CS$<>9__CachedAnonymousMethodDelegate4
68.
69.L_0020:
stloc.0
70.
71.L_0021:
br.sL_0023
72.
73.L_0023:
ldloc.0
74.
75.L_0024:
ret
76.
77.}
看IL代码你就会很容易发现其中究竟了，在T1中，函数对返回的匿名委托构造的是一个类，名称为newobjinstancevoidConsoleApplication1.TCloser/<>c__DisplayClass1:
:
.ctor（），而在T4中，则是仍然是一个普通的Func委托，只不过级别变为类级别了而已。
那我们接着看看T1中声明的类c__DisplayClass1是何方神圣：
1..classautoansisealednestedprivatebeforefieldinit<>c__DisplayClass1
2.
3.extends[mscorlib]System.Object{
4.
5..custominstancevoid[mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute:
:
.ctor（）
6.
7..methodpublichidebysigspecialnamertspecialnameinstancevoid.ctor（）cilmanaged{}
8.
9..methodpublichidebysiginstanceint32b__0（）cilmanaged{}
10.
11..fieldpublicint32n
12.
13.}
看到这里想必你已经明白了，在C#中,原来闭包只是编译器玩的花招而已，它仍然没有脱离.NET对象生命周期的规则，它将需要修改作用域的变量直接封装到返回的类中变成类的一个属性n，从而保证了变量的生命周期不会随函数T1调用结束而结束，因为变量n在这里已经成了返回的类的一个属性了。
看到这里我想大家应该大体上了解C#闭包的来龙去脉了吧，C#中，闭包其实和类中其他属性、方法是一样的，它们的原则都是下一层可以畅快的调用上一层定义的各种设定，但上一层则不具备访问下一层设定的能力。
即类中方法里的变量可以自由访问类中的所有属性和方法，而闭包又可以访问它的上一层即方法中的各种设定。
但类不可以访问方法的局部变量，同理，方法也不可以访问其内部定义的匿名函数所定义的局部变量。
这正是C#中的闭包，它通过超越java语言的委托打下了闭包的第一步基础，随后又通过各种语法糖和编译器来实现如今在.NET世界全面开花的Lamda和LINQ。
也使得我们能够编写出更加简洁优雅的代码。
升级会员 