Diagrammes de dépendances : recommandations
Décrivez l’architecture de votre application de manière générale en créant des diagrammes de dépendances dans Visual Studio. Vérifiez que votre code reste conforme à cette conception en le validant avec un diagramme de dépendances. Vous pouvez également inclure la validation de couche dans votre processus de génération.
Pour connaître les éditions de Visual Studio qui prennent en charge cette fonctionnalité, consultez Prise en charge des éditions pour les outils d’architecture et de modélisation.
Notes
Les diagrammes de dépendances pour les projets .NET Core sont pris en charge à partir de Visual Studio 2019 version 16.2.
Qu’est-ce qu’un diagramme de dépendances ?
À l’image d’un diagramme d’architecture traditionnel, un diagramme de dépendances 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 d’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 garantir que le code de programme continue d’adhérer à l’architecture du système dans les changements futurs. Consultez Diagrammes de dépendances : référence.
Comment concevoir ou mettre à jour votre application avec des diagrammes de dépendances
Les étapes suivantes fournissent une vue d’ensemble de l’utilisation des diagrammes de dépendances 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 dépendances pour l’ensemble de l’application ou pour une de ses couches.
Définissez des couches pour représenter les zones ou composants fonctionnels principaux 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, comme des 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.
Modifiez la disposition et l’aspect du diagramme pour vous aider à en discuter avec vos collègues.
Validez le code par rapport au diagramme de dépendances pour mettre en évidence les conflits entre le code et l’architecture dont vous avez besoin.
Mettez le code à jour pour qu’il suive votre nouvelle architecture. Développez le code de manière itérative et refactorisez-le jusqu'à ce que la validation n'affiche aucun conflit.
Ajoutez la validation de couche au processus de génération pour que le code continue d’adhérer à votre conception.
Créer un diagramme de dépendances
Un diagramme de dépendances doit être créé à l'intérieur d’un projet de modélisation. Vous pouvez ajouter un nouveau diagramme de dépendances à un projet de modélisation existant, créer un projet de modélisation pour le diagramme de dépendances ou copier un diagramme de dépendances existant au sein du même projet de modélisation.
Important
Vous ne pouvez pas ajouter, faire glisser ou copier le diagramme de dépendances existant d’un projet de modélisation dans un autre projet de modélisation ou à un autre emplacement de la solution. Un diagramme de dépendances copié de cette manière a 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 dépendances à partir de votre code.
Définir les couches pour représenter les zones ou les composants fonctionnels
Les couches représentent des groupes logiques d’artefacts, comme des projets, fichiers de code, espaces de noms, classes et méthodes. Vous pouvez créer des couches à partir d’artefacts de projets Visual C# et Visual Basic, ou vous pouvez attacher des spécifications ou des plans à une couche en liant des documents, comme 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.
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 dépendances. Pour voir si l’artefact prend en charge la validation, ouvrez l’Explorateur de couches pour examiner la propriété Prend en charge la validation du lien d’artefact. Consultez Découvrir les dépendances existantes entre les couches.
Lors de la mise à jour d'une application peu familière, vous pouvez également créer des cartes de code. Ces diagrammes peuvent vous aider à découvrir des modèles et des dépendances quand vous explorez le code. Utilisez l'Explorateur de solutions pour explorer des espaces de noms et des classes, qui correspondent souvent à des couches existantes. Attribuez ces artefacts de code à des couches en les faisant glisser de l’Explorateur de solutions vers des diagrammes de dépendances. Vous pouvez ensuite utiliser les diagrammes de dépendances pour vous aider à mettre à jour le code et garantir sa cohérence avec votre conception.
Consultez l'article :
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 voir les artefacts avec des dépendances qui peuvent faire l’objet d’une rétroconception, cliquez avec le bouton droit sur une ou plusieurs couches, puis cliquez sur Voir 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 False ne font pas l’objet d’une rétroconception.
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 les 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 changements que vous voulez faire sur votre système ou l’architecture prévue, utilisez la procédure suivante pour modifier le diagramme de dépendances. 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.
| To | Exécuter ces étapes |
|---|---|
| Supprimer une dépendance qui ne doit pas exister | Cliquez sur la dépendance, puis appuyez sur 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. Quand vous avez terminé, cliquez sur 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é 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é 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 obligatoires 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 bien structuré présente une conception facile à abstraire dans un diagramme de dépendances.
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 ce n’est pas le cas, le code est plus difficile à changer au cours sa vie et est moins adapté à la validation avec des diagrammes de dépendances.
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 dépendances, si possible. Par exemple, un diagramme de dépendances qui décrit une application de bureau peut comprendre des couches comme Présentation, Logique de domaine et Magasin de données. Un diagramme de dépendances qui couvre une seule fonctionnalité au sein d’une application peut avoir des couches comme Modèle, Vue et Contrôleur.
Créez un artefact de code pour chaque couche, comme 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 besoin de lier la plupart des classes et d’autres artefacts aux couches, car ils font partie d’artefacts plus grands, comme 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 dépendances décrivant l’ensemble de 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
Quand vous avez modifié le diagramme, vous pouvez le valider manuellement par rapport au code à tout moment ou automatiquement chaque fois que faites une génération.
Consultez l'article :
Mettre à jour le code pour être conforme à la nouvelle architecture
En général, des erreurs apparaissent la première fois que vous validez le code par rapport à un diagramme de dépendances 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 le code avec des diagrammes de dépendances.
Notes
Quand vous développez ou refactorisez le code, vous pouvez avoir de nouveaux artefacts à lier au diagramme de dépendances. 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. Quand vous supprimez une erreur, la bonne pratique est de journaliser un élément de travail dans Team Foundation. Pour effectuer cette tâche, consultez Valider le code avec des diagrammes de dépendances.
Inclure la validation de couche dans le processus de génération
Pour que les changements de code futurs soient conformes aux diagrammes de dépendances, ajoutez la validation de couche au processus de génération standard de votre solution. Chaque fois que les autres membres d’équipe génèrent la solution, les différences entre les dépendances dans le code et le diagramme de dépendances sont signalées comme des erreurs de génération. Pour plus d’informations sur l’ajout de la validation de couche au processus de génération, consultez Valider du code avec des diagrammes de dépendances.