Mappage personnalisé avec AutoMapper

J'ai deux objets très simples:

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

Lors du mappage d'une Category à un CategoryDto avec AutoMapper, je voudrais le comportement suivant:

Les propriétés doivent être mappées comme d'habitude, sauf pour ceux qui ont la MapTo attribut. Dans ce cas, j'ai de la lecture de la valeur de l'Attribut pour trouver la cible de la propriété. La valeur de la propriété de la source est utilisée pour trouver la valeur pour l'injecter dans la propriété de destination (avec l'aide d'un dictionnaire). Un exemple est toujours mieux que 1000 mots...

Exemple:

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"

La Key propriété est mappée à la MyValueProperty (via le MapTo Attribut), et la valeur assignée est "Mavaleur", parce que la source de la valeur de propriété est "Maclé" qui est mappé (via dictionnaire) "Mavaleur".

Est-ce possible à l'aide de AutoMapper ? J'ai besoin d'une solution qui fonctionne sur tous les objets, pas seulement sur la Catégorie/CategoryDto.

source d'informationauteur Bidou

  1. 8

    J'ai enfin (après de nombreuses heures !!!!) trouvé une solution.
    Je de les partager avec la communauté; j'espère que ça aidera quelqu'un d'autre...

    Edit: Notez qu'il est maintenant beaucoup plus simple (AutoMapper 5.0+), tu peux faire comme j'ai répondu dans ce post: Comment faire AutoMapper tronquer des chaînes selon l'attribut MaxLength?

    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);
}
}
  2. 0

    Ce devrait être assez simple à l'aide d'une mise en œuvre de IValueResolver et la ResolveUsing() la méthode. En gros, vous avez juste besoin d'avoir un constructeur de la résolution qui prend dans la propriété de l'info (ou si vous voulez être de fantaisie qui tient en une expression lambda et résout la propriété info similaire à Comment obtenir le PropertyInfo d'une propriété spécifique?. Si je n'ai pas testé moi-même, j'imagine la suivante devrait fonctionner:

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

    Puis pour configurer le mappage que vous devez faire:

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

    Bien sûr c'est assez brut lamda et je voudrais vous suggérer de le nettoyer en ayant votre propriété résolveur de déterminer la propriété sur l'objet source, il devrait regarder basée sur l'attribut/info propriété de sorte que vous pouvez passer un propre nouvelle PropertyBasedResolver(propriété) dans le ResolveUsing() mais j'espère que c'est ce qui explique assez pour vous mettre sur la bonne voie.

  3. 0

    Permet de supposer que j'ai les classes suivantes

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

    Vous pouvez passer un lambda de ResolveUsing:

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