C#开发-集合使用和技巧（二）Lambda 表达式介绍和应用

C#开发-集合使用和技巧

Lambda 表达式介绍和应用

• C#开发-集合使用和技巧
• 介绍
• • 简单的示例：
  • 集合查询示例：
  • 1. 基本语法
  • • 从主体语句上区分：
    • • 1. 主体为单一表达式
      • 2. 主体是代码块（多个表达式语句）
      • 从参数上区分
      • • 1. 带输入参数的Lambda表达式
        • 2. 不带输入参数的Lambda表达式
        • 特殊用法：
        • 2. 用法和示例
        • • 用法
          • • (1)LINQ 查询
            • (2) 委托和事件处理
            • 高级用法
            • • • (1) 闭包
                • 5. 总结

                  介绍

                  Lambda 表达式在 csharp 中是一种简洁的方式来表示匿名方法（也称为匿名函数）。Lambda 表达式的语法使用 => 操作符，左侧是输入参数，右侧主体是表达式或代码块。

                  Lambda 表达式主要用于简化 LINQ 查询和事件处理代码,在开发过程中，可以很好的简化代码。

                  简单的示例：

                  我们给按钮加一个点击事件，我们需要先写一个点击的方法，然后+=给按钮添加事件

                  ·

                  使用lambda表达式就可以一行搞定

                  

                   public partial class Form1 : Form
                   {
                       int num = 0;
                       public Form1()
                       {
                           InitializeComponent();
                           button1.Click += Button1_Click;
                           button1.Click += (sender, e) => num++;
                       }
                       private void Button1_Click(object sender, EventArgs e)
                       {
                           num++;
                       }
                   }
                  

                  集合查询示例：

                  在一个人员信息集合中找出所以性别为男的

                  

                  如果要在一个集合，可以通过循环查找，这样需要循环+判断，然后将结果添加到新的集合中去

                  

                  也可以使用Linq表达式实现，这样比第一种方法简单一点，但是也要写很长的代码

                  

                  使用lambda表达式，一句话搞定。

                  

                  以下是几种方法的完整的代码

                   List testList = new List
                   {
                       new Person
                       {
                           Id = 1,
                           Name = "张三",
                           City = "北京",
                           Sex = "男"
                       },
                       new Person
                       {
                           Id = 2,
                           Name = "李四",
                           City = "上海",
                           Sex = "女"
                       },
                       new Person
                       {
                           Id = 3,
                           Name = "王五",
                           City = "广州",
                           Sex = "男"
                       },
                       new Person
                       {
                           Id = 4,
                           Name = "赵六",
                           City = "深圳",
                           Sex = "女"
                       },
                       new Person
                       {
                           Id = 5,
                           Name = "孙七",
                           City = "杭州",
                           Sex = "男"
                       }
                   };
                   //方法一：循环查找
                   var ResultList = new List();
                   foreach (var item in testList)
                   {
                       if (item.Sex == "男")
                       {
                           ResultList.Add(item);
                       }
                   }
                   //方法二: Linq语句
                   var ResultList2 = from item in testList where item.Sex == "男" select item;
                   //方法三：lambda
                   var result3 = testList.Where(x => x.Sex == "男");
                  

                  以下是 lambda 表达式的介绍和一些常见用法：

                  1. 基本语法

                  Lambda 表达式有不同的写法

                  从主体语句上区分：

                  1. 主体为单一表达式

                  (parameters) => expression
                  

                  示例：

                  (x)=>x+1
                  x=>x+1
                  //上面两种效果一致，只有一个参数时，括号可以简写
                  //多个参数必须要写括号
                   (x, y) => x + y
                  

                  效果：

                  多个参数必须加括号，不然会报错

                  

                  2. 主体是代码块（多个表达式语句）

                  如果右侧表达主体中有个多个语句，则需要{ }包裹，主体就跟正常写函数一样

                  (parameters) => { statements }
                  

                  示例：

                  (isOpen) =>
                  {
                      if (isOpen)
                      {
                          Console.WriteLine("打开");
                      }
                      else
                      {
                          Console.WriteLine("关闭");
                      }
                  }
                  

                  从参数上区分

                  1. 带输入参数的Lambda表达式

                   (input parameters) => expression
                  

                  示例：

                      (x) => x * 2
                      (x, y) => x + y
                  

                  2. 不带输入参数的Lambda表达式

                   	=> expression
                  

                  示例：

                     () => { return 5; }
                  

                  特殊用法：

                  有些情况，Lambda需要带参数，但是在右侧表达式主体中，又用不到参数，这时就可以使用 _来代替参数，表示

                  _ => 是Lambda表达式的简写形式，其中 _ 通常表示一个未使用的输入参数。

                  _ => expression
                  

                  示例：

                   Action action3 = _ =>
                   {
                       Console.WriteLine("执行了aciton");
                   };
                   
                   
                   button.Clicked += (_, _) => {
                      // 不需要事件参数，直接执行代码
                      DoSomething();
                  };
                  

                  2. 用法和示例

                  用法

                  (1)LINQ 查询

                  Lambda 表达式在 LINQ 查询中广泛使用：

                  List numbers = new List { 1, 2, 3, 4, 5 };
                  var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();
                  

                  在上面的代码中，n => n % 2 == 0 是一个 lambda 表达式，用于筛选出所有偶数。

                  (2) 委托和事件处理

                  Lambda 表达式也可以用于定义委托和事件处理程序：

                  public delegate int MathOperation(int x, int y);
                  MathOperation multiply = (x, y) => x * y;
                  int product = multiply(3, 4);  // product = 12
                  // 事件处理
                  button.Click += (sender, e) => { Console.WriteLine("Button clicked!"); };
                  

                  高级用法

                  (1) 闭包

                  Lambda 表达式可以捕获并使用它们作用域中的变量：

                  int multiplier = 3;
                  Func multiplyBy = x => x * multiplier;
                  int result = multiplyBy(5);  // result = 15
                  

                  在这个例子中，Lambda 表达式 x => x * multiplier 捕获了外部变量 multiplier。

                  5. 总结

                  Lambda 表达式是 C# 中强大的功能特性，用于简化代码、提高可读性，特别是在 LINQ 查询和事件处理方面。它们的语法简单而灵活，能很好地提高代码的简洁性和可维护性。

                  特别是在后续一些集合操作中，基本都要用到Lambda 表达式，掌握好Lambda 表达式，可以很好的提高编程效率。