两段等效LINQ查询为何首次执行更慢？如何对比性能？

1. 为什么首次执行的查询速度更慢？ #

这是.NET的**JIT编译（即时编译）**特性导致的。当你第一次执行一段.NET代码时，CLR（公共语言运行时）需要把中间语言（IL）编译成适配当前机器的原生代码，这个编译过程会消耗一定时间。你的LINQ查询依赖的Where、GroupBy、Select、Any等扩展方法，在首次被调用时都会触发JIT编译，所以第一次执行的查询会包含这个编译开销，自然显得更慢。

而后续执行时，这些方法的原生代码已经被缓存下来了，不需要再重复编译，所以执行速度会大幅提升——快到DateTime.Now的精度（通常10-15毫秒级）都无法捕捉到耗时，因此显示为0毫秒。

2. 如何有效对比这两段LINQ查询的性能？ #

你的当前测试存在几个影响准确性的问题，我们可以从以下几个方向优化测试方案：

优化点1：使用高精度计时工具 #

DateTime.Now的精度不足以测量快速执行的代码，应该改用Stopwatch类，它提供纳秒级的精度，是微基准测试的首选工具。

优化点2：加入热身（Warm-up）阶段 #

在正式测试前，先重复执行几次查询，提前触发JIT编译，消除首次执行的编译开销对测试结果的干扰。

优化点3：放大测试数据量 #

你的测试数据只有1000条，操作耗时太短，无法体现出两种写法的性能差异。可以把数据量增加到几十万甚至几百万条，让查询的耗时足够被准确测量。

优化点4：多次测试取平均值 #

单次测试结果容易受系统临时负载影响，应该多次执行查询，计算平均耗时，得到更可靠的对比结果。

优化后的测试代码示例 #

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Running performance test...");
        var rnd = new Random();
        
        // 热身阶段：提前触发JIT编译，消除首次执行开销
        var warmupData = GetData(rnd, 1000);
        for (int i = 0; i < 3; i++)
        {
            warmupData.Where(l => l.IsActive).GroupBy(l => l.Category).Select(g => g.Count() > 300).Any();
            warmupData.Where(l => l.IsActive).GroupBy(l => l.Category).Select(g => g.Count()).Any(c => c > 300);
        }
        
        // 正式测试：使用更大数据量，多次执行取平均
        const int testRuns = 10;
        const int dataSize = 1_000_000; // 100万条测试数据
        var testData = GetData(rnd, dataSize);
        
        long totalTicks1 = 0;
        long totalTicks2 = 0;
        
        for (int i = 0; i < testRuns; i++)
        {
            // 测试Option 1
            var stopwatch = Stopwatch.StartNew();
            var result1 = testData.Where(l => l.IsActive).GroupBy(l => l.Category).Select(g => g.Count() > 300).Any();
            stopwatch.Stop();
            totalTicks1 += stopwatch.ElapsedTicks;
            
            // 测试Option 2
            stopwatch.Restart();
            var result2 = testData.Where(l => l.IsActive).GroupBy(l => l.Category).Select(g => g.Count()).Any(c => c > 300);
            stopwatch.Stop();
            totalTicks2 += stopwatch.ElapsedTicks;
        }
        
        // 转换为毫秒并计算平均值
        double avgTime1 = (totalTicks1 / (double)testRuns) * (1000.0 / Stopwatch.Frequency);
        double avgTime2 = (totalTicks2 / (double)testRuns) * (1000.0 / Stopwatch.Frequency);
        
        Console.WriteLine($"\nAverage time for Option 1: {avgTime1:F4} ms");
        Console.WriteLine($"Average time for Option 2: {avgTime2:F4} ms");
        Console.ReadKey();
    }
    
    private static List<MyObject> GetData(Random rnd, int size)
    {
        var result = new List<MyObject>(size);
        for (var i = 0; i < size; i++)
        {
            result.Add(new MyObject { Category = rnd.Next(1, 4), IsActive = rnd.Next(0, 2) != 0 });
        }
        return result;
    }
}

public class MyObject
{
    public bool IsActive { get; set; }
    public int Category { get; set; }
}

额外说明：两种LINQ写法的性能差异 #

其实这两种写法的性能非常接近，因为LINQ是延迟执行的：

• Option 1：Select(g => g.Count() > 300).Any()会遍历分组，对每个组计算Count()，一旦找到第一个满足Count()>300的组，就会立即停止遍历并返回true。
• Option 2：Select(g => g.Count()).Any(c => c > 300)同样是遍历分组，计算每个组的Count()，一旦找到第一个大于300的数值就停止。

两者的核心差异仅在于Option 1多了一步将Count()结果转换为bool的操作，但这个差异微乎其微，只有在超大规模数据下才可能被测量到。

内容的提问来源于stack exchange，提问作者Sergio Romero