Entity Framework Lambda表达式查询优化求助：查询频繁超时

我看了你的EF Lambda查询，频繁超时的问题主要出在重复逻辑、嵌套子查询过载，还有缺少关键索引这几个核心点上。下面给你一步步拆解优化方案，都是实际项目里验证过的有效操作：

1. 先清理冗余代码，减少无意义计算 #

你的查询里有个明显的重复判断：

|| x.ProductType.pro_type_name.Contains(keyword) || x.ProductType.pro_type_name.Contains(keyword)

完全可以删掉重复的那部分，改成：

|| x.ProductType.pro_type_name.Contains(keyword)

虽然这不算大问题，但积少成多，先把这类冗余逻辑清掉。

2. 优化嵌套子查询，避免N+1或重复扫描 #

你在Select里针对ProductPrices、ProductDiscounts各写了两次嵌套查询，而且每次都是OrderByDescending+FirstOrDefault——这会导致EF对每个产品都单独发起一次查询（或者生成效率极低的SQL），数据量一大必然超时。

替代方案：用分组预获取最新数据
可以先通过子查询提前筛选出每个产品的最新有效价格和折扣，再和主表关联，比如：

// 预获取每个产品的最新有效价格
var latestPrices = db.ProductPrices
    .Where(y => !y.proprice_is_deleted && y.proprice_applied_datetime <= DateTime.Now)
    .GroupBy(y => y.product_id)
    .Select(g => new {
        ProductId = g.Key,
        LatestPrice = g.OrderByDescending(y => y.proprice_applied_datetime).Select(y => y.proprice_price).FirstOrDefault()
    });

// 预获取每个产品的当前生效折扣
var currentDiscounts = db.ProductDiscounts
    .Where(y => !y.pro_discount_is_deleted && y.pro_discount_start_datetime <= datetimeNow && y.pro_discount_end_datetime >= datetimeNow)
    .GroupBy(y => y.product_id)
    .Select(g => new {
        ProductId = g.Key,
        DiscountType = g.OrderByDescending(y => y.pro_discount_id).Select(y => y.pro_discount_type).FirstOrDefault(),
        DiscountValue = g.OrderByDescending(y => y.pro_discount_id).Select(y => y.pro_discount_value).FirstOrDefault()
    });

之后主查询里直接左连这两个预查询结果，避免重复计算。

3. 预聚合库存数据，减少嵌套Sum #

你的库存计算逻辑是在Select里嵌套Where+Sum，这同样会导致每个产品都触发一次库存统计。可以先预聚合所有符合条件的库存：

var inventoryStats = db.ImportProductDetails
    .Where(y => y.ImportProduct.import_pro_warehouse_id == warehouse_id)
    .GroupBy(y => new { y.imp_pro_detail_product_id, y.imp_pro_detail_shelf_id })
    .Select(g => new {
        ProductId = g.Key.imp_pro_detail_product_id,
        ShelfId = g.Key.imp_pro_detail_shelf_id,
        Inventory = g.Sum(y => y.imp_pro_detail_inventory)
    });

之后主查询根据shelf参数，要么取对应货架的库存，要么取该仓库所有货架的总和，效率会高很多。

4. 添加关键索引，从数据库层面提速 #

这是最核心的优化点之一，EF生成的SQL再高效，没有索引就是白搭：

• Products表：给product_is_deleted、product_name、product_barcode、product_type_id加索引（可以考虑联合索引，比如(product_is_deleted, product_name)）
• ProductType表：给pro_type_name、pro_type_id加索引
• ImportProductDetails表：创建联合索引(imp_pro_detail_product_id, imp_pro_detail_shelf_id)，同时包含imp_pro_detail_inventory字段；另外关联ImportProduct的import_pro_warehouse_id也可以加入索引
• ProductPrices表：联合索引(product_id, proprice_is_deleted, proprice_applied_datetime)，包含proprice_price
• ProductDiscounts表：联合索引(product_id, pro_discount_is_deleted, pro_discount_start_datetime, pro_discount_end_datetime)，包含pro_discount_type、pro_discount_value

5. 其他辅助优化 #

• 加上AsNoTracking()：如果只是查询数据不需要修改，db.Products.AsNoTracking()可以关闭EF的实体跟踪，减少内存和性能开销
• 分页处理：如果查询结果集很大，一定要加上Skip(pageIndex * pageSize).Take(pageSize)，避免一次性加载大量数据
• 查看生成的SQL：用EF的日志功能或者数据库自带的分析工具（比如SQL Server Profiler）查看生成的SQL，直接在数据库里执行分析执行计划，定位慢查询的瓶颈

重构后的示例查询 #

把上面的优化点整合起来，大致的查询结构会变成这样：

// 预查询部分
var latestPrices = db.ProductPrices
    .Where(y => !y.proprice_is_deleted && y.proprice_applied_datetime <= DateTime.Now)
    .GroupBy(y => y.product_id)
    .Select(g => new {
        ProductId = g.Key,
        LatestPrice = g.OrderByDescending(y => y.proprice_applied_datetime).Select(y => y.proprice_price).FirstOrDefault()
    });

var currentDiscounts = db.ProductDiscounts
    .Where(y => !y.pro_discount_is_deleted && y.pro_discount_start_datetime <= datetimeNow && y.pro_discount_end_datetime >= datetimeNow)
    .GroupBy(y => y.product_id)
    .Select(g => new {
        ProductId = g.Key,
        DiscountType = g.OrderByDescending(y => y.pro_discount_id).Select(y => y.pro_discount_type).FirstOrDefault(),
        DiscountValue = g.OrderByDescending(y => y.pro_discount_id).Select(y => y.pro_discount_value).FirstOrDefault()
    });

var inventoryStats = db.ImportProductDetails
    .Where(y => y.ImportProduct.import_pro_warehouse_id == warehouse_id)
    .GroupBy(y => new { y.imp_pro_detail_product_id, y.imp_pro_detail_shelf_id })
    .Select(g => new {
        ProductId = g.Key.imp_pro_detail_product_id,
        ShelfId = g.Key.imp_pro_detail_shelf_id,
        Inventory = g.Sum(y => y.imp_pro_detail_inventory)
    });

// 主查询
queryResult = db.Products.AsNoTracking()
    .Where(x => !x.product_is_deleted)
    .Where(x => x.product_name.Contains(keyword) || x.product_barcode.Contains(keyword) || x.ProductType.pro_type_name.Contains(keyword))
    .GroupJoin(latestPrices, p => p.product_id, price => price.ProductId, (p, prices) => new { p, LatestPrice = prices.Select(pr => pr.LatestPrice).FirstOrDefault() })
    .GroupJoin(currentDiscounts, pp => pp.p.product_id, disc => disc.ProductId, (pp, discs) => new { pp.p, pp.LatestPrice, DiscountType = discs.Select(d => d.DiscountType).FirstOrDefault(), DiscountValue = discs.Select(d => d.DiscountValue).FirstOrDefault() })
    .GroupJoin(inventoryStats, pdd => pdd.p.product_id, inv => inv.ProductId, (pdd, invs) => new { pdd.p, pdd.LatestPrice, pdd.DiscountType, pdd.DiscountValue, Invs = invs })
    .Select(x => new ProductView {
        product_id = x.p.product_id,
        product_barcode = x.p.product_barcode,
        product_name = x.p.product_name,
        product_unit = x.p.product_unit,
        product_size = x.p.product_size,
        product_weight = x.p.product_weight,
        product_type_id = x.p.product_type_id,
        product_inventory = shelf == 0 
            ? x.Invs.Sum(i => i.Inventory) 
            : x.Invs.Where(i => i.ShelfId == shelf).Sum(i => i.Inventory),
        product_opening_stock = x.p.product_opening_stock,
        product_type_name = x.p.ProductType.pro_type_name,
        product_price = x.LatestPrice,
        product_discount_type = x.DiscountType,
        product_discount_value = x.DiscountValue
    })
    .Skip(pageIndex * pageSize)
    .Take(pageSize)
    .ToList();

内容的提问来源于stack exchange，提问作者Huy Pham