Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Mappare le dipendenze nel codice su grafici di dipendenze

Per comprendere le dipendenze nel codice, mapparle con Visual Studio Ultimate. In questo modo è possibile vedere il funzionamento complessivo del codice senza leggere file e righe di codice.

Grafico con elementi selezionati e gruppi espansi

Ecco alcuni video:

Ecco cosa è necessario:

  • Visual Studio Ultimate 2013

  • Codice di Visual C# .NET o di Visual Basic .NET in una soluzione o in assembly (.dll o .exe)

  • Codice C o C++ nativo o gestito in progetti Visual C++, file di intestazione (.h o #include) o file binari

  • Visual Studio 2013 Update 3 per mappare le dipendenze in:

    • Progetti che condividono codice tra più app

    • Progetti X++ e assembly creati da moduli .NET per Microsoft Dynamics AX

    È anche possibile trascinare assembly e file binari da Esplora risorse in un grafico esistente e ottenere relazioni contraddistinte dal colore.

Iniziare qui:

  • Per visualizzare le dipendenze complessive nella soluzione, andare al menu Architettura. Scegliere Genera grafico dipendenze, Per soluzione.

    -oppure-

  • Per visualizzare le dipendenze specifiche nella soluzione, aprire open Esplora soluzioni. Selezionare i progetti, i riferimenti agli assembly, le cartelle, i file, i tipi o i membri di proprio interesse. Nella barra degli strumenti di Esplora soluzioni scegliere Crea un nuovo documento grafico.

È possibile anche:

Dd409453.collapse_all(it-it,VS.120).gifVisualizzare le dipendenze nella soluzione

  1. Scegliere Genera grafico dipendenze dal menu Architettura, quindi Per soluzione.

    Viene visualizzato un grafico che mostra gli assembly di primo livello e i relativi collegamenti aggregati. A una maggiore ampiezza del collegamento aggregato corrisponde un maggior numero di dipendenze che rappresenta. Il gruppo Esterni contiene qualsiasi elemento esterno alla soluzione, incluse le dipendenze della piattaforma. Gli assembly esterni mostrano solo gli elementi usati.

    Grafico dipendenze di primo livello di assembly
  2. Per vedere all'interno di un assembly, espanderlo. Spostare il puntatore del mouse sopra un assembly, quindi scegliere pulsante con la freccia di espansione (^) quando viene visualizzato (tastiera: selezionare l'elemento, quindi premere PIÙ (+)). Per esplorare i livelli più profondi di codice, effettuare la stessa operazione per gli spazi dei nomi, i tipi e i membri.

    Grafico di dipendenze con nodi raggruppati

    Per impostazione predefinita, le relazioni del contenitore vengono visualizzate come gruppi che è possibile espandere e comprimere. Per visualizzare le relazioni di gruppo come collegamenti, nel menu di scelta rapida del grafico fare clic su Gruppo, Disabilita raggruppamento.

    Grafico di dipendenze con nodi e collegamenti

  3. Per esaminare gli elementi e le dipendenze rappresentate da un collegamento di aggregazione, selezionare il collegamento, quindi aprire il menu di scelta rapida. Fare clic su Mostra, Collegamenti partecipanti nel diagramma corrente o Collegamenti partecipanti in un nuovo diagramma.

    In Visual Studio i gruppi vengono espansi a entrambe le estremità del collegamento e vengono mostrati solo gli elementi e le dipendenze che partecipano al collegamento.

  4. Per ottenere altre informazioni su un elemento o un collegamento, spostare il puntatore sull'elemento finché non viene visualizzata una descrizione comando. In questo modo vengono mostrate le categorie rappresentate da un collegamento.

  5. Per visualizzare il significato di un colore, scegliere Legenda sulla barra degli strumenti del grafico.

    Se viene visualizzato un collegamento verde, non necessariamente esiste solo una relazione di ereditarietà. Potrebbero essere presenti anche chiamate al metodo, nascoste dalla relazione di ereditarietà.

  6. Per visualizzare le dipendenze tra membri all'interno di gruppi, scegliere un elemento del grafico.

    Grafico con elementi selezionati e gruppi espansi

  7. Per trovare potenziali problemi nel codice, eseguire un analizzatore.

Vedere:

Dd409453.collapse_all(it-it,VS.120).gifVisualizzare le dipendenze tra assembly o file binari

  • Creare un grafico vuoto o aprire un grafico esistente (file con estensione dgml). Dall'esterno di Visual Studio trascinare gli assembly o i file binari nel grafico.

    Nota Nota

    È possibile trascinare assembly o binari da Esplora risorse solo se Esplora risorse e Visual Studio vengono eseguiti allo stesso livello di autorizzazione del controllo di accesso utente. Se ad esempio il controllo di accesso utente è attivato e si esegue Visual Studio come amministratore, l'operazione di trascinamento verrà bloccata da Esplora risorse. Per risolvere questo problema, assicurarsi di eseguire Visual Studio come amministratore o disattivare Controllo dell'account utente. Si noti che in Windows 8, Esplora risorse è Esplora file.

Dd409453.collapse_all(it-it,VS.120).gifCreare un grafico vuoto

  1. In Esplora soluzioni aprire il menu di scelta rapida per il nodo della soluzione di primo livello. Scegliere Aggiungi, Nuovo elemento.

  2. In Installato scegliere Generale.

  3. Nel riquadro di destra scegliere Documento grafico diretto.

    Ora si ha un grafico vuoto, che viene visualizzato nella cartella Elementi di soluzione della soluzione.

    Per aprire un nuovo grafico vuoto senza aggiungerlo alla soluzione, scegliere Nuovo dal menu File, quindi scegliere File.

    Per aggiungere un grafico vuoto a un progetto di modello, aprire il menu Architettura e scegliere Nuovo diagramma.

Dd409453.collapse_all(it-it,VS.120).gifDomande e risposte

Dd409453.collapse_all(it-it,VS.120).gifD: Perché la creazione del grafico richiede molto tempo?

R: Quando si genera un grafico per la prima volta, Visual Studio indicizza tutte le dipendenze trovate. Questo processo potrebbe richiedere molto tempo, soprattutto per le soluzioni di grandi dimensioni, ma ciò migliorerà le prestazioni successive. Se il codice viene modificato, Visual Studio reindicizza solo il codice aggiornato. Se non si vuole attendere che il grafico completi la generazione dell'indice, è possibile annullare questo passaggio in qualsiasi momento ed effettuare invece operazioni seguenti:

Sebbene Visual Studio sia in grado di funzionare con 1 GB di memoria, è consigliabile che il computer disponga di almeno 2 GB di memoria per evitare lunghi ritardi quando viene creato l'indice del codice e viene generato il grafico.

La creazione di grafici o l'aggiunta di elementi a un grafico da Esplora soluzioni potrebbe richiedere più tempo quando la proprietà Copia in directory di output di un elemento di progetto è impostata su Copia sempre. Ciò potrebbe causare problemi nelle compilazioni incrementali e in Visual Studio per ricompilare il progetto ogni volta. Per aumentare le prestazioni, impostare questa proprietà su Copia se più recente o su PreserveNewest. Vedere Compilazioni incrementali.

Dd409453.collapse_all(it-it,VS.120).gifD: Perché Visual Studio non ha creato il grafico?

R: Questo problema potrebbe verificarsi perché nessuno dei progetti della soluzione è stato compilato correttamente. In Visual Studio viene generato un grafico se almeno un progetto è compilato correttamente. Il grafico mostrerà le dipendenze solo per il codice compilato correttamente. Se si verificano errori di compilazione per determinati componenti, tali errori vengono visualizzati nel grafico. Assicurarsi quindi che un componente venga effettivamente compilato e disponga di dipendenze prima di prendere decisioni a livello di architettura in base al grafico.

Si supponga, ad esempio, di dover eseguire una revisione del codice in alcuni file con modifiche in sospeso. Per visualizzare le dipendenze in queste modifiche, creare un grafico di dipendenze da tali file.

Grafico di dipendenze con nodi raggruppati

Dd409453.collapse_all(it-it,VS.120).gifVisualizzare dipendenze specifiche nella soluzione

  1. Aprire Esplora soluzioni. Selezionare i progetti, i riferimenti agli assembly, le cartelle, i file, i tipi e i membri di proprio interesse.

  2. Rappresentare graficamente gli elementi e i relativi membri. Nella barra degli strumenti di Esplora soluzioni scegliere Crea un nuovo documento grafico.

    Per trovare elementi con dipendenze da tipi o membri, aprire il menu di scelta rapida del tipo o del membro da Esplora soluzioni. Scegliere il tipo di dipendenza, quindi selezionare i risultati.

    Come visualizzare codice specifico

    Per includere le gerarchie padre con gli elementi, nella barra degli strumenti Esplora soluzioni aprire l'elenco Creare un nuovo documento grafico.... Scegliere Nuovo grafico di dipendenze con predecessori.

    Come visualizzare codice specifico ed elementi padre

    È anche possibile trascinare elementi in un grafico vuoto o esistente. Per creare un grafico vuoto, dal menu File scegliere Nuovo, File e infine Documento grafico diretto. Per includere la gerarchia padre per gli elementi, tenere premuto CTRL quando si trascinano gli elementi.

    Nota Nota

    Quando si aggiungono elementi da un progetto condiviso in più applicazioni, ad esempio Windows Phone o Windows Store, tali elementi vengono visualizzati nella mappa insieme al progetto di applicazione attivo. Se si cambia il contesto passando a un altro progetto di applicazione e si aggiungono altri elementi dal progetto condiviso, tali elementi vengono visualizzati con il nuovo progetto di applicazione attivo. Le operazioni eseguite con un elemento nella mappa si applicano solo agli elementi che condividono lo stesso contesto.

  3. Per esplorare gli elementi, espanderli. Spostare il puntatore del mouse sopra un elemento, quindi scegliere il pulsante con la freccia di espansione (^) quando viene visualizzato. Per espandere tutti gli elementi, aprire il menu di scelta rapida del grafico. Scegliere Gruppo, Espandi tutto.

    Nota Nota

    Questa opzione non è disponibile se l'espansione di tutti i gruppi crea un grafico inutilizzabile o problemi di memoria.

  4. Per visualizzare membri presenti nel codice ma che non appaiono nel grafico, scegliere Recupera di nuovo figli. Questi membri del gruppo vengono visualizzati con uno stile diverso per poterli vedere più facilmente. Vedere Modificare e personalizzare grafici dipendenze.

  5. Per visualizzare altri elementi correlati agli elementi del grafico, aprire il menu di scelta rapida di tali elementi. Scegliere Mostra e il tipo di relazione di proprio interesse.

    Per un assembly scegliere:

    Assembly a cui viene fatto riferimento

    Aggiungere gli assembly a cui fa riferimento questo assembly. Gli assembly esterni vengono visualizzati nel gruppo Esterni.

    Assembly di riferimento

    Aggiungere gli assembly della soluzione che fanno riferimento a questo assembly.

    Per una classe scegliere:

    Tipi base

    Per una classe, aggiungere la classe base e le interfacce implementate.

    Per un'interfaccia, aggiungere le interfacce di base.

    Tipi derivati

    Per una classe, aggiungere le classi derivate.

    Per un'interfaccia, aggiungere le interfacce derivate e le classi o gli struct implementati.

    Tutti i tipi di base

    Aggiungere la gerarchia di interfacce o di classi base in modo ricorsivo.

    Tutti i tipi derivati

    Per una classe, aggiungere tutte le classi derivate in modo ricorsivo.

    Per un'interfaccia, aggiungere tutte le interfacce derivate e implementare classi o struct in modo ricorsivo.

    Gerarchia di contenimento

    Aggiungere la gerarchia del contenitore padre.

    Tipi usati

    Aggiungere tutte le classi e i membri usati.

    Tipi Used-By

    Aggiungere tutte le classi e membri che usano la classe.

    Per un metodo scegliere:

    Gerarchia di contenimento

    Aggiungere la gerarchia del contenitore padre.

    Metodi chiamati

    Aggiungere metodi chiamati dal metodo specifico.

    Chiamato da metodi

    Aggiungere metodi che chiamano il metodo specifico.

    Metodi sottoposti a override nei tipi di base

    Per un metodo che esegue l'override di altri metodi o implementa un metodo di interfaccia, aggiungere tutti i metodi astratti o virtuali nelle classi base sottoposte a override e, se disponibile, il metodo di interfaccia implementato.

    Campi a cui si fa riferimento

    Aggiungere i campi cui questo metodo fa riferimento.

    Per un campo scegliere:

    Gerarchia di contenimento

    Aggiungere la gerarchia del contenitore padre.

    Metodi di riferimento

    Aggiungere metodi che fanno riferimento al campo.

Dd409453.collapse_all(it-it,VS.120).gifVisualizzare dipendenze specifiche in assembly o file binari

  1. Nel menu Architettura scegliere Finestre, Esplora architettura.

  2. Nella prima colonna fare clic su Seleziona file in File system.

  3. Nella casella Apri individuare e selezionare gli assembly o i file binari. Scegliere Apri per aggiungerli alla colonna successiva in Esplora architettura.

  4. Nella colonna successiva selezionare gli assembly o i file binari.

    Per impostazione predefinita, nella colonna successiva vengono mostrati gli elementi contenuti dagli elementi selezionati.

    Suggerimento Suggerimento

    Per selezionare gli altri elementi correlati, espandere la colonna compressa a destra della colonna contenente le selezioni. In Navigazione nodi selezionare i tipi di elementi che interessano. In Navigazione esterna o Navigazione interna selezionare i tipi di relazioni che interessano. Vedere Trovare codice con Esplora architettura.

  5. Individuare e selezionare tutti gli elementi da inserire nel grafico.

  6. Per creare un nuovo grafico, sulla barra degli strumenti di Esplora architettura scegliere Crea un nuovo documento grafico da tutti i nodi selezionati.

    -oppure-

    Per aggiungere la selezione al grafico, procedere come illustrato di seguito.

    1. Aprire il file con estensione dgml di un grafico o creare un grafico vuoto.

    2. Sulla barra degli strumenti di Esplora architettura scegliere Aggiunge tutti i nodi selezionati al documento grafico attualmente visibile.

      -oppure-

      Trascinare gli elementi da Esplora architettura nel grafico.

Per creare grafici più completi per i progetti C++, impostare l'opzione del compilatore di informazioni di visualizzazione (/FR) su tali progetti. Vedere /FR, /Fr (Crea file sbr). In caso contrario, viene visualizzato un messaggio con la richiesta di impostare l'opzione. Se si seleziona OK, l'opzione viene impostata solo per il grafico corrente. È possibile scegliere di nascondere il messaggio per tutti i grafici successivi. Se si nasconde il messaggio, è possibile visualizzarlo nuovamente. Impostare la seguente chiave del Registro di sistema su 0 o eliminare la chiave:

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

Quando si apre una soluzione che contiene progetti Visual C++, l'aggiornamento del database di IntelliSense potrebbe richiedere del tempo. Durante questo periodo potrebbe non essere possibile creare grafici di dipendenze per l'intestazione (h) o file #include finché il database IntelliSense non ha completato l'aggiornamento. È possibile monitorare lo stato di avanzamento dell'aggiornamento nella barra di stato di Visual Studio. Per risolvere problemi o messaggi che vengono visualizzati perché determinate impostazioni di IntelliSense sono disattivate, vedere Risoluzione dei problemi relativi ai grafici per il codice C e C++.

  • Per visualizzare le dipendenze tra tutti i file di origine e i file di intestazione nella soluzione, scegliere Genera grafico dipendenze dal menu Architettura, quindi Per file di inclusione.

    Grafico delle dipendenze per il codice nativo

  • Per visualizzare le dipendenze tra i file attualmente aperti e i file di origine e i file di intestazione correlati, aprire il file di origine o il file di intestazione. Aprire il menu di scelta rapida del file in un punto qualsiasi del file. Scegliere Genera grafico dei file di inclusione.

    Grafico delle dipendenze di primo livello per il file con estensione h

Dd409453.collapse_all(it-it,VS.120).gifRisoluzione dei problemi relativi ai grafici per il codice C e C++

Gli elementi seguenti non sono supportati nel codice C e C++:

  • I tipi di base non vengono visualizzati nei grafici che includono la gerarchia padre.

  • La maggior parte delle voci di menu Mostra non è disponibile per il codice C e C++.

Questi problemi potrebbero verificarsi quando si creano grafici di dipendenza per il codice C e C++:

Problema

Possibile causa

Risoluzione

Impossibile generare il grafico di dipendenze.

Nessun progetto nella soluzione è stato compilato correttamente.

Correggere gli errori di compilazione che si sono verificati, quindi rigenerare il grafico.

Quando si tenta di generare un grafico di dipendenze dal menu Architettura, Visual Studio smette di rispondere.

Il file di database del programma (con estensione pdb) potrebbe essere danneggiato.

Nel file pdb sono memorizzate informazioni di debug, ad esempio informazioni sui tipi, sui metodi e sui file di origine.

Ricompilare la soluzione e riprovare.

Alcune impostazioni per il database di esplorazione IntelliSense sono disabilitate.

Alcune impostazioni di IntelliSense potrebbero essere disabilitate nella finestra di dialogo Opzioni di Visual Studio.

Attivare le impostazioni per abilitarle.

Vedere Opzioni, Editor di testo, C/C++, Avanzate.

Il messaggio Metodi sconosciuti viene visualizzato su un nodo di metodo.

Questo problema si verifica perché non è possibile risolvere il nome del metodo.

Il file binario potrebbe non disporre di una tabella di rilocazione di base.

Attivare l'opzione /FIXED:NO nel linker.

Vedere /FIXED (Indirizzo di base fisso).

Il file di database del programma (con estensione pdb) potrebbe non essere compilato.

Nel file pdb sono memorizzate informazioni di debug, ad esempio informazioni sui tipi, sui metodi e sui file di origine.

Attivare l'opzione /DEBUG nel linker.

Vedere /DEBUG (Genera informazioni di debug).

Non è possibile aprire o trovare il file pdb nei percorsi previsti.

Verificare che il file pdb esista nei percorsi previsti.

Le informazioni di debug sono state rimosse dal file pdb.

Se nel linker è stata usata l'opzione /PDBSTRIPED, includere il file pdb completo.

Vedere /PDBSTRIPPED (Rimuove simboli privati).

Il chiamante non è una funzione e non è un thunk nel file binario o un puntatore nella sezione di dati.

Quando il chiamante è un thunk, provare a usare _declspec(dllimport) per evitare il thunk.

Vedere:

Dd409453.collapse_all(it-it,VS.120).gifCondividere il grafico con altri utenti di Visual Studio

  • Usare il menu File per salvare il grafico.

    -oppure-

    Per salvare il grafico come parte del progetto specifico, aprire il menu di scelta rapida per la superficie del grafico. Scegliere Sposta <NomeGraficoDipendenze.dgml> in e il progetto in cui si vuole salvare il grafico.

    In Visual Studio il grafico viene salvato come file con estensione dgml da condividere con altri utenti di Visual Studio Ultimate, Visual Studio Premium e Visual Studio Professional.

    Nota Nota

    Prima di condividere un grafico con coloro che usano Visual Studio Premium e Visual Studio Professional, verificare di espandere tutti i gruppi, visualizzare i nodi nascosti e i collegamenti tra gruppi e recuperare tutti i nodi eliminati che si desidera che vengano visualizzati da altri nel grafico. In caso contrario, altri utenti non saranno in grado di visualizzare questi elementi.

    Si potrebbe verificare il seguente errore quando si salva un grafico che è contenuto in un progetto di modello o è stato copiato da un progetto di modello a un altro percorso:

    "Impossibile salvare nomeFile all'esterno della directory del progetto. Gli elementi collegati non sono supportati."

    In Visual Studio viene visualizzato l'errore, ma viene comunque creata la versione salvata. Per evitare l'errore, creare il grafico all'esterno del progetto di modello. Sarà quindi possibile salvarlo quindi nel percorso desiderato. Il semplice tentativo di copiare il file in un altro percorso della soluzione e salvarlo non produrrà alcun effetto.

Dd409453.collapse_all(it-it,VS.120).gifEsportare il grafico come immagine in modo che sia possibile copiarlo in altre applicazioni, ad esempio in Microsoft Word o PowerPoint.

  1. Aprire il menu di scelta rapida della superficie del grafico. Scegliere Modifica, Copia immagine.

  2. Incollare l'immagine in un'altra applicazione.

Dd409453.collapse_all(it-it,VS.120).gifEsportare il grafico come file XPS in modo che sia possibile visualizzarlo nei visualizzatori XAML o XML come Internet Explorer

  1. Aprire il menu di scelta rapida della superficie del grafico. Scegliere Salva come XPS.

  2. Scegliere la posizione in cui salvare il file.

  3. Assegnare un nome al grafico. Assicurarsi che la casella Salva come sia impostata su File XPS (*.xps). Fare clic su Salva.

Per creare documenti grafici (file .dgml) per poter lavorare durante l'elaborazione batch, eseguire lo strumento da riga di comando GraphCmd.exe. Ad esempio, per trovare le dipendenze che sono cambiate tra le compilazioni, eseguire lo strumento dopo ogni compilazione. Questo strumento è disponibile nella cartella C:\Programmi\Microsoft Visual Studio 12.0\Common7\IDE.

GraphCmd.exe supporta solo il codice .NET e genera informazioni sulle dipendenze solo per assembly o file con estensione dgml e non per il codice sorgente in file di soluzione o di progetto di Visual Studio. GraphCmd.exe viene eseguito all'esterno di Visual Studio, pertanto il supporto per le azioni nelle query DGQL è limitato.

Ecco la sintassi per GraphCmd.exe:

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

Ecco le opzioni per GraphCmd.exe:

È possibile specificare queste opzioni più volte: -input, -query, -exec e -path

-?

Consente di visualizzare la guida per GraphCmd.exe.

-all

Consente di includere tutti i risultati di query intermedi, non solo per l'ultimo set di nodi.

-exceptions

Consente di segnalare le eccezioni di query come file di documento grafico, con estensione dgml.

-input Nome_File

Consente di elaborare il file con estensione dgml specificato.

Si tratta di un'opzione utile per la post-elaborazione in un file con estensione dgml di grandi dimensioni e per l'applicazione di un filtro a tale file in modo da semplificarne la visualizzazione in Visual Studio.

-query Nome_File

Consente di eseguire il file con estensione dgql (DGQL, Directed Graph Query Language).

Vedere:

-exec " Instruzione_DGQL "

Consente di eseguire l'istruzione DGQL specificata.

Vedere Informazioni su DGQL (Directed Graph Query Language).

-output Nome_File

Consente di restituire come output il file con estensione dgml specificato.

-path alias = percorso

Consente di specificare un nuovo alias da usare nell'input e nell'output dei documenti DGML.

Ad esempio:

GraphCmd -output MyGeneratedGraph.dgml -path "MyPathAlias=C:\Program Files\..."

Vedere Alias per i percorsi di utilizzo comune.

Dd409453.collapse_all(it-it,VS.120).gifAlias per i percorsi di utilizzo comune

Gli alias per i percorsi di utilizzo comune consentono di ridurre le dimensioni del file con estensione dgml e il tempo necessario per caricare o salvare il file. Per creare un alias, aggiungere una sezione <Paths></Paths> alla fine del file con estensione dgml. In questa sezione aggiungere un elemento <Path/> per definire un alias per il percorso:

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

Per fare riferimento all'alias da un elemento nel file con estensione dgml, racchiudere il valore Id dell'elemento <Path/> con un segno di dollaro ($) e parentesi (()):

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

Per modificare file con estensione dgml, vedere Modificare e personalizzare grafici dipendenze.

Dd409453.collapse_all(it-it,VS.120).gifAltre informazioni su Directed Graph Query Language (DGQL)

DGQL è un linguaggio di query leggero che è possibile usare per compilare DGML. Un'istruzione DGQL segue un modello alternato di selezione del nodo e azioni, in modo tale che ogni selezione del nodo crea un input per l'azione successiva, il cui output diventa l'input per la selezione del nodo successiva e così via.

Il formato di un'istruzione DGQL è il seguente:

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

Nella tabella seguente viene descritta la sintassi DGQL usata per la selezione dei nodi:

*

Consente di selezionare tutti i nodi.

+ "text"

Seleziona tutti i nodi che contengono "text".

+ Id.Equals("text")

Seleziona tutti i nodi il cui Id è uguale a "text".

+ Background.Contains("text")

Seleziona tutti i nodi il cui attributo Background ha un valore che contiene la stringa "text".

+ "text1" + "text2" + ...

Seleziona tutti i nodi che corrispondono a "text1" o a "text2".

+ MyProperty="True"

Seleziona tutti i nodi con di una proprietà denominata MyProperty il cui valore è "True".

- Label.Contains("text")

Seleziona tutti i nodi ad eccezione di quelli che hanno un attributo Label.Contains con la stringa "text".

+ Category.Is("MyCategory")

Seleziona tutti i nodi con una categoria denominata MyCategory o che eredita da MyCategory.

Nella tabella seguente vengono descritti esempi di azioni dirette che è possibile eseguire nei nodi selezionati:

Azione di esempio

Descrizione

Microsoft.Contains

Consente di restituire tutti i nodi inclusi nei nodi di input. È possibile sostituire Contains con una categoria di collegamento diversa.

Microsoft.Open

Consente di aprire il codice sorgente per i nodi di input.

Nota Nota
Funziona solo in Visual Studio.

Microsoft.AllOutBoundLinks

Consente di restituire tutti i nodi che rappresentano la destinazione di un collegamento in uscita dai nodi di input.

Microsoft.AllInboundLinks

Consente di restituire tutti i nodi che rappresentano l'origine di un collegamento ai nodi di input.

Microsoft.Core.CreateGroupsByProperties

Consente di richiamare l'azione GroupByProperties.

Microsoft.AllNodes

Consente di restituire tutti i nodi nell'intero grafico fino al punto corrente.

Le azioni basate sui dati consentono di selezionare gli elementi solo in base ai dati nei nodi di input e nei collegamenti. Quando si associano le categorie usando azioni basate sui dati, vengono incluse le categorie ereditate. Nella tabella seguente vengono descritti esempi di azioni basate sui dati:

Tipo

Descrizione

Node:Both:Category

Consente di restituire tutti i nodi che dispongono della categoria Category e che sono connessi con i nodi di input da un collegamento che punta in una delle direzioni.

Link:Both:Category

Consente di restituire tutti i nodi connessi con i nodi di input da un collegamento che punta in una delle direzioni e che dispone della categoria Category.

Link:Backward:Category

Consente di restituire tutti i nodi che puntano ai nodi di input con un collegamento che dispone della categoria Category.

Link:Forward:Category

Consente di restituire tutti i nodi che puntano dai nodi di input con un collegamento che dispone della categoria Category.

Dd409453.collapse_all(it-it,VS.120).gifSuggerimenti

  • In genere, è prevista un'azione "predefinita" per un set specifico di nodi di input, selezionata automaticamente da Esplora architettura. Per ottenere lo stesso comportamento, usare un'azione vuota: //

  • Lo spazio vuoto non è significativo in DGQL, pertanto è possibile formattare la query in modo che occupi un'unica riga, se necessario. Questa operazione è utile quando si usa l'opzione –exec con GraphCmd.

  • Quando si esegue il debug di DGQL, usare l'azione "Execute Expanded" in Esplora architettura per visualizzare ogni passaggio della query e individuare quello che non produce i risultati previsti.

Dd409453.collapse_all(it-it,VS.120).gifEsempio

L'istruzione DGQL seguente consente di eseguire una query come descritto nei passaggi seguenti:

+ Id.Equals("Microsoft.Solution.ClassView") / "Microsoft.Solution.ClassView" / * / "Node:Both:CodeSchema_Class" / + CodeSchemaProperty_IsPublic.Equals("True")
  1. Scegliere il nodo Visualizzazione classi nella prima colonna di Esplora architettura.

  2. Eseguire l'azione "Microsoft.Solution.ClassView", che restituisce tutti gli spazi dei nomi della soluzione. 

  3. Usare * per selezionare tutti gli spazi dei nomi.

  4. Selezionare tutti i nodi che dispongono di una categoria denominata CodeSchema_Class e sono correlati a tali spazi dei nomi da un collegamento in una delle due direzioni. Si tratta in genere di collegamenti di contenimento.

  5. Filtrare le classi risultanti per individuare solo quelle che dispongono della proprietà CodeSchemaProperty_IsPublic="True".

Tecnicamente, l'azione "Microsoft.Solution.ClassView" non è necessaria in quanto si tratta dell'azione "predefinita" per il nodo Visualizzazione classi. È pertanto possibile sostituire tale azione con // per semplificare la query e formattarla su una singola riga come illustrato di seguito:

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

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft