使用EF Core构建查询表达式时调用.Any()报错的原因与解决办法

问题场景 #

尝试构建Expression<Func<T, bool>>类型的查询表达式，实现代码如下：

public static Expression<Func<T, bool>> CreateAny<T, TAnother>(
        Expression<Func<T, IEnumerable<TAnother>>> collectionPropertyExpression,
        Expression<Func<TAnother, bool>> anyPredidate
    )
    {
        var param = Expression.Parameter(typeof(T), collectionPropertyExpression.Parameters.Single().Name);
        var anyMethodInfo = typeof(Enumerable)
            .GetMethods(BindingFlags.Public | BindingFlags.Static)
            .Single(m => m.Name == "Any" && m.GetParameters().Length == 2)
            .MakeGenericMethod(typeof(TAnother));
        var anyCallExpression = Expression.Call(
            anyMethodInfo,
            collectionPropertyExpression.Body,
            Expression.Lambda<Func<TAnother, bool>>(anyPredidate.Body, anyPredidate.Parameters.Single())
        );
        return Expression.Lambda<Func<T, bool>>(anyCallExpression, param);
    }

调用方式：

public async Task<IActionResult> Tests()
   {
        /*期望生成表达式：
            a => a.ReceivedNotifications.Any(noti => noti.Status == NotificationStatus.Read)
        */
        var exp = ExpressionHelper.CreateAny<Account, AccountNotification>(
            a => a.ReceivedNotifications,
            noti => noti.Status == NotificationStatus.Read
        );
        logger.LogInformation("{0}", exp); // 输出：a => a.ReceivedNotifications.Any(noti => (Convert(noti.Status, Int32) == 2))
        return Ok(await unitOfWork.Accounts.GetAsync(expression: exp)); // 此处报错
    }

报错信息：

System.InvalidOperationException: The LINQ expression 'a' could not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly by inserting a call to 'AsEnumerable', 'AsAsyncEnumerable', 'ToList', or 'ToListAsync'.

错误原因 #

1. 参数引用不统一：创建最终Lambda表达式时，使用了新生成的param参数，但collectionPropertyExpression.Body内部引用的是原表达式的参数实例，两者是不同的Expression对象，ORM无法识别它们指向同一个变量，导致表达式翻译失败。
2. 误用Enumerable.Any方法：代码中获取的是Enumerable类的Any方法，这类方法用于客户端集合操作；而EF Core等ORM需要的是Queryable类的Any方法，才能将表达式翻译为服务器端SQL查询，误用会触发无法翻译的错误。

解决方法 #

修正步骤 #

1. 统一参数引用：遍历表达式树，将collectionPropertyExpression.Body中原参数的所有引用替换为新创建的参数，确保整个表达式的参数一致。
2. 切换到Queryable.Any方法：改为获取Queryable类的Any方法重载，让ORM能正确识别并翻译为SQL查询。

修正后的代码 #

public static Expression<Func<T, bool>> CreateAny<T, TAnother>(
    Expression<Func<T, IEnumerable<TAnother>>> collectionPropertyExpression,
    Expression<Func<TAnother, bool>> anyPredicate
)
{
    // 获取原表达式的参数
    var originalParam = collectionPropertyExpression.Parameters.Single();
    // 创建新参数（保持名称一致）
    var newParam = Expression.Parameter(typeof(T), originalParam.Name);
    
    // 替换collectionPropertyExpression.Body中的原参数为新参数
    var updatedCollectionBody = ExpressionReplacer.Replace(originalParam, newParam, collectionPropertyExpression.Body);
    
    // 获取Queryable的Any方法（两个参数的重载）
    var anyMethodInfo = typeof(Queryable)
        .GetMethods(BindingFlags.Public | BindingFlags.Static)
        .Single(m => m.Name == "Any" && m.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(TAnother));
    
    // 构建Any调用表达式
    var anyCallExpression = Expression.Call(
        anyMethodInfo,
        updatedCollectionBody,
        anyPredicate
    );
    
    // 返回使用新参数的Lambda表达式
    return Expression.Lambda<Func<T, bool>>(anyCallExpression, newParam);
}

// 辅助类：替换表达式中的参数引用
public class ExpressionReplacer : ExpressionVisitor
{
    private readonly ParameterExpression _oldParam;
    private readonly ParameterExpression _newParam;

    private ExpressionReplacer(ParameterExpression oldParam, ParameterExpression newParam)
    {
        _oldParam = oldParam;
        _newParam = newParam;
    }

    public static Expression Replace(ParameterExpression oldParam, ParameterExpression newParam, Expression expression)
    {
        return new ExpressionReplacer(oldParam, newParam).Visit(expression);
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        return node == _oldParam ? _newParam : base.VisitParameter(node);
    }
}

说明 #

• ExpressionReplacer：继承自ExpressionVisitor，用于遍历表达式树，批量替换参数引用，确保整个表达式的参数实例统一。
• Queryable.Any：使用Queryable类的方法后，EF Core会将表达式翻译为SQL中的EXISTS或ANY逻辑，实现服务器端查询，避免客户端评估的错误。

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