Copier des modèles entre les calques

Question

Lorsque l'on parcourt les couches, il est très fastidieux d'effectuer des affectations droite->gauche pour remplir les modèles. Par exemple :

employeeViewModel.FirstName = employeeModel.FirstName;
employeeViewModel.LastName = employeeModel.LastName;
...

Nous pouvons donc construire un ModelCopier qui utilise la réflexion pour copier les modèles :

var employeeViewModel = ModelCopier.Copy<EmployeeViewModel>(employeeModel);

Cette technique simplifie grandement la tâche. Cependant, il y a quelques éléments qui sont assez troublants à ce sujet :

• Nous avons effectivement perdu la possibilité de suivre l'utilisation des propriétés sur les objets source et destination. Par exemple, la recherche des utilisations (dans Resharper) de la propriété FirstName ne révèle pas les cas ModelCopier.
• Si nous modifions le nom d'une propriété dans la classe source ou la classe de destination, nous pouvons involontairement provoquer des exceptions d'exécution, car nous ne nous rendons peut-être pas compte que nous devons mettre à jour à la fois la classe source et la classe de destination.

D'un côté du spectre, nous pouvons utiliser la réflexion, ce qui est très facile, mais au détriment de la maintenabilité. À l'autre extrémité du spectre, il est très fastidieux mais très facile à maintenir.

Réflexion (facile et dangereuse) <-----> Affectation directe (fastidieuse et facile à maintenir)

Je suis curieux de savoir si quelqu'un a trouvé un compromis qui offre la facilité d'utilisation de la réflexion pour la copie avec la maintenabilité de l'affectation directe.

L'une des solutions que nous avons envisagées consiste à créer un plugin qui génère des méthodes d'extension gérant l'affectation des propriétés dans chaque cas. En d'autres termes, il s'agit de créer un outil qui s'occupera de la partie fastidieuse.

EDIT :

Veuillez comprendre que cette question ne porte pas sur l'outil de cartographie à utiliser. J'essaie de comprendre comment nous pouvons profiter des avantages de la cartographie basée sur la réflexion tout en profitant des avantages de la maintenabilité fournis par l'affectation directe (ou un contrat de cartographie des propriétés).

Answer 1

Sérieusement, utilisez AutoMapper . Il vous permet de mettre en place des conversions d'un type vers un autre type. Toute modification des noms de propriété entraînera une rupture de la configuration de l'automapper, ce qui n'est pas le cas de la réflexion :

Mapper.CreateMap<SiteDto, SiteModel>();
Mapper.CreateMap<SiteModel, SiteDto>();

Ensuite, pour cartographier l'entrée et la sortie, il suffit de procéder comme suit :

SiteDto dto = Mapper.Map<SiteModel, SiteDto>(targetModel);
SiteModel model = Mapper.Map<SiteDto, SiteModel>(targetDto);

Answer 2

Il est probable que le compilateur n'effectue pas les tests nécessaires sur l'ensemble du code... c'est là que les tests unitaires entrent en jeu. Si vous avez défini un test pour la conversion entre les classes dans les différentes couches (oui, toutes les conversions possibles que vous devez effectuer, sinon comment pouvez-vous être sûr que votre approche de réflexion fonctionnera dans toutes les situations une fois en production ?), le simple fait d'exécuter le test indiquera au développeur qui a changé le nom de la propriété que la solution ne passe plus tous les tests. Vous devriez exécuter tous les tests (les tests unitaires, pas les tests d'intégration) à chaque fois que vous voulez vérifier votre code source... et cela ne devrait pas être après quelques mois de codage :))

Je vote donc vraiment pour l'utilisation de l'approche de réflexion, épicée avec une cuillère d'approche de test unitaire.

Answer 3

I compromis qui offre la facilité de d'utiliser la réflexion pour la copie avec la la maintenabilité de l'assignation directe.

On dirait que vous essayez d'avoir le beurre et l'argent du beurre.

C'est un problème auquel les langues dynamiques sont confrontées tous les jours. Il n'y a pas de pilule magique. Il faut soit effectuer les affectations gauche-droite et bénéficier de la protection du compilateur, soit envelopper les affectations critiques dans des tests unitaires.

Mon intuition me dit qu'il s'agit d'un problème de conception et non d'un problème de code.

Answer 4

Une solution consisterait à écrire un utilitaire distinct qui utiliserait la réflexion pour obtenir les noms des propriétés du modèle et qui écrirait ensuite le code source pour exposer les propriétés.

Answer 5

Vos exigences vont au-delà de l'exécution (mise en œuvre) en tant que telle puisque vous (et nous tous) avez besoin de graphes de dépendance, etc. Cela signifie que la découverte dynamique avec la réflexion est exclue. Vous semblez avoir besoin d'une solution à la compilation. A part la suggestion de @amaca d'un plug-in de génération de code (que vous pouvez écrire facilement), quelles sont les autres options possibles ?