如何用LINQ高效合并三个关联列表为嵌套对象

针对你提到的场景——三个列表（Order、PaymentDetail、CouponUsageDetail）通过ProductId/CustomerId/OrderId三个属性完全匹配，要合并成嵌套的OrderDetails结构，同时避免循环查找的性能开销，最优的方式是利用LINQ的分组/查找表+投影，把时间复杂度从O(N*(M+K))降到O(N+M+K)，下面是具体实现：

核心思路 #

先为PaymentDetail和CouponUsageDetail创建基于复合键的查找字典（或利用LINQ的GroupJoin内部的查找机制），这样后续匹配时可以做到O(1)时间查找，避免嵌套循环的重复遍历。

实现方式一：手动构建查找字典（更直观，性能可控） #

这种方式适合需要明确控制查找逻辑的场景，步骤如下：

1. 构建Payment和Coupon的查找字典 #

用匿名类型作为复合键（因为匿名类型会自动实现基于属性的Equals和GetHashCode），把每个键对应的相关数据分组存储：

// 假设你已经从API获取到三个列表：orders, paymentDetails, couponUsageDetails
var paymentLookup = paymentDetails
    .GroupBy(p => new { p.ProductId, p.CustomerId, p.OrderId })
    .ToDictionary(g => g.Key, g => g.ToList());

var couponLookup = couponUsageDetails
    .GroupBy(c => new { c.ProductId, c.CustomerId, c.OrderId })
    .ToDictionary(g => g.Key, g => g.ToList());

2. 投影生成OrderDetails列表 #

遍历Order列表，通过查找字典快速匹配对应的Payment和Coupon数据：

var orderDetailsList = orders
    .Select(order => new OrderDetails
    {
        // 复制Order的基础属性
        ProductId = order.ProductId,
        CustomerId = order.CustomerId,
        OrderId = order.OrderId,
        // 复制Order的其他业务属性，比如：
        // OrderDate = order.OrderDate,
        // TotalAmount = order.TotalAmount,

        // 匹配PaymentDetail，无匹配则返回空列表
        PaymentDetail = paymentLookup.TryGetValue(
            new { order.ProductId, order.CustomerId, order.OrderId }, 
            out var matchedPayments) 
            ? matchedPayments 
            : new List<PaymentDetail>(),

        // 匹配CouponUsageDetail，无匹配则返回空列表
        CouponUsageDetail = couponLookup.TryGetValue(
            new { order.ProductId, order.CustomerId, order.OrderId }, 
            out var matchedCoupons) 
            ? matchedCoupons 
            : new List<CouponUsageDetail>()
    })
    .ToList();

实现方式二：使用LINQ的GroupJoin（代码更简洁） #

GroupJoin内部会自动为右侧集合构建查找表，逻辑和手动字典一致，但代码更紧凑：

var orderDetailsList = orders
    // 第一步：关联Order和PaymentDetail
    .GroupJoin(
        paymentDetails,
        order => new { order.ProductId, order.CustomerId, order.OrderId }, // Order的键
        payment => new { payment.ProductId, payment.CustomerId, payment.OrderId }, // Payment的键
        (order, matchedPayments) => new { Order = order, Payments = matchedPayments }
    )
    // 第二步：关联第一步的结果和CouponUsageDetail
    .GroupJoin(
        couponUsageDetails,
        x => new { x.Order.ProductId, x.Order.CustomerId, x.Order.OrderId }, // 复用Order的键
        coupon => new { coupon.ProductId, coupon.CustomerId, coupon.OrderId }, // Coupon的键
        (x, matchedCoupons) => new OrderDetails
        {
            // 复制Order的属性
            ProductId = x.Order.ProductId,
            CustomerId = x.Order.CustomerId,
            OrderId = x.Order.OrderId,
            // 其他Order属性...
            PaymentDetail = x.Payments.ToList(),
            CouponUsageDetail = matchedCoupons.ToList()
        }
    )
    .ToList();

性能说明 #

两种方式的时间复杂度都是O(N + M + K)（N是Order数量，M是Payment数量，K是Coupon数量），远优于嵌套循环的O(NM + NK)。因为查找字典/GroupJoin的查找表只需要构建一次，后续每个Order的匹配都是常数时间。

需要注意的是：如果你的三个ID组合是唯一的（即每个Order对应唯一的Payment和Coupon），可以把List<PaymentDetail>改成PaymentDetail，并在查找时取FirstOrDefault()，进一步优化内存和访问效率。

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