Partager via

Stabilisation de la structure de l'application à l'aide de diagrammes de couche

  • Article

Lorsqu'une équipe développe du code par petits incréments, elle modifie et étend code fréquemment. Ces modifications peuvent entraîner des dépendances de plus en plus complexes, qui rendent le code plus difficile à modifier au fil du temps. Votre équipe peut utiliser des schémas de couche pour concevoir et valider les dépendances entre les composants dans votre application de manière à éviter ce problème.

À l'aide d'un diagramme de couche, votre équipe peut afficher les parties principales de l'application et les dépendances entre elles, sans détails sur le mode de fonctionnement des parties et leur interaction.

Votre équipe peut également utiliser des schémas de couche pour s'assurer que le code est conforme à l'architecture. Lorsque vous mappez un diagramme de couche dans Visual Studio, vous pouvez assigner des groupes de classes de votre code à chaque couche, et définir les dépendances à l'aide de flèches. Vous pouvez ensuite utiliser Visual Studio pour confirmer que les dépendances dans le code suivent réellement les flèches que vous avez tracées dans le diagramme de couche.

Votre équipe peut vérifier que les futures modifications sont conformes toujours à l'architecture en définissant une stratégie d'archivage pour valider le diagramme de couche et en l'utilisant dans les builds en continu de votre équipe.

Introduction de la validation de couche

Votre équipe peut commencer à utiliser la validation de couche en suivant les procédures décrites dans cette section.

Pour utiliser la validation de couche lorsque vous écrivez un nouveau code

  1. Au moment où vous commencez à écrire le code pour l'application, dessinez un diagramme de couche représentant les principaux composants et leurs dépendances. Vous modifierez probablement le schéma au cours du projet au fur et à mesure que l'application se développe.

    Pour plus d'informations, consultez Diagrammes de couche : référence.

  2. Lorsque vous créez des espaces de noms ou des classes, assignez-les aux couches.

  3. Avant d'archiver le code, cliquez avec le bouton droit sur le diagramme de couche, puis cliquez sur Valider l'architecture.

  4. Ajoutez la validation de couche à l'archivage et aux procédures de builds régulières.

    Pour plus d'informations, consultez Comment : valider du code .NET par rapport à des diagrammes de couche.

Pour introduire la validation de couche lorsque vous mettez à jour une application existante

  1. Utilisez le Navigateur de l'architectur et les graphiques orientés pour explorer l'application afin d'en comprendre sa structure. Les étapes suivantes vous aideront à améliorer votre compréhension.

  2. Décrivez ce que doivent être les principaux composants et les dépendances. Pour plus d'informations, consultez Comment : créer des diagrammes de couche à partir d'artefacts.

  3. Assignez des éléments aux couches en les faisant glisser du Navigateur de l'architecture ou de l'Explorateur de solutions.

  4. Cliquez avec le bouton droit sur le diagramme de couche, puis cliquez sur Valider l'architecture.

  5. Examinez tous les rapports d'erreurs et corrigez toutes les erreurs à l'aide des méthodes suivantes :

    • Corrigez le diagramme de couche. Améliorez le diagramme de couche pour représenter le code existant avec plus de précision, ou réassignez des éléments de code à d'autres couches.

    • Corrigez le code. Si vous estimez que votre diagramme de couche représente une meilleure conception du code existant, vous pouvez mettre à jour le code afin qu'il corresponde à votre diagramme de couche.

      Pour plus d'informations, consultez la section Refactorisation du code existant afin qu'il soit conforme à votre diagramme de couche plus loin dans cette rubrique.

  6. Répétez les étapes précédentes jusqu'à ce qu'aucune erreur ne soit signalée.

  7. Ajoutez la validation de couche à l'archivage et aux procédures de builds régulières.

    Pour plus d'informations, consultez Comment : valider du code .NET par rapport à des diagrammes de couche.

Refactorisez le code existant afin qu'il soit conforme à votre diagramme de couche

Lorsque votre équipe commence à travailler sur une application existante, elle peut trouver que la structure de l'application est plus complexe que ce qu'elle devrait être. Vous le remarquerez lorsque vous essayerez de mapper un diagramme de couche et d'assigner des éléments aux couches. Votre équipe ne pourra pas nécessairement assigner des éléments aux couches d'une façon qui pourra être validée sans introduire de couches et de dépendances logiquement inutiles ou en introduisant des dépendances qui ignorent les couches ou créent des boucles. Ces points faibles rendent le code difficile à comprendre et à modifier et peuvent provoquer un comportement incohérent pour les utilisateurs.

Votre équipe peut simplifier le code en le refactorisant pour en améliorer sa conception. Lorsque votre équipe décide de refactoriser le code pour améliorer la conception, prenez en compte les points suivants :

  • Conservez les modifications de la refactorisation séparées des autres modifications. Une modification de refactorisation ne doit comporter aucun changement important dans les récits utilisateur.

  • Ajoutez chaque modification proposée dans le journal des travaux en souffrance du produit avec une description de la modification et de l'avantage attendu.

    Notes

    La refactorisation des modifications dont l'implémentation et le test ne prennent que quelques heures peut être traitée sous forme de bogues. Pour la refactorisation à plus grande échelle, ajoutez les modifications au journal des travaux en souffrance du produit. Elles doivent être estimées et classées par ordre de priorité avec d'autres éléments dans le journal des travaux en souffrance.

  • Avant de refactoriser, écrivez des tests qui vérifient que la fonctionnalité de la zone que vous modifiez n'a pas changé.

Mise à jour du modèle de couche

Après un ou deux premiers sprints, les diagrammes de couche doivent rester stable. En général, une erreur de validation de couche doit être considérée comme une erreur dans le code, plutôt qu'une erreur dans le modèle de couche.

Lorsque vous devez mettre à jour le modèle de couche, examinez la modification proposée avec votre équipe.

La plupart des modifications apportées au modèle de couche sont répartis entre les catégories suivantes :

  • Extension. Vous ajoutez plus de composants dans le code et vous souhaitez ajouter des couches pour se conformer à ces derniers.

  • Amélioration. Plusieurs éléments de code sont actuellement assignés à une seule couche. Vous souhaitez améliorer l'efficacité de la validation de couche en séparant la couche unique en couches plus petites.

  • Refactorisation. Vous souhaitez améliorer les structures de dépendance du code existant. Les structures existantes sont reflétées dans les diagrammes de couche actuels. Par conséquent, vous souhaitez améliorer simultanément le diagramme de couche et le code.

Rubriques connexes