Entity Framework中如何将嵌套Expression<Func>嵌入另一个Expression<Func>

你需要在EF查询中复用嵌套的Expression<Func<>>来实现多层DTO映射，避免冗长的内联代码，但直接在Select中调用另一个表达式会导致EF无法解析——因为EF需要完整的表达式树生成SQL，直接嵌套表达式会被当作委托调用处理，无法转换为数据库查询逻辑。

以下是两种可行的解决方案：

方案1：手动构建表达式树复用逻辑 #

通过表达式树拼接工具，将嵌套的SelectModels表达式整合到SelectProvider表达式中，确保EF能解析完整的查询逻辑。

1. 实现参数替换工具类 #

用于替换表达式中的参数节点，实现嵌套表达式的复用：

public static class ExpressionExtensions
{
    private class ParameterReplacer : ExpressionVisitor
    {
        private readonly ParameterExpression _oldParam;
        private readonly Expression _newParam;

        public ParameterReplacer(ParameterExpression oldParam, Expression newParam)
        {
            _oldParam = oldParam;
            _newParam = newParam;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            return node == _oldParam ? _newParam : base.VisitParameter(node);
        }
    }

    public static Expression ReplaceParameter(this Expression expression, ParameterExpression oldParam, Expression newParam)
    {
        return new ParameterReplacer(oldParam, newParam).Visit(expression);
    }
}

2. 构建复用式映射表达式 #

手动拼接表达式树，将SelectModels的逻辑嵌入到SelectProvider中：

// 复用的Model→ModelRecord映射表达式
public static Expression<Func<Model, ModelRecord>> SelectModels = y => new ModelRecord(
    y.ModelId,
    y.Name,
    y.Version,
    y.InsertTimeStamp
);

// 构建Provider→ProviderRecord映射表达式，嵌套复用SelectModels
public static Expression<Func<Provider, ProviderRecord>> SelectProvider = BuildSelectProvider();

private static Expression<Func<Provider, ProviderRecord>> BuildSelectProvider()
{
    // 定义Provider参数x
    var x = Expression.Parameter(typeof(Provider), "x");
    
    // 获取x.Models属性节点
    var modelsProperty = Expression.Property(x, nameof(Provider.Models));
    
    // 替换SelectModels中的参数为当前Model节点y
    var y = Expression.Parameter(typeof(Model), "y");
    var modelRecordBody = SelectModels.Body.ReplaceParameter(SelectModels.Parameters[0], y);
    var modelSelector = Expression.Lambda<Func<Model, ModelRecord>>(modelRecordBody, y);
    
    // 构建x.Models.Select(y => ...)的调用表达式
    var selectCall = Expression.Call(
        typeof(Enumerable),
        nameof(Enumerable.Select),
        new[] { typeof(Model), typeof(ModelRecord) },
        modelsProperty,
        modelSelector
    );
    
    // 构建ProviderRecord的构造表达式
    var providerRecordConstructor = typeof(ProviderRecord).GetConstructor(
        new[] { typeof(int), typeof(string), typeof(DateTimeOffset), typeof(IEnumerable<ModelRecord>) }
    );
    var providerRecordExpr = Expression.New(
        providerRecordConstructor,
        Expression.Property(x, nameof(Provider.ProviderId)),
        Expression.Property(x, nameof(Provider.Name)),
        Expression.Property(x, nameof(Provider.InsertTimeStamp)),
        selectCall
    );
    
    return Expression.Lambda<Func<Provider, ProviderRecord>>(providerRecordExpr, x);
}

3. 在查询中使用 #

直接复用构建好的表达式即可：

public async Task<IEnumerable<ProviderRecord>> GetAllProviders() => 
    await _context.Providers
        .Include(x => x.Models)
        .Select(SelectProvider)
        .ToListAsync();

方案2：使用AutoMapper简化映射 #

如果不想手动处理表达式树，可以使用AutoMapper，它会自动生成EF可解析的表达式树，同时支持多层映射的复用。

1. 配置映射关系 #

var mapperConfig = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Provider, ProviderRecord>();
    cfg.CreateMap<Model, ModelRecord>();
});

// 开发阶段验证配置有效性（可选）
mapperConfig.AssertConfigurationIsValid();

2. 在查询中使用ProjectTo #

通过ProjectTo方法将映射转换为EF可解析的表达式树，直接在数据库端完成查询和映射：

private readonly IMapper _mapper;
private readonly YourDbContext _context;

// 通过依赖注入获取IMapper和DbContext
public YourRepository(IMapper mapper, YourDbContext context)
{
    _mapper = mapper;
    _context = context;
}

public async Task<IEnumerable<ProviderRecord>> GetAllProviders() => 
    await _context.Providers
        .Include(x => x.Models)
        .ProjectTo<ProviderRecord>(_mapper.ConfigurationProvider)
        .ToListAsync();

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