C# 初学Lambda表达式

最新推荐文章于 2023-04-26 14:06:43 发布
最新推荐文章于 2023-04-26 14:06:43 发布
阅读量319 收藏 1
点赞数
分类专栏： C# Linq、Lamdba
原文链接：https://www.cnblogs.com/atomy/p/12080368.html
版权

抄自：https://www.cnblogs.com/leslies2/archive/2012/03/22/2389318.html

C# 初学Lambda表达式

一、Lambda 的意义

在Framework 2.0 以前，声明委托的唯一方法是通过方法命名，从Framework 2.0 起，系统开始支持匿名方法。通过匿名方法，可以直接把一段代码绑定给事件，因此减少了实例化委托所需的编码系统开销。而在 Framework 3.0 开始，Lambda表达式开始逐渐取代了匿名方法，作为编写内联代码的首选方式。
总体来说，Lambda 表达式的作用是为了使用更简单的方式来编写匿名方法，彻底简化委托的使用方式。

二、回顾匿名方法的使用

简单回顾一下

static void Main(string[] args)
        {
            #region 事件的使用及方法绑定
            PersonManager personManager = new PersonManager();
            //绑定事件处理方法方式一
            personManager.MyEvent += new MyDelegate(GetName);
            //绑定事件处理方法方式二
            personManager.MyEvent += GetName;
            //绑定事件处理方法方式三(匿名方法)
            personManager.MyEvent += delegate (string name) { Console.WriteLine("My name is " + name); };
            personManager.Execute("Atomy");
            Console.Read();
            #endregion
        }

总是使用 delegate（）{…} 的方式建立匿名方法，令人不禁感觉郁闷。于是从Framework 3.0起，Lambda表达式开始出现。

三、简单介绍泛型委托

在介绍Lambda表达式前，先介绍一下常用的几个泛型委托。

3.1 泛型委托 Predicate

早在Framework 2.0的时候，微软就为List类添加了Find、FindAll、ForEach等方法用作数据的查找。

public T Find ( Predicate<T> match）
public List<T> FindAll（Predicate<T>  match）

在这些方法中存在一个Predicate 表达式，它是一个返回bool的泛型委托，能接受一个任意类型的对象作为参数。

public delegate bool Predicate<T>（T obj）

在下面例子中，Predicate委托绑定了参数为Person类的方法Match作为查询条件，然后使用FindAll方法查找到合适条件的List集合。

class Program
    {
        #region 泛型委托 Predicate<T>
        /// <summary>
        /// Person类
        /// </summary>
        class Person
        {
            public int Id { get; set; }
            public string Name { get; set; }
            public int Age { get; set; }

            public Person(int id, string name, int age)
            {
                Id = id;
                Name = name;
                Age = age;
            }
        }

        /// <summary>
        /// 数据源
        /// </summary>
        /// <returns></returns>
        static List<Person> GetList()
        {
            var personList = new List<Person>();
            var person = new Person(1, "Hello", 29);
            personList.Add(person);
            person = new Person(1, "World", 31);
            personList.Add(person);
            return personList;
        }

        /// <summary>
        /// 查询条件
        /// </summary>
        /// <param name="person"></param>
        /// <returns></returns>
        static bool Match(Person person)
        {
            return person.Age <= 30;
        }
        #endregion

        static void Main(string[] args)
        {
            #region 泛型委托 Predicate<T>
            List<Person> list = GetList();
            //绑定查询条件
            Predicate<Person> predicate = new Predicate<Person>(Match);
            List<Person> result = list.FindAll(predicate);
            Console.WriteLine($"Person count is : {result.Count}");
            Console.Read();
            #endregion
        }
    }

运行结果如下：
在这里插入图片描述

3.2 泛型委托 Action

Action 的使用方式与 Predicate 相似，不同之处在于 Predicate 返回值为 bool , Action 的返回值为 void。

Action 支持0~16个参数，可以按需求任意使用。

public delegate void Action()

public delegate void Action (T1 obj1)

public delegate void Action<T1，T2> (T1 obj1, T2 obj2)

public delegate void Action<T1，T2，T3> (T1 obj1, T2 obj2，T3 obj3)

............

public delegate void Action<T1，T2，T3，…，T16> (T1 obj1, T2 obj2，T3 obj3，…，T16 obj16)

下面代码演示泛型委托Action：

class Program
    {
        #region 泛型委托 Func
        static double Account(double a, bool condition)
        {
            if (condition)
                return a * 1.5;
            else
                return a * 2;
        }
        #endregion

        static void Main(string[] args)
        {
            #region 泛型委托 Func
            Func<double, bool, double> func = Account;
            double result = func(1000, true);
            Console.WriteLine($"Result is : {result}");
            Console.Read();
            #endregion
        }
    }

运行结果如下：
在这里插入图片描述

四、揭开 Lambda 神秘的面纱

Lambda的表达式的编写格式如下：x=> x * 1.5

当中 “ => ”是Lambda表达式的操作符，在左边用作定义一个参数列表，右边可以操作这些参数。

例子一：先把int x设置1000，通过Action把表达式定义为x=x+500，最后通过Invoke激发委托。

class Program
    {
        static void Main(string[] args)
        {
            #region Lambda例子一
            int x = 1000;
            Action action = () => x = x + 500;
            action.Invoke();

            Console.WriteLine($"Result is : {x}");
            Console.Read();
            #endregion
        }
    }

运行结果如下：在这里插入图片描述
例子二：通过Action把表达式定义x=x+500，到最后输入参数1000，得到的结果与例子一相同。

注意，此处Lambda表达式定义的操作使用{ }括弧包括在一起，里面可以包含一系列的操作。

class Program
    {
        static void Main(string[] args)
        {
            #region Lambda例子二
            Action<int> action = (x) =>
            {
                x = x + 500;
                Console.WriteLine($"Result is : {x}");
            };
            action.Invoke(1000);
            Console.Read();
            #endregion
        }
    }

运行结果如下：在这里插入图片描述
例子三：定义一个Predicate，当输入值大约等于1000则返回true，否则返回false。与3.1的例子相比，Predicate的绑定不需要显式建立一个方法，

而是直接在Lambda表达式里完成，简洁方便了不少。


    class Program
    {
        static void Main(string[] args)
        {
            #region Lambda例子三
            Predicate<int> predicate = (x) =>
            {
                if (x >= 1000)
                    return true;
                else
                    return false;
            };
            bool result = predicate.Invoke(500);
            Console.WriteLine($"Result={result}");
            Console.Read();
            #endregion
        }
    }

运行结果如下：

在这里插入图片描述

例子四：在计算商品的价格时，当商品重量超过30kg则打9折，其他按原价处理。此时可以使用Func<double,int,double>，参数1为商品原价，参数2为商品

重量，最后返回值为 double 类型。

class Program
    {
        static void Main(string[] args)
        {
            #region Lambda例子四
            Func<double, int, double> func = (price, weight) =>
            {
                if (weight >= 30)
                    return price * 0.9;
                else
                    return price;
            };
            double totalPrice = func(200.0, 40);
            Console.WriteLine($"TotalPrice={totalPrice}");
            Console.Read();
            #endregion
        }
    }

运行结果如下
在这里插入图片描述
例子五：使用Lambda为Button定义Click事件的处理方法，使用Lambda比使用匿名方法更加简单。

public partial class Main : Form
    {
        public Main()
        {
            InitializeComponent();
        }

        private void Main_Load(object sender, EventArgs e)
        {
            #region Lambda例子五
            btnEvent.Click += (obj,arg)=>
            {
                MessageBox.Show("Hello World");
            };
            #endregion
        }
    }

运行结果如下：
在这里插入图片描述
例子六：此处使用3.1的例子，在List的FindAll方法中直接使用Lambda表达式。相比之下，使用Lambda表达式，不需要定义Predicate对象，也

不需要显式设定绑定方法，简化了不工序。

class Program
    {
        #region 泛型委托 Predicate<T>
        /// <summary>
        /// Person类
        /// </summary>
        class Person
        {
            public int Id { get; set; }
            public string Name { get; set; }
            public int Age { get; set; }

            public Person(int id, string name, int age)
            {
                Id = id;
                Name = name;
                Age = age;
            }
        }

        /// <summary>
        /// 数据源
        /// </summary>
        /// <returns></returns>
        static List<Person> GetList()
        {
            var personList = new List<Person>();
            var person = new Person(1, "Hello", 29);
            personList.Add(person);
            person = new Person(1, "World", 31);
            personList.Add(person);
            return personList;
        }

        /// <summary>
        /// 查询条件
        /// </summary>
        /// <param name="person"></param>
        /// <returns></returns>
        static bool Match(Person person)
        {
            return person.Age <= 30;
        }
        #endregion

        static void Main(string[] args)
        {
            #region Lambda例子六
            List<Person> personList = GetList();
            //查找年龄少于30年的人
            List<Person> result = personList.FindAll((person) => person.Age <= 30);
            Console.WriteLine("Person count is : " + result.Count);
            Console.Read();
            #endregion
        }
    }

运行结果如下：在这里插入图片描述
在使用LINQ技术的时候，到处都会弥漫着Lambda的身影，此时更能体现Lambda的长处。但LINQ涉及到分部类、分部方法、IEnumerable、迭代器等

多方面的知识，这些已经超出本章的介绍范围。通过这一节的介绍，希望能够帮助大家更深入地了解Lambda的使用。

转载自：https://www.cnblogs.com/atomy/p/12080368.html

Wu7z
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lambda表达式详解
08-15
mbda表达式详解,有详细的例子,简单易懂,一看就会,适合还没有接触过Lambda表达式的初学者学习
C#表达式目录树vs实用插件
01-14
同时，你需要熟悉如何通过Lambda表达式创建表达式树，以及如何使用Expression类库中的静态方法来组合和修改节点。一旦掌握了这些基础，你就可以利用表达式目录树的强大能力来实现各种高级编程任务，如动态Linq查询、...
Lambda表达式详解（C#）
草原上唱山歌的博客
03-22 2万+
Lambda表达式可以采用以下任意一种形式的表达式： 1.表达式Lambda，表达式为其主体： (input-parameters) => expression 2.语句Lambda，语句块作为其主体： (input-parameters) => {<sequence-of-statements>} 使用Lambda声明运算符=>，从其主体中分离Lambda参数列表。若要创建Lambda表达式，需要在Lambda运算符左侧指定输入参数（如果有参数时），然后在另一侧输入表达式
C# 常见的Lambda表达式
weixin_57718347的博客
04-26 2253
Lambda表达式是C#中的一种匿名函数，通常用于简化代码和提高效率。
Lambda表达式详细总结
热门推荐
王伯仙的博客
12-23 13万+
（一）输入参数 在Lambda表达式中，输入参数是Lambda运算符的左边部分。它包含参数的数量可以为0、1或者多个。只有当输入参数为1时，Lambda表达式左边的一对小括弧才可以省略。输入参数的数量大于或者等于2时，Lambda表达式左边的一对小括弧中的多个参数质检使用逗号（,）分割。 示例1 下面创建一个Lambda表达式，它的输入参数的数量为0.该表达式将显示“This is a La
C# Lambda表达式和委托
熊思雨的博客
04-10 1623
"Lambda表达式"是一个，是一种高效的类似于函数式编程的表达式，Lambda简化了开发中需要编写的代码量。它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型，支持带有可绑定到委托或表达式树的输入参数的内联表达式。
c# lambda表达式学习
alk61828的博客
06-04 130
1. 普通绑定： public void button1_Click(object sender, EventArgs e) { MessageBox.Show("ok"); } this.button1.Click += button1_Click; 2. 匿名委托： this.button1.Cli...
毕业设计：公车派遣系统，EF框架+T4模板+Lambda表达式+三层设计+MVC.zip
01-02
“Lambda表达式”是C#语言中的一个重要特性，它提供了一种简洁的编写匿名函数的方式，常在LINQ查询中使用，对于处理数据查询和过滤非常便捷。结合“三层设计”，我们可以推测这个系统采用了常见的软件架构模式——...
C# 初学教程.rar
01-08
这部分将深入探讨更多C#的高级特性，如委托（delegate）、事件（event）、匿名方法、Lambda表达式和 LINQ（Language Integrated Query）。委托是C#中实现回调和事件处理的关键，而事件则是组件间通信的常用方式。...
C#初学者课件C#初学者课件
06-21
最后，C#的持续发展引入了许多新特性，例如Lambda表达式、LINQ（Language Integrated Query）以及异步编程模型等，这些都大大简化了代码，提高了开发效率。 总结来说，C#初学者课件将涵盖以上所述的所有知识点，从...
C#lambda表达式入门.pptx
04-26
通过多个示例详细演示了.Net中C#语言lambda表达式的基本用法，主要包括三个方面内容： 1.什么是lambda表达式 2.理解lambda表达式 3.使用lambda表达式
C# Lambda表达式和查询表达式
12-17
C#之Lambda表达式和查询表达式 本文档下载自百度文库
C#基础之Lambda表达式用法实例教程
09-04
主要介绍了C#中Lambda表达式用法,并与之前所述的匿名方法做一比较,详细的讲述了Lambda表达式的定义及具体用法,需要的朋友可以参考下
C# 学习之路 —— Lambda表达式
布衣大侠的博客
08-13 278
C# 3.0引入了Lambda表达式，它是一种简化匿名函数，可用于创建委托或表达式目录树，也可以将表达式作为参数传递或者作为函数调用值调用后返回的一个函数来使用。 (input parameters) => expression Lambda表达式组成部分： 放在括号中的参数列表（未类型化） =>运算符 C# 语句体，可以包含单个或者多个语句，把一个代码块放在花括号中。如...
c# lambda表达式学习(1)
c6088的专栏
07-28 307
using System; using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; using System.Text; namespace ConsoleApplication1 {     class Program     {         delegate
C#Lambda表达式详解
ChinarCSDN的博客
04-30 1万+
C#Lambda表达式详解，Lambda表达式教程 Chinar-本文提供全流程，中文翻译 助力快速理解 Lambda 表达式的用法、规范 Lambda 表达式是一个匿名函数，用它可以高效简化代码，常用作委托，回调 Lambda 表达式都使用运算符=>，所以当你见到这个符号，基本上就是一个 Lambda 表达式 Lambda 运算符的左边是输入参数()，=>，右边是表达式或语句块 Lambda 表达式，是可以访问到外部变量的 可以将此表达式分配给委托类型 Lambda 只有一个参数时，可以省略括
C# Lambda表达式
836811384
09-21 180
自C#3.0开始，就可以使用一种新语法把实现代码赋予委托：Lambda表达式。只要有委托参数类型的地方，就可以使用Lambda表达式。 Lambda表达式的语法比匿名方法简单。如果所调用的方法有参数，且不需要参数，匿名方法的语法就比较简单，因为这样不需要提供参数。 直接上一些例子，读者可以自行运行调试。 static void Main(string[] args) ...
C#中Lambda表达式总结
weixin_43628744的博客
11-19 1047
在C#的语法中有一种比较特殊的写法，叫做Lambda表达式，这种表达式的写法在于你查询数据的时候直接是使用以下箭头的形式来表示查询语句的：=>。例如，我们要查找学生的List<Student>集合中班级编号为1001的所有学生数据，我们即可用Studentlist.Where(t=>t.ClassCode=‘1001’)语句来直接完成，无需再写繁琐的foreach语句或者for循环。Lambda表达式的运算符即为=>。 一、Lambda表达式定义 Lambda表...
C# Lambda的用法
绝圣弃智-零的博客
10-30 1万+
C# Lambda的用法 我们过去遇到循环问题都是用foreach和for，慢慢就成了习惯，不愿意用其他简便的方式，lambda能代替循环而且简便了很多。 1：什么是lambda表示式 Lambda 表达式是一种可用于创建委托或表达式目录树的匿名函数（摘自MSDN）这句话是什么意思下面慢慢开始说起 2：用一张图来表示lambda的组成 就是形如（参数）=>{操作} 3：...
C# func lambda表达式
最新发布
04-04
C#中的Func和Lambda表达式是用于定义匿名函数和委托的重要特性。 Func是一个泛型委托类型，它可以接受多个输入参数并返回一个结果。Func的定义形式为`Func<T1, T2, ..., TResult>`，其中T1、T2等表示输入参数的类型，TResult表示返回结果的类型。例如，`Func<int, int, int>`表示接受两个int类型参数并返回一个int类型结果的委托。 Lambda表达式是一种简洁的语法形式，用于创建匿名函数。它可以在需要函数作为参数的地方使用，例如在LINQ查询、委托和事件处理等场景中。Lambda表达式的一般形式为`(input parameters) => expression`，其中input parameters表示输入参数列表，expression表示函数体的表达式。例如，`(x, y) => x + y`表示接受两个参数x和y，并返回它们的和。 使用Func和Lambda表达式可以方便地定义和传递匿名函数，提高代码的简洁性和可读性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值