- Un cas d'utilisation d'AutoMapper<\/a><\/li><\/ul><\/li>
- Comment utiliser AutoMapper dans notre application<\/a>
- Installation d'AutoMapper<\/a><\/li>
- Configuration d'AutoMapper<\/a><\/li>
- Usage<\/a><\/li>
- Profils<\/a><\/li>
- Mappage vers des propri\u00e9t\u00e9s avec des noms diff\u00e9rents<\/a><\/li>
- Cartographie invers\u00e9e<\/a><\/li><\/ul><\/li>
- Dans les coulisses d'AutoMapper<\/a><\/li>
- Consignes d'utilisation et bonnes pratiques d'AutoMapper<\/a>
- \u00c0 faire<\/a><\/li>
- A ne pas faire<\/a><\/li><\/ul><\/li>
- Aplatir des mod\u00e8les d'objets complexes dans AutoMapper<\/a><\/li>
- Conclusion<\/a><\/li>
- Derniers Articles<\/a><\/li><\/ul>\n\n\n
Qu’est-ce qu’AutoMapper ?<\/h2>\n\n\n\n
Tout d’abord AutoMapper est une biblioth\u00e8que simple qui nous aide \u00e0 transformer un type d’objet en un autre. Il s’agit d’un mappeur d’objet \u00e0 objet bas\u00e9 sur des conventions qui n\u00e9cessite tr\u00e8s peu de configuration. <\/p>\n\n\n\n
Le mappage objet \u00e0 objet fonctionne en transformant un objet d’entr\u00e9e d’un type en un objet de sortie d’un type diff\u00e9rent.<\/p>\n\n\n\n
Un cas d’utilisation d’AutoMapper <\/h3>\n\n\n\n
AutoMapper a \u00e9t\u00e9 con\u00e7u pour r\u00e9soudre un probl\u00e8me complexe auquel la plupart des d\u00e9veloppeurs sont confront\u00e9s dans leur vie quotidienne : \u00e9crire du code qui mappe un type d’objet \u00e0 un autre. Ce type de code est plut\u00f4t fastidieux et ennuyeux \u00e0 \u00e9crire, alors pourquoi ne pas laisser ce travail \u00e0 ce petit outil ?<\/p>\n\n\n\n
Ce qui rend AutoMapper int\u00e9ressant, c’est qu’il fournit des conventions faciles \u00e0 utiliser pour simplifier la t\u00e2che consistant \u00e0 d\u00e9terminer comment mapper
Type A<\/code> versType B<\/code>. Tant qu’ilType B <\/code>suit les conventions \u00e9tablies d’AutoMapper, presque aucune configuration n’est n\u00e9cessaire pour mapper deux types.<\/p>\n\n\n\nVoici un sc\u00e9nario courant. Nous avons cr\u00e9\u00e9 une application et nous souhaitons conserver la s\u00e9paration entre nos mod\u00e8les de domaine et nos mod\u00e8les de vue. <\/p>\n\n\n\n
Pour ce faire, nous devons \u00e9crire le code pour adapter notre mod\u00e8le de domaine \u00e0 notre mod\u00e8le de vue. Ensuite, \u00e0 mesure que nous ajoutons plus de vues et de mod\u00e8les de domaine, nous finissons par \u00e9crire plus d’adaptateurs. Plus tard, nous devrons \u00e9crire encore plus d’adaptateurs pour mapper nos objets de transfert de donn\u00e9es de la couche de base de donn\u00e9es dans nos objets de domaine. <\/p>\n\n\n\n
C’est banal et r\u00e9p\u00e9titif. Et c’est l\u00e0
AutoMapper<\/code> qu’intervient.<\/p>\n\n\n\nComment utiliser AutoMapper dans notre application<\/h2>\n\n\n\n
Voyons comment ajouter Automapper dans notre application .NET Core .<\/p>\n\n\n\n
Installation d’AutoMapper <\/h3>\n\n\n\n
La premi\u00e8re \u00e9tape consiste \u00e0 installer le package NuGet correspondant :<\/p>\n\n\n\n
\nInstall-Package AutoMapper.Extensions.Microsoft.DependencyInjection<\/pre>\n<\/div><\/div>\n\n\n\n
Si nous installons le
AutoMapper.Extensions.Microsoft.DependencyInjection<\/code> package , il installera automatiquement le package AutoMapper pour nous puisqu’il y fait r\u00e9f\u00e9rence.<\/p>\n\n\n\nConfiguration d’AutoMapper <\/h3>\n\n\n\n
Nous expliquerons la configuration pour les versions .NET 5 et .NET 6 et sup\u00e9rieures.<\/p>\n\n\n\n
Apr\u00e8s avoir install\u00e9 le package requis, l’\u00e9tape suivante consiste \u00e0 configurer les services. Faisons-le en
Startup.cs<\/code> classe :<\/p>\n\n\n\n\npublic void ConfigureServices(IServiceCollection services)\n{\n services.AddAutoMapper(typeof(Startup));\n services.AddControllersWithViews();\n}<\/pre>\n<\/div><\/div>\n\n\n\nPour .NET 6, nous devons modifier la classe Program :<\/strong><\/p>\n\n\n\n
\nbuilder.Services.AddAutoMapper(typeof(Program)); \nbuilder.Services.AddControllersWithViews();<\/pre>\n<\/div><\/div>\n\n\n\n
C’est \u00e7a. AutoMapper est install\u00e9 et configur\u00e9 dans notre projet. Voyons maintenant comment l’utiliser avec nos objets.<\/p>\n\n\n\n
Usage<\/h3>\n\n\n\n
Disons que nous avons un objet domaine nomm\u00e9
User<\/code>:<\/p>\n\n\n\n\npublic class User\n{\n public int Id { get; set; }\n public string FirstName { get; set; }\n public string LastName { get; set; }\n public string Email { get; set; }\n public string Address { get; set; }\n}<\/pre>\n<\/div><\/div>\n\n\n\nDans la couche UI, nous aurions un
ViewModel<\/code> pour afficher les informations utilisateur :<\/p>\n\n\n\n\npublic class UserViewModel\n{\n public string FirstName { get; set; }\n public string LastName { get; set; }\n public string Email { get; set; }\n}<\/pre>\n<\/div><\/div>\n\n\n\nVoyons maintenant comment nous allons convertir notre objet de domaine en un mod\u00e8le de vue.<\/p>\n\n\n\n
Profils<\/h3>\n\n\n\n
Une bonne fa\u00e7on d’organiser nos configurations de mappage est avec
Profiles<\/code>. Nous devons cr\u00e9er des classes qui h\u00e9ritent deProfile<\/code> class et mettre la configuration dans le constructeur :<\/p>\n\n\n\n\npublic UserProfile()\n{\n CreateMap<User, UserViewModel>();\n}<\/pre>\n<\/div><\/div>\n\n\n\nUserProfile<\/code> La classe cr\u00e9e le mappage entre notreUser<\/code>objet de domaine etUserViewModel<\/code>. D\u00e8s que notre application d\u00e9marre et initialise AutoMapper, AutoMapper analysera notre application et recherchera les classes qui h\u00e9ritent de laProfile<\/code> classe et chargera leurs configurations de mappage.<\/p>\n\n\n\nMaintenant, d\u00e9finissons un contr\u00f4leur et utilisons les fonctionnalit\u00e9s de mappage automatique que nous venons d’ajouter :<\/p>\n\n\n\n
\npublic class UserController : Controller\n{\n private readonly IMapper _mapper;\n\n public UserController(IMapper mapper)\n {\n _mapper = mapper;\n }\n\n public IActionResult Index()\n {\n \/\/ Populate the user details from DB\n var user = GetUserDetails();\n\n UserViewModel userViewModel = _mapper.Map<UserViewModel>(user);\n\n return View(userViewModel);\n }\n}<\/pre>\n<\/div><\/div>\n\n\n\nTout d’abord, nous injectons l’
mapper<\/code> objet dans le contr\u00f4leur. Ensuite, nous appelons laMap()<\/code>m\u00e9thode, qui mappe l’User<\/code> objet \u00e0 l’UserViewModel<\/code> objet. De plus, faites attention \u00e0 une m\u00e9thode localeGetUserDetails<\/code> que nous utilisons pour le stockage local des donn\u00e9es. Vous pouvez trouver son impl\u00e9mentation dans notre code source.<\/p>\n\n\n\nCr\u00e9ons une m\u00e9thode
View<\/code> pour l’Index<\/code> action comme expliqu\u00e9 dans la section de l’article : Cr\u00e9ation de vues .<\/p>\n\n\n\nEx\u00e9cutons maintenant l’application :<\/p>\n\n\n\n
![\"AutoMapper](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/09\/image.png\")
<\/figure>\n\n\n\nNous pouvons voir que notre
User<\/code> objet de domaine est correctement mapp\u00e9 \u00e0 l’UserViewModel<\/code> objet.<\/p>\n\n\n\nMappage vers des propri\u00e9t\u00e9s avec des noms diff\u00e9rents<\/h3>\n\n\n\n
Eh bien, c’\u00e9tait assez simple, n’est-ce pas ? <\/p>\n\n\n\n
Mais que se passe-t-il si nous avons des noms de propri\u00e9t\u00e9 diff\u00e9rents dans nos objets source et destination. Voyons comment faire le mappage dans ces cas.<\/p>\n\n\n\n
Modifions les noms de propri\u00e9t\u00e9 dans
UserViewModel<\/code> la classe :<\/p>\n\n\n\n\npublic class UserViewModel\n{\n public string FName { get; set; }\n public string LName { get; set; }\n public string Email { get; set; }\n}<\/pre>\n<\/div><\/div>\n\n\n\nIci, nous devons mapper les propri\u00e9t\u00e9s de l’
User<\/code> objet domaine \u00e0 notreUserViewModel<\/code>:<\/p>\n\n\n\n\nUser.FirstName -> UserViewModel.FName\nUser.LastName -> UserViewModel.LName\nUser.EMail -> UserViewModel.Email<\/pre>\n<\/div><\/div>\n\n\n\n
Modifions donc le mappage dans la
UserProfile<\/code> classe :<\/p>\n\n\n\n\npublic UserProfile()\n{\n CreateMap<User, UserViewModel>()\n .ForMember(dest =>\n dest.FName,\n opt => opt.MapFrom(src => src.FirstName))\n .ForMember(dest =>\n dest.LName,\n opt => opt.MapFrom(src => src.LastName))\n}<\/pre>\n<\/div><\/div>\n\n\n\nNous utilisons la
CreateMap()<\/code>m\u00e9thode pour cr\u00e9er un mappage en fournissant les propri\u00e9t\u00e9s source et destination. <\/p>\n\n\n\nSi nous voulons personnaliser la configuration pour des membres individuels, nous pouvons utiliser la
ForMember()<\/code>m\u00e9thode qui a les param\u00e8tresdestinationMember<\/code>, <\/strong>qui est de type Expression<\/a> etmemberOptions<\/code>, <\/strong>qui est de type Action <\/a>.<\/p>\n\n\n\nPar exemple, le code ci-dessus mappe
FirstName<\/code> etLastName<\/code>les propri\u00e9t\u00e9s de l’User<\/code>objet \u00e0 laFName<\/code> et \u00e0 laLName<\/code> propri\u00e9t\u00e9 deUserViewModel<\/code> respectivement.<\/p>\n\n\n\nApr\u00e8s avoir apport\u00e9 ces modifications, ex\u00e9cutons \u00e0 nouveau l’application. Nous pouvons voir que ces propri\u00e9t\u00e9s sont correctement mapp\u00e9es.<\/p>\n\n\n\n
Cartographie invers\u00e9e<\/h3>\n\n\n\n
Jusqu’\u00e0 pr\u00e9sent, nous n’avons examin\u00e9 que le mappage unidirectionnel, ce qui signifie que si nous avons deux types
Type A<\/code> etType B<\/code>, nous mappons uniquementType A<\/code> versType B<\/code>. Mais, en utilisant la capacit\u00e9 de mappage invers\u00e9 d’Automapper, il est possible d’obtenir un mappage bidirectionnel :<\/p>\n\n\n\n\npublic UserProfile()\n{\n CreateMap<User, UserViewModel>()\n .ForMember(dest =>\n dest.FName,\n opt => opt.MapFrom(src => src.FirstName))\n .ForMember(dest =>\n dest.LName,\n opt => opt.MapFrom(src => src.LastName))\n .ReverseMap();\n}<\/pre>\n<\/div><\/div>\n\n\n\nUne fois le Reverse Mapping configur\u00e9, nous pouvons remonter de la destination au type de source :<\/p>\n\n\n\n
\nvar mappedUser = _mapper.Map<User>(userViewModel);<\/pre>\n<\/div><\/div>\n\n\n\n
De cette fa\u00e7on, nous pouvons facilement r\u00e9aliser un mappage bidirectionnel entre les types \u00e0 l’aide des capacit\u00e9s de mappage invers\u00e9 d’AutoMapper. <\/p>\n\n\n\n
Juste une note. Nous pouvons \u00e9galement utiliser AutoMapper de la m\u00eame mani\u00e8re dans le projet d’API Web ASP.NET Core<\/a> , l’impl\u00e9mentation est la m\u00eame, nous ne mapperons pas les mod\u00e8les de vue mais, par exemple, nos classes DTO.<\/p>\n\n\n\n
Dans les coulisses d’AutoMapper <\/h2>\n\n\n\n
Nous avons vu la magie d’AutoMapper en action. Alors que se passe-t-il en arri\u00e8re-plan ? <\/p>\n\n\n\n
AutoMapper utilise un concept de programmation appel\u00e9 Reflection <\/a>pour r\u00e9cup\u00e9rer les m\u00e9tadonn\u00e9es de type des objets. Nous pouvons utiliser la r\u00e9flexion pour obtenir dynamiquement le type d’un objet existant et invoquer ses m\u00e9thodes ou acc\u00e9der \u00e0 ses champs et propri\u00e9t\u00e9s. <\/p>\n\n\n\n
Ensuite, en fonction des conventions et des configurations d\u00e9finies, nous pouvons facilement mapper les propri\u00e9t\u00e9s des deux types. AutoMapper a \u00e9t\u00e9 construit autour de ce concept.<\/p>\n\n\n\n
Consignes d’utilisation et bonnes pratiques d’AutoMapper <\/h2>\n\n\n\n
Comme pour tous les autres composants que nous utilisons dans notre application, il existe certaines directives d’utilisation et les meilleures pratiques que nous devons suivre lors de l’utilisation d’AutoMapper.<\/p>\n\n\n\n
\u00c0 faire <\/strong><\/h3>\n\n\n\n
- \n
- Utilisez toujours le
AutoMapper.Extensions.Microsoft.DependencyInjection<\/code> package dans ASP.NET Core avecservices.AddAutoMapper(assembly[])<\/code>. Ce package effectuera toute l’analyse et l’ enregistrement de l’injection de d\u00e9pendances . Nous avons seulement besoin de d\u00e9clarer les configurations de profil.<\/li>\n\n\n\n- Organisez toujours la configuration en
Profiles<\/code>.Profiles<\/code> permettent de regrouper une configuration commune et d’organiser les mappings par usage. Cela nous permet de rapprocher la configuration de mappage de l’endroit o\u00f9 elle est utilis\u00e9e, au lieu d’un seul fichier de configuration qui devient difficile \u00e0 modifier\/maintenir.<\/li>\n\n\n\n- Utilisez toujours les options de configuration prises en charge par LINQ plut\u00f4t que leurs homologues, car les extensions de requ\u00eate LINQ offrent les meilleures performances de toutes les strat\u00e9gies de mappage.<\/li>\n\n\n\n
- Toujours aplatir les DTO. AutoMapper peut g\u00e9rer les propri\u00e9t\u00e9s de mappage ABC dans ABC. En aplatissant notre mod\u00e8le, nous cr\u00e9ons un objet plus simplifi\u00e9 qui ne n\u00e9cessitera pas beaucoup de navigation pour acc\u00e9der aux donn\u00e9es.<\/li>\n\n\n\n
- Mettez toujours des propri\u00e9t\u00e9s calcul\u00e9es simples communes dans le mod\u00e8le source. De m\u00eame, nous devons placer les propri\u00e9t\u00e9s calcul\u00e9es sp\u00e9cifiques au mod\u00e8le de destination dans le mod\u00e8le de destination.<\/li>\n<\/ul>\n\n\n\n
A ne pas faire<\/strong><\/h3>\n\n\n\n
- \n
- N’appelez pas
CreateMap()<\/code>\u00e0 chaque demande. Il n’est pas recommand\u00e9 de cr\u00e9er la configuration pour chaque demande de mappage. La configuration du mappage doit \u00eatre effectu\u00e9e une fois au d\u00e9marrage.<\/li>\n\n\n\n- N’utilisez pas de cartes en ligne. Les cartes en ligne peuvent sembler plus faciles pour des sc\u00e9narios tr\u00e8s simples, mais nous perdons la facilit\u00e9 de configuration.<\/li>\n\n\n\n
- Si nous devons \u00e9crire un comportement de mappage complexe, il serait peut-\u00eatre pr\u00e9f\u00e9rable d’\u00e9viter d’utiliser
AutoMapper<\/code> pour ce sc\u00e9nario.<\/li>\n\n\n\n- Ne placez aucune logique qui ne corresponde pas strictement au comportement de mappage dans la configuration.
AutoMapper<\/code> ne doit pas ex\u00e9cuter de logique m\u00e9tier, il ne doit g\u00e9rer que le mappage.<\/li>\n\n\n\n- \u00c9vitez de partager des DTO sur plusieurs cartes. Mod\u00e9lisez vos DTO autour d’actions individuelles, et si vous devez le modifier, vous n’affectez que cette action.<\/li>\n\n\n\n
- Ne cr\u00e9ez pas de DTO avec des associations circulaires.
AutoMapper<\/code> le prend en charge, mais cela pr\u00eate \u00e0 confusion et peut entra\u00eener de tr\u00e8s mauvaises performances. Au lieu de cela, nous pouvons cr\u00e9er des DTO distincts pour chaque niveau de la hi\u00e9rarchie que nous voulons.<\/li>\n<\/ul>\n\n\n\nAplatir des mod\u00e8les d’objets complexes dans AutoMapper <\/h2>\n\n\n\n
AutoMapper<\/code> prend en charge l’aplatissement des mod\u00e8les d’objets complexes en DTO ou un autre mod\u00e8le d’objet simple. Par exemple, les objets de domaine ont g\u00e9n\u00e9ralement un mod\u00e8le d’objet complexe avec de nombreuses associations entre eux, mais les ViewModels ont g\u00e9n\u00e9ralement un mod\u00e8le d’objet plat. <\/p>\n\n\n\nNous pouvons mapper des objets de domaine sur des ViewModels avec Flattening d’ AutoMapper <\/a>. <\/p>\n\n\n\n
Si nous suivons les conventions de d\u00e9nomination appropri\u00e9es pour nos mod\u00e8les d’objets, il n’est pas n\u00e9cessaire de fournir de code de configuration suppl\u00e9mentaire.
AutoMapper<\/code> fonctionne avec des conventions et mappe notre mod\u00e8le d’objet du complexe au plat\/simple.<\/p>\n\n\n\nAutoMapper<\/code> utilise les conventions suivantes :<\/p>\n\n\n\n- \n
- Il mappera automatiquement les propri\u00e9t\u00e9s avec les m\u00eames noms.<\/li>\n\n\n\n
- Si l’objet source est associ\u00e9 \u00e0 d’autres objets, il essaiera de mapper avec des propri\u00e9t\u00e9s sur l’objet de destination dont le nom est une combinaison du nom de la classe source et du nom de la propri\u00e9t\u00e9 dans le cas Pascal <\/a>. <\/li>\n\n\n\n
- Il essaiera de mapper des m\u00e9thodes sur l’objet source qui a un
Get<\/code> pr\u00e9fixe avec une propri\u00e9t\u00e9 sur l’objet de destination avec le nom excluant leGet<\/code> pr\u00e9fixe.<\/li>\n<\/ul>\n\n\n\nSi nous suivons ces conventions,
AutoMapper<\/code> mappera automatiquement nos objets. Sinon, nous devrons configurer \u00e0 l’AutoMapper<\/code> aide de l’ API Fluent <\/a>.<\/p>\n\n\n\nModifions notre
User<\/code>objet en ajoutant un objet enfantAddress<\/code>:<\/p>\n\n\n\n\npublic class User\n{\n public int Id { get; set; }\n public string FirstName { get; set; }\n public string LastName { get; set; }\n public string Email { get; set; }\n public Address Address { get; set; }\n\n public string GetFullName()\n {\n return $\"{this.LastName}, {this.FirstName}\";\n }\n}<\/pre>\n<\/div><\/div>\n\n\n\nEt voici \u00e0 quoi
Address<\/code> ressemble la classe :<\/p>\n\n\n\n\npublic class Address\n{\n public int Id { get; set; }\n public string Door { get; set; }\n public string Street1 { get; set; }\n public string Street2 { get; set; }\n public string City { get; set; }\n public string State { get; set; }\n public string Country { get; set; }\n public string ZipCode { get; set; }\n}<\/pre>\n<\/div><\/div>\n\n\n\nNotez \u00e9galement que nous avons ajout\u00e9 une m\u00e9thode
GetFullName()<\/code>pour obtenir le nom complet de l’utilisateur.<\/p>\n\n\n\nModifions la
UserViewModel<\/code> classe :<\/p>\n\n\n\n\npublic class UserViewModel\n{\n [Display(Name = \"Full Name\")]\n public string FullName { get; set; }\n [Display(Name = \"Country\")]\n public string AddressCountry { get; set; }\n public string Email { get; set; }\n}<\/pre>\n<\/div><\/div>\n\n\n\nMaintenant, modifions la classe de profil pour utiliser les conventions par d\u00e9faut :<\/p>\n\n\n\n
\npublic UserProfile()\n{\n CreateMap<User, UserViewModel>();\n}<\/pre>\n<\/div><\/div>\n\n\n\nEx\u00e9cutons \u00e0 nouveau l’application :<\/p>\n\n\n\n
![\"AutoMapper](\"https:\/\/oussamasaidi.com\/wp-content\/uploads\/2022\/09\/image-1.png\")
<\/figure>\n\n\n\nCette fois, nous pouvons voir que la
GetFullName()<\/code>m\u00e9thode sur l’objet source est correctement mapp\u00e9e \u00e0 laFullName<\/code> propri\u00e9t\u00e9 sur l’objet de destination.<\/p>\n\n\n\nDe m\u00eame, la propri\u00e9t\u00e9 User.Address.Country est automatiquement mapp\u00e9e sur
UserViewModel.AddressCountry<\/code>. <\/p>\n\n\n\nCes mappages sont correctement g\u00e9r\u00e9s par l’ \u00e0 l’
AutoMapper<\/code> aide de ses conventions par d\u00e9faut.<\/p>\n\n\n\nConclusion<\/h2>\n\n\n\n
Dans cet article, nous avons appris les concepts suivants :<\/p>\n\n\n\n
- \n
- Le composant AutoMapper \u2013 qu’est-ce que c’est et quand l’utiliser ?<\/li>\n\n\n\n
- Installation, configuration et utilisation du composant AutoMapper dans notre application ASP.NET Core<\/li>\n\n\n\n
- Comment AutoMapper fonctionne dans les coulisses<\/li>\n\n\n\n
- Consignes d’utilisation et meilleures pratiques lors de l’utilisation d’AutoMapper.<\/li>\n\n\n\n
- Aplatir un mod\u00e8le d’objet complexe \u00e0 l’aide des conventions par d\u00e9faut d’AutoMapper.<\/li>\n<\/ul>\n\n\n\n
C’est tout pour le moment. J’esp\u00e8re que vous avez appr\u00e9ci\u00e9 l’article. Nous aborderons des sujets plus avanc\u00e9s li\u00e9s \u00e0 AutoMapper dans l’un des articles suivants .<\/p>\n\n\n\n
Derniers Articles<\/h2>\n\n\n\n
- \n
- Hangfire avec ASP.NET Core<\/a><\/li>\n\n\n\n
- Premiers pas avec AutoMapper dans ASP.NET Core<\/a><\/li>\n\n\n\n
- Serilog dans ASP.NET Core 3.1-La journalisation structur\u00e9e simplifi\u00e9e<\/a><\/li>\n<\/ul>\n\n\n\n
\n\nVous aimez le contenu ?<\/strong><\/h2>\n\n\n\n
Si vous aimez mes articles, pensez \u00e0 m\u2019acheter quelques caf\u00e9s !<\/strong><\/p>\n\n\n\n
\n\n\n\n\n - Premiers pas avec AutoMapper dans ASP.NET Core<\/a><\/li>\n\n\n\n
- Hangfire avec ASP.NET Core<\/a><\/li>\n\n\n\n
- Il essaiera de mapper des m\u00e9thodes sur l’objet source qui a un
- Organisez toujours la configuration en
- A ne pas faire<\/a><\/li><\/ul><\/li>
- Configuration d'AutoMapper<\/a><\/li>
- Comment utiliser AutoMapper dans notre application<\/a>