Avviare, interrompere, eseguire istruzioni, esplorare il codice e arrestare il debug in Visual Studio

Avviare il debug di un progetto VS, connettersi a un processo, inserire un'interruzione nel codice, eseguire il codice un'istruzione alla volta, eseguire fino al cursore, eseguire fino a una funzione nello stack di chiamate, impostare l'istruzione successiva, eseguire Just My Code un'istruzione alla volta, interrompere il debug, riavviare il debug, disconnettersi da un processo sottoposto a debug.

Contenuto

Start debugging a VS project; attach to a process

Break into code, step or run through code, set the next statement to execute

Stop, restart debugging; detach from the debugged process

Avviare il debug di un progetto VS, connettersi a un processo

• Start debugging a VS project**|**Attach to a process

Avviare il debug di un progetto VS

Quando è aperta una soluzione di Visual Studio, si dispone di tre opzioni per avviare il debug:

Scegliere Debug, Avvia debug (tastiera: F5).	L'applicazione viene avviata ed eseguita fino a che: Il debugger raggiunge un punto di interruzione. Scegliere Interrompi debug dal menu Debug. Viene generata un'eccezione. Viene chiusa l'applicazione.
Scegliere Debug, Esegui istruzione (tastiera: F11) o Debug, Esegui istruzione/routine (tastiera: F10).	L'applicazione viene avviata per poi interrompersi alla prima riga.
In una finestra di origine, selezionare una riga di codice eseguibile e scegliere Esegui fino al cursore dal menu di scelta rapida.	L'applicazione verrà avviata ed eseguita fino a raggiungere un punto di interruzione o la posizione del cursore, a seconda dell'evento che si verifica per primo.

Per rilevare visivamente l'esecuzione del codice in una mappa codici durante il debug, vedere Mappare i metodi sullo stack di chiamate durante il debug in Visual Studio.

Contents | Start debugging a VS project; attach to a process

Connettersi a un processo

Il debugger può anche connettersi a un programma in esecuzione in un processo esterno a Visual Studio. Dopo essersi connessi a un programma, è possibile usare i comandi di esecuzione del debugger, analizzare lo stato del programma e così via. La possibilità di analisi del programma dipende dall'eventualità che il programma sia stato generato con informazioni di debug, che si disponga dell'accesso al relativo codice sorgente e che il compilatore JIT di Common Language Runtime stia registrando informazioni di debug.

Per connettersi a un processo in esecuzione nel computer locale

Scegliere Debug, Connetti a processo. Nella finestra di dialogo Connetti a processo selezionare il processo dall'elenco Processi disponibili, quindi scegliere Connetti.

Per altre informazioni, vedere Connessione a processi in esecuzione con il debugger di Visual Studio.

Contents | Start debugging a VS project; attach to a process

Inserire un'interruzione nel codice, eseguire il codice un'istruzione alla volta, impostare l'istruzione successiva da eseguire

• Break into code by using breakpoints or Break All**|Step into, over, or out of the code|Run to a specified location or function|Set the next statement to execute|Restrict stepping to Just My Code|Step into system calls|**Step into properties and operators in managed code

Inserire un'interruzione nel codice utilizzando i punti di interruzione oppure Interrompi tutto

Durante il debug di un'applicazione con il debugger di VS, l'applicazione può essere in esecuzione oppure in modalità di interruzione.

L'esecuzione dell'applicazione viene interrotta dal debugger al raggiungimento di un punto di interruzione oppure se si verifica un'eccezione. È comunque possibile interrompere manualmente l'esecuzione in qualsiasi momento.

Un punto di interruzione è un segnale che indica al debugger di sospendere temporaneamente l'esecuzione dell'applicazione in corrispondenza di un determinato punto. Quando l'esecuzione viene sospesa in corrispondenza di un punto di interruzione, il programma viene detto in modalità di interruzione. L'attivazione della modalità di interruzione non comporta l'arresto né la fine dell'esecuzione del programma; è possibile riprendere l'esecuzione in qualsiasi momento.

La maggior parte delle funzionalità del debugger, come la visualizzazione dei valori variabili nella finestra Variabili locali o la valutazione delle espressioni nella finestra Espressioni di controllo, sono disponibili unicamente in modalità di interruzione. Tutti gli elementi dell'applicazione restano (funzioni, variabili e oggetti restano, ad esempio, in memoria), ma ne vengono sospesi i movimenti e le attività. In modalità di interruzione è possibile esaminare le posizioni e gli stati degli elementi al fine di rilevare violazioni o bug. È anche possibile apportare modifiche all'applicazione in modalità di interruzione

È possibile configurare i punti di interruzione per sospendere l'esecuzione in base a una serie di condizioni. Vedere Punti di interruzione: utilizzare passaggi, funzioni sullo stack di chiamate e condizioni per interrompere nel punto e nel momento desiderati il debugger di Visual Studio. In questa sezione vengono illustrate due operazioni di base per inserire un'interruzione nel codice.

Impostare punti di interruzione nel codice

Per impostare un punto di interruzione semplice nel codice, aprire il file di origine nell'editor di Visual Studio. Impostare il cursore sulla riga di codice che si desidera interrompere, quindi scegliere Punto di interruzione, Inserisci punto di interruzione dal menu di scelta rapida (tastiera: F9). Il debugger interrompe l'esecuzione subito prima che la riga venga eseguita.

I punti di interruzione in Visual Studio forniscono un'ampia gamma di funzionalità aggiuntive, ad esempio punti di interruzione e punti di analisi condizionali. Vedere Punti di interruzione: utilizzare passaggi, funzioni sullo stack di chiamate e condizioni per interrompere nel punto e nel momento desiderati il debugger di Visual Studio.

Inserire un'interruzione nel codice manualmente

Per inserire un'interruzione nella successiva riga di codice disponibile in un'applicazione in esecuzione, scegliere Debug, Interrompi tutto (tastiera: Ctrl+Alt+Break).

• Se si esegue il debug con l'opzione Just My Code attivata, si interrompe alla riga di codice successiva nel progetto. Vedere Restrict stepping to Just My Code.

• Se si sta eseguendo il debug di più programmi, per impostazione predefinita l'utilizzo del comando Interrompi tutto o di un punto di interruzione avrà effetto su tutti i programmi in corso di debug. Vedere Configure the execution behavior of multiple processes.

• Se si interrompe l'esecuzione del codice senza file (con estensione pdf) di simboli o di origine corrispondenti, il debugger visualizza una pagina File di origine non trovati o Simboli non trovati che consente di trovare i file appropriati. Vedere Specifica di file di simboli con estensione pdb) e di file di origine nel debugger di Visual Studio.

  Se non è possibile accedere ai file di supporto, è comunque possibile eseguire il debug delle istruzioni di assembly nella finestra Disassembly.

Contents | Break into code, step or run through code, set the next statement to execute

Eseguire istruzione, istruzione/routine o uscire da istruzione/routine del codice

Una delle più comuni procedure di debug consiste nell'esecuzione di una riga di codice alla volta. Quando è stata interrotta l'esecuzione, ad esempio eseguendo il debugger a un punto di interruzione, è possibile usare tre comandi del menu Debug per eseguire il codice un'istruzione alla volta:

Comando di menu	Tasto di scelta rapida	Descrizione
Esegui istruzione	F11	Se la riga contiene una chiamata di funzione, scegliendo Esegui istruzione verrà eseguita solo la chiamata, quindi il processo si interromperà alla prima riga di codice all'interno della funzione. In caso contrario, scegliendo Esegui istruzione verrà eseguita l'istruzione seguente.
Esegui istruzione/routine	F10	Se la riga contiene una chiamata di funzione, scegliendo Esegui istruzione/routine verrà eseguita funzione chiamata, quindi il processo si interromperà alla prima riga di codice all'interno della funzione chiamante. In caso contrario, scegliendo Esegui istruzione verrà eseguita l'istruzione seguente.
Esci da istruzione/routine	Shift+F11	Scegliendo Esci da istruzione/routine, l'esecuzione del codice verrà ripresa fino a quando la funzione restituirà un risultato e verrà interrotta nel punto di restituzione del risultato all'interno della funzione chiamante.

• In una chiamata di funzione annidata, scegliendo Esegui istruzione verrà eseguita la funzione annidata più interna. Se si usa Esegui istruzione con una chiamata del tipo Func1(Func2()), il debugger eseguirà l'istruzione della funzione Func2.

• Il debugger esegue il codice un'istruzione alla volta anziché le righe fisiche. Ad esempio una clausola if può essere scritta in una riga:

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

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

  Quando si esegue l'istruzione in questa riga, il debugger esegue la condizione come un unico passaggio e la conseguenza come un altro (in questo esempio, la condizione è true).

Per rilevare visivamente lo stack di chiamate mentre si esegue il codice della funzione un'istruzione alla volta, vedere Mappare i metodi sullo stack di chiamate durante il debug in Visual Studio.

Contents | Break into code, step or run through code, set the next statement to execute

Eseguire fino a una funzione o un percorso specificato.

A volte può essere necessario eseguire il programma solo fino a un determinato punto del codice, quindi interromperne l'esecuzione. Se in tale posizione è stato impostato un punto di interruzione, scegliere Debug, Avvia debug se non è stato avviato il debug, o Debug, Continua. In entrambi i casi F5 è il tasto di scelta rapida. Il debugger si arresta in corrispondenza del punto di interruzione successivo nell'esecuzione del codice. Scegliere Debug, Continua fino a raggiungere il punto di interruzione desiderato.

È inoltre possibile eseguire fino alla pozione del cursore nell'editor di codice o eseguire la funzione specificata.

Eseguire fino alla posizione del cursore.

Per eseguire fino alla posizione del cursore, posizionare il cursore su una riga di codice eseguibile in una finestra di origine. Nel menu di scelta rapida dell'editor, scegliere Esegui fino al cursore.

Eseguire fino a una funzione nello stack di chiamate

Nella finestra Stack di chiamate selezionare la funzione e scegliere Esegui fino al cursore dal menu di scelta rapida. Per rilevare visivamente lo stack di chiamate, vedere Mappare i metodi sullo stack di chiamate durante il debug in Visual Studio.

Eseguire fino a una funzione specificata mediante il nome

È possibile indicare al debugger di eseguire l'applicazione fino al raggiungimento di una funzione specificata. È possibile specificare la funzione mediante il nome oppure sceglierla dallo stack di chiamate.

Per specificare una funzione mediante il nome, scegliere Debug, Nuovo punto di interruzione, Interrompi alla funzione, quindi immettere il nome della funzione e altre informazioni di identificazione.

Se la funzione è sottoposta a overload o è disponibile nello spazio dei nomi, è possibile scegliere le funzioni desiderate nella finestra di dialogo Seleziona punti di interruzione.

Contents | Break into code, step or run through code, set the next statement to execute

Impostare l'istruzione successiva da eseguire

Dopo aver inserito un'interruzione nel debugger è possibile spostare il punto di esecuzione per impostare la successiva istruzione di codice da eseguire. La posizione dell'istruzione successiva da eseguire è contrassegnata da una freccia gialla visualizzata sul margine di una finestra di origine o di una finestra Disassembly. Mediante lo spostamento della freccia, è possibile ignorare un segmento di codice oppure tornare a una riga eseguita precedentemente. È possibile usare questa opzione in alcune situazioni, ad esempio quando si desidera ignorare una sezione di codice che contiene un bug noto.

Per impostare l'istruzione successiva da eseguire, utilizzare una di queste procedure:

• In una finestra di origine trascinare la freccia gialla nella posizione in cui si desidera impostare l'istruzione successiva all'interno dello stesso file di origine.

• Nella finestra di origine impostare il cursore sulla riga da eseguire successivamente e scegliere Imposta istruzione successiva nel menu di scelta rapida.

• Nella finestra Disassembly impostare il cursore sull'istruzione dell'assembly che si vuole eseguire successivamente e scegliere Imposta istruzione successiva nel menu di scelta rapida.

Avviso

Quando si imposta l'istruzione successiva, il contatore del programma passa direttamente alla nuova posizione.Usare questo comando con cautela:

• Le istruzioni comprese tra il vecchio e il nuovo punto di esecuzione non verranno eseguite.

• Se si sposta all'indietro il punto di esecuzione, le istruzioni comprese tra questo e il vecchio punto di interruzione non verranno annullate.

• Lo spostamento dell'istruzione successiva in corrispondenza di un'altra funzione o ambito provoca in genere un errore dello stack di chiamate e, conseguentemente, un errore o un'eccezione di runtime.Se si sposta l'istruzione successiva in corrispondenza di un altro ambito, verrà visualizzata una finestra di dialogo contenente un avviso e in cui si può scegliere di annullare l'operazione.In Visual Basic non è possibile spostare l'istruzione successiva in corrispondenza di un altro ambito o di un'altra funzione.

• Se in C++ nativo sono abilitati i controlli runtime, l'impostazione dell'istruzione successiva può causare la generazione di un'eccezione quando l'esecuzione raggiunge la fine del metodo.

• Quando l'opzione Modifica e continuazione è abilitata, Imposta istruzione successiva avrà esito negativo se sono state effettuate modifiche per cui Modifica e continuazione non è immediatamente in grado di eseguire nuovamente il mapping.Ad esempio questo può accadere se è stato modificato del codice all'interno di un blocco catch.In questo caso,verrà visualizzato un messaggio di errore indicante che l'operazione non è supportata.

Nota

Nel codice gestito non è possibile spostare l'istruzione successiva in presenza delle seguenti condizioni:

• L'istruzione successiva è inclusa in un metodo diverso da quello dell'istruzione corrente.

• Il debug è stato avviato utilizzando il debug JIT.

• È in corso la rimozione di uno stack di chiamate.

• È stata generata un'eccezione System.StackOverflowException or System.Threading.ThreadAbortException.

Non è possibile impostare l'istruzione successiva mentre l'applicazione è in esecuzione. Per impostare l'istruzione successiva, è necessario che il debugger sia in modalità di interruzione.

Contents | Break into code, step or run through code, set the next statement to execute

Limitare l'esecuzione di istruzioni a Just My Code

In alcuni casi è possibile che, durante il debug, si desideri vedere solo il codice scritto personalmente e ignorarne altro, come le chiamate di sistema. Questa operazione può essere eseguita con il debug Just My Code, che nasconde il codice non utente in modo che non sia presente nelle finestre del debugger. Durante l'esecuzione, il debugger scorre, un'istruzione alla volta, il codice non utente, ma non si arresta. Vedere Just My Code

Nota

Just My Code non è supportato per progetti per dispositivi.

Contents | Break into code, step or run through code, set the next statement to execute

Eseguire le chiamate di sistema

Se sono stati caricati simboli di debug per il codice di sistema e Just My Code non è abilitato, è possibile eseguire le istruzioni di una chiamata di sistema come una qualsiasi altra chiamata.

Per informazioni su come disabilitare Just My Code, vedere Restrict stepping to Just My Code

Per accedere ai file di simboli Microsoft, vedere Use symbol servers to find symbol files not on your local machine nell'argomento Specifica di file di simboli con estensione pdb) e di file di origine nel debugger di Visual Studio.

Per caricare i simboli per un componente di sistema specifico durante il debug:

1. Aprire la finestra Moduli (tastiera: Ctrl+Alt+U).

2. Selezionare il modulo per cui si desidera caricare i simboli.

   I moduli con i simboli caricati sono presenti nella colonna Stato simboli.

3. Scegliere Carica simboli dal menu di scelta rapida.

Contents | Break into code, step or run through code, set the next statement to execute

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, l'esperienza di debug risulta notevolmente migliorata. Per abilitare l'esecuzione di istruzioni di proprietà o operatori, scegliere Debug, Opzioni e impostazioni. Nella pagina Debug, Generale deselezionare la casella di controllo Esegui istruzione/routine di proprietà e operatori (solo gestito)

Contents | Break into code, step or run through code, set the next statement to execute

Interrompere il debug, riavviare il debug, disconnettersi dal processo sottoposto a debug

Terminare il debug significa terminare la sessione di debug. Terminare l'esecuzione significa terminare il processo di cui è in corso il debug e la sessione di debug. Questa operazione non deve essere confusa con l'interruzione dell'esecuzione che blocca temporaneamente l'esecuzione del processo di cui è in corso il debug mantenendo attiva la sessione di debug. La disconnessione da un processo interrompe la sessione di debug ma non interrompe l'esecuzione del processo.

• Stop debugging from VS**|Close the app that is being debugged|Restart debugging|**Detach from the debugged app

Interrompere il debug da VS

Scegliere Debug, Interrompi debug per terminare il processo di cui è in corso il debug quando il programma è stato avviato da Visual Studio. Se si è effettuata la connessione al processo, anziché averlo avviato da Visual Studio, l'esecuzione del processo continua.

Contents | Stop, restart debugging; detach from the debugged process

Chiudere l'applicazione di cui si sta eseguendo il debug

Quando si esce da un'applicazione di cui si sta eseguendo il debug, il debug viene interrotto automaticamente.

Riavviare il debug

Scegliere Debug, Riavvia per interrompere la sessione di debug corrente e per riavviare il progetto di avvio del debugger.

Contents | Stop, restart debugging; detach from the debugged process

Disconnettersi dall'applicazione sottoposta a debug

Scegliere Debug, Disconnetti tutto per interrompere il debug mantenendo in esecuzione il processo o i processi sottoposti a debug.

Suggerimento

Vedere Connessione a processi in esecuzione con il debugger di Visual Studio e Eseguire il debug di uno o più processi in Visual Studio per ulteriori informazioni sulla connessione e sul controllo di più processi con Visual Studio.

Contents | Stop, restart debugging; detach from the debugged process