详细介绍一下C#中Lambda表达式的使用场景

最新推荐文章于 2025-03-25 22:53:56 发布

alankuo

最新推荐文章于 2025-03-25 22:53:56 发布

阅读量1.2k

点赞数 33

分类专栏：前端程序开发文章标签：前端

本文链接：https://blog.youkuaiyun.com/alankuo/article/details/143471217

版权

前端同时被 2 个专栏收录

221 篇文章

订阅专栏

程序开发

40 篇文章

订阅专栏

C#中的Lambda表达式提供了一种简洁、灵活的方式来定义匿名方法，它在很多场景下都有广泛的应用，以下是一些常见的使用场景：

一、作为委托的实例化快捷方式

常规委托实例化：
- 在没有Lambda表达式之前，要实例化一个委托，通常需要先定义一个具有特定签名的方法，然后将该方法赋值给委托变量。例如，定义一个委托用于执行数学运算：

delegate int MathOperationDelegate(int a, int b);

class Program
{
    static int Add(int a, int b)
    {
        return a + b;
    }

    static void Main()
    {
        MathOperationDelegate operation;
        operation = Add;
        int result = operation(3, 5);
        Console.WriteLine(result);
    }
}

- 这里先定义了 `MathOperationDelegate` 委托，然后定义了 `Add` 方法，最后将 `Add` 方法赋值给委托变量 `operation` 来执行加法运算。

使用Lambda表达式实例化委托：
- Lambda表达式可以直接在定义委托变量时作为实例化的值，无需单独定义方法。例如：

delegate int MathOperationDelegate(int a, int b);

class Program
{
    static void Main()
    {
        MathOperationDelegate operation = (a, b) => a + b;
        int result = operation(3, 5);
        Console.WriteLine(result);
    }
}

- 在上述代码中，通过Lambda表达式 `(a, b) => a + b` 直接实例化了 `MathOperationDelegate` 委托变量 `operation`，它实现了与前面定义 `Add` 方法相同的加法运算功能，但代码更加简洁。

二、在集合操作中的应用

List 等集合的筛选操作：
- 当需要从一个 List（或其他集合类型）中筛选出满足特定条件的元素时，Lambda表达式可以很方便地实现这一功能。例如，有一个 List 包含一些整数，要筛选出其中的偶数：

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        List<int> evenNumbers = numbers.Where(x => x % 2 == 0).ToList();

        foreach (int num in evenNumbers)
        {
            Console.WriteLine(num);
        }
    }
}

- 这里使用 `List` 的 `Where` 方法结合Lambda表达式 `x => x % 2 == 0` 来筛选出满足条件（即能被2整除）的元素，将筛选结果转换为 `List` 类型后进行遍历输出。

集合的排序操作：
- 在对集合进行排序时，Lambda表达式可以用来指定排序的规则。例如，对一个包含学生对象的 List 按照学生的年龄进行排序：

class Student
{
    public string Name;
    public int Age;

    public Student(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

class Program
{
    static void Main()
    {
        List<Student> students = new List<Student>()
        {
            new Student("Alice", 20),
            new Student("Bob", 22),
            new Student("Charlie", 18),
            new Student("David", 25)
        };

        students.Sort((x, y) => x.Age - y.Age);

        foreach (Student student in students)
        {
            Console.WriteLine($"{student.Name} - {student.Age}");
        }
    }
}

- 在上述代码中，通过 `List` 的 `Sort` 方法结合Lambda表达式 `(x, y) => x.Age - y.Age` 来指定排序规则，即按照学生年龄的差值来排序，使得 `List` 中的学生对象按照年龄从小到大进行排列。

集合的映射操作（转换操作）：
- 有时候需要将集合中的每个元素进行某种转换操作，生成一个新的集合。例如，将一个包含整数的 List 中的每个元素都平方后生成一个新的 List：

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        List<int> squaredNumbers = numbers.Select(x => x * x).ToList();

        foreach (int num in squaredNumbers)
        {
            Console.WriteLine(num);
        }
    }
}

- 这里使用 `List` 的 `Select` 方法结合Lambda表达式 `x => x * x` 来对集合中的每个元素进行平方操作，将结果转换为 `List` 类型后进行遍历输出。

三、在LINQ查询中的应用

基本LINQ查询操作：
- LINQ（Language Integrated Query）是C#中的一种查询语言，它允许在不同类型的数据源（如集合、数据库等）中进行统一的查询操作。Lambda表达式在LINQ查询中扮演着重要角色。例如，从一个包含员工信息的 List 中查询出工资高于某一标准的员工：

class Employee
{
    public string Name;
    public decimal Salary;

    public Employee(string name, decimal salary)
    {
        Name = name;
        Salary = salary;
    }
}

class Program
{
    static void Main()
    {
        List<Employee> employees = new List<Employee>()
        {
            new Employee("Alice", 5000),
            new Employee("Bob", 6000),
            new Employee("Charlie", 4500),
            new Employee("David", 7000)
        };

        var highSalaryEmployees = from e in employees
                                  where e.Salary > 5500
                                  select e;

        foreach (Employee employee in highSalaryEmployees)
        {
            Console.WriteLine($"{employee.Name} - {employee.Salary}");
        }
    }
}

- 上述代码展示了一种传统的LINQ查询语法（查询表达式语法），它使用 `from`、`where`、`select` 等关键字来构建查询。其实，这种查询也可以使用Lambda表达式来实现，如下：

class Employee
{
    public string Name;
    public decimal Salary;

    public Employee(string name, decimal Salary)
    {
        Name = name;
        this.Salary = Salary;
    }
}

class Program
{
    static void Main()
    {
        List<Employee> employees = new List<Employee>()
        {
            new Employee("Alice", 5000),
            new Employee("Bob", 6000),
    ));
    }
}

- 上述代码展示了一种传统的LINQ查询语法（查询表达式语法），它使用 `from`、`where`、`select` 等关键字来构建查询。其实，这种查询也可以使用Lambda表达式来实现，如下：

class Employee
{
    public string Name;
    public decimal Salary;

    public Employee(string name, decimal Salary)
    {
    Name = name;
    this.Salary = Salary;
    }
}

class Program
{
    static void Main()
    {
        List<Employee> employees = new List<Employee>()
        {
            new Employee("Alice", 5000),
            new Employee("Bob", 6000),
            new Employee("Charlie", 4500),
            new Employee("David", 7000)
        };

        var highSalaryEmployees = employees.Where(e => e.Salary > 5500);

        foreach (Employee employee in highSalaryEmployees)
        {
            Console.WriteLine($"{employee.Name} - {employee.Salary}");
        }
    }
}

- 这里使用 `List` 的 `Where` 方法结合Lambda表达式 `e => e.Salary > 5500` 来实现与前面传统LINQ查询语法相同的功能，即筛选出工资高于5500的员工。并且，这种方式在一些复杂的查询场景中可能更加简洁和灵活。

四、在事件处理中的应用

简化事件处理方法的定义：
- 在C#中，事件处理通常需要定义一个方法来响应事件的触发。传统上，需要明确地定义一个方法，然后将其注册到事件上。例如，在一个简单的按钮点击事件处理中：

class Program
{
    static void Main()
    {
        Button button = new Button();

        button.Click += Button_Click;

        // 模拟按钮被点击
        button.PerformClick();
    }

    static void Button_Click(object sender, EventArgs e)
    {
        Console.WriteLine("按钮被点击了");
    }
}

- 这里定义了 `Button_Click` 方法来处理按钮的点击事件，并将其注册到按钮的 `Click` 事件上。

使用Lambda表达式处理事件：
- Lambda表达式可以用来简化事件处理方法的定义和注册过程。例如：

class Program
{
    static void Main()
    {
        Button button = new Button();

        button.Click += (sender, e) => Console.WriteLine("按钮被点击了");

        // 模拟按钮被点击
        button.PerformClick();
    }
}

- 在上述代码中，通过Lambda表达式 `(sender, e) => Console.WriteLine("按钮被点击了")` 直接定义了事件处理方法，并将其注册到按钮的 `Click` 事件上，省去了单独定义一个明确方法的步骤，使得代码更加简洁。

五、在异步编程中的应用

异步委托的使用：
- 在异步编程中，有时需要定义异步委托来执行一些耗时的操作，并在操作完成后进行相应的处理。Lambda表达式可以方便地定义这些异步委托。例如，模拟一个异步下载文件的操作：

class Program
{
    static void Main()
    {
        Func<string, Task> downloadFileAsync = async (url) =>
        {
            // 模拟下载文件的过程
            await Task.Delay(5000);
            Console.WriteLine($"文件从 {url} 下载完成");
        };

        downloadFileAsync("http://example.com/file.txt");

        Console.WriteLine("主线程继续执行其他任务");
    }
}

- 这里定义了一个异步委托 `downloadFileAsync`，它的类型是 `Func<string, Task>`，通过Lambda表达式 `async (url) =>` 后面的代码块来定义异步下载文件的操作过程，包括模拟下载等待时间和下载完成后的提示信息。在调用 `downloadFileAsync` 委托时，主线程不会被阻塞，可以继续执行其他任务。

async 和 await 结合Lambda表达式：
- 在更复杂的异步编程场景中，结合 async 和 await 与Lambda表达式可以实现更加灵活的异步操作。例如，同时下载多个文件并在所有文件下载完成后进行统一处理：

class Program
{
    static async Task Main()
    {
        List<string> urls = new List<string>() { "http://example.com/file1.txt", "http://example.com/file2.txt", "http://example.com/file3.txt" };

        var downloadTasks = urls.Select(async (url) =>
        {
            // 模拟下载文件的过程
            await Task.Delay(5000);
            Console.WriteLine($"文件从 {url} 下载完成");
        });

        await Task.WhenAll(downloadTasks);

        Console.WriteLine("所有文件下载完成，主线程继续执行其他任务");
    }
}

- 在上述代码中，首先通过 `List` 的 `Select` 方法结合Lambda表达式 `async (url) =>` 后面的代码块来创建一个包含多个异步下载任务的集合 `downloadTasks`。然后通过 `Task.WhenAll` 方法等待所有异步任务完成，最后在所有文件下载完成后输出提示信息，主线程继续执行其他任务。

Lambda表达式在C#中的应用场景非常广泛，它能够简化代码、提高代码的可读性和灵活性，在各种需要定义匿名方法、进行集合操作、LINQ查询、事件处理以及异步编程等场景中都发挥着重要作用。