Mapper les dépendances dans votre code dans des graphiques de dépendance

Article
06/10/2015

Quand vous voulez comprendre les dépendances présentes dans votre code, mappez-les avec Visual Studio Ultimate. Lorsque vous voulez comprendre les dépendances présentes dans l'ensemble de votre code, visualisez-les en créant les cartes de code (Visual Studio Ultimate uniquement). Vous pouvez ainsi voir comment le code s'ajuste sans avoir à parcourir les fichiers et les lignes de code.

Graphique avec des éléments sélectionnés et des groupes développés

Voici quelques vidéos :

Voici ce dont vous aurez besoin :

Visual Studio Ultimate 2013
Code de Visual C# .NET ou Visual Basic .NET dans une solution ou des assemblys (.dll ou .exe)
Code C ou C++ natif ou managé dans des projets, fichiers d'en-tête (.h ou #include) ou des fichiers binaires Visual C++
Visual Studio 2013 Update 3 pour mapper des dépendances dans :
- projets qui partagent du code entre plusieurs applications ;
- projets et assemblys X++ créés à partir de modules .NET pour Microsoft Dynamics AX.
Vous pouvez également faire glisser des assemblys et des fichiers binaires à partir de l'Explorateur Windows vers un graphique existant et obtenir des relations à code de couleurs.

Démarrez ici :

Pour voir les dépendances globales dans votre solution, accédez au menu Architecture. Cliquez sur Générer un graphique de dépendance, Pour la solution.

ou
Pour voir les dépendances spécifiques dans votre solution, ouvrez l'Explorateur de solutions. Sélectionnez les projets, références d'assembly, dossiers, fichiers, types ou membres qui vous intéressent. Dans la barre d'outils Explorateur de solutions, cliquez sur Créer un document de graphique .

Vous pouvez aussi :

Visualiser les dépendances entre les fichiers sources et les fichiers d'en-tête C ou C++
Partager des graphiques de dépendance
Créer des graphiques par programmation

Visualiser les dépendances globales

Visualiser les dépendances dans votre solution

Dans le menu Architecture, cliquez sur Générer un graphique de dépendance, Pour la solution.

Vous obtenez un graphique qui affiche les assemblys de niveau supérieur et les liens globaux qui les lient. Plus le lien global est large, plus il représente de dépendances. Le groupe Externes contient les éléments qui ne font pas partie de votre solution, notamment les dépendances de plateforme. Les assemblys externes affichent uniquement les éléments utilisés.
Pour voir l'intérieur d'un assembly, développez-le. Déplacez le pointeur de la souris au-dessus d'un assembly, puis cliquez sur le chevron (^) quand il apparaît. (Raccourci : sélectionnez l'élément, puis appuyez sur la touche PLUS (+).) Pour explorer des niveaux plus profonds de code, procédez de même pour les espaces de noms, les types et les membres.

Par défaut, les relations d'imbrication apparaissent sous forme de groupes que vous pouvez développer et réduire. Pour visualiser les relations de groupe sous forme de liens, dans le menu contextuel du graphique, cliquez sur Groupe, Désactiver le regroupement.
Pour examiner les éléments et les dépendances représentés par un lien global, sélectionnez d'abord le lien, puis ouvrez son menu contextuel. Cliquez sur Afficher, Liens de contribution dans le diagramme actuel ou Liens de contribution dans un nouveau diagramme.

Visual Studio développe les groupes aux deux extrémités du lien et affiche uniquement les éléments et les dépendances qui participent au lien.
Pour obtenir plus d'informations sur un élément ou un lien, déplacez le pointeur en haut de l'élément jusqu'à ce qu'une info-bulle apparaisse. Elle présente les catégories qu'un lien représente.
Pour savoir ce que signifie la couleur du lien, dans la barre d'outils du graphique, cliquez sur Légende.

Si vous voyez un lien vert, il ne signifie peut-être pas qu'il existe simplement 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 les dépendances entre les membres dans les groupes, cliquez sur un élément dans le graphique.
Pour rechercher les éventuels problèmes dans votre code, exécutez un analyseur.

Reportez-vous à :

Visualiser les dépendances entre les assemblys ou fichiers binaires

Créez un graphique vide ou ouvrez le fichier d'un graphique existant (.dgml). En dehors de Visual Studio, faites glisser les assemblys ou les binaires vers le graphique.

Notes

Vous pouvez faire glisser des assemblys ou des binaires à partir de l'Explorateur Windows uniquement si vous disposez du même niveau d'autorisations de contrôle d'accès d'utilisateur (UAC) pour exécuter Windows Explorer et Visual Studio.Par exemple, si le contrôle de compte d'utilisateur est activé et que vous exécutez Visual Studio en tant qu'administrateur, l'Explorateur Windows bloquera l'opération glisser.Pour résoudre ce problème, assurez-vous que Visual Studio s'exécute en tant qu'administrateur ou désactivez le contrôle de compte d'utilisateur.Notez que dans Windows 8, l'Explorateur Windows est l'Explorateur de fichiers.

Créer un graphique vide

Dans l'Explorateur de solutions, ouvrez le menu contextuel du nœud racine de votre solution. Cliquez sur Ajouter, Nouvel élément.
Sous Installé, cliquez sur Général.
Dans le volet droit, cliquez sur Document de graphique orienté.

Vous disposez maintenant d'un graphique vide, qui apparaît dans le dossier Éléments de solution de votre solution.

Pour ouvrir un nouveau graphique vide sans l'ajouter à votre solution, dans le menu Fichier, cliquez sur Nouveau, Fichier.

Pour ajouter un graphique vide à un projet de modélisation, ouvrez le menu Architecture, cliquez sur Nouveau diagramme.

Q et R

Q : Pourquoi faut-il si longtemps pour créer le graphique ?

R : Quand vous générez un graphique pour la première fois, Visual Studio indexe toutes les dépendances qu'il trouve. Ce processus peut prendre un certain temps, en particulier pour les grandes solutions, mais il améliore les performances ultérieures. Si votre code change, Visual Studio réindexe uniquement le code mis à jour. Si vous ne voulez pas attendre la fin du graphique, vous pouvez annuler cette étape à tout moment et essayer ce qui suit :

Effectuez un graphique des dépendances qui vous intéressent uniquement.
Avant de générer le graphique pour une solution entière, limitez la portée de la solution.

Bien que Visual Studio puisse fonctionner avec 1 Go de mémoire, nous recommandons que votre ordinateur ait au moins 2 Go de mémoire pour éviter des retards importants lorsque Visual Studio crée l'index de code et génère le graphique.

Lorsque la propriété Copier dans le répertoire de sortie d'un élément de projet a la valeur Toujours copier, la création de graphiques ou l'ajout d'éléments à un graphique à partir de l'explorateur de solutions peut prendre plus de temps. Les problèmes liés aux builds incrémentielles et à Visual Studio peuvent provoquer la régénération du projet à chaque fois. Pour accroître les performances, remplacez la valeur de cette propriété par Copier si plus récent ou PreserveNewest. Consultez Builds incrémentielles.

Q : Pourquoi Visual Studio n'a pas créé mon graphique ?

R : Peut-être parce qu'aucun des projets de votre solution n'ont été créés correctement. Visual Studio génère un graphique si au moins un projet est correctement généré. Le graphique présente les dépendances uniquement pour le code correctement généré. Si des erreurs de build se produisent pour certains composants, alors ces erreurs apparaissent sur le graphique. Assurez-vous qu'un composant est réellement généré et qu'il a des dépendances avant de prendre des décisions architecturales basées sur le graphique.

Visualiser les dépendances spécifiques

Par exemple, supposons que vous deviez réviser du code dans certains fichiers contenant des modifications en attente. Pour visualiser les dépendances dans ces modifications, créez un graphique de dépendance à partir de ces fichiers.

Graphique de dépendance avec des nœuds regroupés

Visualiser les dépendances spécifiques dans votre solution

Ouvrez l'Explorateur de solutions. Sélectionnez les projets, références d'assembly, dossiers, fichiers, types et membres qui vous intéressent.
Créez un graphique de vos éléments et de leurs membres. Dans la barre d'outils Explorateur de solutions, cliquez sur Créer un document de graphique .

Pour rechercher les éléments qui ont des dépendances sur les types ou les membres, ouvrez le menu contextuel du type ou du membre depuis l'Explorateur de solutions. Cliquez sur le type de dépendance. Sélectionnez ensuite les résultats.

Pour inclure les hiérarchies parentes avec vos éléments, dans la barre d'outils Explorateur de solutions, ouvrez la liste Créer un document de graphique.... Cliquez sur Nouveau graphique de dépendance avec des ancêtres.

Vous pouvez également faire glisser des éléments vers un graphique vide ou existant. Pour créer un graphique vide, dans le menu Fichier, choisissez Nouveau, Fichier, Document de graphique orienté. Pour inclure la hiérarchie parente de vos éléments, appuyez sur la touche Ctrl et maintenez-la enfoncée pendant que vous faites glisser les éléments.

Notes

Lorsque vous ajoutez des éléments à partir d'un projet partagé par plusieurs applications, comme Windows Phone ou Windows Store, ces éléments apparaissent sur la carte avec le projet d'application actif.Si vous modifiez le contexte vers un autre projet d'application et ajoutez des éléments à partir du projet partagé, ces éléments apparaissent alors avec le projet d'application qui vient d'être activé.Les opérations que vous effectuez avec un élément de la carte s'appliquent uniquement aux éléments qui partagent le même contexte.
Pour explorer des éléments, développez-les. Déplacez le pointeur de la souris en haut d'un élément, puis cliquez sur le chevron (^) lorsqu'il apparaît. Pour développer tous les éléments, ouvrez le menu contextuel du graphique. Cliquez sur Groupe, Développer tout.

Notes

Cette option n'est pas disponible si le développement de tous les groupes crée un graphique inutilisable ou des problèmes de mémoire.
Pour visualiser les membres qui sont dans le code mais qui n'apparaissent pas sur le graphique, cliquez sur Récupérer à nouveau les enfants . Ces membres du groupe s'affichent avec un style différent afin que vous puissiez les voir plus facilement. Consultez Modifier et personnaliser des graphiques de dépendance.

Pour visualiser les autres éléments associés à un élément du graphique, ouvrez son menu contextuel. Cliquez sur Afficher et le type de relation qui vous intéresse.

Pour un assembly, cliquez sur :

Assemblys référencés	Ajoutez les assemblys que cet assembly référence. Les assemblys externes apparaissent dans le groupe Externes.
Référencement d'assemblys	Ajoutez les assemblys de la solution qui référencent cet assembly.

Pour une classe, cliquez sur :

Types de base	Pour une classe, ajoutez la classe de base et les interfaces implémentées. Pour une interface, ajoutez des interfaces de base.
Types dérivés	Pour une classe, ajoutez des classes dérivées. Pour une interface, ajoutez les interfaces dérivées et les structures et classes d'implémentation.
Tous les types de base	Ajoutez la hiérarchie de classe de base ou d'interface de manière récursive.
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 les structures et classes d'implémentation de manière récursive.
Hiérarchie de contenance	Ajoutez la hiérarchie de conteneurs parents.
Types utilisés	Ajoutez toutes les classes, avec leurs membres, que cette classe utilise.
Types Used-By	Ajoutez toutes les classes, avec leurs membres, qui utilisent cette classe.

Pour une méthode, cliquez sur :

Hiérarchie de contenance	Ajoutez la hiérarchie de conteneurs parents.
Méthodes appelées	Ajoutez les méthodes que cette méthode appelle.
Méthodes appelées par	Ajoutez les méthodes qui appellent cette méthode.
Méthodes substituées dans les types de base	Pour une méthode qui remplace 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 qui sont substituées et, le cas échéant, la méthode de l'interface implémentée.
Champs référencés	Ajoutez les champs que cette méthode référence.

Pour une champ, cliquez sur :

Hiérarchie de contenance	Ajoutez la hiérarchie de conteneurs parents.
Méthodes de référence	Ajoutez les méthodes qui référencent ce champ.

Visualiser les dépendances spécifiques dans les assemblys ou les fichiers binaires

Dans le menu Architecture, cliquez sur Fenêtres, Navigateur de l'architecture.
Dans la première colonne, sous Système de fichiers, cliquez sur Sélectionner les fichiers.
Dans la zone Ouvrir, recherchez et sélectionnez les assemblys ou les binaires. Cliquez sur Ouvrir pour les ajouter à la colonne suivante dans le Navigateur de l'architecture.
Dans la colonne suivante, sélectionnez les assemblys ou les binaires.

Par défaut, la colonne suivante affiche les éléments contenus dans les éléments sélectionnés.

Conseil

Pour sélectionner d'autres éléments associés, développez la colonne réduite qui est située à droite de la colonne comportant vos sélections.Sous Navigation des nœuds, sélectionnez les genres d'éléments voulus.Sous Navigation sortante ou Navigation entrante, sélectionnez les genres de relations voulus.Consultez Rechercher du code avec le navigateur de l'architecture.
Recherchez et sélectionnez tous les éléments que vous souhaitez mettre sur le graphique.
Pour créer un graphique, dans la barre d'outils Navigateur de l'architecture, cliquez sur Créer un document de graphique à partir de tous les nœuds sélectionnés .

ou

Pour ajouter votre sélection à un graphique, suivez les étapes ci-après :
1. Ouvrez le fichier .dgml du graphique existant ou créez un graphique vide.
2. Dans la barre d'outils du Navigateur de l'architecture, cliquez sur Ajouter tous les nœuds sélectionnés au document de graphique visible actuellement .
  
  ou
  
  Faites glisser les éléments à partir du Navigateur de l'architecture vers le graphique.

Visualiser les dépendances entre les fichiers sources et les fichiers d'en-tête C et C++

Si vous voulez créer des graphiques plus complets pour des projets C++, définissez l'option du compilateur d'informations de consultation (/FR) sur ces projets. Consultez /FR, /Fr (Créer un fichier .sbr). Sinon, un message vous invite à définir cette option. Si vous sélectionnez OK, l'option est définie uniquement pour le graphique actif. Vous pouvez choisir de masquer le message pour tous les graphiques ultérieurs. Si vous masquez ce message, vous pouvez le faire réapparaître. Affectez à la clé de Registre suivante la valeur 0 ou supprimez-la :

HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\12.0\NativeProvider : AutoEnableSbr

Lorsque vous ouvrez une solution qui contient des projets Visual C++, la mise à jour de la base de données IntelliSense peut prendre un certain temps. Pendant ce temps, il est impossible de créer des graphiques de dépendance pour les fichiers d'en-tête (.h ou #include) tant que la base de données IntelliSense ne termine pas la mise à jour. Vous pouvez surveiller la progression des mises à jour dans la barre d'état de Visual Studio. Pour résoudre les problèmes ou messages qui s'affichent en raison de la désactivation de certains paramètres IntelliSense, consultez Résoudre les problèmes liés aux graphiques dans le code C et C++.

Pour visualiser les dépendances entre tous les fichiers sources et fichiers d'en-tête de votre solution, dans le menu Architecture, cliquez sur Générer un graphique de dépendance, Pour le fichier Include.
Pour visualiser les dépendances entre le fichier actuellement ouvert et les fichiers sources et fichiers d'en-tête associés, ouvrez soit le fichier source, soit le fichier d'en-tête. Ouvrez le menu contextuel n'importe où dans le fichier. Cliquez sur Générer le graphique des fichiers Include.

Résoudre les problèmes liés aux graphiques dans le code C et C++

Ces éléments ne sont pas pris en charge pour le code C et C++ :

Les types de base n'apparaissent pas sur les graphiques qui incluent la hiérarchie parente.
La plupart des éléments de menu Affichage ne sont pas disponibles pour le code C et C++.

Ces problèmes peuvent se produire quand vous créez des graphiques de dépendance pour du code C ou C++ :

Problème	Causes possibles	Solution
Échec de la génération du graphique de dépendance.	Aucun projet de la solution n'a été généré correctement.	Résolvez les erreurs de build qui se sont produites, puis régénérez le graphique.
Visual Studio ne répond pas lorsque vous essayez de générer un graphique de dépendance dans le menu Architecture.	Le fichier de base de données du programme (.pdb) peut être endommagé. Un fichier .pdb stocke des informations de débogage, telles que des informations sur le type, la méthode et le fichier source.	Régénérez la solution puis recommencez.
Certains paramètres de la base de données de navigation IntelliSense sont désactivés.	Certains paramètres IntelliSense peuvent être désactivés dans la boîte de dialogue Visual Studio Options.	Activez les paramètres. Consultez Options, Éditeur de texte, C/C++, Avancé.
Le message Méthodes inconnues s'affiche sur un nœud de méthode. Ce problème se produit car le nom de la méthode ne peut pas être résolu.	Le fichier binaire peut ne pas avoir de table de réadressage de base.	Activez l'option /FIXED:NO dans l'éditeur de liens. Consultez /FIXED (Adresse de base fixe).
	Le fichier de base de données du programme (.pdb) peut ne pas être généré. Un fichier .pdb stocke des informations de débogage, telles que des informations sur le type, la méthode et le fichier source.	Activez l'option /DEBUG dans l'éditeur de liens. Consultez /DEBUG (Générer les informations de débogage).
	Impossible d'ouvrir ou de localiser le fichier .pdb aux emplacements attendus.	Assurez-vous que le fichier .pdb existe dans les emplacements attendus.
	Les informations de débogage ont été supprimées du fichier .pdb.	Si l'option /PDBSTRIPED a été utilisée dans l'éditeur de liens, incluez à la place le fichier .pdb complet. Consultez /PDBSTRIPPED (Supprimer les symboles privés).
	L'appelant n'est pas une fonction ; il correspond à un thunk dans le fichier binaire ou à un pointeur dans la section de données.	Lorsque l'appelant est un thunk, essayez d'utiliser _declspec(dllimport) pour éviter le thunk. Reportez-vous à : Règles générales et limitations Importation d'appels de fonctions à l'aide de __declspec(dllimport) dllexport, dllimport

Partager des graphiques de dépendance

Partager le graphique avec d'autres utilisateurs de Visual Studio

Utilisez le menu Fichier pour enregistrer le graphique.

ou

Pour enregistrer le graphique dans le cadre d'un projet spécifique, ouvrez le menu contextuel pour la surface du graphique. Cliquez sur Déplacer <DependencyGraphName.dgml> vers, ainsi que sur le projet où vous voulez enregistrer le graphique.

Visual Studio enregistre le graphique en tant que fichier .dgml que vous pouvez partager avec d'autres utilisateurs de Visual Studio Ultimate, Visual Studio Premium et Visual Studio Professional.

Notes

Avant de partager un graphique avec les utilisateurs de Visual Studio Premium et Visual Studio Professional, veillez à développer tous les groupes, nœuds cachés et liens entre les groupes, et à extraire les nœuds supprimés que vous souhaitez afficher sur votre graphique.Sinon, les utilisateurs ne pourront pas afficher ces éléments.

L'erreur suivante peut se produire lorsque vous enregistrez un graphique se trouvant dans un projet de modélisation ou ayant été copié à partir d'un projet de modélisation vers un autre emplacement.

« Impossible d'enregistrer fileName en dehors du répertoire du projet.Les éléments liés ne sont pas pris en charge. »

Visual Studio affiche l'erreur, mais crée quand même la version enregistrée.Pour éviter cette erreur, créez le graphique en dehors du projet de modélisation.Vous pouvez ensuite l'enregistrer à l'emplacement que vous souhaitez.Le fait de copier le fichier vers un autre emplacement de la solution, puis de tenter de l'enregistrer, ne fonctionnera pas.

Exporter le graphique en tant qu'image pour pouvoir le copier dans d'autres applications, telles que Microsoft Word ou PowerPoint

Ouvrez le menu contextuel de la surface du graphique. Cliquez sur Modifier, Copier l'image.
Collez l'image dans une autre application.

Exporter le graphique en tant que fichier XPS pour pouvoir le voir dans des visionneuses XML ou XAML comme Internet Explorer

Ouvrez le menu contextuel de la surface du graphique. Cliquez sur Enregistrer sous XPS.
Accédez à l'emplacement auquel enregistrer le fichier.
Nommez le graphique. Assurez-vous que la zone Type de fichier a la valeur Fichiers XPS (*.xps). Cliquez sur Enregistrer.

Créer des graphiques par programmation

Pour créer des documents de graphique (fichiers .dgml) afin de travailler pendant le traitement par lots, exécutez l'outil en ligne de commande GraphCmd.exe. Par exemple, vous pouvez exécuter l'outil après chaque build pour trouver les dépendances qui ont changé entre les builds. Cet outil se trouve dans le dossier : C:\Program Files\Microsoft Visual Studio 12.0\Common7\IDE.

GraphCmd.exe prend uniquement en charge le code .NET et ne génère les informations sur les dépendances que pour les assemblys ou les fichiers .dgml, et non pour le code source figurant dans une solution ou les fichiers projet Visual Studio. Comme GraphCmd.exe s'exécute en dehors de Visual Studio, la prise en charge des actions dans les requêtes DGQL est limitée.

Voici la syntaxe de GraphCmd.exe :

GraphCmd -? -all -exceptions -input File_Name -query File_Name -exec "DGQL_Statement" -output File_Name -path alias=path

Voici les options de GraphCmd.exe :

Vous pouvez spécifier ces options plusieurs fois : -input, -query, -exec et -path.

-?	Afficher l'aide de GraphCmd.exe.
-all	Inclure tous les résultats de requête intermédiaires, et pas seulement ceux du dernier ensemble de nœuds.
-exceptions	Signaler les exceptions de requête sous la forme d'un fichier de document de graphique (.dgml).
-input File_Name	Traiter le fichier .dgml spécifié. Cela s'avère utile lorsque vous procédez au post-traitement et filtrez un gros fichier .dgml, car vous pouvez le visualiser plus facilement dans Visual Studio.
-query File_Name	Exécuter le fichier .dgql (DGQL, Directed Graph Query Language) spécifié. Reportez-vous à : Rechercher du code avec le navigateur de l'architecture Fonctionnement du langage DGQL (Directed Graph Query Language)
-exec "DGQL_Statement"	Exécuter l'instruction DGQL spécifiée. Consultez Fonctionnement du langage DGQL (Directed Graph Query Language, DGQL).
-output File_Name	Obtenir la sortie du fichier .dgml spécifié.
-path alias=path	Spécifier un nouvel alias à utiliser dans l'entrée et la sortie de documents DGML. Par exemple : `GraphCmd -output MyGeneratedGraph.dgml -path "MyPathAlias=C:\Program Files\..."` Consultez Alias pour les chemins d'accès fréquemment utilisés.

Alias pour les chemins d'accès fréquemment utilisés

Les alias pour les chemins d'accès fréquemment utilisés réduisent la taille du fichier .dgml, ainsi que la durée nécessaire au téléchargement et à l'enregistrement du fichier. Pour créer un alias, ajoutez une section <Paths></Paths> à la fin du fichier .dgml. Dans cette section, ajoutez un élément <Path/> pour définir un alias pour le chemin d'accès :

<Paths>
   <Path Id="MyPathAlias" Value="C:\...\..." />
</Paths>

Pour référencer l'alias à partir d'un élément du fichier .dgml, mettez l'Id de l'élément <Path/> entre parenthèses (()) et faites précéder le tout du signe dollar ($) :

<Nodes>
   <Node Id="MyNode" Reference="$(MyPathAlias)MyDocument.txt" />
</Nodes>
<Properties>
   <Property Id="Reference" Label="My Document" DataType="System.String" IsReference="True" />
</Properties>

Pour modifier les fichiers .dgml, consultez Modifier et personnaliser des graphiques de dépendance.

En savoir plus sur le langage DGQL (Directed Graph Query Language)

Le langage DGQL est un langage de requêtes simplifié que vous pouvez utiliser pour générer du code DGML. Une instruction DGQL suit un modèle alternant une sélection de nœuds et des actions, de sorte que chaque sélection de nœuds crée l'entrée de l'action suivante, dont la sortie devient l'entrée de la sélection de nœuds suivante, et ainsi de suite.

Le format d'une instruction DGQL est le suivant :

<node selection> / <action> / <node selection> / <action> / ...

Le tableau suivant décrit la syntaxe DGQL utilisée pour sélectionner des nœuds :

*	Sélectionner tous les nœuds.
+ "text"	Sélectionner tous les nœuds qui contiennent "text".
+ Id.Equals("text")	Sélectionnez tous les nœuds dont Id a la valeur "text".
+ Background.Contains("text")	Sélectionner tous les nœuds dont l'attribut Background a une valeur qui contient la chaîne "text".
+ "text1" + "text2" + ...	Sélectionner tous les nœuds qui correspondent à "text1" ou "text2".
+ MyProperty="True"	Sélectionner tous les nœuds qui ont une propriété nommée MyProperty dont la valeur est "True".
- Label.Contains("text")	Sélectionner tous les nœuds, sauf ceux qui ont un attribut Label qui contient (Contains) la chaîne "text".
+ Category.Is("MyCategory")	Sélectionner tous les nœuds qui ont une catégorie nommée MyCategory ou qui héritent de MyCategory.

Le tableau suivant décrit des exemples d'actions directes pouvant être exécutées sur les nœuds sélectionnés :

Exemple d'action	Description
Microsoft.Contains	Retourner tous les nœuds qui sont contenus par les nœuds d'entrée. Vous pouvez remplacer Contains par une autre catégorie de lien.
Microsoft.Open	Ouvrir le code source des nœuds d'entrée. Notes Fonctionne uniquement dans Visual Studio.
Microsoft.AllOutBoundLinks	Retourner tous les nœuds qui sont la cible d'un lien sortant à partir des nœuds d'entrée.
Microsoft.AllInboundLinks	Retourner tous les nœuds qui sont l'extrémité source d'un lien vers les nœuds d'entrée.
Microsoft.Core.CreateGroupsByProperties	Appeler l'action GroupByProperties.
Microsoft.AllNodes	Retourner tous les nœuds figurant jusqu'ici dans l'ensemble du graphique.

Les actions pilotées par des données sélectionnent des éléments qui reposent uniquement sur les données figurant dans les nœuds d'entrée et les liens. Lorsque des catégories sont mises en correspondance grâce aux actions pilotées par des données, les catégories héritées sont incluses. Le tableau suivant décrit des exemples d'actions pilotées par des données :

Type	Description
Node:Both:Category	Retourner tous les nœuds qui possèdent la catégorie Category et qui sont reliés aux nœuds d'entrée par un lien qui pointe vers l'une ou l'autre direction.
Link:Both:Category	Retourner tous les nœuds qui sont reliés aux nœuds d'entrée par un lien qui pointe vers l'une ou l'autre direction et qui possèdent la catégorie Category.
Link:Backward:Category	Retourner tous les nœuds qui pointent vers les nœuds d'entrée ayant un lien qui possède la catégorie Category.
Link:Forward:Category	Retourner tous les nœuds qui pointent à partir des nœuds d'entrée ayant un lien qui possède la catégorie Category.

Conseils

En général, une action « par défaut » est définie pour un ensemble donné de nœuds d'entrée ; celle-ci est automatiquement sélectionnée par le Navigateur de l'architecture. Pour obtenir le même comportement, utilisez une action vide : //
Comme l'espace blanc n'est pas significatif en langage DGQL, vous pouvez mettre en forme votre requête de telle sorte qu'elle tienne sur une seule ligne si nécessaire. Cela est utile quand vous utilisez l'option –exec avec GraphCmd.
Lorsque vous déboguez du code DGQL, utilisez l'action "Execute Expanded" dans le Navigateur de l'architecture pour afficher chaque étape de la requête et repérer l'étape qui ne produit pas les résultats attendus.

Exemple

L'instruction DGQL suivante exécute une requête décrite dans les étapes ci-dessous :

+ Id.Equals("Microsoft.Solution.ClassView") / "Microsoft.Solution.ClassView" / * / "Node:Both:CodeSchema_Class" / + CodeSchemaProperty_IsPublic.Equals("True")

Cliquez sur le nœud Affichage de classes de la première colonne du Navigateur de l'architecture.
Exécutez l'action "Microsoft.Solution.ClassView" pour retourner tous les espaces de noms de la solution.
Utilisez * pour sélectionner tous les espaces de noms.
Sélectionnez tous les nœuds de catégorie CodeSchema_Class, associés à ces espaces de noms par un lien dans un sens ou dans l'autre. Ce seront généralement des liens de relation contenant-contenu.
Filtrez les classes résultantes pour ne conserver que celles qui possèdent la propriété CodeSchemaProperty_IsPublic="True".

L'action "Microsoft.Solution.ClassView" est techniquement inutile, car il s'agit de l'action « par défaut » du nœud Affichage de classes. Vous pouvez par conséquent remplacer cette action par // pour simplifier la requête et la mettre en forme sur une seule ligne de la manière suivante :

+Id.Equals("Microsoft.Solution.ClassView")//*/"Node:Both:CodeSchema_Class"/+CodeSchemaProperty_IsPublic.Equals("True")

Que puis-je faire d'autre ?

Où peut-on obtenir plus d'informations ?

Catégorie	Liens
Forums	Outils de visualisation et de modélisation Visual Studio
Blogs	Graphiques de dépendance et DGML Comment comprendre votre code à l'aide des graphiques de dépendance, des diagrammes de séquence et du navigateur de l'architecture Améliorations apportées au mappage de code dans Visual Studio Ultimate 2013 Update 3 CTP1

Partager via