动态构建多层级查询的Dynamic Linq Expression问题求助

针对你要动态构建的多层嵌套LINQ表达式树，核心难点在于处理嵌套的Select/Any方法调用，而不仅仅是简单的属性访问。我来一步步拆解实现过程，帮你构建出目标表达式：

一、动态构建Filter表达式（Expression<Func<TXLifeRequest, bool>>） #

我们把目标表达式拆成两个核心部分：IsDeleted == false的基础条件，以及嵌套的Any层级判断，最后用AndAlso组合起来。

1. 初始化根参数和基础条件

// 定义根参数 txreq
ParameterExpression txreqParam = Expression.Parameter(typeof(TXLifeRequest), "txreq");

// 构建 txreq.IsDeleted == false
MemberExpression isDeletedProp = Expression.Property(txreqParam, nameof(TXLifeRequest.IsDeleted));
ConstantExpression falseConst = Expression.Constant(false, typeof(bool));
BinaryExpression isDeletedCondition = Expression.Equal(isDeletedProp, falseConst);

2. 构建嵌套的Holding.Select(h => h.Policy).Any(...)部分

这部分需要逐层构建方法调用：

步骤1：访问txreq.OLifE.Holding

MemberExpression oLifeProp = Expression.Property(txreqParam, nameof(TXLifeRequest.OLifE));
MemberExpression holdingProp = Expression.Property(oLifeProp, nameof(OLifE.Holding));

步骤2：构建Select(h => h.Policy)调用

要调用Enumerable.Select泛型方法，需要先获取正确的泛型重载：

// 定义Select的参数h
ParameterExpression holdingParam = Expression.Parameter(typeof(Holding), "h");
// 构建h => h.Policy的lambda
MemberExpression policyFromHolding = Expression.Property(holdingParam, nameof(Holding.Policy));
Expression<Func<Holding, Policy>> selectPolicyLambda = Expression.Lambda<Func<Holding, Policy>>(policyFromHolding, holdingParam);

// 获取Enumerable.Select的泛型方法（匹配2个参数的重载）
MethodInfo selectMethod = typeof(Enumerable)
    .GetMethods()
    .First(m => m.Name == "Select" && m.GetParameters().Length == 2)
    .MakeGenericMethod(typeof(Holding), typeof(Policy));

// 构建Select调用表达式
MethodCallExpression selectCall = Expression.Call(selectMethod, holdingProp, selectPolicyLambda);

步骤3：构建内层的p.RequirementInfo.Any(r => r.ReqStatus.tc == ...)

先处理最内层的条件，再逐层向外包装：

// 目标状态值
string targetReqStatusTc = OLI_LU_REQSTAT.OLI_REQSTAT_OUTSTANDING.tc;

// 构建r => r.ReqStatus.tc == targetTc的lambda
ParameterExpression reqInfoParam = Expression.Parameter(typeof(RequirementInfo), "r");
MemberExpression reqStatusProp = Expression.Property(reqInfoParam, nameof(RequirementInfo.ReqStatus));
MemberExpression reqStatusTcProp = Expression.Property(reqStatusProp, nameof(OLI_LU_REQSTAT.tc));
ConstantExpression targetTcConst = Expression.Constant(targetReqStatusTc, typeof(string));
BinaryExpression reqStatusCondition = Expression.Equal(reqStatusTcProp, targetTcConst);
Expression<Func<RequirementInfo, bool>> reqInfoAnyLambda = Expression.Lambda<Func<RequirementInfo, bool>>(reqStatusCondition, reqInfoParam);

// 获取Enumerable.Any的泛型方法（带谓词的重载）
MethodInfo anyMethodForReqInfo = typeof(Enumerable)
    .GetMethods()
    .First(m => m.Name == "Any" && m.GetParameters().Length == 2)
    .MakeGenericMethod(typeof(RequirementInfo));

步骤4：构建外层的p => p.RequirementInfo.Any(...)并调用Any

// 定义Any的参数p
ParameterExpression policyParam = Expression.Parameter(typeof(Policy), "p");
MemberExpression reqInfoListProp = Expression.Property(policyParam, nameof(Policy.RequirementInfo));
// 调用RequirementInfo列表的Any
MethodCallExpression reqInfoAnyCall = Expression.Call(anyMethodForReqInfo, reqInfoListProp, reqInfoAnyLambda);
// 构建p => ...的lambda
Expression<Func<Policy, bool>> policyAnyLambda = Expression.Lambda<Func<Policy, bool>>(reqInfoAnyCall, policyParam);

// 获取Policy列表的Any方法
MethodInfo anyMethodForPolicy = typeof(Enumerable)
    .GetMethods()
    .First(m => m.Name == "Any" && m.GetParameters().Length == 2)
    .MakeGenericMethod(typeof(Policy));
// 调用Select结果的Any
MethodCallExpression policyAnyCall = Expression.Call(anyMethodForPolicy, selectCall, policyAnyLambda);

3. 组合所有条件，生成最终Filter

// 用AndAlso组合两个条件
BinaryExpression finalFilterBody = Expression.AndAlso(isDeletedCondition, policyAnyCall);
// 生成完整的filter表达式
Expression<Func<TXLifeRequest, bool>> filter = Expression.Lambda<Func<TXLifeRequest, bool>>(finalFilterBody, txreqParam);

二、动态构建Include表达式 #

你的Include是嵌套的Select调用，同样需要用表达式树构建：

// 定义Include的根参数r
ParameterExpression includeParam = Expression.Parameter(typeof(TXLifeRequest), "r");

// 访问r.OLifE.Holding
MemberExpression oLifeIncludeProp = Expression.Property(includeParam, nameof(TXLifeRequest.OLifE));
MemberExpression holdingIncludeProp = Expression.Property(oLifeIncludeProp, nameof(OLifE.Holding));

// 构建第一个Select(h => h.Policy)
ParameterExpression holdingIncludeParam = Expression.Parameter(typeof(Holding), "h");
MemberExpression policyIncludeProp = Expression.Property(holdingIncludeParam, nameof(Holding.Policy));
Expression<Func<Holding, Policy>> selectPolicyIncludeLambda = Expression.Lambda<Func<Holding, Policy>>(policyIncludeProp, holdingIncludeParam);
MethodInfo selectIncludeMethod1 = typeof(Enumerable)
    .GetMethods()
    .First(m => m.Name == "Select" && m.GetParameters().Length == 2)
    .MakeGenericMethod(typeof(Holding), typeof(Policy));
MethodCallExpression selectIncludeCall1 = Expression.Call(selectIncludeMethod1, holdingIncludeProp, selectPolicyIncludeLambda);

// 构建第二个Select(p => p.RequirementInfo)
ParameterExpression policyIncludeParam = Expression.Parameter(typeof(Policy), "p");
MemberExpression reqInfoIncludeProp = Expression.Property(policyIncludeParam, nameof(Policy.RequirementInfo));
Expression<Func<Policy, List<RequirementInfo>>> selectReqInfoLambda = Expression.Lambda<Func<Policy, List<RequirementInfo>>>(reqInfoIncludeProp, policyIncludeParam);
MethodInfo selectIncludeMethod2 = typeof(Enumerable)
    .GetMethods()
    .First(m => m.Name == "Select" && m.GetParameters().Length == 2)
    .MakeGenericMethod(typeof(Policy), typeof(List<RequirementInfo>));
MethodCallExpression selectIncludeCall2 = Expression.Call(selectIncludeMethod2, selectIncludeCall1, selectReqInfoLambda);

// 生成Include表达式
Expression<Func<TXLifeRequest, IEnumerable<List<RequirementInfo>>>> includeExpression = 
    Expression.Lambda<Func<TXLifeRequest, IEnumerable<List<RequirementInfo>>>>(selectIncludeCall2, includeParam);

三、最终调用 #

把构建好的表达式传入你的查询：

var results = db.GetQueryable(filter)
    .Include(includeExpression)
    .ToList();

关键注意事项 #

• 泛型方法获取：获取Enumerable.Select和Any时，一定要匹配正确的重载（比如带2个参数的版本，一个是源集合，一个是委托），否则会出现方法找不到的错误。
• 参数类型匹配：所有表达式的参数类型必须严格对应，比如Select的泛型参数要和集合元素、返回值类型一致。
• 嵌套lambda的参数隔离：每一层lambda的参数（比如h、p、r）都是独立的，不能重复使用同一个参数表达式，否则会导致表达式树逻辑错误。

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