如何将C# AspNet.Core请求查询参数转换为EF Core谓词表达式优化Azure端访问UX

核心设计思路 #

这个方案的核心是让前端可以灵活组合查询条件，后端不需要为不同的查询场景单独写接口，减少前后端联调成本的同时，所有查询逻辑都会被EF Core翻译成原生SQL执行，不会出现内存过滤的性能问题，尤其适配Azure云环境下的接口低延迟要求，最大化客户端体验。

分步实现流程 #

• 第一步：定义通用查询参数接收模型
  先定义统一的参数结构，用于接收前端通过Query传递的过滤、排序、分页规则，AspNet Core会自动把Query字符串绑定到该模型：

public class FilterRule
{
    // 要过滤的实体属性名，不区分大小写
    public string Field { get; set; }
    // 操作符：支持eq(等于)/ne(不等于)/gt(大于)/lt(小于)/ge(大于等于)/le(小于等于)/contains(包含)/startsWith(开头匹配)/endsWith(结尾匹配)
    public string Op { get; set; }
    // 过滤值
    public string Value { get; set; }
    // 和下一个条件的逻辑连接符：and/or，默认and
    public string Logic { get; set; } = "and";
}

// 通用查询请求类
public class QueryRequest
{
    public List<FilterRule> Filters { get; set; } = new();
    public string SortField { get; set; }
    public bool SortDesc { get; set; } = false;
    public int PageIndex { get; set; } = 1;
    public int PageSize { get; set; } = 20;
}

• 第二步：实现Expression动态构建逻辑
  核心工具类，把前端传的过滤规则转换成EF Core可以识别的强类型Predicate表达式，不存在的属性会自动忽略，避免接口报错：

using System.Linq.Expressions;
using System.Reflection;

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> BuildPredicate<T>(List<FilterRule> filters)
    {
        if (!filters.Any()) return x => true;
        
        var parameter = Expression.Parameter(typeof(T), "x");
        Expression combinedExp = null;

        foreach (var rule in filters)
        {
            // 忽略实体不存在的属性，避免非法参数报错
            var property = typeof(T).GetProperty(rule.Field, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
            if (property == null) continue;
            
            // 把前端传的字符串值转换为实体属性对应的类型
            var convertedValue = Convert.ChangeType(rule.Value, property.PropertyType);
            var constant = Expression.Constant(convertedValue, property.PropertyType);
            var propertyAccess = Expression.Property(parameter, property);

            // 匹配操作符生成对应表达式
            Expression currentExp = rule.Op.ToLower() switch
            {
                "eq" => Expression.Equal(propertyAccess, constant),
                "ne" => Expression.NotEqual(propertyAccess, constant),
                "gt" => Expression.GreaterThan(propertyAccess, constant),
                "lt" => Expression.LessThan(propertyAccess, constant),
                "ge" => Expression.GreaterThanOrEqual(propertyAccess, constant),
                "le" => Expression.LessThanOrEqual(propertyAccess, constant),
                "contains" => Expression.Call(propertyAccess, 
                    typeof(string).GetMethod("Contains", new[] { typeof(string) })!, 
                    constant),
                "startswith" => Expression.Call(propertyAccess,
                    typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!,
                    constant),
                "endswith" => Expression.Call(propertyAccess,
                    typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!,
                    constant),
                _ => Expression.Constant(true)
            };

            // 按逻辑符拼接多个条件
            if (combinedExp == null)
            {
                combinedExp = currentExp;
            }
            else
            {
                combinedExp = rule.Logic.ToLower() switch
                {
                    "and" => Expression.AndAlso(combinedExp, currentExp),
                    "or" => Expression.OrElse(combinedExp, currentExp),
                    _ => combinedExp
                };
            }
        }

        return Expression.Lambda<Func<T, bool>>(combinedExp ?? Expression.Constant(true), parameter);
    }
}

• 第三步：接口层集成使用
  直接在接口参数上标记[FromQuery]，即可自动绑定Query参数，配合EF Core完成数据库查询：

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly YourDbContext _dbContext;

    public ProductsController(YourDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    [HttpGet]
    public async Task<IActionResult> GetList([FromQuery] QueryRequest request)
    {
        // 构建过滤表达式
        var predicate = PredicateBuilder.BuildPredicate<Product>(request.Filters);
        var query = _dbContext.Products.Where(predicate);
        
        // 动态排序
        if (!string.IsNullOrEmpty(request.SortField))
        {
            query = request.SortDesc 
                ? query.OrderByDescending(p => EF.Property<object>(p, request.SortField)) 
                : query.OrderBy(p => EF.Property<object>(p, request.SortField));
        }
        
        // 分页查询
        var total = await query.CountAsync();
        var data = await query
            .Skip((request.PageIndex - 1) * request.PageSize)
            .Take(request.PageSize)
            .ToListAsync();
        
        return Ok(new { total, data });
    }
}

面向Azure端点的体验优化点 #

• 新增参数校验逻辑，提前拦截非法的字段名、操作符请求，避免EF生成无效SQL，同时限制PageSize最大值，防止客户端请求全量数据导致接口超时、带宽占用过高
• 高频查询可以接入Azure Redis Cache做结果缓存，降低数据库访问压力，进一步缩短接口响应时间
• 生产环境开启EF Core慢查询日志，针对高频查询添加对应数据库索引，优化SQL执行效率
• 可新增查询条件白名单机制，只开放允许客户端查询的字段，避免敏感字段被非法查询泄露数据

调用示例 #

客户端直接拼接Query字符串即可完成自定义查询，示例请求：
GET /api/products?Filters[0].Field=Name&Filters[0].Op=contains&Filters[0].Value=phone&Filters[1].Field=Price&Filters[1].Op=le&Filters[1].Value=5000&SortField=Price&SortDesc=true&PageIndex=1&PageSize=10
上述请求会自动转换为：查询名称包含phone、价格小于等于5000的商品，按价格倒序排列，返回第一页10条数据。

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