请选择 进入手机版 | 继续访问电脑版
MSIPO技术圈 首页 IT技术 查看内容

C#:了解LINQ,简化数据查询和操作的强大工具

2023-07-13

linq关键字

以下是 LINQ(Language Integrated Query)中常见的关键字及其作用,并给出一个示例以展示其执行结果:

from

  1. from:用于指定数据源,可以是集合、数组、数据库表等。
    示例:
    var numbers = new List<int> { 1, 2, 3, 4, 5 };
    var result = from num in numbers
                 select num * 2;
    // 执行结果:result = { 2, 4, 6, 8, 10 }
    

where

  1. where:用于筛选满足指定条件的元素。
    示例:
    var numbers = new List<int> { 1, 2, 3, 4, 5 };
    var result = from num in numbers
                 where num % 2 == 0
                 select num;
    // 执行结果:result = { 2, 4 }
    

select

  1. select:用于选择返回的结果集。
    示例:
    var numbers = new List<int> { 1, 2, 3, 4, 5 };
    var result = from num in numbers
                 select $"Number: {num}";
    // 执行结果:result = { "Number: 1", "Number: 2", "Number: 3", "Number: 4", "Number: 5" }
    

orderby

  1. orderby:用于对结果集按指定的属性进行排序。
    示例:
    var numbers = new List<int> { 3, 1, 4, 2, 5 };
    var result = from num in numbers
                 orderby num descending
                 select num;
    // 执行结果:result = { 5, 4, 3, 2, 1 }
    

join

  1. join:用于在两个数据源之间执行联接操作。
    示例:
    var students = new List<Student>
    {
        new Student { Id = 1, Name = "Alice" },
        new Student { Id = 2, Name = "Bob" }
    };
    var scores = new List<Score>
    {
        new Score { StudentId = 1, Value = 90 },
        new Score { StudentId = 2, Value = 85 }
    };
    var result = from student in students
                 join score in scores on student.Id equals score.StudentId
                 select new { student.Name, score.Value };
    // 执行结果:result = { { "Alice", 90 }, { "Bob", 85 } }
    

group

  1. group:用于按指定的键对结果集进行分组。
    示例:
    var numbers = new List<int> { 1, 2, 3, 4, 5 };
    var result = from num in numbers
                 group num by num % 2 into grouped
                 select new { Key = grouped.Key, Numbers = grouped.ToList() };
    // 执行结果:result = { { Key = 0, Numbers = { 2, 4 } }, { Key = 1, Numbers = { 1, 3, 5 } } }
    

let

  1. let:用于在查询过程中定义中间变量。
    示例:
    var numbers = new List<int> { 1, 2, 3, 4, 5 };
    var result = from num in numbers
                 let squared = num * num
                 select squared;
    // 执行结果:result = { 1, 4, 9, 16, 25 }
    

into

  1. into:用于将查询结果存储到临时结果集中,以供后续查询操作使用。
    示例:
    var numbers = new List<int> { 1, 2, 3, 4, 5 };
    var result = from num in numbers
                 where num > 2
                 select num
                 into filtered
                 where filtered < 5
                 select filtered;
    // 执行结果:result = { 3, 4 }
    

这些关键字是构建 LINQ 查询和操作表达式的重要组成部分。每个关键字都有其特定的用途,可用于执行不同的查询操作。通过组合和嵌套使用这些关键字,可以以声明性的方式构建复杂的查询逻辑。上述示例仅展示了每个关键字的一种常见用法,实际使用时可以根据需求进行灵活组合和定制。

linq方法

在 LINQ(Language Integrated Query)中,提供了许多方法用于查询和操作数据。这些方法可用于对各种数据源(如集合、数组、数据库表等)执行查询、筛选、排序、投影、分组、聚合等操作。以下是一些常见的 LINQ 方法:

筛选方法

Where

  • Where: 根据指定条件筛选元素。
var numbers = new List<int> { 1, 2, 3, 4, 5 };
var result = numbers.Where(num => num % 2 == 0);
// 执行结果:result = { 2, 4 }

OfType

  • OfType: 筛选指定类型的元素。
var mixedList = new List<object>
{
    1, "Alice", 2, "Bob", 3, "Charlie"
};
var numbers = mixedList.OfType<int>();
// 执行结果:numbers = { 1, 2, 3 }
var names = mixedList.OfType<string>();
// 执行结果:names = { "Alice", "Bob", "Charlie" }

排序方法:

OrderBy

  • OrderBy: 根据指定的键进行升序排序。

OrderByDescending

  • OrderByDescending: 根据指定的键进行降序排序。
var numbers = new List<int> { 3, 1, 4, 2, 5 };
var ascendingOrder = numbers.OrderBy(num => num);
// 执行结果:ascendingOrder = { 1, 2, 3, 4, 5 }

var descendingOrder = numbers.OrderByDescending(num => num);
// 执行结果:descendingOrder = { 5, 4, 3, 2, 1 }

ThenBy

  • ThenBy: 在已排序的结果集上根据额外的键进行升序排序。
    ThenBy 方法用于在已经进行排序的结果集上根据额外的键进行升序排序。它通常与 OrderByOrderByDescending 方法一起使用。以下是 ThenBy 方法的使用示例:
var students = new List<Student>
{
    new Student { Name = "Alice", Grade = "A", Age = 20 },
    new Student { Name = "Bob", Grade = "B", Age = 22 },
    new Student { Name = "Charlie", Grade = "A", Age = 21 },
    new Student { Name = "David", Grade = "B", Age = 20 }
};

var sortedStudents = students.OrderBy(student => student.Grade)
                             .ThenBy(student => student.Age);

经过 OrderBy 方法根据成绩进行升序排序后,students 列表将变为:

Student { Name = "Alice", Grade = "A", Age = 20 }
Student { Name = "Charlie", Grade = "A", Age = 21 }
Student { Name = "Bob", Grade = "B", Age = 22 }
Student { Name = "David", Grade = "B", Age = 20 }

然后,应用 ThenBy 方法在已排序的结果上根据年龄进行升序排序,最终的排序结果为:

Student { Name = "Alice", Grade = "A", Age = 20 }
Student { Name = "David", Grade = "B", Age = 20 }
Student { Name = "Charlie", Grade = "A", Age = 21 }
Student { Name = "Bob", Grade = "B", Age = 22 }

在上述示例中,我们有一个学生列表 students,每个学生都有姓名、成绩和年龄属性。我们首先使用 OrderBy 方法根据学生的成绩进行升序排序,然后使用 ThenBy 方法在已排序的结果上根据学生的年龄进行升序排序。

执行结果 sortedStudents 是一个按成绩和年龄排序的学生列表。如果学生有相同的成绩,那么他们将按照年龄进行排序。

注意,ThenBy 方法必须在 OrderByOrderByDescending 方法之后使用,以确保正确的排序顺序。

这个示例展示了如何使用 ThenBy 方法在已排序的结果上进行进一步的排序操作,以满足复合排序的需求。

ThenByDescending

  • ThenByDescending: 在已排序的结果集上根据额外的键进行降序排序。
    在这里插入图片描述
    在这里插入图片描述

投影方法:

Select

  • Select: 选择指定元素或属性。
var numbers = new List<int> { 1, 2, 3, 4, 5 };
var squares = numbers.Select(num => num * num);
// 执行结果:squares = { 1, 4, 9, 16, 25 }

var names = new List<string> { "Alice", "Bob", "Charlie" };
var nameLengths = names.Select(name => name.Length);
// 执行结果:nameLengths = { 5, 3, 7 }

SelectMany

  • SelectMany: 投影并平坦化嵌套的集合。
    SelectMany 方法用于将一个集合中的每个元素的子集合(集合中的集合)合并为一个扁平化的结果集合。以下是一个使用 SelectMany 方法的示例:
var teams = new List<Team>
{
    new Team { Name = "Team A", Members = new List<string> { "Alice", "Bob" } },
    new Team { Name = "Team B", Members = new List<string> { "Charlie", "David" } },
    new Team { Name = "Team C", Members = new List<string> { "Eve", "Frank" } }
};

var allMembers = teams.SelectMany(team => team.Members);

在上述示例中,我们有一个包含多个团队的 teams 列表,每个团队都有一个名称和成员列表。使用 SelectMany 方法,我们将每个团队的成员列表合并为一个扁平化的结果集合 allMembers
执行结果 allMembers 是一个包含所有团队成员的扁平化集合:

"Alice", "Bob", "Charlie", "David", "Eve", "Frank"

注意,allMembers 中的元素是从每个团队的成员列表中提取出来的,并被合并为一个单独的集合。
使用 SelectMany 方法,你可以在涉及嵌套集合的情况下,方便地将多个子集合合并为一个扁平化的结果集合,以便进行进一步的操作或处理。

分组方法:

GroupBy

  • GroupBy: 根据指定键将元素分组。
    GroupBy 方法用于根据指定的键对集合进行分组。它将集合中具有相同键的元素分组,并返回一个包含分组结果的序列。以下是一个使用 GroupBy 方法的示例:
var students = new List<Student>
{
    new Student { Name = "Alice", Grade = "A" },
    new Student { Name = "Bob", Grade = "B" },
    new Student { Name = "Charlie", Grade = "A" },
    new Student { Name = "David", Grade = "B" }
};
var groupedStudents = students.GroupBy(student => student.Grade);

在上述示例中,我们有一个包含多个学生的 students 列表,每个学生都有一个姓名和成绩。使用 GroupBy 方法,我们根据学生的成绩将学生分组。
执行结果 groupedStudents 是一个包含分组结果的序列,每个分组都表示一个成绩。每个分组都是一个键/值对的集合,其中键是成绩,值是具有相同成绩的学生集合。
你可以通过迭代分组结果来访问每个分组和其中的元素。例如,可以通过 foreach 循环来遍历每个分组并打印出其中的学生姓名:

foreach (var group in groupedStudents)
{
    Console.WriteLine("Grade: " + group.Key);
    foreach (var student in group)
    {
        Console.WriteLine("  " + student.Name);
    }
    Console.WriteLine();
}

执行结果:

Grade: A
  Alice
  Charlie
Grade: B
  Bob
  David

在上述示例中,我们使用 group.Key 来获取分组的键(成绩),然后使用内部的 foreach 循环来迭代每个分组中的学生,并打印出学生的姓名。
GroupBy 方法允许你根据指定的键对集合进行灵活的分组操作,并且可以对每个分组进行进一步的处理和操作。

连接方法:

Join

  • Join: 在两个数据源之间执行内部联接。
    Join 方法用于根据两个集合中的共同键将它们进行连接。它返回一个新的集合,其中包含了两个集合中共同键匹配的元素。以下是一个使用 Join 方法的示例:
var customers = new List<Customer>
{
    new Customer { Id = 1, Name = "Alice" },
    new Customer { Id = 2, Name = "Bob" },
    new Customer { Id = 3, Name = "Charlie" }
};

var orders = new List<Order>
{
    new Order { OrderId = 1, CustomerId = 2, Product = "Phone" },
    new Order { OrderId = 2, CustomerId = 1, Product = "Laptop" },
    new Order { OrderId = 3, CustomerId = 2, Product = "Tablet" }
};

var result = customers.Join(
    orders,
    customer => customer.Id,
    order => order.CustomerId,
    (customer, order) => new { CustomerName = customer.Name, OrderProduct = order.Product });

foreach (var item in result)
{
    Console.WriteLine($"Customer: {item.CustomerName}, Product: {item.OrderProduct}");
}

在上述示例中,我们有两个集合:customersorderscustomers 集合包含了客户信息,orders 集合包含了订单信息。我们使用 Join 方法将这两个集合连接起来,基于它们共同的键(CustomerIdId),并创建一个包含连接结果的新集合。
Join 方法的参数中,我们指定了两个集合的键以及连接后的结果的形式。在这个示例中,我们将客户的名称和订单的产品信息连接到一个匿名类型的对象中。
执行结果:

Customer: Bob, Product: Phone
Customer: Alice, Product: Laptop
Customer: Bob, Product: Tablet

在上述示例中,我们遍历连接后的结果集合 result,并打印每个连接结果的客户名称和订单产品信息。
Join 方法允许你根据共同键将两个集合进行连接,并获取连接后的结果。你可以根据具体的需求在连接后的结果中选择所需的信息并进行进一步的处理。

GroupJoin

  • GroupJoin: 在两个数据源之间执行左外部联接。
    GroupJoin 方法用于根据一个集合的键,将该集合与另一个集合进行分组连接。它返回一个新的集合,其中每个元素包含了原始集合的元素以及与之匹配的分组的元素。以下是一个使用 GroupJoin 方法的示例:
var departments = new List<Department>
{
    new Department { Id = 1, Name = "Sales" },
    new Department { Id = 2, Name = "Marketing" },
    new Department { Id = 3, Name = "IT" }
};

var employees = new List<Employee>
{
    new Employee { Id = 1, Name = "Alice", DepartmentId = 1 },
    new Employee { Id = 2, Name = "Bob", DepartmentId = 2 },
    new Employee { Id = 3, Name = "Charlie", DepartmentId = 1 },
    new Employee { Id = 4, Name = "David", DepartmentId = 3 },
    new Employee { Id = 5, Name = "Eve", DepartmentId = 2 }
};

var result = departments.GroupJoin(
    employees,
    department => department.Id,
    employee => employee.DepartmentId,
    (department, employeeGroup) => new { DepartmentName = department.Name, Employees = employeeGroup });

foreach (var item in result)
{
    Console.WriteLine($"Department: {item.DepartmentName}");
    foreach (var employee in item.Employees

相关阅读

热门文章