EF Core（EF 6）主查询与嵌套查询Where条件动态实现咨询

针对你现在这套带回复的评论查询代码，要给主查询（顶级评论）和嵌套子查询（评论回复）添加动态Where条件，下面是几种实用的实现方案，同时会帮你优化原代码的重复逻辑和性能问题：

第一步：重构原代码，复用查询逻辑 #

原代码里主查询和子查询重复写了Comment与User的Join逻辑，先把这段抽成可复用方法，减少冗余：

// 复用的Comment-User关联查询
private IQueryable<(Comment Comment, User User)> GetCommentUserQuery()
{
    return dbContext.Comments
        .Join(dbContext.Users,
            c => c.User_Id,
            u => u.User_Id,
            (c, u) => (Comment: c, User: u));
}

后续主查询和子查询都可以直接调用这个方法，不用重复写Join代码。

方案一：手动拼接Linq条件（适合简单动态场景） #

如果你的动态条件是固定的几个可选参数（比如时间范围、部门关键词、内容搜索），可以直接在IQueryable上链式拼接Where条件：

1. 定义动态查询参数类 #

先把所有可能的动态条件封装成一个类，方便接口传参和管理：

public class CommentQueryParams
{
    public Guid PostId { get; set; }
    public string? Status { get; set; }
    public DateTime? StartDate { get; set; } // 评论创建起始时间
    public DateTime? EndDate { get; set; }   // 评论创建结束时间
    public string? Divisi { get; set; }      // 用户部门过滤
    public string? ContentKeyword { get; set; } // 评论内容关键词
    // 可根据需求添加更多条件
}

2. 主查询+子查询添加动态条件 #

修改原接口方法，接收参数类后拼接动态条件：

public async Task<IActionResult> GetCommentsWithReplies(
    [FromRoute] Guid POST_ID, 
    [FromRoute] string STATUS, 
    [FromQuery] PaginationFilter paginationFilter,
    [FromQuery] CommentQueryParams queryParams)
{
    var validFilter = new PaginationFilter(paginationFilter.PageNumber, paginationFilter.PageSize);
    var commentUserQuery = GetCommentUserQuery();

    // 构建主查询的动态条件
    var mainQuery = commentUserQuery
        .Where(x => x.Comment.Post_Id == POST_ID && x.Comment.Parent_Id == null);

    // 动态添加Status过滤（优先用queryParams里的值，没有则用路由传的STATUS）
    var targetStatus = queryParams.Status ?? STATUS;
    if (!string.IsNullOrEmpty(targetStatus))
    {
        mainQuery = mainQuery.Where(x => x.Comment.Status == targetStatus);
    }

    // 动态添加时间范围过滤
    if (queryParams.StartDate.HasValue)
    {
        mainQuery = mainQuery.Where(x => x.Comment.Created_At >= queryParams.StartDate.Value);
    }
    if (queryParams.EndDate.HasValue)
    {
        mainQuery = mainQuery.Where(x => x.Comment.Created_At <= queryParams.EndDate.Value);
    }

    // 动态添加用户部门过滤
    if (!string.IsNullOrEmpty(queryParams.Divisi))
    {
        mainQuery = mainQuery.Where(x => x.User.Divisi == queryParams.Divisi);
    }

    // 动态添加内容关键词搜索
    if (!string.IsNullOrEmpty(queryParams.ContentKeyword))
    {
        mainQuery = mainQuery.Where(x => x.Comment.Content.Contains(queryParams.ContentKeyword));
    }

    // 构建带动态条件的子查询（评论回复）
    var pagedData = mainQuery
        .OrderByDescending(x => x.Comment.Created_At)
        .Select(x => new Comment_Main
        {
            Comment_Id = x.Comment.Comment_Id,
            Parent_Id = x.Comment.Parent_Id,
            Post_Id = x.Comment.Post_Id,
            Content = x.Comment.Content,
            User_Id = x.Comment.User_Id,
            Status = x.Comment.Status,
            First_Name = x.User.First_Name,
            Last_Name = x.User.Last_Name,
            Posted_At = x.Comment.Posted_At,
            Created_At = x.Comment.Created_At,
            User_Name = x.User.User_Name,
            Divisi = x.User.Divisi,
            Departemen = x.User.Departemen,
            // 子查询复用主查询的动态条件
            Comment_Replies = GetCommentUserQuery()
                .Where(y => y.Comment.Parent_Id == x.Comment.Comment_Id)
                .WhereIf(!string.IsNullOrEmpty(targetStatus), y => y.Comment.Status == targetStatus)
                .WhereIf(queryParams.StartDate.HasValue, y => y.Comment.Created_At >= queryParams.StartDate.Value)
                .WhereIf(queryParams.EndDate.HasValue, y => y.Comment.Created_At <= queryParams.EndDate.Value)
                .OrderBy(y => y.Comment.Created_At)
                .Select(y => new Comment_Replies
                {
                    Comment_Id = y.Comment.Comment_Id,
                    Parent_Id = y.Comment.Parent_Id,
                    Post_Id = y.Comment.Post_Id,
                    Content = y.Comment.Content,
                    User_Id = y.User.User_Id,
                    Status = y.Comment.Status,
                    First_Name = y.User.First_Name,
                    Last_Name = y.User.Last_Name,
                    Posted_At = y.Comment.Posted_At,
                    Created_At = y.Comment.Created_At,
                    User_Name = y.User.User_Name,
                    Divisi = y.User.Divisi,
                    Departemen = y.User.Departemen
                })
        })
        // 分页必须放在AsEnumerable之前，让数据库执行分页逻辑，避免拉全量数据到内存
        .Skip((validFilter.PageNumber - 1) * validFilter.PageSize)
        .Take(validFilter.PageSize)
        .AsEnumerable(); // 最后再把分页后的数据拉到内存

    // 总记录数查询复用主查询的动态条件
    var totalRecords = mainQuery.Count();

    var totalPages = Convert.ToInt32(Math.Ceiling((double)totalRecords / (double)paginationFilter.PageSize));
    return Ok(new PagedResponse<List<Comment_Main>>(pagedData.ToList(), validFilter.PageNumber, validFilter.PageSize, totalPages, totalRecords));
}

上面用到的WhereIf是EF 6的扩展方法，如果你的项目里没有，可以自己实现：

public static class QueryableExtensions
{
    public static IQueryable<T> WhereIf<T>(this IQueryable<T> source, bool condition, Expression<Func<T, bool>> predicate)
    {
        return condition ? source.Where(predicate) : source;
    }
}

方案二：使用表达式树（适合复杂动态条件） #

如果你的动态条件是完全动态的（比如前端可以选择任意字段组合过滤），可以用表达式树构建Where条件：

示例：构建动态表达式 #

// 构建针对主查询的动态表达式
private Expression<Func<(Comment Comment, User User), bool>> BuildMainCommentExpression(CommentQueryParams queryParams)
{
    var parameter = Expression.Parameter(typeof((Comment Comment, User User)), "x");
    var commentProp = Expression.Property(parameter, nameof((Comment Comment, User User).Comment));
    var userProp = Expression.Property(parameter, nameof((Comment Comment, User User).User));

    var conditions = new List<Expression>();

    // 添加固定的PostId和ParentId条件
    conditions.Add(Expression.Equal(Expression.Property(commentProp, nameof(Comment.Post_Id)), Expression.Constant(queryParams.PostId)));
    conditions.Add(Expression.Equal(Expression.Property(commentProp, nameof(Comment.Parent_Id)), Expression.Constant(null, typeof(Guid?))));

    // 动态添加Status条件
    if (!string.IsNullOrEmpty(queryParams.Status))
    {
        conditions.Add(Expression.Equal(Expression.Property(commentProp, nameof(Comment.Status)), Expression.Constant(queryParams.Status)));
    }

    // 动态添加时间范围
    if (queryParams.StartDate.HasValue)
    {
        conditions.Add(Expression.GreaterThanOrEqual(Expression.Property(commentProp, nameof(Comment.Created_At)), Expression.Constant(queryParams.StartDate.Value)));
    }

    // 动态添加部门过滤
    if (!string.IsNullOrEmpty(queryParams.Divisi))
    {
        conditions.Add(Expression.Equal(Expression.Property(userProp, nameof(User.Divisi)), Expression.Constant(queryParams.Divisi)));
    }

    // 把所有条件用And连接
    var finalCondition = conditions.Aggregate(Expression.AndAlso);
    return Expression.Lambda<Func<(Comment Comment, User User), bool>>(finalCondition, parameter);
}

然后在主查询中直接使用：

var mainQuery = commentUserQuery.Where(BuildMainCommentExpression(queryParams));

子查询的表达式可以类似构建，只需要修改Parent_Id的条件为等于主评论的Comment_Id即可。

关键注意事项 #

1. 性能优化：原代码把AsEnumerable放在分页之前，会导致数据库返回所有符合条件的数据再在内存分页，一定要把Skip和Take放在AsEnumerable之前，让数据库执行分页逻辑。
2. 子查询的AsEnumerable：除非需要在内存中处理回复数据，否则不要给子查询加AsEnumerable，让EF生成嵌套SQL，数据库一次性查询出所有需要的数据。
3. SQL注入防护：EF会自动做参数化查询，不要手动拼接SQL字符串，避免注入风险。
4. EF版本兼容：如果后续升级到EF Core，大部分逻辑可以复用，EF Core内置了WhereIf方法，不需要自己实现。

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