Individuelle Mapping mit AutoMapper

Question

ich zwei sehr einfache Objekte haben:

public class CategoryDto 
{ 
    public string Id { get; set; } 

    public string MyValueProperty { get; set; } 
} 

public class Category 
{ 
    public string Id { get; set; } 

    [MapTo("MyValueProperty")] 
    public string Key { get; set; } 
} 

Bei der Zuordnung einer Category zu einem CategoryDto mit AutoMapper, ich möchte folgendes Verhalten:

Die Eigenschaften sollten wie üblich abgebildet werden, außer denen, die das MapTo Attribut haben. In diesem Fall muss ich den Wert des Attributs lesen, um die Zieleigenschaft zu finden. Der Wert der source -Eigenschaft wird verwendet, um den Wert zu finden, der in die Zieleigenschaft (mit Hilfe eines Wörterbuchs) injiziert werden soll. Ein Beispiel dafür ist immer besser, dass 1000 Worte ...

Beispiel:

Dictionary<string, string> keys = 
    new Dictionary<string, string> { { "MyKey", "MyValue" } }; 

Category category = new Category(); 
category.Id = "3"; 
category.Key = "MyKey"; 

CategoryDto result = Map<Category, CategoryDto>(category); 
result.Id    // Expected : "3" 
result.MyValueProperty // Expected : "MyValue" 

Die Key Eigenschaft wird die MyValueProperty (über das Attribut MapTo) abgebildet, und der zugewiesene Wert ist „MyValue“, weil die Quelleigenschaftswert ist "MyKey", der (über ein Wörterbuch) "MyValue" zugeordnet wird.

Ist dies mit AutoMapper möglich? Ich brauche natürlich eine Lösung, die bei jedem Objekt funktioniert, nicht nur bei Category/CategoryDto.

Answer 1

Ich endlich (nach so vielen Stunden !!!!) fand eine Lösung. Ich teile das mit der Gemeinschaft; hoffentlich hilft es jemand anderes ...

public static class Extensions 
{ 
    public static IMappingExpression<TSource, TDestination> MapTo<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression) 
    { 
     Type sourceType = typeof(TSource); 
     Type destinationType = typeof(TDestination); 

     TypeMap existingMaps = Mapper.GetAllTypeMaps().First(b => b.SourceType == sourceType && b.DestinationType == destinationType); 
     string[] missingMappings = existingMaps.GetUnmappedPropertyNames(); 

     if (missingMappings.Any()) 
     { 
      PropertyInfo[] sourceProperties = sourceType.GetProperties(); 
      foreach (string property in missingMappings) 
      { 
       foreach (PropertyInfo propertyInfo in sourceProperties) 
       { 
        MapToAttribute attr = propertyInfo.GetCustomAttribute<MapToAttribute>(); 
        if (attr != null && attr.Name == property) 
        { 
         expression.ForMember(property, opt => opt.ResolveUsing(new MyValueResolve(propertyInfo))); 
        } 
       } 
      } 
     } 

     return expression; 
    } 
} 

public class MyValueResolve : IValueResolver 
{ 
    private readonly PropertyInfo pInfo = null; 

    public MyValueResolve(PropertyInfo pInfo) 
    { 
     this.pInfo = pInfo; 
    } 

    public ResolutionResult Resolve(ResolutionResult source) 
    { 
     string key = pInfo.GetValue(source.Value) as string; 
     string value = dictonary[key]; 
     return source.New(value); 
    } 
} 

Answer 2

Dies sollte relativ einfach mit einer Implementierung von IValueResolver und der ResolveUsing() -Methode sein. Sie müssen im Grunde nur einen Konstruktor für den Resolver haben, der die Property-Informationen aufnimmt (oder wenn Sie Lust auf einen Lambda-Ausdruck haben und die Property-Informationen ähnlich wie How to get the PropertyInfo of a specific property? auflösen. Obwohl ich es nicht selbst getestet habe, stelle ich mir das vor folgende funktionieren würde:

public class PropertyBasedResolver : IValueResolver 
{ 
    public PropertyInfo Property { get; set; } 

    public PropertyBasedResolver(PropertyInfo property) 
    { 
      this.Property = property; 
    } 

    public ResolutionResult Resolve(ResolutionResult source) 
    { 
      var result = GetValueFromKey(property, source.Value); // gets from some static cache or dictionary elsewhere in your code by reading the prop info and then using that to look up the value based on the key as appropriate 
      return source.New(result) 
    } 
} 

dann das Mapping Sie tun müssen, einzurichten:

AutoMapper.Mapper.CreateMap<Category, CategoryDto>() 
    .ForMember(
     dest => dest.Value, 
     opt => opt.ResolveUsing(
       src => 
        new PropertyBasedResolver(typeof(Category.Key) as PropertyInfo).Resolve(src))); 

natürlich ist das ein ziemlich eklig lamda ist und ich würde vorschlagen, dass Sie es aufzuräumen, indem Sie Ihre Eigenschaft, resolver bestimmt die Eigenschaft des Quellobjekts, das es anhand des Attributs/der Eigenschafteninformation untersuchen soll, damit Sie ju St übergeben Sie eine saubere neue PropertyBasedResolver (Eigenschaft) in die ResolveUsing(), aber hoffentlich erklärt dies genug, um Sie auf den richtigen Weg zu bringen.

Answer 3

Nehmen wir an, ich die folgenden Klassen haben

public class foo 
{ 
    public string Value; 
} 
public class bar 
{ 
    public string Value1; 
    public string Value2; 
} 

Sie eine Lambda ResolveUsing passieren kann:

.ForMember(f => f.Value, o => o.ResolveUsing(b => 
{ 
    if (b.Value1.StartsWith("A"));) 
    { 
     return b.Value1; 
    } 
    return b.Value2; 
} 


));