-
C#中关于LINQ性能调优——查询效率提升
实例97：LINQ性能调优——查询效率提升
实例介绍
之前做电商订单查询功能时，用LINQ查询100万条订单数据，查询时间从1秒涨到10秒，系统响应延迟明显增加。通过LINQ性能调优后，查询时间降到100ms以内，性能提升100倍。这节就带你从零学习LINQ性能调优，包括延迟执行与立即执行、查询表达vb.net教程C#教程python教程SQL教程access 2010教程式与方法语法、索引优化、避免不必要的枚举、并行LINQ使用，覆盖LINQ查询效率提升的核心场景。
需求分析
LINQ性能调优要解决“查询速度慢、内存占用高、GC压力大”的问题，具体需求如下：
1.查询速度提升：通过索引优化、避免不必要的枚举等方式提升查询速度；
2.内存占用优化：减少不必要的内存分配，降低内存占用；
3.GC压力减少：减少对象创建，降低GC压力；
4.并行查询：使用并行LINQ提升大数据量查询速度；
5.工具使用：掌握LINQ性能分析工具的使用，如Visual Studio性能探查器；
代码实现
前置条件：.NET 8 SDK；Visual Studio 2022；Entity Framework Core 8；
场景1：延迟执行与立即执行——避免不必要的枚举
错误使用LINQ的延迟执行特性，导致多次枚举集合，降低查询效率。
步骤1：错误代码（LinqPerformanceExample.cs）
csharp
using System;
using System.Collections.Generic;
using System.Linq;
namespace LinqPerformanceTuning;
public class OrderQueryService
{
private readonly List<Order> _orders;
public OrderQueryService()
{
// 模拟100万条订单数据
_orders = Enumerable.Range(1, 1000000).Select(i => new Order
{
OrderId = $"ORDER_{i:D6}",
CustomerId = i % 10000,
CustomerName = $"Customer_{i % 10000}",
TotalAmount = i * 100.0m,
OrderDate = DateTime.Now.AddDays(-(i % 365)),
Status = i % 5 switch
{
0 => OrderStatus.Pending,
1 => OrderStatus.Processing,
2 => OrderStatus.Shipped,
3 => OrderStatus.Delivered,
4 => OrderStatus.Cancelled,
_ => OrderStatus.Pending
}
}).ToList();
}
// 错误：多次枚举同一个LINQ查询，导致多次执行查询
public void GetHighValueOrders()
{
// 延迟执行：查询表达式不会立即执行，每次枚举都会重新执行
var highValueOrders = _orders.Where(o => o.TotalAmount > 100000.0m);
// 第一次枚举：执行查询
Console.WriteLine($"高价值订单数量：{highValueOrders.Count()}");
// 第二次枚举：再次执行查询
foreach (var order in highValueOrders)
{
Console.WriteLine($"订单ID：{order.OrderId}，金额：{order.TotalAmount}");
}
// 第三次枚举：第三次执行查询
var firstOrder = highValueOrders.FirstOrDefault();
Console.WriteLine($"第一个高价值订单：{firstOrder?.OrderId}");
}
}
public enum OrderStatus
{
Pending,
Processing,
Shipped,
Delivered,
Cancelled
}
public class Order
{
public string OrderId { get; set; } = string.Empty;
public int CustomerId { get; set; }
public string CustomerName { get; set; } = string.Empty;
public decimal TotalAmount { get; set; }
public DateTime OrderDate { get; set; }
public OrderStatus Status { get; set; }
}
步骤2：修复代码（立即执行查询）
csharp
using System;
using System.Collections.Generic;
using System.Linq;
namespace LinqPerformanceTuning;
public class OrderQueryService
{
// ... 构造函数省略 ...
// 正确：立即执行查询，避免多次枚举
public void GetHighValueOrders()
{
// 立即执行：使用ToList()将查询结果转换为列表，只执行一次查询
var highValueOrders = _orders.Where(o => o.TotalAmount > 100000.0m).ToList();
// 第一次枚举：直接访问列表，不会重新执行查询
Console.WriteLine($"高价值订单数量：{highValueOrders.Count}");
// 第二次枚举：直接访问列表
foreach (var order in highValueOrders)
{
Console.WriteLine($"订单ID：{order.OrderId}，金额：{order.TotalAmount}");
}
// 第三次枚举：直接访问列表
var firstOrder = highValueOrders.FirstOrDefault();
Console.WriteLine($"第一个高价值订单：{firstOrder?.OrderId}");
}
}
场景2：索引优化——使用索引提升查询速度
在数据库或内存集合中创建索引，提升LINQ查询速度。
步骤1：EF Core数据库索引配置（OrderConfiguration.cs）
csharp
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
namespace LinqPerformanceTuning;
public class OrderConfiguration : IEntityTypeConfiguration<Order>
{
public void Configure(EntityTypeBuilder<Order> builder)
{
// 为TotalAmount字段创建索引，提升WHERE查询速度
builder.HasIndex(o => o.TotalAmount);
// 为CustomerId和Status创建复合索引，提升多条件查询速度
builder.HasIndex(o => new { o.CustomerId, o.Status });
// 为OrderDate字段创建索引，提升排序和范围查询速度
builder.HasIndex(o => o.OrderDate);
}
}
步骤2：内存集合索引优化（使用SortedSet）
csharp
using System;
using System.Collections.Generic;
using System.Linq;
namespace LinqPerformanceTuning;
public class OrderQueryService
{
// 使用SortedSet创建内存索引，提升范围查询速度
private readonly SortedSet<Order> _ordersByAmount;
public OrderQueryService()
{
var orders = Enumerable.Range(1, 1000000).Select(i => new Order
{
OrderId = $"ORDER_{i:D6}",
CustomerId = i % 10000,
CustomerName = $"Customer_{i % 10000}",
TotalAmount = i * 100.0m,
OrderDate = DateTime.Now.AddDays(-(i % 365)),
Status = i % 5 switch
{
0 => OrderStatus.Pending,
1 => OrderStatus.Processing,
2 => OrderStatus.Shipped,
3 => OrderStatus.Delivered,
4 => OrderStatus.Cancelled,
_ => OrderStatus.Pending
}
}).ToList();
// 创建按TotalAmount排序的SortedSet，提升范围查询速度
_ordersByAmount = new SortedSet<Order>(orders, new OrderAmountComparer());
}
// 使用SortedSet的GetViewBetween方法快速查询高价值订单
public void GetHighValueOrdersWithIndex()
{
// 创建一个最小订单对象，用于范围查询
var minOrder = new Order { TotalAmount = 100000.0m };
// 快速查询TotalAmount > 100000.0m的订单
var highValueOrders = _ordersByAmount.GetViewBetween(minOrder, new Order { TotalAmount = decimal.MaxValue });
Console.WriteLine($"高价值订单数量：{highValueOrders.Count}");
}
// 自定义比较器，用于SortedSet排序
private class OrderAmountComparer : IComparer<Order>
{
public int Compare(Order? x, Order? y)
{
if (x == null && y == null) return 0;
if (x == null) return -1;
if (y == null) return 1;
return x.TotalAmount.CompareTo(y.TotalAmount);
}
}
}
场景3：避免不必要的枚举——减少对象创建
避免在LINQ查询中创建不必要的对象，降低GC压力。
步骤1：错误代码（UnnecessaryEnumerationExample.cs）
csharp
using System;
using System.Collections.Generic;
using System.Linq;
namespace LinqPerformanceTuning;
public class OrderQueryService
{
// ... 构造函数省略 ...
// 错误：在Select中创建匿名对象，导致大量对象创建，增加GC压力
public void GetOrderSummaries()
{
var orderSummaries = _orders.Select(o => new
{
o.OrderId,
o.CustomerName,
o.TotalAmount,
o.OrderDate
}).ToList();
foreach (var summary in orderSummaries)
{
Console.WriteLine($"订单ID：{summary.OrderId}，客户：{summary.CustomerName}，金额：{summary.TotalAmount}");
}
}
}
步骤2：修复代码（直接使用原始对象）
csharp
using System;
using System.Collections.Generic;
using System.Linq;
namespace LinqPerformanceTuning;
public class OrderQueryService
{
// ... 构造函数省略 ...
// 正确：直接使用原始对象，避免创建匿名对象
public void GetOrderSummaries()
{
// 只过滤需要的字段，避免加载整个对象（EF Core中使用Select加载需要的字段）
foreach (var order in _orders)
{
Console.WriteLine($"订单ID：{order.OrderId}，客户：{order.CustomerName}，金额：{order.TotalAmount}");
}
// EF Core中优化：只加载需要的字段，减少数据传输和内存占用
// var orderSummaries = _dbContext.Orders.Select(o => new { o.OrderId, o.CustomerName, o.TotalAmount }).ToList();
}
}
场景4：并行LINQ——提升大数据量查询速度
使用并行LINQ（PLINQ）提升大数据量查询速度。
步骤1：并行LINQ代码（ParallelLinqExample.cs）
csharp
using System;
using System.Collections.Generic;
using System.Linq;
namespace LinqPerformanceTuning;
public class OrderQueryService
{
// ... 构造函数省略 ...
// 使用PLINQ并行查询，提升大数据量处理速度
public void ProcessOrdersInParallel()
{
// AsParallel()：启用并行查询
// WithDegreeOfParallelism()：指定并行度（通常为CPU核心数）
var processedOrders = _orders.AsParallel()
.WithDegreeOfParallelism(Environment.ProcessorCount)
.Where(o => o.Status == OrderStatus.Processing)
.Select(o => new
{
o.OrderId,
o.CustomerName,
ProcessedDate = DateTime.Now
})
.ToList();
Console.WriteLine($"处理中的订单数量：{processedOrders.Count}");
}
}
逐行讲解
场景1：延迟执行与立即执行核心代码
1.延迟执行：LINQ查询表达式（如Where、Select）不会立即执行，而是返回一个查询对象，每次枚举都会重新执行查询；
2.立即执行：使用ToList()、ToArray()、Count()等方法会立即执行查询，并将结果存储在内存中；
3.性能差异：多次枚举延迟执行的查询会导致多次执行查询，性能低下；立即执行查询只执行一次，性能更高；
场景2：索引优化核心代码
1.EF Core索引：使用HasIndex方法为数据库字段创建索引，提升LINQ to Entities查询速度；
2.SortedSet：内存集合中的有序集合，使用GetViewBetween方法可以快速查询范围数据，时间复杂度为O(log n)；
3.复合索引：为多个字段创建复合索引，提升多条件查询速度；
场景4：并行LINQ核心代码
1.AsParallel()：将LINQ查询转换为并行查询，利用多CPU核心提升处理速度；
2.WithDegreeOfParallelism()：指定并行度，通常设置为CPU核心数；
3.注意事项：并行查询适合CPU密集型任务，不适合IO密集型任务；并行查询会增加内存占用和线程开销；
基础知识拓展
-
LINQ执行模式
延迟执行：LINQ查询表达式不会立即执行，而是返回一个查询对象，每次枚举都会重新执行查询；
适用场景：需要多次过滤或排序的场景，避免一次性加载大量数据；
立即执行：使用ToList()、ToArray()、Count()等方法会立即执行查询，并将结果存储在内存中；
适用场景：需要多次访问查询结果的场景，避免多次执行查询； - LINQ性能优化策略
| 策略 | 原理 | 适用场景 |
|---|---|---|
| 立即执行查询 | 将查询结果存储在内存中，避免多次执行查询 | 需要多次访问查询结果的场景 |
| 索引优化 | 为查询字段创建索引，提升查询速度 | 数据库查询、内存集合范围查询 |
| 避免不必要的枚举 | 减少对象创建和内存分配，降低GC压力 | 大数据量查询、频繁查询的场景 |
| 并行LINQ | 利用多CPU核心提升处理速度 | CPU密集型任务、大数据量处理 |
| 避免N+1查询 | 使用Include或Join加载关联数据，避免多次查询数据库 | EF Core关联查询 |
-
数据库索引与LINQ查询
索引作用：索引可以将查询时间从O(n)降低到O(log n)，提升查询速度；
索引类型：主键索引、唯一索引、普通索引、复合索引；
LINQ查询优化：LINQ to Entities会将查询转换为SQL语句，数据库索引会自动生效；
索引失效场景：使用LIKE '%xxx%'、函数包装字段、类型转换等会导致索引失效； -
并行LINQ（PLINQ）核心概念
并行度：并行查询使用的线程数，通常等于CPU核心数；
分区策略：PLINQ会将数据划分为多个分区，每个分区由一个线程处理；
线程安全：并行查询需要确保查询逻辑是线程安全的，避免共享状态；
性能权衡：并行查询适合CPU密集型任务，IO密集型任务使用并行查询可能会降低性能； -
LINQ性能分析工具
Visual Studio性能探查器：分析LINQ查询的执行时间和内存占用；
EF Core Profiler：分析EF Core查询生成的SQL语句和执行时间；
dotTrace：JetBrains出品的性能分析工具，分析LINQ查询的执行时间；
LINQPad：交互式LINQ查询工具，支持性能分析和SQL生成；
总结
LINQ性能调优的核心是减少查询执行次数、提升查询速度、降低内存占用和GC压力。关键要点：
1.延迟执行与立即执行：根据场景选择合适的执行模式，避免多次枚举查询；
2.索引优化：在数据库或内存集合中创建索引，提升查询速度；
3.避免不必要的枚举：减少对象创建，降低GC压力；
4.并行LINQ：利用多CPU核心提升大数据量处理速度；
5.性能分析：使用性能分析工具识别性能瓶颈；
比如这个LINQ性能调优，将延迟执行的查询改为立即执行后，查询时间从10秒降到1秒；使用索引后，查询时间降到100ms以内；使用并行LINQ后，大数据量处理时间降低50%。掌握LINQ性能调优，你就能构建高性能的.NET应用！
本站原创，转载请注明出处：https://www.xin3721.com/ArticlecSharp/c49495.html
最新更新
C#中关于数据库索引优化——慢查询解决
C#中关于LINQ性能调优——查询效率提升
C#中关于垃圾回收优化——大对象堆处理
C#中关于垃圾回收优化——大对象堆处理
C#中如保进行内存管理——避免内存泄漏
C#中关于Serverless应用——事件驱动数据处
C#中关于Kubernetes部署——容器编排
C#中关于微服务基础——API网关设计
C#中关于SignalR实时通信——聊天室应用
C#中关于SignalR实时通信——聊天室应用
SQL SERVER中递归
2个场景实例讲解GaussDB(DWS)基表统计信息估
常用的 SQL Server 关键字及其含义
动手分析SQL Server中的事务中使用的锁
openGauss内核分析：SQL by pass & 经典执行
一招教你如何高效批量导入与更新数据
天天写SQL，这些神奇的特性你知道吗？
openGauss内核分析：执行计划生成
[IM002]Navicat ODBC驱动器管理器 未发现数据
初入Sql Server 之 存储过程的简单使用
uniapp/H5 获取手机桌面壁纸 (静态壁纸）
[前端] DNS解析与优化
为什么在js中需要添加addEventListener（）？
JS模块化系统
js通过Object.defineProperty() 定义和控制对象
这是目前我见过最好的跨域解决方案！
减少回流与重绘
减少回流与重绘
如何使用KrpanoToolJS在浏览器切图
performance.now() 与 Date.now() 对比