拉姆达表达式学习(2)

在.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作为参数的写法

秒客网

拉姆达表达式学习(2)

相关文章