LINQ子查询和延迟执行编程实例(LINQ子查询与延迟执行编程实例详解)

原创

ithorizon 6个月前 (10-20) 阅读数 15 #后端开发

LINQ子查询与延迟执行编程实例详解

一、引言

LINQ（Language Integrated Query）是.NET框架中一个强劲的查询工具，它允许开发者在C#或VB.NET中以声明性行为处理数据。LINQ赞成多种数据源，包括集合、数据库、XML等。在LINQ查询中，子查询和延迟执行是两个重要的概念。本文将详细介绍LINQ子查询和延迟执行的编程实例，帮助开发者更好地明白和运用这些概念。

二、LINQ子查询

子查询是指在主查询中嵌套的查询，它可以用来筛选、聚合或转换数据。子查询通常用于相关性数据源中的表或集合，以及执行更繁复的查询操作。

2.1 子查询的基本语法

子查询的基本语法如下：

from 子查询的别名 in 主查询的数据源

where 子查询的条件

select 子查询的最终

2.2 子查询实例

下面通过一个明了的实例来演示LINQ子查询的使用。假设我们有一个学生类（Student）和一个成绩类（Score），现在要查询所有学生的姓名和他们的平均成绩。


using System;
using System.Collections.Generic;
using System.Linq;
class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
}
class Score
{
    public int StudentId { get; set; }
    public double ScoreValue { get; set; }
}
class Program
{
    static void Main()
    {
        List students = new List
        {
            new Student { Id = 1, Name = "张三" },
            new Student { Id = 2, Name = "李四" },
            new Student { Id = 3, Name = "王五" }
        };
        List scores = new List
        {
            new Score { StudentId = 1, ScoreValue = 90 },
            new Score { StudentId = 1, ScoreValue = 85 },
            new Score { StudentId = 2, ScoreValue = 92 },
            new Score { StudentId = 2, ScoreValue = 88 },
            new Score { StudentId = 3, ScoreValue = 75 },
            new Score { StudentId = 3, ScoreValue = 80 }
        };
        var query = from student in students
                    join score in scores on student.Id equals score.StudentId into scoreGroup
                    select new
                    {
                        StudentName = student.Name,
                        AverageScore = scoreGroup.Average(s => s.ScoreValue)
                    };
        foreach (var item in query)
        {
            Console.WriteLine($"姓名：{item.StudentName}, 平均成绩：{item.AverageScore}");
        }
    }
}

三、LINQ延迟执行

延迟执行是指查询表达式在调用迭代器方法（如foreach循环）之前不执行任何操作。这意味着查询仅在需要最终时才会执行，并且可以基于当前上下文进行优化。

3.1 延迟执行的工作原理

在LINQ中，查询表达式通常被编译成一个表达式树。当迭代器方法（如foreach循环）被调用时，表达式树会被转换成一个迭代器，这个迭代器会按需执行查询。

3.2 延迟执行实例

下面通过一个明了的实例来演示LINQ延迟执行的使用。假设我们有一个整数列表，现在要查询其中的偶数。


using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List numbers = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        // 延迟执行查询
        IEnumerable query = numbers.Where(n => n % 2 == 0);
        // 修改原始列表
        numbers.Remove(2);
        // 执行查询
        foreach (int number in query)
        {
            Console.WriteLine(number);
        }
    }
}

在上面的代码中，我们首先创建了一个整数列表numbers，并定义了一个延迟执行的查询来获取其中的偶数。然后，我们在执行查询之前修改了原始列表，移除了数字2。当我们执行查询时，会发现输出最终中不包含数字2，这证明了查询是在迭代器方法调用时才执行的，即延迟执行。

四、子查询与延迟执行的组合使用

子查询和延迟执行可以组合使用，以实现更繁复的查询操作。下面通过一个实例来演示这种组合使用。

4.1 组合使用实例

假设我们有一个订单类（Order）和一个订单详情类（OrderDetail），现在要查询所有订单的订单号和订单总金额。


using System;
using System.Collections.Generic;
using System.Linq;
class Order
{
    public int OrderId { get; set; }
    public List Details { get; set; }
}
class OrderDetail
{
    public int OrderId { get; set; }
    public double Amount { get; set; }
}
class Program
{
    static void Main()
    {
        List orders = new List
        {
            new Order
            {
                OrderId = 1,
                Details = new List
                {
                    new OrderDetail { OrderId = 1, Amount = 100 },
                    new OrderDetail { OrderId = 1, Amount = 150 }
                }
            },
            new Order
            {
                OrderId = 2,
                Details = new List
                {
                    new OrderDetail { OrderId = 2, Amount = 200 },
                    new OrderDetail { OrderId = 2, Amount = 250 }
                }
            },
            new Order
            {
                OrderId = 3,
                Details = new List
                {
                    new OrderDetail { OrderId = 3, Amount = 300 },
                    new OrderDetail { OrderId = 3, Amount = 350 }
                }
            }
        };
        var query = from order in orders
                    select new
                    {
                        OrderId = order.OrderId,
                        TotalAmount = order.Details.Sum(d => d.Amount)
                    };
        foreach (var item in query)
        {
            Console.WriteLine($"订单号：{item.OrderId}, 总金额：{item.TotalAmount}");
        }
    }
}