[C# 基础知识系列]专题十一:匿名方法解析

 引言：

　　感觉好久没有更新博客了的，真是对不住大家了。在这个专题中将介绍匿名方法，匿名方法看名字也能明白，当然就是没有名字的方法了(现实生活中也有很多这样的匿名过程,如匿名投票,匿名举报等等,相信微软在命名方面肯定是根据了生活中例子的)，然而匿名方法的理解却不是仅仅是这一句话(这句话指的是没有名字的方法)，它还有很多内容，下面就具体介绍下匿名方法有哪些内容 

一、匿名方法

 　　之前一直认为匿名方法是在C# 3.0中提出的，之前之所以这么认为主要是因为知道C# 3.0中提出了匿名类型，所以看到匿名方法就很理所当然的认为也是在C# 3.0中提出来，然而经过系统的学习C#特性后才发现匿名方法在C# 2.0 的时候就已经提出来了，从特性的提出发展中可以看出，微软的团队是非常有计划的，后面的特性其实在之前特性的提出就已经计划好，并且后面的特性都是之前特性演变而来，之所以有新特性的提出，主要是为了方便大家编写程序，减轻程序员的工作，让编译器去执行更加复杂的操作，使程序员可以把精力放在实现自己系统的业务逻辑方法（这也是微软的主要思想，也是大部分软件所强调的良好的用户体验），然而匿名方法也正是建立在C#1.0中委托的基础上的（同时C# 2.0中对委托有所增强，提出了泛型委托，以及委托参数的协变和逆变，具体的可以参考本系列的前面专题），下面就具体介绍下为什么说匿名方法是如何建立在委托基础之上的（委托是方法的包装，匿名方法也是方法，只是匿名方法是没有名字的方法而已，所以委托也可以包装匿名方法）。

　　首先，先介绍下匿名方法的概念，匿名方法——没有名字的方法（方法也就是数学中的函数的概念），匿名方法只是在我们编写的源代码中没有指定名字而已，其实编译器会帮匿名方法生成一个名字，然而就是因为在源代码中没有名字，所以匿名方法只能在定义的时候才能调用，在其他地方不能被调用（匿名方法把方法的定义和方法的实现内嵌在一起），下面通过一个例子来看看匿名方法的使用和如何与委托关联起来的：

1. namespace 匿名方法Demo  
2. {  
3.     class Program  
4.     {  
5.         // 定义投票委托  
6.         delegate void VoteDelegate(string name);  
7.  
8.         static void Main(string[] args)  
9.         {  
10.             // 实例化委托对象  
11.             VoteDelegate votedelegate = new VoteDelegate(new Friend().Vote);  
12.  
13.             // 使用匿名方法的代码  
14.             // 匿名方法内联了一个委托实例（可以对照上面的委托实例化的代码来理解）  
15.             // 使用匿名方法后，我们就不需要定义一个Friend类以及单独定义一个投票方法  
16.             // 这样就可以减少代码量，代码少了，阅读起来就容易多了，以至于不会让过多的回调方法的定义而弄糊涂了  
17.             //VoteDelegate votedelegate = delegate(string nickname)  
18.             //{  
19.             //    Console.WriteLine("昵称为：{0} 来帮Learning Hard投票了", nickname);  
20.             //};  
21.  
22.             // 通过调用托来回调Vote()方法  
23.             votedelegate("SomeBody");  
24.             Console.Read();  
25.         }  
26.     }  
27.  
28.     public class Friend  
29.     {  
30.         // 朋友的投票方法  
31.         public void Vote(string nickname)  
32.         {  
33.             Console.WriteLine("昵称为：{0} 来帮Learning Hard投票了", nickname);  
34.         }  
35.     }  
36. } 

　　因为前段时间参加了51博客大赛，在投票阶段也拉了好多朋友来帮忙投票的，所以为了感谢他们，所以上面就以投票作为例子来引出匿名方法，注释的部分中已经解释了匿名方法的好处的，可以帮助我们减少书写代码量，便于阅读，然而上面地方可以使用匿名方法来代替委托呢？是不是所有使用委托的地方我们都需要用匿名方法去代替的呢？事实不是这样的，因为匿名方法是没有名字的方法，所以在其他地方就不能被调用，所以不具有复用作用，并且匿名方法自动形成"闭包"（如果对于闭包不理解的朋友可以参考这两个链接：http://baike.baidu.com/view/648413.htm 和http://zh.wikipedia.org/wiki/闭包_(计算机科学) ，我理解的闭包大概是当一个函数中（外部函数）调用了另个一个函数（称内部函数）时，当内部函数使用了外部函数中的变量时，这样就可能会形成闭包。具体的概念可以参考上面的两个链接，关于闭包在后面部分也会给出相关的例子来帮助大家理解，由于匿名函数会形成闭包，这就会延长变量的生命周期）。所以如果委托包装的方法相对简单（就像上面代码中只是单独一行输出语句），并且这个方法在其他地方使用的频率很低时，这时候就可以考虑用匿名方法来代替委托。

二、使用匿名方法来忽略委托参数

　　第一部分主要介绍了匿名方法的概念，使用以及介绍了我所理解的为什么会有匿名方法的提出（为了方便我们实例化委托实例，通过匿名方法可以内联委托实例，这样就避免额外定义一个实例方法，减少代码量，利于阅读），在这一部分中将介绍匿名方法的另外一个好处——忽略委托参数。下面通过一个示例代码来来帮助大家理解，代码中会有详细的注释，所以这里就不多说了，直接看代码了：

1. namespace 忽略委托参数Demo  
2. {  
3.     class Program  
4.     {  
5.         static void Main(string[] args)  
6.         {  
7.             // Timer类在应用程序中生成定期事件  
8.             System.Timers.Timer timer = new System.Timers.Timer();  
9.  
10.             // 该值指示是否引发Elapsed事件  
11.             timer.Enabled = true;  
12.  
13.             // 设置引发Elapsed事件的间隔  
14.             timer.Interval = 1000;  
15.  
16.             // Elapsed事件是达到间隔时发生，前面设置了时间间隔为1秒，  
17.             // 所以每一秒就会触发Elapsed事件，从而回调timer_Elapsed方法，输出当前的时间  
18.             // timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);  
19.  
20.             // 此时timer_Elapsed方法中的参数根本就不需要，所以我们可以使用匿名方法来省略委托参数  
21.             // 省略了参数后我们的代码就更加简洁了，看的多舒服啊  
22.             // 在开发WinForm程序中我们经常会用不到委托的参数，此时就可以使用匿名方法来省略参数  
23.             timer.Elapsed += delegate 
24.             {  
25.                 Console.WriteLine(DateTime.Now);  
26.             };  
27.  
28.             Console.Read();  
29.         }  
30.  
31.         public static void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)  
32.         {  
33.             Console.WriteLine(DateTime.Now);  
34.         }  
35.     }  
36. } 

运行结果为：

　　上面代码使用了匿名方法来省略委托参数，然而对于编译器而言，它还是会调用委托的构造函数来实例化委托，所以如果匿名方法能转换为多个委托类型时，此时如果省略了委托参数，编译器就不知道把匿名方法转化为哪个具体的委托类型，所以此时就会出现编译时错误，此时就必须人为的指定参数来告诉编译器如何实例化委托，下面就以创建线程为例子来帮助大家理解匿名方法省略委托参数所带来的问题（因为线程的创建涉及了两个委托类型： public delegate void ThreadStart() 和public delegaye void ParameterizedThreadStart(objec obj)）：

1. class Program  
2.     {  
3.         static void Main(string[] args)  
4.         {  
5.             new Thread(delegate()  
6.                 {  
7.                     Console.WriteLine("线程一");  
8.                 });  
9.  
10.             new Thread(delegate(object o)  
11.             {  
12.                 Console.WriteLine("线程二");  
13.             });  
14.  
15.             new Thread(delegate 
16.             {  
17.                 Console.WriteLine("线程三");  
18.             });  
19.             Console.Read();  
20.         }  
21.     } 

此时第三个创建线程的代码会出现下面的编译错误：

三、在匿名方法中捕捉变量

 　　前面介绍中提到使用匿名方法时会形成闭包，闭包指的就是在匿名方法中捕捉了变量，为了更好的理解闭包的概念，首先需要理解两个概念 ——外部变量和被捕捉的外部变量，下面通过一个例子来解释这个两个概念：

1. class Program  
2.     {  
3.         // 定义闭包委托  
4.         delegate void ClosureDelegate();  
5.  
6.         static void Main(string[] args)  
7.         {  
8.             closureMethod();  
9.             Console.Read();  
10.         }  
11.  
12.         // 闭包方法  
13.         private static void closureMethod()  
14.         {  
15.             // outVariable和capturedVariable对于匿名方法而言都是外部变量  
16.             // 然而outVariable是未捕获的外部变量，子所以是未捕获，是因为匿名方法中未引用该变量  
17.             string outVariable = "外部变量";  
18.  
19.             //  而capturedVariable是被匿名方法捕获的外部变量  
20.             string capturedVariable = "捕获变量";  
21.             ClosureDelegate closuredelegate = delegate 
22.             {  
23.                 // localvariable是匿名方法中局部变量  
24.                 string localvariable = "匿名方法局部变量";  
25.  
26.                 Console.WriteLine(capturedVariable+" "+localvariable);  
27.             };  
28.  
29.             // 调用委托  
30.             closuredelegate();  
31.         }  
32.     } 

　　一个变量被捕捉后，被匿名方法捕捉到的是真的变量，而不是创建委托实例时该变量的值，并且被匿名方法中捕捉到的变量会延长生命周期（意思是说对于一个被捕捉的变量，只要还有任何委托实例引用它，它就一直存在，而不会当委托实例调用结束后就被垃圾回收），下面通过一个具体的例子看看匿名方法是如何延长变量的生命周期的：

1. class Program  
2.     {  
3.         // 定义闭包委托  
4.         delegate void ClosureDelegate();  
5.  
6.         static void Main(string[] args)  
7.         {  
8.             ClosureDelegate test = CreateDelegateInstance();  
9.             test();  
10.      
11.             Console.Read();  
12.         }  
13.  
14.         // 闭包延长变量的生命周期  
15.         private static ClosureDelegate CreateDelegateInstance()  
16.         {  
17.             int count = 1;  
18.     
19.             ClosureDelegate closuredelegate = delegate 
20.             {  
21.                 Console.WriteLine(count);  
22.                 count++;  
23.             };  
24.  
25.             // 调用委托  
26.             closuredelegate();  
27.             return closuredelegate;  
28.         }  
29. } 

运行结果为：

　　第一行中的1是CreateDelegateInstance内部调用委托实例输出的结果，首先大家肯定认为count是在栈上分配的（因为count是值类型），当CreateDelegateInstance方法调用完后，count的值也会被销毁，当执行 test()这行代码时，此时会回调匿名方法来输出count的值，因为count被销毁，按理应该会出现异常才对的，然而结果却为2，然而结果并没有错，根据结果去倒推的话，可以得出，第二次调用委托实例也还是在使用原来的那个count，然而之所以我们认为会有异常抛出，主要原因是因为我们认为count是分配在栈上的，然而事实并不是这样的，count变量并不是分配在栈上的，事实上，编译器会创建一个额外的类来容纳变量(此时count变量时分配在堆上的），CreateDelegateInstance方法有该类的一个实例的引用，所以此时匿名方法捕捉到的变量count是它的一个引用，而不是真真的值，同时匿名方法也延长了变量count的生命周期，使它感觉不再像是一个局部变量，反而像是一个"全局变量"了(因为第二次中调用的委托实例使用的是同一个count)。

匿名方法捕捉到的变量，编译器会额外创建一个类来容纳该变量，对于这点，大家可以通过IL反汇编程序进行查看，下面是上面程序中使用反汇编程序得到的截图：

　　从上面的截图中可以看出，在源代码中根本没有<>c_DisplayClass1类的定义的，然而这个类真是编译器为我们创建来容纳捕获变量count的，并且该类中容纳了CreateDelegateInstance方法，从上图的左半部分中间语言代码可以看出，源代码中定义的CreateDelegateInstance方法具有该<>c_DisplayClass1的一个引用，在源代码中使用到的count变量编译器认为是<>c_DisplayClass1中的一个字段。

四、小结

 　　这个专题中主要介绍了匿名方法的使用以及匿名方法通过捕获变量来延长变量的生命周期，希望通过本专题的介绍大家可以对匿名方法可以有个全面的认识，并且匿名方法也是Lambda表达式的基础，Lambda表达式只是C# 3.0中提出更简洁的方式来实现匿名方法的。

     本文转自LearningHard 51CTO博客，原文链接http://blog.51cto.com/learninghard/1076169：，如需转载请自行联系原作者