Blog de Nico-pyright(c)

27
octobre
2009

[C#] Mapping automatique avec AutoMapper

Un article de nico-pyright(c) Comments

AutoMapper est un outil permettant de définir une stratégie de mapping objet-objet.

Il peut être utilisé lorsqu’on a besoin de passer des objets entre des couches qui doivent être indépendantes, pour transformer des objets complexes en DTO ou inversement, etc …

Toutes ces opérations de transformation d’un objet A en objet B sont souvent redondantes, fastidieuses et sujettes à des erreurs.

Quoi de plus frustrant que de se rendre compte après moultes débuggages que si la nouvelle propriété n’est pas correcte c’est simplement parce qu’on a oublié de la mapper dans un assembleur perdu au fin fond de notre code ?

Tout ceci devient transparent grâce à automapper. Il est possible de définir des mappings automatiques entres objets.

Pour ce faire, AutoMapper se base le plus qu’il peut sur des conventions, les cas particuliers étant configurés par le développeur.

Par exemple, pour Mapper une Classe A en une Classe B de la sorte :

public class ClassA
{
    public string Chaine { get; set; }
    public int Entier { get; set; }
    public long Long { get; set; }
}
public class ClassB
{
    public string Chaine { get; set; }
    public int Entier { get; set; }
    public long Long { get; set; }
}

Il suffit simplement de faire :

   1: Mapper.CreateMap<ClassA, ClassB>(); // défini le mapping
   2: ClassB classB = Mapper.Map<ClassA, ClassB>(classA); // fait la conversion

Ici AutoMapper est assez malin pour se baser sur le nommage des propriétés et se rendre compte qu’ils sont équivalents dans les deux objets.

Rajoutons un champ aux deux classes, et il n’y a rien à changer dans le code effectuant la conversion !!

Si un nom ne correspond pas d’un objet à un autre :

public class ClassA
{
    public long Long { get; set; }
}
public class ClassB
{
    public long Valeur { get; set; }
}

Il est possible de l’indiquer à AutoMapper avec :

   1: Mapper.CreateMap<ClassA, ClassB>()
   2:     .ForMember(dest => dest.Valeur, opt => opt.MapFrom(src => src.Long));

Il est également capable de traiter des objets complexes :

public class ClassA
{
    public ClassC Obj { get; set; }
}
public class ClassB
{
    public ClassD Obj { get; set; }
}
  
public class ClassC
{
    public int Val { get; set; }
}
public class ClassD
{
    public int Val { get; set; }
}

Pour ce faire, il faut rajouter le mapping de la ClassC vers la ClassD :

   1: Mapper.CreateMap<ClassA, ClassB>();
   2: Mapper.CreateMap<ClassC, ClassD>();

AutoMapper est également capable de faire des conversions entre types à priori incompatibles.

public class ClassA
{
    public string EnumValue{ get; set; }
}
public class ClassB
{
    public EnumValue EnumValue { get; set; }
}
  
public enum EnumValue
{
    Val1 = 1,
    Val2 = 2
}

en définissant un convertisseur :

ClassA classA = new ClassA { EnumValue = "Val2"};
  
Mapper.CreateMap<ClassA, ClassB>();
Mapper.CreateMap<string, EnumValue>().ConvertUsing<EnumValueTypeConverter<EnumValue>>();

avec (par exemple) :

public class EnumValueTypeConverter<T> : ITypeConverter<string, T>
{
    public T Convert(string source)
    {
        string foundedEnum = Enum.GetNames(typeof(T)).Where(e => string.Compare(e, source, StringComparison.InvariantCultureIgnoreCase) == 0).Single();
        if (string.IsNullOrEmpty(foundedEnum))
            throw new ArgumentException();
        return (T)Enum.Parse(typeof(T), foundedEnum);
    }
}

Retrouvez toutes les conversions/conventions sur le site d’AutoMapper.

Notons quand même que toutes ces conversions automatiques ont un coup au niveau de la performance. AutoMapper utilisant la réflexion pour effectuer ses mappings, il en résulte un peu plus de temps de conversion.

Pour moi, une excellente bibliothèque pour s’affranchir de code répétitif et succeptible de contenir des erreurs.

2 Commentaires + Ajouter un commentaire

nico-pyright(c) 3 novembre 2009 à 8 h 45 min

je suis bien d’accord.
J’essaie de le faire adopter, mais chez moi on se montre très réticent dès qu’il y a un poil de reflexion.
Qui a dit que la réflexion c’était le mal ? :aie:

Connectez-vous pour répondre
Philippe Vialatte 2 novembre 2009 à 22 h 28 min

Zut, j’etais en train de preparer un post sur Automapper quand j’ai vu le tien

Donc, +1 pour la simplicité et la puissance de l’outil, je m’en sers pour mapper des DTO sur du subsonic, et pour le moment, la perte de perf est infime par rapport au gain en lisibilité

Connectez-vous pour répondre

Laisser un commentaire

Vous devez être connecté pour poster un commentaire.

Connexion

Identifiez-vous

Créer un compte

Blog de Nico-pyright(c)

2 Commentaires + Ajouter un commentaire

Laisser un commentaire

Articles récents

Commentaires récents

Archives

Catégories

Méta

Identifiant
Mot de passe

Mot de passe oublié ?