使用AutoMapper将扁平化DTO映射至含子集合的父实体

嘿，我完全懂你现在的困扰——用AutoMapper把扁平化DTO转成带子对象集合的Parent实体，这种场景确实不像常规父子映射那么直观，我给你整理了两种靠谱的实现方式，还有一些注意事项。

首先先补全你没写完的示例类，方便后续演示：

// 目标Parent实体
public class Parent 
{ 
    public int ParentId { get; set; } 
    public string ParentName { get; set; } 
    public List<Child> Children { get; set; } = new List<Child>();
}

// 子实体Child
public class Child
{
    public int ChildId { get; set; }
    public string ChildName { get; set; }
}

// 扁平化的DTO示例（假设包含2个子对象的字段，你可以根据实际数量调整）
public class ParentFlatDto
{
    public int ParentId { get; set; }
    public string ParentName { get; set; }
    // 第一个子对象的字段
    public int Child1Id { get; set; }
    public string Child1Name { get; set; }
    // 第二个子对象的字段
    public int Child2Id { get; set; }
    public string Child2Name { get; set; }
}

方法一：直接用自定义映射逻辑（快速上手） #

这是最直接的方式，在AutoMapper的映射配置里，手动把DTO里的扁平化子字段转换成Child对象，再塞进集合里：

var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<ParentFlatDto, Parent>()
        // 父级字段AutoMapper会自动匹配同名的，这里可以省略，要是字段名不一样才需要配置
        .ForMember(dest => dest.Children, opt => opt.MapFrom(src => 
        {
            var children = new List<Child>();
            // 这里根据你的业务规则判断子对象是否有效，比如Id不为0或者Name非空
            if (src.Child1Id != 0)
            {
                children.Add(new Child 
                { 
                    ChildId = src.Child1Id, 
                    ChildName = src.Child1Name 
                });
            }
            if (src.Child2Id != 0)
            {
                children.Add(new Child 
                { 
                    ChildId = src.Child2Id, 
                    ChildName = src.Child2Name 
                });
            }
            // 要是有更多子对象，继续加对应的判断逻辑就行
            return children;
        }));
});

// 开发阶段强烈建议调用这个方法，能提前发现映射配置的问题
config.AssertConfigurationIsValid();

// 实际使用映射
var mapper = config.CreateMapper();
var flatDto = new ParentFlatDto 
{ 
    ParentId = 1, 
    ParentName = "Parent A",
    Child1Id = 101, 
    Child1Name = "Child 1",
    Child2Id = 102, 
    Child2Name = "Child 2"
};
Parent parent = mapper.Map<Parent>(flatDto);

方法二：用ValueResolver封装（优雅复用） #

如果这种扁平化转集合的场景在你的项目里多次出现，建议封装成自定义的ValueResolver，代码更干净，也方便复用：

首先创建一个Resolver类：

public class FlatChildToCollectionResolver : IValueResolver<ParentFlatDto, Parent, List<Child>>
{
    public List<Child> Resolve(ParentFlatDto source, Parent destination, List<Child> destMember, ResolutionContext context)
    {
        var children = new List<Child>();
        if (source.Child1Id != 0)
        {
            children.Add(new Child { ChildId = source.Child1Id, ChildName = source.Child1Name });
        }
        if (source.Child2Id != 0)
        {
            children.Add(new Child { ChildId = source.Child2Id, ChildName = source.Child2Name });
        }
        return children;
    }
}

然后在映射配置里使用这个Resolver：

var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<ParentFlatDto, Parent>()
        .ForMember(dest => dest.Children, opt => opt.MapFrom<FlatChildToCollectionResolver>());
});

一些重要的注意事项 #

• 业务规则判断：一定要根据你的实际业务来判断子对象是否需要加入集合，比如有的场景下，即使ChildId为0但Name有值也算有效，你要调整对应的判断条件。
• 动态子对象数量：如果DTO里的子对象数量不固定（比如可能有N个），硬编码的方式就不合适了，这时候可以考虑用反射遍历DTO里的Child相关字段，动态创建Child对象，但要注意性能和代码维护性。
• 配置验证：开发阶段一定要调用AssertConfigurationIsValid()，AutoMapper会帮你检查所有映射是否配置正确，避免运行时出意外。

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