使用AutoMapper壓扁嵌套對象的更好方法？

Question

我已被平坦化的域對象插入的DTO如顯示在下面的例子：

public class Root 
{ 
    public string AParentProperty { get; set; } 
    public Nested TheNestedClass { get; set; } 
} 

public class Nested 
{ 
    public string ANestedProperty { get; set; } 
} 

public class Flattened 
{ 
    public string AParentProperty { get; set; } 
    public string ANestedProperty { get; set; } 
} 

// I put the equivalent of the following in a profile, configured at application start 
// as suggested by others: 

Mapper.CreateMap<Root, Flattened>() 
     .ForMember 
     (
      dest => dest.ANestedProperty 
      , opt => opt.MapFrom(src => src.TheNestedClass.ANestedProperty) 
     ); 

// This is in my controller: 
Flattened myFlattened = Mapper.Map<Root, Flattened>(myRoot); 

我已經看過了一些實例，且到目前爲止，這似乎是一個壓平嵌套層級的方式。但是，如果子對象具有多個屬性，則此方法不會節省太多編碼。

我發現這個例子：

http://consultingblogs.emc.com/owainwragg/archive/2010/12/22/automapper-mapping-from-multiple-objects.aspx

，但它需要映射的對象，由圖（）函數要求，按照我的理解，這將不與輪廓工作的實例。

我是AutoMapper的新手，所以我想知道是否有更好的方法來做到這一點。

Answer 1

在最新版本的AutoMapper中，可以使用命名約定來避免多個.ForMember語句。

在您的例子，如果你更新你的平頂類是：

public class Flattened 
{ 
    public string AParentProperty { get; set; } 
    public string TheNestedClassANestedProperty { get; set; } 
} 

可避免使用ForMember聲明：

Mapper.CreateMap<Root, Flattened>(); 

Automapper會（按照約定）地圖Root.TheNestedClass.ANestedProperty到在這種情況下爲Flattened.TheNestedClassANestedProperty。當你使用真實的類名時，它看起來不那麼難看，誠實！

Answer 2

2個可能的解決方案：

Mapper.CreateMap<Nested, Flattened>() 
    .ForMember(s=>s.AParentProperty, o=>o.Ignore()); 
Mapper.CreateMap<Root, Flattened>() 
    .ForMember(d => d.ANestedProperty, o => o.MapFrom(s => s.TheNestedClass)); 

另一種方法是下面的，但它不會通過Mapper.AssertConfigurationIsValid()。

Mapper.CreateMap<Nested, Flattened>() 
//.ForMember map your properties here 
Mapper.CreateMap<Root, Flattened>() 
//.ForMember... map you properties here 
.AfterMap((s, d) => Mapper.Map(s.TheNestedClass, d)); 

Answer 3

我寫的擴展方法來解決類似的問題：

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

所以你的情況可以用這樣的：

var nestedMap = Mapper.CreateMap<Nested, Flattened>() 
         .IgnoreAllNonExisting(); 

Mapper.CreateMap<Root, Flattened>() 
     .FlattenNested(s => s.TheNestedClass, nestedMap); 

IgnoreAllNonExisting()是here。

雖然它不是通用的解決方案，但對於簡單的情況應該足夠了。

所以，

1. 你並不需要按照扁平化公約目標的屬性
2. Mapper.AssertConfigurationIsValid（）將通過
3. 可以在非靜態API使用此方法（配置文件）

Answer 4

要改善另一個答案，請爲兩個映射指定MemberList.Source，並設置要忽略的嵌套屬性。驗證然後通過確定。

Mapper.Initialize(cfg => 
{ 
    cfg.CreateMap<SrcNested, DestFlat>(MemberList.Source); 
    cfg.CreateMap<SrcRoot, DestFlat>(MemberList.Source) 
     .ForSourceMember(s => s.Nested, x => x.Ignore()) 
     .AfterMap((s, d) => Mapper.Map(s.Nested, d)); 
}); 

Mapper.AssertConfigurationIsValid(); 

var dest = Mapper.Map<SrcRoot, DestFlat>(src);