引言

大家好，我是刚子。

在C# LINQ中，Join 是最常用的数据关联操作，但很多开发者却经常被它的参数顺序绊倒，或者在处理多表连接和空值时写出难以维护的代码。本文将逐一攻克这些痛点，让你真正掌握 Join。

一、参数顺序 —— 80% 错误的根源

Enumerable.Join 的方法签名为：

public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
    this IEnumerable<TOuter> outer,
    IEnumerable<TInner> inner,
    Func<TOuter, TKey> outerKeySelector,
    Func<TInner, TKey> innerKeySelector,
    Func<TOuter, TInner, TResult> resultSelector)

容易混淆的点：

  • 第一个参数 inner 实际上是内集合（需要匹配的集合）
  • outerKeySelector 作用于外集合（调用 Join 的那个集合），而不是内集合。

正确示例：

var orders = new[] { new { OrderId = 1, CustomerId = 101 } };
var customers = new[] { new { CustomerId = 101, Name = "张三" } };

var query = orders.Join(customers,   // outer = orders
                o => o.CustomerId,   // outerKeySelector
                c => c.CustomerId,   // innerKeySelector
                (o, c) => new { o.OrderId, c.Name });
// 结果: OrderId=1, Name=张三

常见错误：把外键和内键写反，导致匹配不到任何数据。

二、多表关联查询 —— 链式 Join 的清晰写法

当需要关联三张及以上表时，建议使用链式 Join，并为每个结果选择器创建匿名对象传递上下文。

var orders = GetOrders();
var customers = GetCustomers();
var shippers = GetShippers();

var result = orders
    .Join(customers,
        o => o.CustomerId,
        c => c.Id,
        (o, c) => new { Order = o, Customer = c })
    .Join(shippers,
        oc => oc.Order.ShipperId,
        s => s.Id,
        (oc, s) => new { oc.Order, oc.Customer, Shipper = s });

注意：匿名对象链会稍微增加内存开销，但对于大多数业务场景（< 10万条）完全可接受。若追求极致性能，可考虑使用 GroupJoin 后再扁平化。

三、空值（null）处理 —— 避免静默失败

当关联键可能为 null 时，直接使用会抛出 NullReferenceException。解决方案是提前过滤或提供默认键。

方案一：过滤 null 源数据

var validOrders = orders.Where(o => o.CustomerId != null);
var result = validOrders.Join(customers, ...);

方案二：使用可空类型转换（适用于值类型）

var result = orders.Join(customers,
    o => o.CustomerId ?? 0,        // 将 null 映射为 0
    c => c.Id,
    (o, c) => new { o, c });

方案三：自定义比较器（处理引用类型键） 见下一篇文章的自定义比较器章节。

总结

  • 牢记参数顺序：outer.Join(inner, outerKey, innerKey, result)
  • 多表关联时用链式 Join + 匿名对象传递中间结果
  • 优先在 Join 前过滤掉 null 键值，或使用默认值替换

我是刚子，一个还在写 .NET 的程序员。咱们下回见！