C# 使用自定义映射自动映射展平多个复杂对象

因此，除了通常的DTO到业务映射器之外，我还有一些东西，我正在尝试用最少的映射代码来映射它们

设置

public class Target {

    public string propA { get; set; }
    public string propB { get; set; }
    public string propC { get; set; }
    public string propD { get; set; }
    public string propE { get; set; }
    public List<KeyValuePair> Tokens { get; set; }
}

public class Source {
    public SomeClass SomeClass { get; set; }
    public AnotherClass AnotherClass { get; set; }

}

public class SomeClass {
    public string propA { get; set; }
    public string propB { get; set; }
    public string propDifferent { get; set; }
    public List<KeyValuePair> Tokens { get; set; }
}

public class AnotherClass {
    public string propC { get; set; }
    public string propD { get; set; }
    public List<KeyValuePair> Tokens { get; set; }
}

注意：我使用

Name.ToLowerInvariant（）

来匹配

AccountID

->

AccountID

和类似内容

用法

AutoMapper.Mapper.CreateMap<Source, Target>()
    .FlattenNested<Source, SomeClass, Target>()
    .FlattenNested<Source, AnotherClass, Target>()
    .ForMember(dest => dest.propE, opt => opt.MapFrom(src => src.propDifferent));

public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Address Address { get; set; }
}

public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

public class CustomerDto
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string City { get; set; }
    public string Street { get; set; }
}

public class CustomerProfile : Profile
{
    protected override void Configure()
    {
        var nestedMap = CreateMap<Address, CustomerDto>()
            .IgnoreAllNonExisting();

        CreateMap<Customer, CustomerDto>()
            .FlattenNested(s => s.Address, nestedMap);
    }
}

[TestFixture]
public class CustomerProfileTests
{
    [Test]
    public void Test()
    {
        Mapper.Initialize(c => c.AddProfile<CustomerProfile>());
        Mapper.AssertConfigurationIsValid();
    }
}

AutoMapper.Mapper.CreateMap（）


.ForMember（dest=>dest.propE，opt=>opt.MapFrom（src=>src.propDifferent））；

---

我在

IMappingExpression

中发现了一些其他属性，我可能能够大量使用和清理这些属性。将在我找到它们时更新。

要使用BeforeMap实例化对象：

更新：

Mapper.CreateMap<Source, Target>()
.BeforeMap(( Source, Target) => {
     Source.SomeClass = new SomeClass();
     Source.AnotherClass = new AnotherClass();
 })  
 .AfterMap(( Source, Target) => {
     Target.SomeClass = Mapper.Map<AnotherClass, Target>(Target);
     Target.AnotherClass = Mapper.Map<SomeClass, Target>(Target);
 })

Mapper.CreateMap（）
.BeforeMap（（源、目标）=>{
Source.SomeClass=新的SomeClass（）；
Source.AnotherClass=新的AnotherClass（）；
})  
.AfterMap（（源、目标）=>{
Target.SomeClass=Mapper.Map（Target）；
Target.AnotherClass=Mapper.Map（目标）；
})

这将允许您在映射单个对象属性之前映射父对象

我想我在你的基类名称中迷失了方向，但是你可以调用mapper.Map属性来映射对象

更新2：

基于此代码：

Mapper.CreateMap<Source, Target>()
.ForMember(dest => **dest**, opt => opt.MapFrom(src => src.SomeClass))
.ForMember(dest => **dest**, opt => opt.MapFrom(src => src.AnotherClass));

Mapper.CreateMap（）
.ForMember（dest=>**dest**，opt=>opt.MapFrom（src=>src.SomeClass））
.ForMember（dest=>**dest**，opt=>opt.MapFrom（src=>src.AnotherClass））；

Dest正在尝试解析一个对象。如果您只想解析这些对象上的属性，那么我建议您指定它们

Mapper.CreateMap<Source, Target>()
 .ForMember(dest => dest.propA, opt => opt.MapFrom(src => src.SomeClass.propA
 .ForMember(dest => dest.propB, opt => opt.MapFrom(src => src.SomeClass.propB
 .ForMember(dest => dest.propC, opt => opt.MapFrom(src => src.AnotherClass.propC
 .ForMember(dest => dest.propD, opt => opt.MapFrom(src => src.AnotherClass.propD

Mapper.CreateMap（）
.FormMember（dest=>dest.propA，opt=>opt.MapFrom（src=>src.SomeClass.propA
.FormMember（dest=>dest.propB，opt=>opt.MapFrom（src=>src.SomeClass.propB
.FormMember（dest=>dest.propC，opt=>opt.MapFrom（src=>src.AnotherClass.propC
.ForMember（dest=>dest.propD，opt=>opt.MapFrom（src=>src.AnotherClass.propD

这就是我解决类似问题的方法：

public static IMappingExpression<TSource, TDestination> FlattenNested<TSource, TNestedSource, TDestination>(
    this IMappingExpression<TSource, TDestination> expression,
    Expression<Func<TSource, TNestedSource>> nestedSelector,
    IMappingExpression<TNestedSource, TDestination> nestedMappingExpression)
{
    var dstProperties = typeof(TDestination).GetProperties().Select(p => p.Name);

    var flattenedMappings = nestedMappingExpression.TypeMap.GetPropertyMaps()
                                                    .Where(pm => pm.IsMapped() && !pm.IsIgnored())
                                                    .ToDictionary(pm => pm.DestinationProperty.Name,
                                                                    pm => Expression.Lambda(
                                                                        Expression.MakeMemberAccess(nestedSelector.Body, pm.SourceMember),
                                                                        nestedSelector.Parameters[0]));

    foreach (var property in dstProperties)
    {
        if (!flattenedMappings.ContainsKey(property))
            continue;

        expression.ForMember(property, opt => opt.MapFrom((dynamic)flattenedMappings[property]));
    }

    return expression;
}

publicstaticimappingexpression(
这个IMappingExpression表达式，
表达式嵌套选择器，
IMappingExpression嵌套的映射表达式）
{
var dstProperties=typeof（tdestinition）.GetProperties（）.Select（p=>p.Name）；
var flattedMappings=nestedMappingExpression.TypeMap.GetPropertyMaps（）
.Where（pm=>pm.IsMapped（）&&！pm.IsIgnored（））
.ToDictionary（pm=>pm.DestinationProperty.Name，
pm=>Expression.Lambda(
表达式.MakeMemberAccess（nestedSelector.Body，pm.SourceMember），
nestedSelector.Parameters[0]）；
foreach（dstProperties中的var属性）
{
如果（！FlattedMappings.ContainsKey（属性））
继续；
expression.ForMember（属性，opt=>opt.MapFrom（（动态）flattedMappings[property]）；
}
返回表达式；
}

用法

AutoMapper.Mapper.CreateMap<Source, Target>()
    .FlattenNested<Source, SomeClass, Target>()
    .FlattenNested<Source, AnotherClass, Target>()
    .ForMember(dest => dest.propE, opt => opt.MapFrom(src => src.propDifferent));

public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Address Address { get; set; }
}

public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

public class CustomerDto
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string City { get; set; }
    public string Street { get; set; }
}

public class CustomerProfile : Profile
{
    protected override void Configure()
    {
        var nestedMap = CreateMap<Address, CustomerDto>()
            .IgnoreAllNonExisting();

        CreateMap<Customer, CustomerDto>()
            .FlattenNested(s => s.Address, nestedMap);
    }
}

[TestFixture]
public class CustomerProfileTests
{
    [Test]
    public void Test()
    {
        Mapper.Initialize(c => c.AddProfile<CustomerProfile>());
        Mapper.AssertConfigurationIsValid();
    }
}

公共类客户
{
公共字符串名{get；set；}
公共字符串LastName{get；set；}
公共广播地址{get；set；}
}
公共课堂演讲
{
公共字符串City{get；set；}
公共字符串Street{get；set；}
}
公共类CustomerDto
{
公共字符串名{get；set；}
公共字符串LastName{get；set；}
公共字符串City{get；set；}
公共字符串Street{get；set；}
}
公共类CustomerProfile:配置文件
{
受保护的覆盖无效配置（）
{
var nestedMap=CreateMap

虽然它不是通用的解决方案，但对于简单的情况应该足够了

优点是：

您可以使用AutoMapper创建嵌套映射，这样您就可以依赖受信任的代码，还可以使用
RecognizePrefixes
等内容
由于需要指定嵌套特性选择器，因此当具有多个相同类型的嵌套特性时，可以避免可能出现的歧义
你确定吗？我在
BeforeMap
Target
中得到了同样的错误，没有
SomeClass
或
AnotherClass
，只有平面属性。从错误来看，似乎只有非平面顶级属性可以映射为平面属性。谢谢，但这正是我想要避免的。我有硬连线的个人pr属性手动现在，但我想利用“自动映射”！：）谢谢。虽然我现在正试图摆脱自动映射。