如何在EF Core 3.1自定义Specification中实现ThenInclude对象模式？

当然可以实现基于对象表达式的ThenInclude多级关联！下面我会一步步改造你现有的Specification模式，让它支持EF Core的链式ThenInclude调用，彻底摆脱字符串路径的硬编码问题。

1. 扩展ISpecification接口 #

首先，我们需要修改原来的ISpecification<T>接口，替换掉单一的Includes集合，换成能存储Include+ThenInclude链的结构：

public interface ISpecification<T> where T : class
{
    Expression<Func<T, bool>> Criteria { get; }
    // 替换原有的Includes，改用存储包含链的集合
    List<IncludeExpressionInfo<T>> IncludeExpressions { get; }
    List<string> IncludeStrings { get; }
}

// 辅助类：存储主Include和对应的ThenInclude表达式链
public class IncludeExpressionInfo<T>
{
    public Expression<Func<T, object>> MainInclude { get; set; }
    public List<object> ThenIncludes { get; set; } = new List<object>();
}

2. 给Specification基类添加链式AddInclude方法 #

假设你有一个BaseSpecification<T>实现了ISpecification<T>，我们给它添加支持ThenInclude的便捷方法：

public class BaseSpecification<T> : ISpecification<T> where T : class
{
    public Expression<Func<T, bool>> Criteria { get; protected set; }
    public List<IncludeExpressionInfo<T>> IncludeExpressions { get; } = new List<IncludeExpressionInfo<T>>();
    public List<string> IncludeStrings { get; } = new List<string>();

    // 添加主Include，并返回一个可链式调用ThenInclude的对象
    public IncludeBuilder<T, TProperty> AddInclude<TProperty>(Expression<Func<T, TProperty>> includeExpression)
    {
        var includeInfo = new IncludeExpressionInfo<T>
        {
            MainInclude = includeExpression.Body is UnaryExpression u 
                ? Expression.Lambda<Func<T, object>>(u.Operand, includeExpression.Parameters) 
                : Expression.Lambda<Func<T, object>>(includeExpression.Body, includeExpression.Parameters)
        };
        IncludeExpressions.Add(includeInfo);
        return new IncludeBuilder<T, TProperty>(includeInfo);
    }

    // 内部Builder类，用于链式ThenInclude
    public class IncludeBuilder<TEntity, TPreviousProperty> where TEntity : class
    {
        private readonly IncludeExpressionInfo<TEntity> _includeInfo;

        public IncludeBuilder(IncludeExpressionInfo<TEntity> includeInfo)
        {
            _includeInfo = includeInfo;
        }

        public IncludeBuilder<TEntity, TNextProperty> ThenInclude<TNextProperty>(Expression<Func<TPreviousProperty, TNextProperty>> thenIncludeExpression)
        {
            _includeInfo.ThenIncludes.Add(thenIncludeExpression);
            return new IncludeBuilder<TEntity, TNextProperty>(_includeInfo);
        }
    }
}

这里的IncludeBuilder类是关键，它让我们可以像EF Core原生那样链式调用ThenInclude，自动把后续的表达式存入对应的包含链中。

3. 更新QuerySpecificationExtensions的Specify方法 #

现在需要修改你的扩展方法，处理这些包含链，依次调用Include和ThenInclude：

public static class QuerySpecificationExtensions
{
    public static IQueryable<T> Specify<T>(this IQueryable<T> query, ISpecification<T> spec) where T : class
    {
        // 处理Include+ThenInclude链
        var queryWithIncludes = spec.IncludeExpressions.Aggregate(query, (current, includeInfo) =>
        {
            // 先调用主Include
            var includedQuery = current.Include(includeInfo.MainInclude);
            
            // 依次调用每个ThenInclude
            foreach (var thenInclude in includeInfo.ThenIncludes)
            {
                includedQuery = ThenInclude(includedQuery, thenInclude);
            }
            
            return includedQuery;
        });

        // 处理字符串形式的Include（保留原有逻辑）
        var queryWithStringIncludes = spec.IncludeStrings.Aggregate(queryWithIncludes, (current, include) => current.Include(include));

        // 应用查询条件
        return queryWithStringIncludes.Where(spec.Criteria);
    }

    // 反射调用对应的ThenInclude方法（因为泛型参数需要动态匹配）
    private static IQueryable<T> ThenInclude<T, TPrevious, TNext>(IQueryable<T> query, Expression<Func<TPrevious, TNext>> thenIncludeExpr) where T : class
    {
        var includeMethod = typeof(EntityFrameworkQueryableExtensions)
            .GetMethods()
            .First(m => m.Name == nameof(EntityFrameworkQueryableExtensions.ThenInclude) && m.GetParameters().Length == 2)
            .MakeGenericMethod(typeof(T), typeof(TPrevious), typeof(TNext));

        return (IQueryable<T>)includeMethod.Invoke(null, new object[] { query, thenIncludeExpr });
    }
}

这里用反射来调用EF Core的ThenInclude泛型方法，因为每个ThenInclude的泛型参数依赖于前一个导航属性的类型，反射是EF Core 3.1里实现这种动态调用的可靠方式。

4. 使用示例 #

现在你就可以像使用原生EF Core那样，用表达式链式调用Include和ThenInclude了：

// 定义一个具体的Specification
public class OrderSpecification : BaseSpecification<Order>
{
    public OrderSpecification(int orderId)
    {
        Criteria = o => o.Id == orderId;
        
        // 链式多级关联查询
        AddInclude(o => o.User)
            .ThenInclude(u => u.UserRole)
            .ThenInclude(ur => ur.Role);
    }
}

// 在业务逻辑中使用
var order = await _dbContext.Orders
    .Specify(new OrderSpecification(1))
    .FirstOrDefaultAsync();

这样就完全实现了基于对象表达式的多级关联查询，避免了字符串路径的拼写错误，同时保留了Specification模式的封装性。

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