基于Sprache的递归表达式树解析：IEnumerable动态处理方案问询

核心思路是拆分集合属性与元素条件，将原表达式中针对集合元素的条件部分，切换上下文后解析为集合元素的Lambda，再通过Enumerable.Any方法组合最终表达式。

关键步骤 #

1. 识别路径中的IEnumerable节点：在解析属性路径时，一旦遇到返回IEnumerable<T>的属性，就停止继续解析当前路径，记录集合表达式、元素类型以及剩余未解析的条件字符串。
2. 切换上下文解析元素条件：将剩余的条件字符串（例如.Name != "flour"），以集合元素为参数重新解析，得到针对元素的条件表达式。
3. 构建Any方法调用：通过反射获取Enumerable.Any的泛型重载，将集合表达式和元素条件Lambda组合成最终的调用表达式。

代码实现示例 #

1. 解析Enumerable属性路径 #

先实现一个方法，专门解析包含IEnumerable属性的路径，返回集合表达式、元素类型和剩余条件：

private (Expression CollectionExpr, Type ElementType, string RemainingInput) ParseEnumerablePropertyPath(Expression parameter, string input)
{
    var currentExpr = parameter;
    Type currentType = parameter.Type;
    int position = 0;

    while (position < input.Length)
    {
        if (input[position] != '.') break;
        position++;
        
        // 用Sprache解析属性名
        var propertyName = ParseIdentifier().Parse(input.Substring(position));
        position += propertyName.Length;

        var property = currentType.GetProperty(propertyName) 
            ?? throw new ParseException($"属性 {propertyName} 在类型 {currentType} 中不存在");
        currentExpr = Expression.Property(currentExpr, property);
        currentType = property.PropertyType;

        // 检测是否为IEnumerable<T>
        if (currentType.IsGenericType && currentType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        {
            var elementType = currentType.GetGenericArguments()[0];
            return (currentExpr, elementType, input.Substring(position));
        }
    }

    throw new ParseException("路径中未找到可枚举属性");
}

2. 修改主解析方法，兼容Enumerable场景 #

在原有的ParseFilter方法中，先尝试解析Enumerable路径，失败则走原有逻辑：

public Expression<Func<T, bool>> ParseFilter<T>(string filter)
{
    var rootParam = Expression.Parameter(typeof(T), "x");

    try
    {
        // 尝试解析包含Enumerable的路径
        var (collectionExpr, elementType, remainingFilter) = ParseEnumerablePropertyPath(rootParam, filter);
        // 移除剩余条件开头的点（如果有）
        var elementConditionStr = remainingFilter.StartsWith(".") ? remainingFilter[1..] : remainingFilter;
        
        // 创建集合元素参数
        var elementParam = Expression.Parameter(elementType, "y");
        // 解析针对元素的条件（复用原有条件解析逻辑，切换参数为elementParam）
        var elementCondition = ParseElementCondition(elementParam, elementConditionStr);
        
        // 获取Enumerable.Any的泛型方法
        var anyMethod = typeof(Enumerable).GetMethods()
            .First(m => m.Name == "Any" && m.GetParameters().Length == 2)
            .MakeGenericMethod(elementType);
        // 构建Any调用表达式
        var anyCall = Expression.Call(anyMethod, collectionExpr, Expression.Lambda(elementCondition, elementParam));
        
        return Expression.Lambda<Func<T, bool>>(anyCall, rootParam);
    }
    catch (ParseException)
    {
        // 非Enumerable场景，走原有解析逻辑
        var parse = from left in ParseLeftExpr(rootParam)
                    from op in ParseOperator()
                    from right in ParseRightExpr()
                    select CreateComparison(left, op, right);
        
        var conditionExpr = parse.Parse(filter);
        return Expression.Lambda<Func<T, bool>>(conditionExpr, rootParam);
    }
}

// 复用原有的条件解析逻辑，仅更换参数为集合元素
private Expression ParseElementCondition(Expression elementParam, string condition)
{
    var parse = from left in ParseLeftExpr(elementParam)
                from op in ParseOperator()
                from right in ParseRightExpr()
                select CreateComparison(left, op, right);
    
    return parse.Parse(condition);
}

3. 处理嵌套Enumerable场景 #

如果需要支持多层嵌套（例如Orders.Items.Name == "apple"），只需将ParseElementCondition替换为通用的条件解析方法，让它自动检测当前参数的属性是否为Enumerable，重复上述解析流程即可。

注意事项 #

• 方法重载匹配：获取Enumerable.Any时，要确保拿到带谓词参数的重载（参数数量为2），避免匹配无参数的重载。
• 异常处理：添加解析失败的捕获逻辑，确保非Enumerable表达式能正常走原有流程。
• 类型检查：在解析属性时，要严格校验属性存在性和类型，避免运行时异常。

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