Entity Framework Core 如何在实体配置中为属性设置全局默认排序规则

EF Core原生确实没有提供默认排序的配置API，你可以通过自定义元数据标记+表达式树拦截的方式完全实现你设想的HasDefaultSortAsc()效果，具体步骤如下：

步骤1：定义排序配置扩展方法 #

首先给Fluent API的PropertyBuilder添加扩展方法，将排序规则存入实体的元数据中：

// 先定义排序方向枚举
public enum SortDirection
{
    Ascending,
    Descending
}

public static class PropertyBuilderExtensions
{
    public static void HasDefaultSortAsc<TProperty>(this PropertyBuilder<TProperty> propertyBuilder)
    {
        var entityType = propertyBuilder.Metadata.DeclaringEntityType;
        // 存储排序属性和方向到实体元数据
        entityType.SetAnnotation("DefaultSortProperty", propertyBuilder.Metadata.Name);
        entityType.SetAnnotation("DefaultSortDirection", SortDirection.Ascending);
    }

    // 可按需扩展降序配置
    public static void HasDefaultSortDesc<TProperty>(this PropertyBuilder<TProperty> propertyBuilder)
    {
        var entityType = propertyBuilder.Metadata.DeclaringEntityType;
        entityType.SetAnnotation("DefaultSortProperty", propertyBuilder.Metadata.Name);
        entityType.SetAnnotation("DefaultSortDirection", SortDirection.Descending);
    }
}

扩展后你就可以直接在实体配置类里用你写的builder.Property(x => x.Priority).HasDefaultSortAsc();代码了，不会报错。

步骤2：实现查询表达式拦截器 #

编写表达式访问者，在查询执行前自动读取元数据中的排序规则，附加OrderBy逻辑：

public class DefaultSortExpressionVisitor : ExpressionVisitor
{
    private readonly IModel _model;

    public DefaultSortExpressionVisitor(IModel model)
    {
        _model = model;
    }

    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        // 仅处理Queryable的查询操作，且查询未手动指定排序时才附加默认排序
        if (node.Method.DeclaringType == typeof(Queryable) 
            && node.Method.Name is not nameof(Queryable.OrderBy) and not nameof(Queryable.OrderByDescending))
        {
            var entityClrType = node.Arguments[0].Type.GetGenericArguments().First();
            var entityType = _model.FindEntityType(entityClrType);
            
            // 读取实体的默认排序配置
            var sortPropertyName = entityType?.FindAnnotation("DefaultSortProperty")?.Value?.ToString();
            var sortDirection = entityType?.FindAnnotation("DefaultSortDirection")?.Value as SortDirection?;
            
            if (!string.IsNullOrEmpty(sortPropertyName) && sortDirection.HasValue)
            {
                // 构造OrderBy表达式
                var parameter = Expression.Parameter(entityClrType, "e");
                var sortProperty = Expression.Property(parameter, sortPropertyName);
                var sortLambda = Expression.Lambda(sortProperty, parameter);

                var orderByMethodName = sortDirection.Value == SortDirection.Ascending 
                    ? nameof(Queryable.OrderBy) 
                    : nameof(Queryable.OrderByDescending);
                var orderByMethod = typeof(Queryable)
                    .GetMethods()
                    .First(m => m.Name == orderByMethodName && m.GetParameters().Length == 2)
                    .MakeGenericMethod(entityClrType, sortProperty.Type);

                // 附加OrderBy到当前查询
                var orderByCall = Expression.Call(null, orderByMethod, node, sortLambda);
                return base.VisitMethodCall(orderByCall);
            }
        }
        return base.VisitMethodCall(node);
    }
}

步骤3：在DbContext中应用拦截逻辑 #

重写DbContext的Set<T>()方法，给所有查询自动应用排序拦截：

public class YourDbContext : DbContext
{
    public DbSet<Country> Countries { get; set; }
    // 其他DbSet...

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // 你的原有数据库配置逻辑
    }

    public override IQueryable<TEntity> Set<TEntity>() where TEntity : class
    {
        var originalQuery = base.Set<TEntity>();
        var sortVisitor = new DefaultSortExpressionVisitor(Model);
        var processedExpression = sortVisitor.Visit(originalQuery.Expression);
        return originalQuery.Provider.CreateQuery<TEntity>(processedExpression);
    }
}

配置完成后，所有加了HasDefaultSortAsc配置的实体，查询时都会自动按指定属性升序排列，不需要每次手动写OrderBy，手动写的OrderBy优先级高于默认配置，不会被覆盖。

如果你的项目规模不大，不想做复杂的拦截逻辑，可以用接口+扩展方法的方案实现，代码量更少也更易维护：

1. 定义公共接口：

public interface IHasPriority
{
    int Priority { get; set; }
}

2. 所有带Priority属性的实体实现该接口：

public class Country : IHasPriority
{
    public int Id {get; set;}
    public string Name {get; set;}
    public int Priority {get; set;}
}

3. 编写IQueryable扩展方法：

public static class QueryableExtensions
{
    public static IQueryable<T> OrderByPriority<T>(this IQueryable<T> query) where T : IHasPriority
    {
        return query.OrderBy(x => x.Priority);
    }
}

4. 查询时调用扩展方法即可：

var sortedCountries = dbContext.Countries.OrderByPriority().Where(x => x.Name.Contains("中国")).ToList();

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