AutoMapper内存查询与EF SQL投影映射兼容问题求助

针对你遇到的AutoMapper无法同时生效内存映射和EF投影配置的问题，这里提供几个实用的解决思路：

方案一：统一映射逻辑为可解析的表达式（推荐） #

AutoMapper的MapFrom支持传入Expression<Func<TSource, TDestMember>>，这种表达式既能被EF解析为SQL投影逻辑，也能在内存映射时直接执行。我们可以把本地化描述的逻辑封装成共享表达式，同时适配两种场景：

步骤1：定义共享的表达式逻辑 #

public static class ProductMappingExpressions
{
    public static readonly Expression<Func<ProductEntity, string?>> GetLocalizedDescription = 
        product => product.Descriptions!
            .FirstOrDefault(d => d.Language.Equals(
                Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName, 
                StringComparison.InvariantCultureIgnoreCase))
            ?.Description;
}

步骤2：修改AutoMapper配置 #

只保留一个CreateMap配置，用上面的表达式作为映射源：

public class ProductMappings : Profile
{
    public ProductMappings()
    {
        CreateMap<ProductEntity, ProductWithDescription>()
            .ForMember(dst => dst.Description, 
                exp => exp.MapFrom(ProductMappingExpressions.GetLocalizedDescription));
    }
}

这样配置后，EF的ProjectTo<ProductWithDescription>()会把表达式解析为SQL的过滤和投影逻辑，内存映射时也能直接执行表达式获取描述，无需分开配置。

方案二：根据场景使用不同的Mapper实例 #

如果必须保留两种不同的逻辑，可以创建两个独立的AutoMapper配置，分别对应内存映射和EF投影，然后在不同场景下使用对应的Mapper：

步骤1：创建两个配置类 #

// 内存映射专用配置
public class ProductMemoryMappings : Profile
{
    public ProductMemoryMappings()
    {
        CreateMap<ProductEntity, ProductWithDescription>()
            .ForMember(dst => dst.Description, 
                exp => exp.MapFrom(src => GetLocalizedDescription(src)));
    }

    private static string? GetLocalizedDescription(ProductEntity product) =>
        product.Descriptions
               ?.FirstOrDefault(description => Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName.Equals(description.Language, StringComparison.InvariantCultureIgnoreCase))
               ?.Description;
}

// EF投影专用配置
public class ProductProjectionMappings : Profile
{
    public ProductProjectionMappings()
    {
        CreateProjection<ProductEntity, ProductWithDescription>()
            .ForMember(dst => dst.Description, 
                exp => exp.MapFrom(src => src.Descriptions!
                    .First(description => description.Language == Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName)
                    .Description));
    }
}

步骤2：注入两个Mapper实例 #

在DI容器中注册两个不同的Mapper实例（可通过命名服务或自定义标记区分）：

// 注册内存映射Mapper
services.AddAutoMapper(cfg => cfg.AddProfile<ProductMemoryMappings>());

// 注册EF投影Mapper
services.AddSingleton<IMapper>(sp => 
    new Mapper(new MapperConfiguration(cfg => cfg.AddProfile<ProductProjectionMappings>())));

步骤3：在业务逻辑中切换使用 #

修改GetAllAsync方法，根据缓存状态选择对应的Mapper：

private readonly IMapper _memoryMapper;
private readonly IMapper _projectionMapper;

// 构造函数注入两个Mapper实例
public YourService(IMapper memoryMapper, IMapper projectionMapper)
{
    _memoryMapper = memoryMapper;
    _projectionMapper = projectionMapper;
}

public async Task<ICollection<TModel>> GetAllAsync<TModel>(Expression<Func<TEntity, bool>> predicate,
                                                           Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null)
{
    if (_cache.RunningState != CacheRunningState.Running)
    {
        var query = _repository.Entities.Where(predicate);
        query = orderBy?.Invoke(query) ?? query;
        // EF查询用投影Mapper的ProjectTo
        return await query.ProjectTo<TModel>(_projectionMapper.ConfigurationProvider).ToListAsync();
    }

    var filteredEntities = _cache.Entities.Where(predicate);
    filteredEntities = orderBy == null ? filteredEntities : orderBy(filteredEntities);
    // 缓存命中时用内存Mapper
    return _memoryMapper.Map<ICollection<TModel>>(filteredEntities);
}

方案三：手动处理投影，避免AutoMapper冲突 #

如果不想依赖AutoMapper的投影功能，可以在EF查询时手动编写Select表达式，缓存时继续用AutoMapper的普通映射：

修改EF查询逻辑 #

public async Task<ICollection<TModel>> GetAllAsync<TModel>(Expression<Func<TEntity, bool>> predicate,
                                                           Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>? orderBy = null)
{
    if (_cache.RunningState != CacheRunningState.Running)
    {
        var lang = Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName;
        var query = _repository.Entities.Where(predicate);
        query = orderBy?.Invoke(query) ?? query;
        
        // 针对ProductWithDescription手动写投影逻辑
        if (typeof(TModel) == typeof(ProductWithDescription))
        {
            var result = await query.Select(p => new ProductWithDescription
            {
                ProductNumber = p.ProductNumber,
                Description = p.Descriptions!
                    .FirstOrDefault(d => d.Language.Equals(lang, StringComparison.InvariantCultureIgnoreCase))
                    ?.Description
            }).ToListAsync();
            return (ICollection<TModel>)(object)result;
        }
        // 其他类型继续使用AutoMapper的ProjectTo
        return await query.ProjectTo<TModel>(_mapper.ConfigurationProvider).ToListAsync();
    }

    var filteredEntities = _cache.Entities.Where(predicate);
    filteredEntities = orderBy == null ? filteredEntities : orderBy(filteredEntities);
    return _mapper.Map<ICollection<TModel>>(filteredEntities);
}

这个方案适合只有少数特殊映射需要处理的场景，避免AutoMapper的配置冲突。

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