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. Acquisire maggiore familiarità con i comandi e i tasti di scelta rapida del debugger, è possibile trovare e risolvere i problemi delle app più velocemente e più 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.

Nota

Se non si ha familiarità con il debug del codice, è possibile leggere Debug per principianti e tecniche e strumenti di debug assoluti prima di leggere questo articolo.

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 la 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 di Visual Studio è possibile usare il comando Esegui a 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 del codice possono essere usati per avviare l'app, ma vengono usati più comunemente dopo l'avvio della modalità di interruzione.

Spostarsi nel codice in modalità di interruzione

Alcuni comandi di spostamento vengono usati principalmente in modalità di interruzione, ovvero mentre si è sospesi nel debugger.

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

• Alcuni comandi, ad esempio Esegui per fare clic , 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, ad esempio moduli e espressioni di controllo, è disponibile solo quando il debugger è collegato all'app. Alcune funzionalità del debugger, ad esempio la visualizzazione dei valori delle variabili nella finestra Variabili locali o la valutazione delle espressioni nella finestra Espressioni di controllo, sono disponibili solo quando il debugger viene sospeso ,ovvero in modalità di interruzione.

Nota

Se si esegue un'interruzione nel codice in cui non sono caricati file di origine o simboli (con estensione pdb), il debugger visualizza una pagina File di origine non trovati o Simboli non trovati che consentono di trovare e caricare i file. Vedere Specificare file di simboli (con estensione pdb) e di origine. Se non è possibile caricare i file di simboli o di origine, è comunque possibile eseguire il debug delle istruzioni dell'assembly nella finestra Disassembly .

Istruzione del codice

L'istruzione di codice si riferisce all'esecuzione del codice dell'applicazione di 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.

Eseguire l'istruzione nel codice

Per arrestare ogni istruzione durante il debug, usare Debug>Passaggio in o selezionare F11.

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

C#

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

VB

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

Tuttavia, quando si esegue l'istruzione in questa riga, il debugger considera la condizione come un passaggio e la conseguenza come un altro. Nell'esempio precedente la condizione è true.

In una chiamata di funzione annidata, scegliendo Esegui istruzione verrà eseguita la funzione annidata più interna. Ad esempio, se si usa Esegui istruzione in una chiamata come Func1(Func2()), il debugger esegue la procedura nella funzione Func2.

Suggerimento

Quando si esegue ogni riga di codice, è possibile passare il puntatore del mouse sulle variabili per visualizzarne i valori oppure usare le finestre Variabili locali e Espressioni di controllo per controllare la modifica dei valori. È anche possibile tracciare visivamente lo stack di chiamate durante l'istruzione delle funzioni. (solo per Visual Studio Enterprise, vedere Eseguire il mapping dei metodi nello stack di chiamate durante il debug.

Eseguire il codice e ignorare 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 comandi seguenti per ignorare il codice quando si esegue l'istruzione del codice. Le funzioni continuano a essere eseguite, ma il debugger li ignora.

Comando da tastiera	Comando del menu Debug	Descrizione
F10	Esegui istruzione/routine	Se la riga corrente contiene una chiamata di funzione, Esegui istruzione/routine esegue il codice e quindi sospende l'esecuzione alla prima riga di codice dopo la restituzione della funzione chiamata.
MAIUSC+F11	Esci da istruzione/routine	Step Out continua a eseguire il codice e sospende l'esecuzione quando la funzione corrente viene restituita. Il debugger ignora la funzione corrente.

Eseguire in 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.

Eseguire in 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 Attiva>/Disattiva punto di interruzione oppure fare clic con il pulsante destro del mouse e selezionare Inserisci punto> di interruzione. Il punto di interruzione viene visualizzato come punto rosso nel margine sinistro accanto alla riga di codice. Il debugger sospende l'esecuzione subito prima dell'esecuzione della riga.

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 Uso dei punti di interruzione.

Eseguire in un punto di interruzione della funzione

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

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

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

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

   

3. Seleziona OK.

Se la funzione è in overload o in più spazi dei nomi, è 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>stack di chiamate di Windows.>

2. Nella finestra Stack di chiamate fare clic con il pulsante destro del mouse su una funzione e scegliere Esegui in cursore oppure premere CTRL+F10.

Per informazioni sulla traccia visiva dello stack di chiamate, vedere Eseguire il mapping dei metodi nello stack di chiamate durante il debug.

Eseguire in una posizione del cursore

Per eseguire la posizione del cursore, nel codice sorgente o nella finestra Stack di chiamate selezionare la riga da interrompere, quindi fare clic con il pulsante destro del mouse e selezionare Esegui al cursore oppure premere CTRL+F10. La selezione di Esegui in cursore è simile all'impostazione di un punto di interruzione temporaneo.

Forzare l'esecuzione in una posizione del cursore

Per eseguire nella posizione del cursore, nel codice sorgente o nella finestra Stack di chiamate selezionare la riga da interrompere, quindi fare clic con il pulsante destro del mouse e selezionare Forza esecuzione in cursore. Se si seleziona Forza esecuzione in cursore, verranno ignorati tutti i punti di interruzione e le eccezioni di prima probabilità fino a quando il debugger non raggiunge la riga di codice in cui si trova il cursore.

Esegui fino alla riga selezionata

Mentre il debugger è in pausa, è possibile passare il puntatore del mouse su un'istruzione nel codice sorgente o nella finestra Disassembly e selezionare la freccia verde Esegui esecuzione qui . L'uso di Esegui per fare clic è simile all'impostazione di un punto di interruzione temporaneo.

Nota

Esegui su Clic è disponibile a partire da Visual Studio 2017.

Forzare l'esecuzione per fare clic

Mentre il debugger è in pausa, è possibile passare il puntatore del mouse su un'istruzione nel codice sorgente premendo il tasto MAIUSC e quindi selezionare Forza esecuzione fino a qui (doppia freccia verde). Quando si sceglie questa opzione, l'applicazione collega il debugger di Visual Studio e si sospende nella posizione del cursore. Tutti i punti di interruzione e le eccezioni first-chance rilevati durante l'esecuzione vengono temporaneamente disabilitati.

Nota

Force Run to Click è disponibile a partire da Visual Studio 2022.

Inserire un'interruzione nel codice manualmente

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

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 Strumenti (o Debug) >Opzioni>debug deselezionare la casella di controllo Abilita Just My Code. Quando Just My Code è disabilitato, il codice non utente viene visualizzato nelle finestre del debugger e il debugger può eseguire l'istruzione nel codice non utente.

Nota

Just My Code non è supportato per i progetti di dispositivo.

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.

A partire da Visual Studio 2022 versione 17.7, è possibile completare automaticamente il codice .NET durante l'esecuzione di istruzioni in codice esterno senza la necessità di caricare manualmente i simboli di debug. Per altre informazioni, vedere Generare codice sorgente da assembly .NET durante il debug.

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 selezionando Debug moduli> di Windows>o premendo CTRL+ALT+U.

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

Eseguire istruzioni di proprietà e operatori nel codice gestito

Il debugger esegue le istruzioni/routine di proprietà e operatori nel codice gestito per impostazione predefinita. Nella maggior parte dei casi, questo comportamento offre un'esperienza di debug migliore. Per disabilitare l'esecuzione di istruzioni in proprietà o operatori, selezionare Opzioni di debug>. Nella pagina Debug>generale deselezionare la casella di controllo Esegui istruzione su 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 altre informazioni, vedere Spostare il puntatore di esecuzione.

Contenuto correlato

• Che cos'è il debug?
• Tecniche e strumenti di debug
• Esaminare prima di tutto il debug