为何等价表达式树生成不同SQL？EF全局查询过滤问题

在Entity Framework项目中，我通过两种方式实现全局查询过滤，用于验证用户对RandomTable的访问权限（AuthorisedUsers表存储用户ID与RandomTableID的关联，二者为一对多关系），但生成的SQL却存在明显差异：

1. 编译时表达式（SQL符合预期） #

直接在编译阶段定义的表达式：

Expression<Func<RandomTable, bool>> test = c => AuthorisedUsers.Any(b => b.RandomTableId == c.RandomTableId && b.UserId == UserId);

生成的SQL简洁且符合预期：

SELECT *
FROM [RandomTable] AS [h]
WHERE EXISTS (
    SELECT 1
    FROM [AuthorisedUsers] AS [p0]
    WHERE ([h].[ID] = [p0].[RandomTableId]) AND ([p0].[UserId] = @__userId_0))

2. 运行时构建的表达式（SQL含冗余子查询） #

通过LambdaExpression动态为DbContext中所有表构建等价表达式，生成的SQL却多了一层无意义的嵌套子查询：

SELECT *
FROM [RandomTable] AS [h]
WHERE EXISTS (
 SELECT 1               
    FROM [AuthorisedUsers] AS [p] 
    WHERE EXISTS (
        SELECT 1
        FROM [AuthorisedUsers] AS [p0]
        WHERE ([p0].[RandomTableId] = [p].[RandomTableId]) AND ([p0].[UserId] = @__ef_filter__GetUserId_1)) AND (([p].[RandomTableId] = [h].[RandomTableId]) AND ([p].[UserId] = @__ef_filter__GetUserId_0)))

运行时表达式构建代码 #

// 目标等价于Lambda表达式：c => AuthorisedUsers.Any(b => b.RandomTableId == c.RandomTableId && b.UserId == GetUserId);
ParameterExpression b = Expression.Parameter(typeof(AuthorisedUsers), "b");
ParameterExpression x = Expression.Parameter(entityType.ClrType, "x");

MethodInfo anymethod = typeof(Queryable).GetMethods().Single(mi => mi.Name == "Any" && mi.GetParameters().Length == 2).MakeGenericMethod(typeof(AuthorisedUsers));
MemberExpression localUserId = Expression.MakeMemberAccess(Expression.Constant(this), typeof(DbContext).GetProperty(nameof(GetUserId), BindingFlags.Instance | BindingFlags.Public));

MemberExpression getAuthorisedUsers = Expression.MakeMemberAccess(
            Expression.Constant(this), typeof(DbContext).GetProperty(nameof(AuthorisedUsers)));

MemberExpression randomtableid = Expression.MakeMemberAccess(b, typeof(AuthorisedUsers).GetProperty("RandomTableId"));

MemberExpression userid = Expression.MakeMemberAccess(b, typeof(AuthorisedUsers).GetProperty("UserId"));

BinaryExpression randomTableIdmatch = Expression.Equal(randomtableid,
                         Expression.Convert(Expression.MakeMemberAccess(x, entityType.ClrType.GetProperty(propertyName)), typeof(int)));

LambdaExpression g = Expression.Lambda(Expression.Call(anymethod, getAuthorisedUsers,
                       Expression.Quote(
                           Expression.Lambda(Expression.AndAlso(randomTableIdmatch,
                           Expression.Equal(userid, localUserId)
                       ), b)
               )
           ),
           x
       );

entityType.SetQueryFilter(g);

问题核心 #

调试显示两个表达式树结构几乎一致，表达式可视化工具也判定二者逻辑等价，但SQL生成结果差异明显——为何运行时构建的表达式会产生冗余子查询？

原因分析 #

问题根源在于EF对数据源类型的识别差异：

1. 编译时表达式中，AuthorisedUsers是DbContext的DbSet<AuthorisedUsers>属性，编译器会直接将其标记为数据库层面的可查询数据源，Any调用会被转换为针对该表的单层EXISTS子查询。
2. 运行时表达式中，你通过Expression.Constant(this)获取AuthorisedUsers属性，此时EF会将这个Constant节点指向的对象识别为内存集合而非数据库中的DbSet。为了验证内存集合中是否存在匹配项，EF会额外生成一层子查询：先从数据库取出AuthorisedUsers数据，再在内存集合中做匹配，最终表现为SQL中的嵌套EXISTS结构。

简单来说：编译时EF能准确识别AuthorisedUsers是数据库表，直接生成高效查询；运行时构建表达式时的Constant节点，导致EF误判数据源类型，从而生成冗余嵌套查询。

修复方案 #

调整getAuthorisedUsers的构建方式，确保EF能识别它是DbSet而非内存集合：

// 替换原getAuthorisedUsers的构建代码
var dbSetProperty = typeof(DbContext).GetProperty(nameof(AuthorisedUsers));
// 使用Expression.Property直接访问DbContext的DbSet属性，而非从Constant实例读取值
MemberExpression getAuthorisedUsers = Expression.Property(Expression.Constant(this), dbSetProperty);

修改后，EF会正确将AuthorisedUsers识别为数据库表，生成和编译时一致的简洁SQL。

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