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 }
委托和一个匿名方法一个Lambda表达式
01:50:11 2019-02-09
回头找找Lambda和集合泛型的用法
原文地址：https://www.cnblogs.com/myjobok/p/10357063.html
时间： 2024-11-12 16:19:15