拉姆达表达式学习(2)

ゞ浴缸里的玫瑰 2022-10-01 02:59 186阅读 0赞

本文转载自：[http://www.cnblogs.com/zhouji432600/archive/2010/05/30/1747383.html][http_www.cnblogs.com_zhouji432600_archive_2010_05_30_1747383.html]

在.net3.5里面,委托的定义和实现被大大的简化了!使用关键字Func或Action就可以定义一个委托,使用拉姆达表达式就可以实现一个具体的委托.  
Func关键字是用来定义一个有返回值的委托,它一共有五个重载,我们介绍其中的三个  
1 public delegate TResult Func<TResult>();  
  这表示一个没有参数,只有一个返回值的委托,返回值的类型就是TResult(泛型)

代码

1  public class test  
 2     \{  
 3         /// <summary>  
 4         /// 定义一个委托  
 5         /// </summary>  
 6         public Func<string> \_GetName;  
 7         /// <summary>  
 8         /// 一个普通的没有参数,有返回值的方法  
 9         /// </summary>  
10         /// <returns></returns>  
11         public string GetName()  
12         \{  
13             return "张三";  
14         \}  
15         public void Main()  
16         \{  
17             //3.5以前的委托的实现,直接赋值  
18             \_GetName = GetName;  
19   
20             //拉姆达表达式的实现方法  
21             \_GetName = (  
22                 ()          //因为这个委托没参数,所以参数列表没有东西  
23                     =>      //拉姆达表达式的符号  
24                 \{           //大括号的代码段表示具体的委托的实现  
25                     return "还是张三";  
26                 \});  
27             //拉姆达表达式的简写,如果委托的实现代码段中只有一句return 则可以省略代码段最外面的大括号,和return关键字  
28             \_GetName = () => "总是张三";  
29             //调用  
30             string MyName = \_GetName();  
31         \}  
32     \}

2 public delegate TResult Func<T, TResult>(T arg);  
 这表示有且仅有一个参数,并且有返回值的委托.

代码

1  public class test  
 2     \{  
 3         /// <summary>  
 4         /// 定义一个委托,有一个参数和一个返回值  
 5         /// </summary>  
 6         public Func<string, string> \_GetName;  
 7         /// <summary>  
 8         /// 有一个参数的方法  
 9         /// </summary>  
10         /// <param name="strName">这是一个参数!</param>  
11         /// <returns>这是一个返回值</returns>  
12         public string GetName(string strName)  
13         \{  
14             return strName;  
15         \}  
16         public void Main()  
17         \{  
18             //3.5以前的委托的实现,直接赋值  
19             \_GetName = GetName;  
20   
21             //拉姆达表达式的实现方法  
22             \_GetName = (  
23                 (S)          //有一个参数!所以参数列表里面有一个东西,这个东西随大家高兴叫个阿猫阿狗都行!只要符合规范  
24                     =>      //拉姆达表达式的符号  
25                 \{           //大括号的代码段表示具体的委托的实现  
26                     return "还是" + S;  
27                 \});  
28             //拉姆达表达式的简写,如果委托的实现代码段中只有一句return 则可以省略代码段最外面的大括号,和return关键字  
29             \_GetName = (abc) => "总是" + abc;  
30             //调用  
31             string MyName = \_GetName("张三");  
32         \}  
33     \}

3 public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);  
 这表示有且仅有两个参数,并且有返回值的委托.

代码

1  public class test  
 2     \{  
 3         /// <summary>  
 4         /// 定义一个委托,有一个参数和一个返回值  
 5         /// </summary>  
 6         public Func<string, int, string> \_GetName;  
 7         /// <summary>  
 8         /// 这是一个有两个参数的方法,方法的参数类型的顺序必须和委托的参数类型顺序一致  
 9         /// </summary>  
10         /// <param name="strName">第一个是字符类型</param>  
11         /// <param name="intAGE">第二个是整形,请不要颠倒类型!</param>  
12         /// <returns>返回一个字符串,对应委托的最后一个参数</returns>  
13         public string GetName(string strName, int intAGE)  
14         \{  
15             return string.Format("\{0\}的年龄是\{1\}岁", strName, intAGE);  
16         \}  
17         public void Main()  
18         \{  
19             //3.5以前的委托的实现,直接赋值  
20             \_GetName = GetName;  
21   
22             //拉姆达表达式的实现方法  
23             \_GetName = (  
24                 (S, W)          //有一个参数!所以参数列表里面有一个东西,这个东西随大家高兴叫个阿猫阿狗都行!只要符合规范  
25                     =>      //拉姆达表达式的符号  
26                 \{           //大括号的代码段表示具体的委托的实现  
27                     return string.Format("\{0\}的年龄是\{1\}岁", S, W);  
28                 \});  
29             //拉姆达表达式的简写,如果委托的实现代码段中只有一句return 则可以省略代码段最外面的大括号,和return关键字  
30             \_GetName = (abc, efd) => string.Format("\{0\}的年龄是\{1\}岁", abc, efd);  
31             //调用  
32             string MyName = \_GetName("张三", 33);  
33         \}  
34     \}

Action关键字用来定义一个没有返回值的方法,它有一个非泛型方法,和四个泛型方法,一共五种.Action和func的区别就在于一个没有返回值,一个有返回值!其他的都一样!就好像VB的sub和function一样!  
1 public delegate void Action();  
没有参数也没有返回值

代码

1 public class test  
 2     \{  
 3         /// <summary>  
 4         /// 定义一个委托,没有返回值也没有参数  
 5         /// </summary>  
 6         public Action \_GetName;  
 7   
 8         public void GetName()  
 9         \{  
10             System.Windows.Forms.MessageBox.Show("没有参数也没有返回值,我只要自己显示了!");  
11         \}  
12         public void Main()  
13         \{  
14             //3.5以前的委托的实现,直接赋值  
15             \_GetName = GetName;  
16   
17             //拉姆达表达式的实现方法  
18             \_GetName = (  
19                 ()  
20                     =>      //拉姆达表达式的符号  
21                 \{           //大括号的代码段表示具体的委托的实现  
22                     System.Windows.Forms.MessageBox.Show("没有参数也没有返回值,我只要自己显示了!");  
23                 \});  
24             //因为action没有返回值,所以下面的简写方式是错误的  
25             //\_GetName = () => System.Windows.Forms.MessageBox.Show("没有参数也没有返回值,我只要自己显示了!");   
26             //调用  
27             \_GetName();  
28         \}  
29     \}

2  public delegate void Action<T>(T obj);  
有一个参数但没有返回值

代码

1 public class test  
 2     \{  
 3         /// <summary>  
 4         /// 定义一个委托,没有返回值也没有参数  
 5         /// </summary>  
 6         public Action<bool> \_GetName;  
 7   
 8         public void GetName(bool blnShow)  
 9         \{  
10             if (blnShow)  
11             \{  
12                 System.Windows.Forms.MessageBox.Show("要我显示就显示,多没面子");  
13             \}  
14             else  
15             \{  
16                 System.Windows.Forms.MessageBox.Show("不要我显示,我偏要显示");  
17             \}  
18         \}  
19         public void Main()  
20         \{  
21             //3.5以前的委托的实现,直接赋值  
22             \_GetName = GetName;  
23   
24             //拉姆达表达式的实现方法  
25             \_GetName = (  
26                 (b)  
27                     =>      //拉姆达表达式的符号  
28                 \{           //大括号的代码段表示具体的委托的实现  
29                     if (b)  
30                     \{  
31                         System.Windows.Forms.MessageBox.Show("要我显示就显示,多没面子");  
32                     \}  
33                     else  
34                     \{  
35                         System.Windows.Forms.MessageBox.Show("不要我显示,我偏要显示");  
36                     \}  
37                 \});  
38   
39             \_GetName(true);  
40         \}  
41     \}

不过通常func和action并不是单独定义,然后使用,而是当作某个方法的参数的类型!下一次使用linq的方法,讲解一下func和action作为参数的写法

[http_www.cnblogs.com_zhouji432600_archive_2010_05_30_1747383.html]: http://www.cnblogs.com/zhouji432600/archive/2010/05/30/1747383.html