Lambda表达式在LINQ查询中有哪些应用？

Lambda表达式在LINQ（Language Integrated Query）查询中有多种重要应用，以下是详细介绍：

一、筛选数据（Where子句）

1. 基本筛选示例：
   • LINQ中的 Where 子句用于从数据源中筛选出满足特定条件的元素。Lambda表达式可以简洁地定义筛选条件。例如，假设有一个包含整数的列表 List<int>，要筛选出其中大于5的整数：

List<int> numbers = new List<int>() { 1, 3, 6, 8, 4, 9, 2 };

var filteredNumbers = numbers.Where(x => x > 5).ToList();

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

- 在上述代码中，`Where` 方法接受一个Lambda表达式 `x => x > 5` 作为参数。这里的 `x` 代表列表中的每个元素，整个表达式表示筛选出 `x`（即列表中的元素）大于5的那些元素，最后将筛选结果转换为列表并进行遍历输出。

2. 复杂条件筛选：
   • 可以使用更复杂的Lambda表达式来定义包含多个条件的筛选。例如，从一个包含学生对象的列表中筛选出年龄在18到22岁之间且成绩大于80分的学生：

class Student
{
    public string Name;
    public int Age;
    public int Score;

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

List<Student> students = new List<Student>()
{
    new Student("Alice", 19, 85),
    new Student("Bob", 20, 78),
    new Student("Charlie", 23, 82),
    new Student("David", 17, 90),
    new Student("Eve", 21, 88)
};

var selectedStudents = students.Where(s => s.Age >= 18 && s.Age <= 22 && s.Score > 80).ToList();

foreach (Student student in selectedStudents)
{
    Console.WriteLine($"{student.Name}, {student.Age}, {student.Score}");
}

- 这里的Lambda表达式 `s => s.Age >= 18 && s.Age <= 22 && s.Score > 80` 定义了三个条件，分别对学生的年龄和成绩进行限制，只有同时满足这三个条件的学生才会被筛选出来。

二、排序数据（OrderBy 和 OrderByDescending 子句）

1. 简单排序示例：
   • LINQ中的 OrderBy 子句用于按照指定的规则对数据源中的元素进行升序排序，OrderByDescending 则用于降序排序。Lambda表达式可用来指定排序规则。例如，对一个包含整数的列表按照从小到大的顺序进行排序：

List<int> numbers = new List<int>() { 5, 3, 8, 1, 6 };

var sortedNumbers = numbers.OrderBy(x => x).ToList();

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

- 在上述代码中，`OrderBy` 方法接受Lambda表达式 `x => x`，这里的 `x` 代表列表中的每个元素，按照元素本身的值进行升序排序。如果要进行降序排序，可以使用 `OrderByDescending` 方法，如 `numbers.OrderByDescending(x => x).ToList()`。

2. 基于对象属性排序：
   • 当数据源是包含对象的列表时，可以根据对象的某个属性进行排序。例如，对一个包含学生对象的列表按照学生的年龄进行升序排序：

class Student
{
    public string Name;
    public int Age;

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

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

var sortedStudents = students.OrderBy(s => s.Age).ToList();

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

- 这里的Lambda表达式 `s => s.Age` 指定了按照学生对象的 `Age` 属性值进行升序排序，使得列表中的学生按照年龄从小到大排列。同样，如果要进行降序排序，可以使用 `OrderByDescending` 方法并传入相同的Lambda表达式。

三、选择数据（Select 子句）

1. 简单选择示例：
   • LINQ中的 Select 子句用于从数据源中选择特定的元素或对元素进行某种变换操作，然后生成一个新的序列。Lambda表达式可用于定义选择或变换的规则。例如，从一个包含整数的列表中选择每个整数的平方值：

List<int> numbers = new List<int>() { 1, 2, 3, 4, 5 };

var squaredNumbers = numbers.Select(x => x * x).ToList();

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

- 在上述代码中，`Select` 方法接受Lambda表达式 `x => x * x`，它将列表中的每个元素 `x` 进行平方操作，然后将结果组成一个新的列表并进行遍历输出。

2. 选择对象的部分属性：
   • 当数据源是包含对象的列表时，可以使用 Select 子句结合Lambda表达式选择对象的部分属性并生成一个新的序列。例如，从一个包含学生对象的列表中只选择学生的姓名并组成一个新的列表：

class Student
{
    public string Name;
    public int Age;

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

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

var studentNames = students.Select(s => s.Name).ToList();

foreach (string name in studentNames)
{
    Console.WriteLine(name);
}

- 这里的Lambda表达式 `s => s.Name` 从每个学生对象 `s` 中选择其 `Name` 属性值，将这些值组成一个新的列表并进行遍历输出。

四、分组数据（GroupBy 子句）

1. 基本分组示例：
   • LINQ中的 GroupBy 子句用于将数据源中的元素按照指定的标准进行分组。Lambda表达式可用来定义分组的标准。例如，对一个包含整数的列表按照能否被2整除进行分组：

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

var groupedNumbers = numbers.GroupBy(x => x % 2 == 0).ToList();

foreach (var group in groupedNumbers)
{
    Console.WriteLine($"分组依据: {group.Key}");
    foreach (int num in group)
    {
        Console.WriteLine(num);
    }
}

- 在上述代码中，`GroupBy` 方法接受Lambda表达式 `x => x % 2 == 0`，这里的 `x` 代表列表中的每个元素，根据元素能否被2整除（即 `x % 2 == 0` 的结果）来进行分组。分组结果是一个包含多个分组的列表，每个分组有一个 `Key`（这里是 `true` 或 `false`，表示能否被2整除）和一组属于该分组的元素。

2. 基于对象属性分组：
   • 当数据源是包含对象的列表时，可以根据对象的某个属性进行分组。例如，对一个包含学生对象的列表按照学生所在的班级进行分组：

class Student
{
    public string Name;
    public int Age;
    public string Class;

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

List<Student> students = new List<Student>()
{
    new Student("Alice", 20, "ClassA"),
    new Student("Bob", 22, "ClassB"),
    new Student("Charlie", 18, "ClassA"),
    new Student("David", 25, "ClassB")
};

var groupedStudents = students.GroupBy(s => s.Class).ToList();

foreach (var group in groupedStudents)
{
    Console.WriteLine($"分组依据: {group.Key}");
    foreach (Student student in group)
    {
        Console.WriteLine($"{student.Name}, {student.Age}");
    }
}

- 这里的Lambda表达式 `s => s.Class` 根据学生对象 `s` 的 `Class` 属性值来进行分组，将属于同一班级的学生分在同一组，分组结果同样是一个包含多个分组的列表，每个分组有一个 `Key`（这里是班级名称）和一组属于该分组的学生对象。

五、聚合操作（Sum、Average、Count 等）

1. 简单聚合示例：
   • LINQ提供了一系列聚合操作函数，如 Sum、Average、Count 等，这些函数可以结合Lambda表达式来对数据源进行相应的聚合计算。例如，计算一个包含整数的列表中所有元素的总和：

List<int> numbers = new List<int>() { 1, 2, 3, 4, 5 };

var sum = numbers.Sum(x => x);

Console.WriteLine($"总和: {sum}");

- 在上述代码中，`Sum` 方法接受Lambda表达式 `x => x`，这里的 `x` 代表列表中的每个元素，计算所有元素 `x` 的总和。

2. 基于对象属性的聚合：
   • 当数据源是包含对象的列表时，可以根据对象的某个属性进行聚合计算。例如，计算一个包含学生对象的列表中所有学生的平均年龄：

class Student
{
    public string Name;
    public int Age;

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

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

var averageAge = students.Average(s => s.Age);

Console.WriteLine($"平均年龄: {averageAge}");

- 这里的Lambda表达式 `s => s.Age` 根据学生对象 `s` 的 `Age` 属性值来进行聚合计算，计算出所有学生的平均年龄。

Lambda表达式在LINQ查询中扮演着至关重要的角色，通过简洁地定义各种查询条件、排序规则、选择和变换操作、分组标准以及聚合计算等，使得LINQ查询更加灵活、高效且易于编写和理解。