拉姆达表达式学习(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作为参数的写法