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

Question

因此，除了常规的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; }
}

映射器配置

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


Mapper.CreateMap<AnotherClass, Target>();

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

这样做抛出

错误：AutoMapper.AutoMapperConfigurationException：仅类型的顶级单个成员支持成员的自定义配置。

而且我还需要获取AnotherClass.Tokens和SomeClass.Tokens并将其添加到Target.Tokens 。

我知道我可以使用.ConvertUsing但是随后我必须为每个属性定义映射，而我失去了基于约定的映射来匹配属性的优点。

除了实现.ConvertUsing或手动映射每个属性之外，还有其他方法可以实现吗？

如果不通过Automapper，它是通过EmitMapper可行？ 我想添加到令牌列表可能可以通过EmitMapper的PostProcessing 。

更新

经过一番黑客攻击后，我找到了一种方法：

public static IMappingExpression<TSource, TDestination> FlattenNested<TSource, TNestedSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
{
    var sourceType = typeof(TNestedSource);
    var destinationType = typeof(TDestination);
    var sourceProperties = sourceType.GetProperties().ToDictionary(x => x.Name.ToLowerInvariant());
    var childPropName = typeof (TSource).GetProperties().First(x => x.PropertyType == sourceType).Name;
    var mappableProperties = destinationType.GetProperties()
        .Where(p => sourceProperties.ContainsKey(p.Name.ToLowerInvariant()) &&
                    sourceProperties[p.Name.ToLowerInvariant()].PropertyType ==
                    p.PropertyType)
        .Select(p => new {DestProperty = p.Name, SrcProperty = sourceProperties[p.Name.ToLowerInvariant()].Name});


    foreach (var property in mappableProperties)
    {
        expression.ForMember(property.DestProperty,
            opt => opt.MapFrom(src => src.GetPropertyValue(childPropName).GetPropertyValue(property.SrcProperty)));
    }

    return expression;
}

注意：我执行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));

我在IMappingExpression中发现了一些其他属性， IMappingExpression属性也许可以使用和清除。 找到我会更新。

Answer 1

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

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;
}

用法

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();
    }
}

IgnoreAllNonExisting()在这里找到。

尽管它不是通用解决方案，但对于简单的案例来说就足够了。

优点是：

1. 您可以使用AutoMapper来创建嵌套地图，从而依赖于受信任的代码，还可以使用RecognizePrefixes东西。
2. 由于需要指定嵌套属性选择器，因此当您具有多个相同类型的嵌套属性时，可以避免产生歧义。

Answer 2

您要使用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.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<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