Linq查询生成重复子查询是否为Bug？性能问题咨询

首先，我们先看你提供的Linq查询和生成的SQL：

原始Linq查询 #

return (from k in ctx.UzajamnaKasa 
        join p in ctx.UzajamnaKasaPozajmice on k.UzajamnaKasaId equals p.UzajamnaKasaId 
        where k.ClanId == clanId 
        select p.Iznos + p.Donos - (from ot in ctx.UzajamnaKasaPozajmiceOtplate 
                                   where p.PozajmicaId == ot.PozajmicaId 
                                   group ot.Iznos by ot.PozajmicaId into g 
                                   select g.Sum()).FirstOrDefault() 
       ).Sum();

生成的冗余SQL片段 #

select top (1) [GroupBy2].[A1] as [C1] 
from ( 
    select [Extent4].[PozajmicaId] as [K1] , sum([Extent4].[Iznos]) as [A1] 
    from [dbo].[UzajamnaKasaPozajmiceOtplate] as [Extent4] 
    where [Project2].[PozajmicaId] = [Extent4].[PozajmicaId] 
    group by [Extent4].[PozajmicaId] 
) as [GroupBy2]

这不是Linq的Bug，而是你的写法没有适配EF的查询优化逻辑 #

这种重复子查询的出现，本质是因为你在投影（select子句）中直接嵌套了一个聚合子查询，而Entity Framework（假设你使用的是EF）的查询翻译器在处理这种结构时，无法自动识别出这个子查询可以被复用。

具体来说：

• 你的Linq查询在每一行的计算中都嵌入了一个针对UzajamnaKasaPozajmiceOtplate的聚合查询，EF会将这个嵌套子查询直接翻译为SQL中的相关子查询，而且在部分版本的EF中，不会对重复的子查询结构进行合并优化，导致生成重复的SQL代码。
• 更关键的是，这种相关子查询会被执行多次（外层查询有多少行，就可能执行多少次），这才是真正影响性能的核心问题，而不仅仅是SQL代码的冗余。

为什么正确写法能避免这个问题？ #

正确的写法通常会先预先计算出每个PozajmicaId的总还款额，将其作为一个独立的数据集，再通过JOIN的方式与主查询关联，比如：

// 先预计算每个借款的总还款额
var otplateSum = from ot in ctx.UzajamnaKasaPozajmiceOtplate
                 group ot by ot.PozajmicaId into g
                 select new { PozajmicaId = g.Key, TotalOtplata = g.Sum(x => x.Iznos) };

// 主查询通过JOIN关联预计算结果
var result = (from k in ctx.UzajamnaKasa
              join p in ctx.UzajamnaKasaPozajmice on k.UzajamnaKasaId equals p.UzajamnaKasaId
              join otSum in otplateSum on p.PozajmicaId equals otSum.PozajmicaId into otSumGroup
              from otSum in otSumGroup.DefaultIfEmpty()
              where k.ClanId == clanId
              select p.Iznos + p.Donos - (otSum?.TotalOtplata ?? 0)).Sum();

这种写法会让EF生成带有LEFT JOIN的SQL，而不是重复的相关子查询，从而大幅提升性能，同时避免SQL代码的冗余。

内容的提问来源于stack exchange，提问作者Hrvoje Batrnek