AutoMapper：IQueryable与IEnumerable的子对象差异化映射方案

要让AutoMapper区分这两种场景，核心思路是利用AutoMapper对IQueryable的原生支持，同时为内存中的IEnumerable对象配置自定义属性解析器从DbContext加载关联子集合。以下是具体实现方案：

1. 利用ProjectTo处理IQueryable场景 #

AutoMapper的ProjectTo方法专门为IQueryable设计，它会将映射逻辑转换为LINQ to Entities查询，EF Core会自动生成关联SQL加载子集合，无需额外配置：

// 直接通过ProjectTo将IQueryable映射为DTO集合，EF自动处理子集合查询
var queryableOrders = dbContext.Orders;
var orderDtos = queryableOrders.ProjectTo<OrderDto>(mapper.ConfigurationProvider).ToList();

2. 自定义解析器处理内存中的IEnumerable场景 #

对于已加载到内存的IEnumerable对象，需要通过自定义IValueResolver从DbContext主动加载子集合，以下是优化后的批量加载实现（避免N+1查询）：

步骤1：定义实体与DTO #

// 数据库实体
public class Order
{
    public int Id { get; set; }
    public string OrderNumber { get; set; }
    public ICollection<OrderItem> OrderItems { get; set; }
}

public class OrderItem
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public string ProductName { get; set; }
    public decimal Price { get; set; }
}

// 传输DTO
public class OrderDto
{
    public int Id { get; set; }
    public string OrderNumber { get; set; }
    public IEnumerable<OrderItemDto> OrderItems { get; set; }
}

public class OrderItemDto
{
    public int Id { get; set; }
    public string ProductName { get; set; }
    public decimal Price { get; set; }
}

步骤2：实现批量子集合解析器 #

public class BatchOrderItemsResolver : IValueResolver<Order, OrderDto, IEnumerable<OrderItemDto>>
{
    private readonly AppDbContext _dbContext;
    private readonly IMapper _mapper;
    private static readonly ConcurrentDictionary<ResolutionContext, Dictionary<int, List<OrderItem>>> _batchCache = new();

    public BatchOrderItemsResolver(AppDbContext dbContext, IMapper mapper)
    {
        _dbContext = dbContext;
        _mapper = mapper;
    }

    public IEnumerable<OrderItemDto> Resolve(Order source, OrderDto destination, IEnumerable<OrderItemDto> destMember, ResolutionContext context)
    {
        // 一次性加载当前批次所有Order对应的子集合，避免N+1查询
        if (!_batchCache.TryGetValue(context, out var orderItemsMap))
        {
            var allOrderIds = context.SourceItems.Cast<Order>().Select(o => o.Id).ToList();
            var allOrderItems = _dbContext.OrderItems.Where(oi => allOrderIds.Contains(oi.OrderId)).ToList();
            orderItemsMap = allOrderItems.GroupBy(oi => oi.OrderId).ToDictionary(g => g.Key, g => g.ToList());
            _batchCache.TryAdd(context, orderItemsMap);
        }

        orderItemsMap.TryGetValue(source.Id, out var items);
        return _mapper.Map<List<OrderItemDto>>(items ?? new List<OrderItem>());
    }
}

步骤3：配置AutoMapper映射规则 #

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        // 基础映射
        CreateMap<OrderItem, OrderItemDto>();

        // 为Order到OrderDto的子集合属性指定解析器
        CreateMap<Order, OrderDto>()
            .ForMember(dest => dest.OrderItems, opt => opt.MapFrom<BatchOrderItemsResolver>());
    }
}

步骤4：处理内存中的IEnumerable对象 #

// 已加载到内存的Order集合（未包含子集合）
var inMemoryOrders = dbContext.Orders.AsNoTracking().ToList();

// 调用Map时，AutoMapper会触发解析器从DbContext加载子集合
var orderDtos = mapper.Map<List<OrderDto>>(inMemoryOrders);

方案可行性说明 #

• 当使用ProjectTo处理IQueryable时，AutoMapper会忽略ValueResolver（因为解析器逻辑无法转换为SQL），转而直接映射实体的导航属性，EF Core自动生成关联查询完成子集合加载。
• 当处理内存中的IEnumerable时，AutoMapper会执行ValueResolver的逻辑，通过DbContext批量加载子集合，避免重复查询。

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