zoukankan      html  css  js  c++  java
  • 拉姆达表达式学习(2)

     本文转载自: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作为参数的写法

  • 相关阅读:
    重学数据结构系列之——图的储存
    重学数据结构系列之——森林之并查集(Disjoint set)
    nginx的sbin和conf文件不在同一目录怎么装安全狗
    优先队列解哈夫曼编码问题之带权路径长度
    重学数据结构系列之——堆及堆排序
    搭建git私有服务器及同步更新自己网站的文件
    void类型指针的基本用法
    关于c++中const的基本用法
    1054 求平均值 (20 分)
    数数
  • 原文地址:https://www.cnblogs.com/xinting/p/12536183.html
Copyright © 2011-2022 走看看