Esplorare il codice usando il debugger di Visual Studio

Il debugger di Visual Studio consente di esplorare il codice per esaminare lo stato di un'app e visualizzarne il flusso di esecuzione, noto anche come istruzione di codice . È possibile usare i tasti di scelta rapida, i comandi di debug, i punti di interruzione e altre funzionalità per accedere rapidamente al codice da esaminare. Acquisendo maggiore familiarità con i comandi e i tasti di scelta rapida del debugger, è possibile trovare e risolvere i problemi delle app più velocemente e facilmente. Per un elenco dei tasti di scelta rapida più comuni correlati all'esplorazione e al debug del codice, vedere la sezione Debug in Scelte rapide da tastiera.

Avviare il debug e attivare la modalità di interruzione

Alcuni comandi di spostamento avviano l'app e collegano automaticamente il debugger. L'app si sospende su una riga di codice specifica in base al comando usato per avviare la navigazione e si immette modalità di interruzione ( ovvero l'app viene sospesa nel debugger).

In modalità di interruzione, l'esecuzione dell'app viene sospesa mentre le funzioni, le variabili e gli oggetti rimangono in memoria. Quando il debugger è in modalità di interruzione, è possibile spostarsi nel codice. Esistono due modi molto comuni per attivare rapidamente la modalità di interruzione:

• Impostare un punto di interruzione e avviare l'app.

• Eseguire in una posizione o una funzione specifica.

  Ad esempio, nell'editor di codice in Visual Studio è possibile usare il comando Esegui al cursore per avviare l'app, con il debugger collegato e attivare la modalità di interruzione. È quindi possibile usare i comandi step per spostarsi nel codice.

  

  

i comandi di esecuzione passo-passo del codice possono essere usati per avviare la tua app, ma vengono usati più comunemente dopo essere entrati in modalità di interruzione.

Navigare nel codice in modalità pausa

Alcuni comandi di navigazione vengono usati principalmente in modalità di pausa, cioè mentre si è sospesi nel debugger.

• I comandi di esecuzione passo-passo del codice vengono usati più comunemente in modalità di interruzione.

• Alcuni comandi come Esegui per fare clic su possono essere usati solo in modalità di interruzione.

Debug e modalità di interruzione

Quando si è in modalità di interruzione, è possibile usare vari comandi per spostarsi nel codice. È possibile esaminare i valori delle variabili per cercare violazioni o bug. Per alcuni tipi di progetto, puoi anche apportare modifiche all'app quando sei in modalità di interruzione.

La maggior parte delle finestre del debugger, come le finestre Modules e Watch, sono disponibili solo quando il debugger è collegato all'app. Alcune funzionalità del debugger, come ad esempio la visualizzazione dei valori delle variabili nella finestra Locals o la valutazione delle espressioni nella finestra Watch, sono disponibili solo quando il debugger è in pausa, ovvero in modalità di pausa.

Esecuzione del codice passo-passo

Esecuzione passo-passo del codice si riferisce al processo di esecuzione del codice dell'applicazione un'istruzione alla volta, con il debugger collegato. I comandi dei passaggi del debugger consentono di osservare gli effetti di ogni istruzione e di scoprire di più sul flusso di esecuzione.

Entra nel codice

Per arrestare ogni istruzione durante il debug, usare Debug>Esegui istruzioneoppure selezionare F11.

Il debugger esegue le istruzioni di codice, non le righe fisiche. Ad esempio, una clausola if può essere scritta su una riga:

int x = 42;
string s = "Not answered";
if( int x == 42) s = "Answered!";

Dim x As Integer = 42
Dim s As String = "Not answered"
If x = 42 Then s = "Answered!"

Ma quando entri in questa riga, il debugger tratta la condizione come un'operazione e la conseguenza come un'altra. Nell'esempio precedente, la condizione è vera.

In una chiamata di funzione nidificata, Fai un passo dentro la funzione più profondamente nidificata. Ad esempio, se si usa entra nella in una chiamata come Func1(Func2()), il debugger entra nella funzione Func2.

Passare attraverso il codice e saltare alcune funzioni

Quando si esegue il debug, è possibile che non ci si preoccupi di una funzione. In alternativa, è possibile conoscere il funzionamento di codice, ad esempio codice di libreria ben testato. È possibile usare i seguenti comandi per ignorare il codice durante l'esecuzione passo a passo. Le funzioni continuano a essere eseguite, ma il debugger li ignora.

Spostarsi verso una posizione o una funzione specifica

È consigliabile eseguire direttamente in una posizione o una funzione specifica quando si conosce esattamente il codice da esaminare o se si sa dove si vuole avviare il debug.

• L'impostazione di un punto di interruzione è ottimale se si ritiene di voler riutilizzare il punto di interruzione.
• Altri metodi sono utili e sono simili all'impostazione di un punto di interruzione temporaneo.

Raggiungere un punto di interruzione nel codice

Per impostare un punto di interruzione semplice nel codice, selezionare il margine all'estrema sinistra accanto alla riga di codice in cui si vuole sospendere l'esecuzione. È anche possibile selezionare la riga e quindi selezionare F9, selezionare Debug>Attiva/Disattiva Breakpointoppure fare clic con il pulsante destro del mouse e scegliere Breakpoint>Inserisci Breakpoint. Il punto di interruzione viene visualizzato come punto rosso nel margine sinistro accanto alla riga di codice. Il debugger sospende l'esecuzione appena prima che la riga venga eseguita.

I punti di interruzione in Visual Studio offrono un set completo di funzionalità, ad esempio punti di interruzione condizionali e punti di traccia. Per informazioni dettagliate, vedere Utilizzo dei punti di interruzione.

Eseguire fino a un punto di interruzione della funzione

È possibile impostare il debugger da eseguire fino a quando non raggiunge una funzione specificata. È possibile specificare la funzione in base al nome oppure è possibile sceglierla dallo stack di chiamate.

Per specificare un punto di interruzione della funzione in base al nome:

1. Selezionare Debug>Nuovo punto di interruzione>Punto di interruzione funzione.

2. Nella finestra di dialogo Nuovo punto di interruzione funzione immettere il nome della funzione e selezionarne la lingua:

   

   

3. Selezionare OK.

Se la funzione è in overload o in più di un namespace, è possibile scegliere quella desiderata nella finestra punti di interruzione.

Per selezionare un punto di interruzione della funzione dallo stack di chiamate:

1. Durante il debug, aprire la finestra Stack di chiamate selezionando Debug>Windows>Stack di chiamate.

2. Nella finestra stack di chiamate fare clic con il pulsante destro del mouse su una funzione e selezionare Esegui in cursoreoppure selezionare CTRL+F10.

Per informazioni sulla traccia visiva dello stack di chiamate, vedere Metodi map nello stack di chiamate durante il debug di.

Correre fino a una posizione del cursore

Per eseguire nella posizione del cursore, nel codice sorgente o nella finestra stack di chiamate selezionare la riga da interrompere e quindi fare clic con il pulsante destro del mouse e selezionare Esegui al cursoreoppure selezionare CTRL+F10. Selezionando Esegui al cursore è simile a impostare un punto di interruzione temporaneo .

Corri per cliccare

Mentre il debugger è in pausa, è possibile passare il puntatore del mouse su un'istruzione nel codice sorgente o nella finestra Disassembly e selezionare Esegui fino a qui freccia verde. Usare Esegui per cliccare è simile a impostare un punto di interruzione temporaneo .

Suddividere manualmente il codice

Per passare alla riga di codice disponibile successiva in un'app in esecuzione, selezionare Debug>Interrompi tuttooppure selezionare CTRL+ALT+Interrompi.

Eseguire il debug di codice non utente

Per impostazione predefinita, il debugger tenta di eseguire il debug solo del codice dell'app abilitando un'impostazione denominata Just My Code. Per informazioni dettagliate sul funzionamento di questa funzionalità per vari tipi di progetto e linguaggi e su come personalizzarla, vedere Just My Code.

Per esaminare il codice del framework, il codice della libreria di terze parti o le chiamate di sistema durante il debug, è possibile disabilitare Just My Code. In Tools (o Debug) >Opzioni>debugdeselezionare la casella di controllo Abilita Just My Code. Quando Just My Code è disabilitato, il codice non utente appare nelle finestre del riquadro di debug e il debugger può eseguire il codice non utente.

Eseguire il debug del codice di sistema

Se sono stati caricati simboli di debug per il codice di sistema Microsoft e si è disabilitato Just My Code, è possibile eseguire una chiamata di sistema esattamente come qualsiasi altra chiamata.

Per informazioni sul caricamento dei simboli Microsoft, vedere Configurare il percorso dei file di simboli e le opzioni di caricamento.

Per caricare i simboli per un componente di sistema specifico:

1. Durante il debug, aprire la finestra moduli di selezionando Debug>Moduli di Windows> o premendo CTRL+ALT+U.

2. Nella finestra Moduli è possibile indicare quali moduli hanno simboli caricati nella colonna Stato simboli. Fare clic con il pulsante destro del mouse sul modulo per cui caricare i simboli e quindi selezionare Carica simboli.

Esaminare le proprietà e gli operatori nel codice gestito

Il debugger salta le proprietà e gli operatori nel codice gestito per impostazione predefinita. Nella maggior parte dei casi, questo comportamento offre un'esperienza di debug migliore. Per abilitare l'esame delle proprietà o degli operatori, selezionare Opzioni di debug>. Nella pagina Debugging>Generale, deseleziona la casella di controllo Ignora proprietà e operatori (solo gestito).

Spostare il puntatore per modificare il flusso di esecuzione

È possibile modificare l'istruzione successiva che verrà eseguita spostando il puntatore di esecuzione giallo. È possibile usare questa funzionalità in modalità di interruzione.

Si tratta di una funzionalità avanzata del debugger. Per ulteriori informazioni, vedere Sposta il puntatore di esecuzione.

Contenuto correlato

• Che cos'è il debug?
• tecniche e strumenti di debug
• Prima analisi del debug