c# - カスタムマッピングを使用して複数の複雑なオブジェクトを平坦化する Automapper

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経由で実行できますか? Tokens リストへの追加は、おそらく 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この多くを使用してクリーンアップできる可能性があるという点で、他のプロパティをいくつか見つけました。見つけ次第更新します。

score 1 · Accepted Answer

それが私が同様の問題を解決した方法です：

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()ここにあります。

普遍的な解決策ではありませんが、単純なケースには十分なはずです。

利点は次のとおりです。

AutoMapper を使用してネストされたマップを作成するため、信頼できるコードに依存し、などを使用することもできますRecognizePrefixes。
ネストされたプロパティセレクターを指定する必要があるため、同じタイプのネストされたプロパティが複数ある場合に発生する可能性のあるあいまいさを回避します。

score 0 · Accepted Answer

オブジェクトをインスタンス化するには、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));

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

c# - カスタム マッピングを使用して複数の複雑なオブジェクトを平坦化する Automapper

2 に答える 2

Related

Reference

c# - カスタムマッピングを使用して複数の複雑なオブジェクトを平坦化する Automapper