Diagrammes de couche : instructions
Vous pouvez décrire l'architecture de votre application à un niveau élevé en créant des diagrammes de couche dans Visual Studio Ultimate. Pour garantir que votre code demeure conforme à cette conception, validez votre code avec un diagramme de couche dans Visual Studio Ultimate ou Visual Studio Premium. Vous pouvez également inclure la validation de couche dans votre processus de génération. Voir la vidéo Channel 9: Utilisation de diagrammes de couche pour concevoir et valider votre architecture.
Qu'est-ce qu'un diagramme de couche ?
À l'image d'un diagramme d'architecture traditionnel, un diagramme de couche identifie les principaux composants ou unités fonctionnelles de la conception et leurs interdépendances. Chaque nœud du diagramme, appelé couche, représente un groupe logique d'espaces de noms, de projets ou autres artefacts. Vous pouvez dessiner les dépendances qui doivent exister dans votre conception. Contrairement à un diagramme d'architecture traditionnel, vous pouvez vérifier que les dépendances réelles dans le code source sont conformes aux dépendances prévues que vous avez spécifiées. En incluant la partie validation d'une build normale dans Team Foundation Server, vous pouvez vous assurer que le code du programme continue à respecter l'architecture du système au travers des modifications futures. Consultez Diagrammes de couche : référence.
Procédure pour concevoir ou mettre à jour votre application avec les diagrammes de couche
Les étapes suivantes fournissent une vue d'ensemble de l'utilisation des diagrammes de couche dans le processus de développement. Les sections suivantes de cette rubrique décrivent plus en détail chaque étape. Si vous développez une nouvelle conception, ignorez les étapes qui font référence au code existant.
Notes
Ces étapes s'affichent selon un ordre approximatif.Vous souhaiterez probablement superposer les tâches, les réorganiser en fonction de votre propre cas et les réexaminer au début de chaque itération de votre projet.
Créez un diagramme de couche pour toute l'application ou pour l'une de ses couches.
Définissez les couches pour représenter les zones fonctionnelles principales ou les composants majeurs de votre application. Nommez ces couches d'après leur fonction, par exemple, « Présentation » ou « Services ». Si vous avez une solution Visual Studio, vous pouvez associer chaque couche à une collection d'artefacts, tels que projets, espaces de noms, fichiers, etc.
Découvrez les dépendances existantes entre les couches.
Modifiez les couches et les dépendances pour afficher la conception mise à jour que le code doit refléter.
Concevez les nouvelles zones de votre application en créant des couches pour représenter les principaux composants ou blocs architecturaux et en définissant des dépendances pour montrer comment chaque couche utilise les autres.
Éditez la disposition et l'aspect du diagramme pour vous aider à en discuter avec vos collègues.
Validez le code par rapport au diagramme de couche pour mettre en évidence les conflits entre le code et l'architecture dont vous avez besoin.
Mettez le code à jour pour qu'il soit conforme à la nouvelle architecture. Développez le code de manière itérative et refactorisez-le jusqu'à ce que la validation n'affiche aucun conflit.
Incluez la validation de couche dans le processus de génération pour vous assurer que le code continue à respecter votre conception.
Créer un diagramme de couche
Un diagramme de couche doit être créé à l'intérieur d'un projet de modélisation. Vous pouvez ajouter un nouveau diagramme de couche à un projet de modélisation existant, créer un nouveau projet de modélisation pour le diagramme de couche ou copier un diagramme de couche existant au sein du même projet de modélisation.
Important
Vous ne pouvez pas copier un diagramme de couche existant d'un projet de modélisation vers un autre projet de modélisation ou un autre emplacement de la solution, ni l'y ajouter ou l'y glisser-déposer.Un diagramme de couche ainsi copié aura les mêmes références que le diagramme d'origine, même si vous modifiez le diagramme.La validation de couche ne peut alors fonctionner correctement et d'autres problèmes peuvent survenir, tels que l'absence d'éléments ou autre erreurs lors de l'ouverture du diagramme.
Consultez Créer des diagrammes de couche à partir du code.
Définir les couches pour représenter les zones ou les composants fonctionnels
Les couches représentent des groupes logiques d'artefacts, tels que projets, fichiers de code, espaces de noms, classes et méthodes. Vous pouvez créer des couches à partir d'artefacts de projets Visual C# .NET et Visual Basic .NET, ou vous pouvez attacher des spécifications ou des plans à une couche en liant des documents, tels que des fichiers Word ou des présentations PowerPoint. Chaque couche apparaît comme un rectangle sur le diagramme et indique le nombre d'artefacts qui lui sont liés. Une couche peut contenir des couches imbriquées qui décrivent des tâches plus spécifiques.
En règle générale, nommez les couches selon leur fonction : par exemple, « Présentation » ou « Services ». Si les artefacts sont étroitement interdépendants, placez-les dans la même couche. Si les artefacts peuvent être mis à jour séparément ou utilisés dans des applications distinctes, placez-les dans des couches différentes. Pour en savoir plus sur les modèles en couches, consultez le site Patterns & Practices à l'adresse https://go.microsoft.com/fwlink/?LinkId=145794.
Conseil
Il existe certains types d'artefacts que vous pouvez lier aux couches, mais qui ne prennent pas en charge la validation par rapport au diagramme de couche.Pour voir si l'artefact prend en charge la validation, ouvrez Explorateur de couches et examinez la propriété Prend en charge la validation du lien d'artefact.Consultez Découvrir les dépendances existantes entre les couches.
Lorsque vous mettez à jour une application peu familière, vous pouvez utiliser les graphiques de dépendance pour vous aider à explorer et à comprendre le code. Ces graphiques peuvent vous aider à découvrir des clusters et des dépendances dans le code. Vous pouvez également utiliser le navigateur de l'architecture pour explorer des espaces de noms et des classes, qui correspondent souvent aux couches existantes. Il vous est ainsi plus facile d'assigner des artefacts aux couches. Vous pouvez utiliser ensuite des diagrammes de couche pour vous aider à mettre à jour le code.
Pour plus d'informations, consultez les rubriques suivantes :
Découvrir les dépendances existantes entre les couches
Une dépendance existe chaque fois qu'un artefact associé à une couche comporte une référence à un artefact associé à une autre couche. Par exemple, une classe dans une couche déclare une variable qui a une classe dans une autre couche. Vous pouvez découvrir les dépendances existantes par rétroconception.
Notes
Les dépendances ne peuvent pas faire l'objet d'une ingénierie à rebours pour certains genres d'artefacts.Par exemple, aucune dépendance ne fera l'objet d'une ingénierie à rebours depuis ou vers une couche qui est liée à un fichier texte.Pour identifier les artefacts ayant des dépendances qui peuvent faire l'objet d'une rétroconception, cliquez avec le bouton droit sur une ou plusieurs couches, puis choisissez Afficher les liens.Dans l'Explorateur de couches, examinez la colonne Prend en charge la validation.Les dépendances des artefacts pour lesquels cette colonne affiche la valeur False ne feront pas l'objet d'une ingénierie à rebours.
Pour procéder à la rétroconception des dépendances existantes entre couches
- Sélectionnez une ou plusieurs couches, cliquez avec le bouton droit sur une couche sélectionnée, puis cliquez sur Générer des dépendances.
En général, des dépendances qui ne devraient pas exister s'affichent. Vous pouvez modifier ces dépendances pour les ajuster à la conception prévue.
Modifier les couches et les dépendances pour afficher la conception prévue
Pour décrire les modifications que vous envisagez d'apporter à votre système ou l'architecture prévue, utilisez la procédure suivante pour modifier le diagramme de couche : vous pouvez aussi envisager d'apporter des modifications de refactorisation pour améliorer la structure du code avant de l'étendre. Consultez Amélioration de la structure du code.
Pour |
Exécuter ces étapes |
|---|---|
Supprimer une dépendance qui ne doit pas exister |
Sélectionnez la dépendance, puis appuyez sur la touche SUPPR. |
Changer ou restreindre la direction d'une dépendance |
Définissez sa propriété Direction. |
Créer de nouvelles dépendances |
Utilisez les outils Dépendance et Dépendance bidirectionnelle. Pour dessiner plusieurs dépendances, double-cliquez sur l'outil. Lorsque vous avez terminé, sélectionnez l'outil Pointeur ou appuyez sur la touche Échap. |
Spécifier que les artefacts associés à une couche ne peuvent pas dépendre des espaces de noms spécifiés |
Tapez les espaces de noms dans la propriété Forbidden Namespace Dependencies (Dépendances d'espaces de noms interdits) de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms. |
Spécifier que les artefacts associés à une couche ne doivent pas appartenir aux espaces de noms spécifiés |
Tapez les espaces de noms dans la propriété Forbidden Namespaces (Espaces de noms interdits) de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms. |
Spécifier que les artefacts associés à une couche doivent appartenir à un des espaces de noms spécifiés |
Tapez l'espace de noms dans la propriété Espace de noms requis de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms. |
Amélioration de la structure du code
Les modifications de refactorisation sont des améliorations qui n'affectent pas le comportement de l'application, mais qui contribuent à rendre le code plus facile à modifier et à étendre à l'avenir. Le code correctement structuré présente une conception qu'il est facile de résumer en un diagramme de couche.
Par exemple, si vous créez une couche pour chaque espace de noms dans le code, puis soumettez les dépendances à une rétroconception, il doit exister un ensemble minimal de dépendances unidirectionnelles entre les couches. Si vous créez un diagramme plus détaillé à l'aide de classes ou de méthodes en tant que couches, le résultat doit également présenter les mêmes caractéristiques.
Si tel n'est pas le cas, le code sera plus difficile à modifier tout au long de son cycle de vie et sera moins adapté à la validation à l'aide de diagrammes de couche.
Concevoir les nouveaux domaines de votre application
Lorsque vous démarrez le développement d'un nouveau projet, ou d'une nouvelle partie d'un nouveau projet, vous pouvez dessiner des couches et des dépendances pour aider à identifier les principaux composants avant de commencer à développer le code.
Affichez des modèles architecturaux identifiables dans vos diagrammes de couche, si possible. Par exemple, un diagramme de couche qui décrit une application bureautique peut inclure des couches telles que Présentation, Logique de domaine et Magasin de données. Un diagramme de couche qui couvre une fonctionnalité unique au sein d'une application peut avoir des couches telles que Modèle, Vue et Contrôleur. Pour plus d'informations sur ces modèles, consultez Patterns & Practices : Architecture d'application.
Si vous créez fréquemment des modèles similaires, créez un outil personnalisé. Consultez Comment : définir un élément de boîte à outils de modélisation personnalisé.
Créez un artefact de code pour chaque couche, tel qu'un espace de noms, une classe ou un composant. Il est ainsi plus facile de suivre le code et de lier les artefacts de code aux couches. Dès que vous créez un artefact, liez-le à la couche appropriée.
Vous n'avez pas à lier la plupart des classes et autres artefacts aux couches, car ils font partie d'artefacts plus importants, tels que les espaces de noms que vous avez déjà liés aux couches.
Créez un diagramme pour une nouvelle fonctionnalité. En général, il y a un ou plusieurs diagrammes de couche décrivant toute l'application. Si vous concevez une nouvelle fonctionnalité dans l'application, ne modifiez pas les diagrammes existants ou ne la leur ajoutez pas. Créez à la place votre propre diagramme qui reflète les nouvelles parties du code. Les couches du nouveau diagramme peuvent inclure la présentation, la logique de domaine et les couches de base de données pour la nouvelle fonctionnalité.
Lorsque vous générez l'application, votre code est validé par rapport au diagramme global et à votre diagramme de fonctionnalités détaillé.
Modifier la disposition pour la présentation et la discussion
Pour vous aider à identifier des couches et des dépendances ou à en discuter avec les membres de l'équipe, modifiez l'aspect et la disposition du diagramme comme suit :
Modifiez les tailles, formes et positions des couches.
Modifiez les couleurs des couches et des dépendances.
- Sélectionnez une ou plusieurs couches ou dépendances, cliquez avec le bouton droit, puis cliquez sur Propriétés. Dans la fenêtre Propriétés, modifiez la propriété Couleur.
Valider le code par rapport au diagramme
Lorsque vous avez modifié le diagramme, vous pouvez le valider manuellement par rapport au code à tout moment ou automatiquement chaque fois que vous exécutez une génération locale ou Team Foundation Build.
Reportez-vous à :
Inclure la validation de couche dans le processus de génération
Mettre à jour le code pour être conforme à la nouvelle architecture
En général, les erreurs apparaissent la première fois que vous validez le code par rapport à un diagramme de couche mis à jour. Ces erreurs peuvent avoir plusieurs causes :
Un artefact est assigné à une couche inappropriée. Dans ce cas, déplacez l'artefact.
Un artefact, tel qu'une classe, utilise une autre classe d'une manière qui génère un conflit avec votre architecture. Dans ce cas, refactorisez le code pour supprimer la dépendance.
Pour résoudre ces erreurs, mettez à jour le code de façon à ce que la validation ne génère plus d'erreur. Il s'agit généralement d'un processus itératif. Pour plus d'informations sur ces erreurs, consultez Valider du code avec des diagrammes de couche.
Notes
Lorsque vous développez ou refactorisez le code, il se peut que vous ayez de nouveaux artefacts à lier au diagramme de couche.Toutefois, cela peut ne pas être nécessaire : par exemple, lorsque des couches représentent des espaces de noms existants et que le nouveau code ajoute seulement plus de documentation à ces espaces de noms.
Pendant le processus de développement, vous pouvez supprimer certains conflits signalés pendant la validation. Par exemple, vous pouvez supprimer des erreurs que vous êtes déjà en train de traiter qui ne sont pas pertinentes dans le cadre de votre scénario spécifique. Lorsque vous supprimez une erreur, il est conseillé d'entrer un élément de travail dans Team Foundation. Pour effectuer cette tâche, consultez Valider du code avec des diagrammes de couche.
Inclure la validation de couche dans le processus de génération
Pour vous assurer que les futures modifications du code sont conformes aux diagrammes de couche, incluez la validation de couche au processus de génération standard de votre solution. Chaque fois que les autres membres de l'équipe génèrent la solution, les différences entre les dépendances dans le code et le diagramme de couche sont signalées comme erreurs de build. Pour plus d'informations sur l'inclusion de la validation de couche dans le processus de génération, consultez Valider du code avec des diagrammes de couche.