委托，匿名方法，Lambda表达式

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace 委托
 7 {
 8     class Program
 9     {
10         /// <summary>
11         /// 
12         /// </summary>
13         /// <param name="param1"></param>
14         /// 把委托变量作为参数传递给一个函数。函数就可以使用委托调用它引用的任何函数。
15         /// 简单讲：各种方法都可以给委托调用，然后根据条件判断具体使用的哪个方法；不用关心具体的方法，感觉没啥用啊！！！
16         /// <param name="param2"></param>
17         /// <returns></returns>
18         delegate double processDelegate(double param1 ,double param2);//委托的声明
19         static double multiply(double param1, double param2)
20         { return param1 * param2; }
21         static double divide(double param1, double param2)
22         { return param1 / param2; }
23         static void Main(string[] args)
24         {
25             processDelegate process;
26             double d1 = 3;
27             double d2 = 2;
28             int i1;
29             input: Console.WriteLine("输入一个数字用来判断");
30 
31              try
32             {
33                 i1 = Convert.ToInt32(Console.ReadLine());
34                 Console.WriteLine("输入的数字是：{0}",i1.ToString());
35             }
36             catch (Exception e)
37             {
38 
39                 // throw ;
40                 Console.WriteLine(e.Message+"请在提示后重新输入");
41 
42                 goto input;
43             }
44            
45            
46             if (i1>=0&&i1<=5)
47             {
48                 Console.WriteLine("相除");
49                 process = new processDelegate(divide);
50                
51             }
52             else
53             {
54                 Console.WriteLine("相乘");
55                 process = new processDelegate(multiply);
56             }
57            
58             Console.WriteLine(process(d1,d2));
59             Console.ReadLine();
60         }
61     }
62 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace 委托
 7 {
 8     class Program
 9     {
10         /// <summary>
11         /// 
12         /// </summary>
13         /// <param name="param1"></param>
14         /// 把委托变量作为参数传递给一个函数。函数就可以使用委托调用它引用的任何函数。
15         /// 简单讲：各种方法都可以给委托调用，然后根据条件判断具体使用的哪个方法；不用关心具体的方法，感觉没啥用啊！！！
16         /// 加上匿名方法，感觉挺有意思了
17         /// <param name="param2"></param>
18         /// <returns></returns>
19         delegate double processDelegate(double param1 ,double param2);//委托的声明
20        
21         
22         //static double multiply(double param1, double param2)
23         //{ return param1 * param2; }
24         //static double divide(double param1, double param2)
25         //{ return param1 / param2; }
26         //把上面两个方法给匿名了
27             
28         static void Main(string[] args)
29         {
30             processDelegate process;
31             double d1 = 3;
32             double d2 = 2;
33             int i1;
34             input: Console.WriteLine("输入一个数字用来判断");
35 
36              try
37             {
38                 i1 = Convert.ToInt32(Console.ReadLine());
39                 Console.WriteLine("输入的数字是：{0}",i1.ToString());
40             }
41             catch (Exception e)
42             {
43 
44                 // throw ;
45                 Console.WriteLine(e.Message+"请在提示后重新输入");
46 
47                 goto input;
48             }
49            
50            
51             if (i1>=0&&i1<=5)
52             {
53                 Console.WriteLine("相除");
54                 //process = new processDelegate(divide);//匿名了
55                 process = delegate (double param1, double param2)
56                     { return param1 / param2; };
57              
58                
59             }
60             else
61             {
62                 Console.WriteLine("相乘");
63                 //process = new processDelegate(multiply);//匿名了
64                 process = delegate (double param1, double param2)
65                 { return param1 * param2; };
66 
67             }
68            
69             Console.WriteLine(process(d1,d2));
70             Console.ReadLine();
71         }
72     }
73 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace 委托
 7 {
 8     class Program
 9     {
10         /// <summary>
11         /// 
12         /// </summary>
13         /// <param name="param1"></param>
14         /// 把委托变量作为参数传递给一个函数。函数就可以使用委托调用它引用的任何函数。
15         /// 简单讲：各种方法都可以给委托调用，然后根据条件判断具体使用的哪个方法；不用关心具体的方法，感觉没啥用啊！！！
16         /// 加上匿名方法，感觉挺有意思了
17         /// 加上Lambda
18         /// <param name="param2"></param>
19         /// <returns></returns>
20         delegate double processDelegate(double param1 ,double param2);//委托的声明
21        
22         
23         //static double multiply(double param1, double param2)
24         //{ return param1 * param2; }
25         //static double divide(double param1, double param2)
26         //{ return param1 / param2; }
27         //把上面两个方法给匿名了
28             
29         static void Main(string[] args)
30         {
31             processDelegate process;
32             double d1 = 3;
33             double d2 = 2;
34             int i1;
35             input: Console.WriteLine("输入一个数字用来判断");
36 
37              try
38             {
39                 i1 = Convert.ToInt32(Console.ReadLine());
40                 Console.WriteLine("输入的数字是：{0}",i1.ToString());
41             }
42             catch (Exception e)
43             {
44 
45                 // throw ;
46                 Console.WriteLine(e.Message+"请在提示后重新输入");
47 
48                 goto input;
49             }
50            
51            
52             if (i1>=0&&i1<=5)
53             {
54                 Console.WriteLine("相除");
55                 //process = new processDelegate(divide);//匿名了
56                 process = delegate (double param1, double param2)//匿名方法
57                     { return param1 / param2; };
58              
59                
60             }
61             else
62             {
63                 Console.WriteLine("相乘");
64                 //process = new processDelegate(multiply);//匿名了
65 
66                 // process =  (p1, p2) => p1 * p2;//Lambda表达式，现在更简单了
67                 //可以在Lambda中写更多的方法，类似上面的匿名方法
68                 process = (double p1, double p2) =>
69                   {
70                       Console.WriteLine("我是表达式");
71                       return p1 * p2;
72                   };//注意这里的这个符号哦，这个是表达式的格式规范
73             }
74            
75             Console.WriteLine(process(d1,d2));
76             Console.ReadLine();
77         }
78     }
79 }