如何在运行时生成Dynamic LINQ IQueryable Join的关联键？

你的核心问题在于：EF Core的IQueryable.Join方法需要的是表达式树（Expression<Func<...>>），而不是普通的方法调用或委托。你自定义的MyMethod会被EF当作要翻译的SQL函数，自然无法正确解析——我们得动态构建EF能理解的表达式树，模拟你手动写的new { Prop1 = EF.Property<object>(entity, "Id"), ... }逻辑。

核心思路 #

EF能解析的是表达式树，所以我们需要在运行时动态生成和你手动写的匿名类型键选择器完全一致的表达式。主要分两步：

1. 构建单个EF.Property<object>(entity, propertyName)的表达式节点；
2. 将多个这样的节点组合成匿名类型（或ValueTuple）的实例化表达式，作为键选择器。

具体实现 #

1. 辅助方法：动态生成单属性键选择器 #

先从最简单的单键场景入手，写一个通用方法生成entity => EF.Property<object>(entity, "PropertyName")的表达式：

using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore;

public static class QueryExtensions
{
    // 生成单属性的键选择器表达式
    public static Expression<Func<TEntity, object>> BuildSingleKeySelector<TEntity>(string propertyName)
    {
        // 定义参数：entity
        var entityParam = Expression.Parameter(typeof(TEntity), "entity");
        
        // 获取EF.Property<object>(object, string)方法
        var efPropertyMethod = typeof(EF)
            .GetMethod(nameof(EF.Property), new[] { typeof(object), typeof(string) })
            ?.MakeGenericMethod(typeof(object));
        
        if (efPropertyMethod == null)
            throw new InvalidOperationException("无法找到EF.Property方法");
        
        // 构建EF.Property<object>(entity, propertyName)的调用表达式
        var propertyCall = Expression.Call(
            efPropertyMethod,
            entityParam,
            Expression.Constant(propertyName)
        );
        
        // 包装成Lambda表达式
        return Expression.Lambda<Func<TEntity, object>>(propertyCall, entityParam);
    }
}

2. 扩展：多属性匿名类型键选择器 #

如果需要多个关联键，我们可以动态构建匿名类型的实例化表达式。这里需要先创建一个匿名类型的示例来获取其类型，再生成对应的表达式：

// 生成多属性匿名类型的键选择器
public static Expression<Func<TEntity, TKey>> BuildAnonymousKeySelector<TEntity, TKey>(
    Dictionary<string, string> propertyMappings) where TKey : class
{
    var entityParam = Expression.Parameter(typeof(TEntity), "entity");
    var efPropertyMethod = typeof(EF)
        .GetMethod(nameof(EF.Property), new[] { typeof(object), typeof(string) })
        ?.MakeGenericMethod(typeof(object));
    
    if (efPropertyMethod == null)
        throw new InvalidOperationException("无法找到EF.Property方法");
    
    // 获取匿名类型的构造函数和属性
    var keyType = typeof(TKey);
    var constructor = keyType.GetConstructors().First();
    var keyProperties = keyType.GetProperties();
    
    var propertyExpressions = new List<Expression>();
    foreach (var keyProp in keyProperties)
    {
        if (!propertyMappings.TryGetValue(keyProp.Name, out var entityPropName))
            throw new ArgumentException($"未找到键属性 {keyProp.Name} 对应的实体属性映射");
        
        // 构建每个EF.Property的调用
        var propertyCall = Expression.Call(
            efPropertyMethod,
            entityParam,
            Expression.Constant(entityPropName)
        );
        propertyExpressions.Add(propertyCall);
    }
    
    // 构建匿名类型的new表达式
    var newKeyExpr = Expression.New(constructor, propertyExpressions);
    
    return Expression.Lambda<Func<TEntity, TKey>>(newKeyExpr, entityParam);
}

3. 实际使用示例 #

假设你的实体是Order，关联实体是OrderItem，需要通过Order.Id和OrderItem.OrderId、Order.TenantId和OrderItem.TenantId关联：

// 1. 定义匿名类型示例（用于获取类型）
var keySample = new { OrderId = (object)null, TenantId = (object)null };

// 2. 生成左右两边的键选择器
var orderKeySelector = QueryExtensions.BuildAnonymousKeySelector<Order, dynamic>(
    new Dictionary<string, string>
    {
        { "OrderId", "Id" },
        { "TenantId", "TenantId" }
    });

var orderItemKeySelector = QueryExtensions.BuildAnonymousKeySelector<OrderItem, dynamic>(
    new Dictionary<string, string>
    {
        { "OrderId", "OrderId" },
        { "TenantId", "TenantId" }
    });

// 3. 执行Join
var joinedQuery = dbContext.Orders
    .Join(dbContext.OrderItems,
        orderKeySelector,
        orderItemKeySelector,
        (order, item) => new { Order = order, OrderItem = item });

备选方案：使用Dynamic LINQ库 #

如果你已经在使用Dynamic LINQ，可以直接用字符串格式的键选择器，更简洁：

using System.Linq.Dynamic.Core;

var joinedQuery = dbContext.Orders
    .Join(dbContext.OrderItems,
        "new(EF.Property(object, 'Id') as OrderId, EF.Property(object, 'TenantId') as TenantId)",
        "new(EF.Property(object, 'OrderId') as OrderId, EF.Property(object, 'TenantId') as TenantId)",
        "new(outer as Order, inner as OrderItem)");

关键注意点 #

• 必须传递Expression<Func<...>>类型的参数给Join，而不是普通的Func<...>，前者才会被EF解析成SQL；
• 动态构建表达式时，要确保调用的是EF.Property方法，而不是直接访问实体属性——这在处理动态属性名时是必须的，因为EF需要知道这是属性访问而不是其他操作；
• 匿名类型的键需要左右两边的属性名和类型完全一致，EF才能正确匹配连接条件。

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