使用ExpressionVisitor改写查询替换Or为Contains时遇AndAlso运算符错误

我来帮你搞定这个问题！你遇到的错误核心是AndAlso操作数的类型不匹配——它需要两个返回bool类型的表达式树节点，但你替换后的左操作数意外变成了Func<foo.MV, System.Boolean>委托类型，导致框架无法识别这个二元运算符。

错误原因分析 #

大概率是你在替换Or表达式为Contains方法时，不小心把表达式树转换成了委托（比如误调用了Compile()），或者生成的Contains表达式没有正确保持bool返回类型的表达式树结构，最终让AndAlso的左右操作数一个是委托、一个是bool表达式，自然触发了类型不兼容的错误。

解决方案：正确实现Or转Contains的ExpressionVisitor #

下面是一个可直接复用的访问器实现，专门处理AndAlso左侧的连续Or表达式，将其合并为Contains调用，同时严格保持表达式树的类型正确性：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

public class OrToContainsVisitor : ExpressionVisitor
{
    protected override Expression VisitBinary(BinaryExpression node)
    {
        // 优先处理AndAlso节点，递归修改其左右操作数
        if (node.NodeType == ExpressionType.AndAlso)
        {
            var processedLeft = Visit(node.Left);
            var processedRight = Visit(node.Right);
            
            // 确保两个操作数都是返回bool的表达式
            if (processedLeft.Type != typeof(bool) || processedRight.Type != typeof(bool))
            {
                throw new InvalidOperationException("AndAlso的操作数必须返回bool类型");
            }
            
            return Expression.AndAlso(processedLeft, processedRight);
        }
        // 处理连续的OrElse节点，尝试合并为Contains调用
        else if (node.NodeType == ExpressionType.OrElse)
        {
            var containsExpression = TryConvertOrSequenceToContains(node);
            return containsExpression ?? base.VisitBinary(node);
        }
        
        return base.VisitBinary(node);
    }

    /// <summary>
    /// 尝试将连续的OrElse相等判断（如x.Name == "A" || x.Name == "B"）转为Contains调用
    /// </summary>
    private Expression TryConvertOrSequenceToContains(BinaryExpression orNode)
    {
        var equalityExpressions = new List<BinaryExpression>();
        var currentNode = orNode;

        // 遍历所有连续的OrElse节点，收集内部的相等判断
        while (currentNode.NodeType == ExpressionType.OrElse)
        {
            if (currentNode.Left is BinaryExpression leftEq && leftEq.NodeType == ExpressionType.Equal)
            {
                equalityExpressions.Add(leftEq);
            }
            else
            {
                // 存在非相等判断的Or，无法合并
                return null;
            }
            currentNode = currentNode.Right as BinaryExpression;
        }

        // 处理最后一个OrElse的右节点
        if (currentNode != null && currentNode.NodeType == ExpressionType.Equal)
        {
            equalityExpressions.Add(currentNode);
        }
        else
        {
            return null;
        }

        // 检查所有相等判断的左侧是否是同一个属性/表达式（比如都是x.Name）
        var targetProperty = equalityExpressions[0].Left;
        if (!equalityExpressions.All(e => AreExpressionsEqual(e.Left, targetProperty)))
        {
            return null;
        }

        // 收集所有要匹配的值
        var valueExpressions = equalityExpressions.Select(e => e.Right).ToArray();
        var valueType = targetProperty.Type;

        // 创建数组表达式（而非实际数组实例，确保ORM能解析为SQL IN语句）
        var arrayExpr = Expression.NewArrayInit(valueType, valueExpressions);
        
        // 获取Enumerable.Contains方法
        var containsMethod = typeof(Enumerable)
            .GetMethods(BindingFlags.Public | BindingFlags.Static)
            .First(m => m.Name == "Contains" && m.GetParameters().Length == 2)
            .MakeGenericMethod(valueType);

        // 返回Contains调用表达式
        return Expression.Call(containsMethod, arrayExpr, targetProperty);
    }

    /// <summary>
    /// 辅助方法：判断两个表达式是否结构相等
    /// </summary>
    private bool AreExpressionsEqual(Expression a, Expression b)
    {
        if (a == b) return true;
        if (a.NodeType != b.NodeType || a.Type != b.Type) return false;

        switch (a)
        {
            case MemberExpression meA when b is MemberExpression meB:
                return meA.Member == meB.Member && AreExpressionsEqual(meA.Expression, meB.Expression);
            case ParameterExpression peA when b is ParameterExpression peB:
                return peA.Name == peB.Name && peA.Type == peB.Type;
            case ConstantExpression ceA when b is ConstantExpression ceB:
                return Equals(ceA.Value, ceB.Value);
            default:
                return false;
        }
    }
}

使用示例 #

假设你的原始查询表达式是这样的：

Expression<Func<foo.MV, bool>> originalQuery = 
    x => (x.UserName == "Alice" || x.UserName == "Bob" || x.UserName == "Charlie") && x.IsActive;

用访问器修改后：

var visitor = new OrToContainsVisitor();
var modifiedQuery = (Expression<Func<foo.MV, bool>>)visitor.Visit(originalQuery);

最终生成的表达式等价于：

x => new[] {"Alice", "Bob", "Charlie"}.Contains(x.UserName) && x.IsActive;

关键注意事项 #

1. 绝对不要调用Compile()：这个方法会把表达式树转换成委托，一旦转换就无法再作为表达式树节点参与后续的AndAlso组合。
2. 确保类型一致性：所有返回给AndAlso的操作数必须是Expression类型，且返回值为bool。
3. 兼容ORM解析：用Expression.NewArrayInit创建数组表达式，而不是实例化实际的List，这样EF Core等ORM才能将Contains正确解析为SQL的IN语句。

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