Mapper des dépendances avec des cartes de code

Dans cet article, vous allez apprendre à visualiser les dépendances entre votre code avec des mappages de code.

Qu’est-ce que les cartes de code ?

Dans Visual Studio, les mappages de code vous aident à voir plus rapidement comment votre code de programme s’adapte sans lire les fichiers et les lignes de code. Avec ces cartes, vous pouvez voir l’organisation et les relations dans votre code, y compris sa structure et ses dépendances, comment la mettre à jour et estimer le coût des modifications proposées.

Vous pouvez mapper des dépendances pour le code dans ces langages :

Visual C# ou Visual Basic dans une solution ou des assemblys (.dll ou .exe)
Code C ou C++ natif ou managé dans des projets Visual C++, des fichiers d’en-tête (.h ou #include) ou des fichiers binaires
Projets et assemblys X++ créés à partir de modules .NET pour Microsoft Dynamics AX

Note

Pour les projets autres que C# ou Visual Basic, il existe moins d’options pour démarrer un mappage de code ou ajouter des éléments à un mappage de code existant. Par exemple, vous ne pouvez pas cliquer avec le bouton droit sur un objet dans l’éditeur de texte d’un projet C++ et l’ajouter à un mappage de code. Toutefois, vous pouvez faire glisser-déplacer des éléments ou des fichiers de code individuels à partir de l’Explorateur de solutions, de l’affichage de classes et de l’Explorateur d’objets.

Prerequisites

Pour créer une carte de code dans Visual Studio, installez d’abord les composants Code Map et Live Dependency Validation

Pour créer et modifier des mappages de code, vous avez besoin de Visual Studio Enterprise Edition. Toutefois, dans les éditions Visual Studio Community et Professional, vous pouvez ouvrir des diagrammes générés dans l’édition Entreprise, mais vous ne pouvez pas les modifier.

Note

Avant de partager des cartes créées dans Visual Studio Enterprise avec d’autres utilisateurs de Visual Studio Professional, assurez-vous que tous les éléments de la carte (tels que les éléments masqués, les groupes développés et les liens entre groupes) sont visibles.

Ajouter un mappage de code

Vous pouvez créer un mappage de code vide et faire glisser des éléments vers celui-ci, y compris des références d’assembly, des fichiers et des dossiers, ou vous pouvez générer un mappage de code pour toute ou partie de votre solution.

Pour ajouter un mappage de code vide :

Dans l’Explorateur de solutions, ouvrez le menu contextuel de votre nœud de solution de niveau supérieur. Choisissez Ajouter un>nouvel élément.
Dans la boîte de dialogue Ajouter un nouvel élément , sous Installé, choisissez la catégorie Général .
Choisissez le modèle de document graph dirigé (.dgml), puis sélectionnez Ajouter.

Tip

Ce modèle peut ne pas apparaître par ordre alphabétique. Faites donc défiler vers le bas de la liste des modèles si vous ne le voyez pas.

Une carte vide s’affiche dans le dossier Éléments de solution de votre solution.

De même, vous pouvez créer un fichier de mappage de code sans l’ajouter à votre solution en sélectionnant Architecture>New Code Map ou File>New>File.

Pour en savoir plus:

Générer un mappage de code pour votre solution

Pour afficher toutes les dépendances dans votre solution :

Dans la barre de menus, choisissez Architecture>Generate Code Map for Solution. Si votre code n’a pas changé depuis la dernière fois que vous l’avez créé, vous pouvez sélectionner à la place Architecture>Générer une carte de code pour la solution sans génération.

Une carte est générée pour afficher les assemblages de niveau supérieur et les liens agrégés entre eux. Plus le lien d'agrégation est large, plus il représente de dépendances.
Utilisez le bouton Légende de la barre d’outils de la carte de code pour afficher ou masquer la liste des icônes de type projet (par exemple, Test, Web et Phone Project), des éléments de code (tels que Classes, Méthodes et Propriétés) et des types de relation (tels que Hériter, Implémenter et Appels).

Cet exemple de solution contient des dossiers de solutions (tests et composants), des projets de test, des projets web et des assemblys. Par défaut, toutes les relations d’isolement apparaissent sous forme de groupes, que vous pouvez développer et réduire. Le groupe Externals contient tout ce qui se trouve en dehors de votre solution, y compris les dépendances de plateforme. Les assemblages externes montrent uniquement les éléments utilisés. Par défaut, les types de base système sont masqués sur la carte pour réduire l’encombrement.
Pour descendre dans la hiérarchie de la carte, développez les groupes qui représentent des projets et des assemblys. Vous pouvez développer tout en appuyant sur Ctrl+A pour sélectionner tous les nœuds, puis en choisissant Grouper, Développez à partir du menu contextuel.
Toutefois, cela peut ne pas être utile pour une solution volumineuse. En fait, pour les solutions complexes, les limitations de mémoire peuvent vous empêcher de développer tous les groupes. Au lieu de cela, pour voir à l’intérieur d’un nœud individuel, dépliez-le. Déplacez le pointeur de la souris en haut du nœud, puis cliquez sur le chevron (flèche vers le bas) lorsqu’il apparaît.

Vous pouvez également utiliser le clavier en sélectionnant l’élément, puis en appuyant sur la touche plus (+). Pour explorer des niveaux de code plus approfondis, procédez de la même façon pour les espaces de noms, les types et les membres.

Tip

Pour plus d’informations sur l’utilisation des cartes de code à l’aide de la souris, du clavier et du toucher, consultez Parcourir et réorganiser les cartes de code.
Pour simplifier la carte et vous concentrer sur des parties individuelles, choisissez Filtres dans la barre d’outils du mappage de code et sélectionnez uniquement les types de nœuds et de liens qui vous intéressent. Par exemple, vous pouvez masquer tous les conteneurs de dossiers de solution et d’assembly.

Vous pouvez également simplifier la carte en masquant ou en supprimant des groupes et des éléments individuels de la carte, sans affecter le code de solution sous-jacent.
Pour afficher les relations entre les éléments, sélectionnez-les dans la carte. Les couleurs des liens indiquent les types de relation, comme indiqué dans le volet Légende .

Dans cet exemple, les liens violets sont des appels, les liens en pointillés sont des références et les liens bleu clair sont un accès au champ. Les liens verts peuvent être hérités, ou ils peuvent être des liens d’agrégation qui indiquent plusieurs types de relation (ou catégorie).

Tip

Si vous voyez un lien vert, cela peut ne pas signifier qu’il n’y a qu’une relation d’héritage. Il peut également exister des appels de méthode, mais ceux-ci sont masqués par la relation d’héritage. Pour afficher des types de liens spécifiques, utilisez les cases à cocher dans le volet Filtres pour masquer les types qui ne vous intéressent pas.
Pour obtenir plus d’informations sur un élément ou un lien, déplacez le pointeur sur celui-ci jusqu’à ce qu’une info-bulle apparaisse. Cela montre les détails d’un élément de code ou des catégories qu’un lien représente.
Pour examiner les éléments et les dépendances représentés par un lien d’agrégation, sélectionnez d’abord le lien, puis ouvrez son menu contextuel. Choisissez Afficher les liens de contribution (ou Afficher les liens contributeurs sur la nouvelle carte de code). Cela étend les groupes aux deux extrémités du lien et affiche uniquement les éléments et les dépendances qui participent au lien.
Pour vous concentrer sur des parties spécifiques de la carte, vous pouvez continuer à supprimer les éléments qui ne vous intéressent pas. Par exemple, pour analyser l’affichage des classes et des membres, filtrez simplement tous les nœuds d’espace de noms dans le volet Filtres .
Une autre façon de se concentrer sur une carte de solution complexe consiste à générer une nouvelle carte contenant des éléments sélectionnés à partir d’une carte existante. Maintenez la touche Ctrl enfoncée tout en sélectionnant les éléments sur lesquels vous souhaitez vous concentrer, ouvrez le menu contextuel, puis choisissez Nouveau graphique dans La sélection.
Le contexte est reporté sur la nouvelle carte. Masquer les dossiers de solution et les autres conteneurs que vous ne souhaitez pas voir à l’aide du volet Filtres .
Développez les groupes et sélectionnez des éléments dans la carte pour afficher les relations.

Voir aussi :

Parcourir et réorganiser des cartes de code
Personnaliser des mappages de code en modifiant les fichiers DGML
Trouver des problèmes potentiels dans votre code en exécutant un analyseur

Afficher les dépendances

Supposons que vous ayez une révision du code à effectuer dans certains fichiers avec des modifications en attente. Pour afficher les dépendances dans ces modifications, vous pouvez créer un mappage de code à partir de ces fichiers.

Capture d’écran montrant les dépendances sur une carte de code.

Faites glisser des éléments de l’Explorateur de solutions, de la vue de classe ou de l’Explorateur d’objets dans un mappage de code nouveau ou existant. Pour inclure la hiérarchie parente de vos éléments, appuyez longuement sur la touche Ctrl pendant que vous faites glisser des éléments, ou utilisez le bouton Inclure les parents dans la barre d’outils de carte de code pour spécifier l’action par défaut. Vous pouvez également faire glisser des fichiers d’assembly en dehors de Visual Studio, par exemple à partir de l’Explorateur Windows.

Note

Lorsque vous ajoutez des éléments à partir d’un projet partagé entre plusieurs applications, comme Windows Phone ou Microsoft Store, ces éléments apparaissent sur la carte avec le projet d’application actuellement actif. Si vous remplacez le contexte par un autre projet d’application et ajoutez d’autres éléments à partir du projet partagé, ces éléments apparaissent désormais avec le projet d’application nouvellement actif. Les opérations que vous effectuez avec un élément sur la carte s’appliquent uniquement aux éléments qui partagent le même contexte.
Le plan affiche les éléments sélectionnés dans leurs assemblages contenant.
Pour explorer les éléments, développez-les. Déplacez le pointeur de la souris en haut d’un élément, puis cliquez sur l’icône chevron (flèche bas) lorsqu’elle apparaît.

Pour développer tous les éléments, sélectionnez-les à l’aide de Ctrl+A, puis ouvrez le menu contextuel de la carte et choisissez Groupe>Développer. Toutefois, cette option n'est pas disponible si le déploiement de tous les groupes crée une carte inutilisable ou des problèmes de mémoire.
Continuez d'étendre les éléments qui vous intéressent, jusqu'au niveau de la classe et du membre si nécessaire.

Pour afficher les membres figurant dans le code, mais qui n’apparaissent pas sur la carte, cliquez sur l’icône dans le coin supérieur gauche d’un groupe.

Pour afficher d’autres éléments liés à ceux de la carte, sélectionnez-en un et choisissez Afficher associé dans la barre d’outils de la carte de code, puis sélectionnez le type d’éléments associés à ajouter à la carte. Vous pouvez également sélectionner un ou plusieurs éléments, ouvrir le menu contextuel, puis choisir l’option Afficher pour le type d’éléments associés à ajouter à la carte. Par exemple:

Pour un assemblage, choisissez :

Option	Description
Afficher les assemblies référencés par cette référence	Ajoutez les assemblys que cet assembly référence. Les assemblys externes apparaissent dans le groupe Externals .
Afficher les assemblies qui référencent celui-ci	Ajoutez les assemblys de la solution qui référencent cet assembly.

Pour un namespace, choisissez Afficher l'assembly contenant s’il n’est pas visible.

Pour une classe ou une interface, choisissez :

Option	Description
Afficher les types de base	Pour une classe, ajoutez la classe de base et les interfaces implémentées. Pour une interface, ajoutez les interfaces de base.
Afficher les types dérivés	Pour une classe, ajoutez les classes dérivées. Pour une interface, ajoutez les interfaces dérivées et les classes ou structs d’implémentation.
Afficher les types de ces références	Ajoutez toutes les classes et leurs membres que cette classe utilise.
Afficher les types faisant référence à ceci	Ajoutez toutes les classes et leurs membres qui utilisent cette classe.
Afficher l’espace de noms contenant	Ajoutez l’espace de noms parent.
Afficher l’espace de noms contenant et l’assembly conteneur	Ajoutez la hiérarchie du conteneur parent.
Afficher tous les types de base	Ajoutez la classe de base ou la hiérarchie d’interface de manière récursive.
Afficher tous les types dérivés	Pour une classe, ajoutez toutes les classes dérivées de manière récursive. Pour une interface, ajoutez toutes les interfaces dérivées et implémentez des classes ou des structs de manière récursive.

Pour une méthode, choisissez :

Option	Description
Afficher les méthodes que ceux-ci appellent	Ajoutez des méthodes que cette méthode appelle.
Afficher les champs qui sont référencés par cela	Ajoutez des champs référencés par cette méthode.
Afficher le type conteneur	Ajoutez le type parent.
Afficher le type conteneur, l’espace de noms contenant et l’assembly conteneur	Ajoutez la hiérarchie du conteneur parent.
Afficher les méthodes remplacées	Pour une méthode qui substitue d’autres méthodes ou implémente la méthode d’une interface, ajoutez toutes les méthodes abstraites ou virtuelles dans les classes de base substituées et, le cas échéant, la méthode de l’interface implémentée.

Pour un champ ou une propriété, choisissez :

Option	Description
Afficher le type contenant	Ajoutez le type parent.
Afficher le type, le namespace et l'assembly contenant	Ajoutez la hiérarchie du conteneur parent.

Capture d’écran montrant la commande pour afficher les méthodes.

La carte affiche les relations. Dans cet exemple, la carte montre les méthodes appelées par la Find méthode et leur emplacement dans la solution ou en externe.
Pour simplifier la carte et vous concentrer sur des parties individuelles, choisissez Filtres dans la barre d’outils du mappage de code et sélectionnez uniquement les types de nœuds et de liens qui vous intéressent. Par exemple, désactivez l’affichage des dossiers solution, des assemblys et des espaces de noms.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-04-23