C#使用表达式树编写动态查询函数的报错问题

原始基础查询 #

var query = context.Customers            
    .Join(context.Orders,
        customer => customer.CustomerId,
        order => order.CustomerId,
    (customer, order) => new
    {
        customer.ContactName,
        order.ShipCountry
    }).Where(customer => customer.ContactName.StartsWith("A"))
    .ToList();

尝试的表达式树封装代码 #

public static IEnumerable<object> GetContactNameandOrderDate(string prop_1, string prop_2, string prop_3, string text)
{

    NorthwindContext context = new();

    var customer = Expression.Parameter(typeof(Customer));    //customer  
    var order = Expression.Parameter(typeof(Order));          //order

    var customerCustomerId = Expression.PropertyOrField(customer, prop_1);        //customer.CustomerId
    var orderCustomerId = Expression.PropertyOrField(order, prop_1);              //order.CustomerId
    var customerContactName = Expression.PropertyOrField(customer, prop_2);       //customer.ContactName
    var orderShipCountry = Expression.PropertyOrField(order, prop_3);             //order.ShipCountry

    var textConstant = Expression.Constant(text);  //"A"

    Expression<Func<Customer, int>> lambda_1 = Expression.Lambda<Func<Customer, int>>(customerCustomerId, customer);  //customer => customer.CustomerId
    Expression<Func<Order, int>> lambda_2 = Expression.Lambda<Func<Order, int>>(orderCustomerId, order);     //  order => order.CustomerId

    Expression startsWith = Expression.Call(                    //customer.ContactName.StartsWith("A"))
                                customerContactName,
                                typeof(String).GetMethod("StartsWith",
                                            new Type[] { typeof(String) }), textConstant );

    Expression<Func<Customer, bool>> lambda_3 = Expression.Lambda<Func<Customer, bool>>(startsWith, customer); //customer => customer.ContactName.StartsWith("A"))

    var values = context.Customers.Join(context.Orders, lambda_1, lambda_2, (customer, order) => new { customerContactName, orderShipCountry }).Where(lambda_3).ToList();  //lambda_3 error
    return values;
}

错误信息 #

Error CS1503 Argument 2: cannot convert from 'System.Linq.Expressions.Expression<System.Func<expression_trees.Entities.Customer, bool>>' to 'System.Func<<anonymous type: System.Linq.Expressions.MemberExpression customerContactName, System.Linq.Expressions.MemberExpression orderShipCountry>, bool>'

问题分析 #

错误的核心是类型不匹配：
Join操作返回的是包含customerContactName和orderShipCountry的匿名类型，但你传入的lambda_3是针对Customer实体类型的表达式。而原始基础查询中，Where里的customer其实是Join后的匿名类型，并非原始Customer实体，这是你混淆的关键。

解决方法 #

方案1：提前过滤（推荐，性能更优） #

将过滤条件应用到Customers数据源上，再执行Join，既避免类型匹配问题，又减少数据库返回的数据量：

public static IEnumerable<object> GetContactNameandOrderDate(string prop_1, string prop_2, string prop_3, string text)
{
    using var context = new NorthwindContext();

    // 1. 构建Customer的过滤表达式
    var customerParam = Expression.Parameter(typeof(Customer), "customer");
    var contactNameProp = Expression.PropertyOrField(customerParam, prop_2);
    var startsWithMethod = typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!;
    var textConstant = Expression.Constant(text);
    var startsWithExpr = Expression.Call(contactNameProp, startsWithMethod, textConstant);
    var filterLambda = Expression.Lambda<Func<Customer, bool>>(startsWithExpr, customerParam);

    // 2. 构建Join的键选择器表达式
    var customerKeySelector = Expression.Lambda<Func<Customer, int>>(
        Expression.PropertyOrField(customerParam, prop_1),
        customerParam);

    var orderParam = Expression.Parameter(typeof(Order), "order");
    var orderKeySelector = Expression.Lambda<Func<Order, int>>(
        Expression.PropertyOrField(orderParam, prop_1),
        orderParam);

    // 3. 执行查询：先过滤再Join
    var values = context.Customers
        .Where(filterLambda)
        .Join(context.Orders, customerKeySelector, orderKeySelector, (c, o) => new { c.ContactName, o.ShipCountry })
        .ToList<object>();

    return values;
}

方案2：针对Join后匿名类型构建过滤表达式（复杂场景可选） #

如果必须在Join后过滤，需要构建针对匿名类型的表达式树（需通过反射获取匿名类型属性）：

// 仅作示例，实际场景推荐方案1
public static IEnumerable<object> GetContactNameandOrderDate(string prop_1, string prop_2, string prop_3, string text)
{
    using var context = new NorthwindContext();

    // 构建Join键选择器
    var customerParam = Expression.Parameter(typeof(Customer), "customer");
    var orderParam = Expression.Parameter(typeof(Order), "order");
    var customerKeySelector = Expression.Lambda<Func<Customer, int>>(
        Expression.PropertyOrField(customerParam, prop_1), customerParam);
    var orderKeySelector = Expression.Lambda<Func<Order, int>>(
        Expression.PropertyOrField(orderParam, prop_1), orderParam);

    // 执行Join获取匿名类型实例，用于反射获取类型
    var sampleProjection = new { ContactName = "", ShipCountry = "" };
    var projectionType = sampleProjection.GetType();

    // 构建针对匿名类型的过滤表达式
    var projectionParam = Expression.Parameter(projectionType, "item");
    var contactNameProp = Expression.PropertyOrField(projectionParam, prop_2);
    var startsWithMethod = typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!;
    var textConstant = Expression.Constant(text);
    var startsWithExpr = Expression.Call(contactNameProp, startsWithMethod, textConstant);
    var filterLambda = Expression.Lambda(startsWithExpr, projectionParam);

    // 执行查询
    var query = context.Customers
        .Join(context.Orders, customerKeySelector, orderKeySelector, (c, o) => new { c.ContactName, o.ShipCountry });
    var filteredQuery = query.Provider.CreateQuery(
        Expression.Call(
            typeof(Queryable),
            "Where",
            new[] { projectionType },
            query.Expression,
            filterLambda));

    return filteredQuery.Cast<object>().ToList();
}

动态查询实践建议 #

• 过滤条件前置：优先在数据源层面过滤，减少数据库IO，提升查询性能。
• 类型一致性：表达式树的参数类型必须与当前查询序列的元素类型完全匹配。
• 避免匿名类型：复杂动态场景下，使用自定义DTO类替代匿名类型，简化表达式树构建。
• 方法获取严谨性：用GetMethod时需处理返回null的情况，可结合空合并运算符!或空判断。

学习资源 #

• 《C# 高级编程》：深入讲解表达式树的构造逻辑与LINQ集成方式。
• EF官方文档：查看“动态查询”章节，了解EF对表达式树的支持细节。
• 微软API文档：学习System.Linq.Expressions命名空间下核心类（如Expression、LambdaExpression）的用法。

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