Avviare, interrompere, esplorare e arrestare il debugger di Visual Studio

In questo argomento

In questo argomento

Avviare il debug

• Connettersi a un processo

• Avviare automaticamente un'applicazione nel debugger

Esplorare il codice in una sessione di debug

• Arrestare il codice utilizzando i punti di interruzione oppure arrestare tutti

• Avanzare in, in, o dal codice

• Esecuzione fino a una posizione o a una funzione specificata

• Impostare l'istruzione successiva da eseguire

• Limitare l'esecuzione di istruzioni a Just My Code

• Avanzare nelle chiamate al sistema

• Avanzare di proprietà e operatori nel codice gestito

Interrompere il debug

Avviare il debug

Quando la soluzione viene aperta in Visual Studio, si dispone di tre opzioni per avviare il debug:

Connettersi a un processo

Il debugger può anche l'associazione a un programma in esecuzione in un processo esterno di Visual Studio.Dopo aver associato a un programma, è possibile utilizzare i comandi di esecuzione del debugger, esaminare lo stato del programma, e così via.La possibilità di analisi del programma potrebbe risultare limitata, come se il programma è stato compilato con informazioni di debug e se è possibile accedere al codice sorgente e che il compilatore JIT di Common Language Runtime è informazioni di debug di rilevamento.

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 e quindi scegliere Allega.

Per ulteriori informazioni, vedere Connessione a processi in esecuzione.

Avviare automaticamente un'applicazione nel debugger

In alcuni casi è necessario eseguire il debug del codice di avvio di un'applicazione avviata da un altro processo.Può ad esempio trattarsi di servizi o operazioni di installazione personalizzate.In questi scenari è possibile avviare e connettere il debugger automaticamente all'avvio dell'applicazione.

1. Avviare l'editor del Registro di sistema (regedit.exe).

2. Passare a HKEY_LOCAL_MACHINE \ software \ Microsoft \ Windows NT \ CurrentVersion \ opzioni esecuzione del file di immagine la cartella.

3. Selezionare la cartella dell'applicazione che si desidera avviare il debugger.

   Se il nome dell'applicazione non è elencato come cartella figlio, Opzioni di esecuzione file immagine quindi scegliere Nuova, Chiave il menu di scelta rapida.Selezionare la nuova chiave, scegliere Rinomina il menu di scelta rapida e quindi il nome dell'applicazione.

4. Scegliere dal menu di scelta rapida della cartella applicazione, scegliere Nuova, Valore stringa.

5. Modificare il nome di un nuovo valore da New Value a debugger.

6. Scegliere dal menu di scelta rapida della voce del debugger, scegliere Modifica.

7. Nella finestra di dialogo stringa di modifica, digitare vsjitdebugger.exe nella casella Dati valore.

   

In questo argomento

Esplorare il codice in una sessione di debug

Arrestare il codice utilizzando i punti di interruzione oppure arrestare tutti

Quando si esegue il debug di un'applicazione con il debugger di Visual Studio, l'applicazione può essere in esecuzione oppure in modalità di interruzione.

Il debugger interrompe l'esecuzione dell'applicazione quando l'esecuzione raggiunge un punto di interruzione o quando si verifica un'eccezione.È inoltre 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 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 visualizzare i valori delle variabili nella finestra variabili locali o valutazione di espressioni nella finestra Espressioni di controllo, sono disponibili solo in modalità di interruzione.Tutti gli elementi dell'applicazione restano (funzioni, variabili e oggetti restano in memoria, ad esempio, ma i movimenti e le attività vengono sospesi.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 di sospendere l'esecuzione basata su una serie di condizioni.Vedere Utilizzo di punti di interruzione e punti di analisi.In questa sezione vengono illustrate due modalità di base passare al codice.

Impostare i 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 a cui si desidera interrompere quindi scegliere Punto di interruzione, Inserisci punto di interruzione nel menu di scelta rapida (tastiera: F9.L'esecuzione del debugger si arresta immediatamente prima della riga viene eseguita.

I punti di interruzione in Visual Studio forniscono un'ampia gamma di funzionalità aggiuntive, ad esempio i punti di interruzione e punti di analisi.Vedere Utilizzo di punti di interruzione e punti di analisi.

Arrestare manualmente nel codice

Per interrompere la riga di codice successivo 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 del 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 Change the break behavior of multiple processes in questo argomento.

• Se si interrompe l'esecuzione di codice senza file corrispondenti del simbolo o di origine (con estensione pdf), il debugger visualizza Impossibile trovare file di origine o una pagina Simboli non trovati in grado di trovare i file appropriati.Vedere Trovare file di simboli (.pdb), di origine e binari.

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

Avanzare in, in, o dal codice

Una delle più comuni procedure di debug consiste nell'esecuzionedi una riga di codice alla volta.Quando è stato interrotto l'esecuzione, come eseguire il debugger a un punto di interruzione, è possibile utilizzare tre controlli menu Debug eseguire il codice:

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

• Il debugger effettivamente esegue le istruzioni con istruzioni di codice anziché le righe fisiche.Ad esempio una clausola di 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 in questa riga, il debugger esegue la condizione come un passo e la conseguenza come un altro (in questo esempio, la condizione è true).

Esecuzione fino a una posizione o a una funzione specificata

Talvolta potrebbe essere necessario eseguire un determinato punto del codice e quindi vengono arrestate l'esecuzione.Se si dispone di un punto di interruzione impostato sulla posizione in cui si desidera interrompere, 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 interrompe al punto di interruzione successivo nell'esecuzione del codice.Scegliere Debug, Continua fino a raggiungere il punto di interruzione desiderati.Vedere Set breakpoints in the code in questo argomento.

È inoltre possibile eseguire sul percorso in cui è posizionato il cursore nell'editor di codice, o l'esecuzione della funzione specificata.

Esecuzione fino alla posizione del cursore

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

Funzioni 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.

Funzioni a una funzione specificata per nome

È possibile indicare al debugger di eseguire l'applicazione fino al raggiungimento di una funzione specificata.È possibile specificare la funzione per nome oppure può stack di chiamate.

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

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

Impostare l'istruzione successiva da eseguire

Dopo che si interrompe il debugger, è possibile spostare il punto di esecuzione per impostare l'istruzione successiva del 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 utilizzare 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, seguire una di queste procedure:

• In una finestra di origine, trascinare la freccia gialla a una posizione in cui si desidera impostare l'istruzione successiva nello stesso file di origine

• In una finestra di origine, impostare il cursore sulla riga che si desidera eseguire successivamente e scegliere Imposta istruzione successiva dal menu di scelta rapida.

• Nella finestra disassembly, impostare il cursore all'istruzione di assembly che si desidera eseguire successivamente e scegliere Imposta istruzione successiva dal menu di scelta rapida.

Attenzione

Quando si imposta l'istruzione successiva, il contatore del programma passa direttamente alla nuova posizione.Utilizzare 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. In C++ nativo, se sono attivati i controlli runtime, impostare l'istruzione successiva può causare la generazione di un'eccezione quando l'esecuzione raggiunge la fine del metodo. Quando è attivo Modifica e continuazione, Imposta istruzione successiva avrà esito negativo se sono state apportate modifiche che Modifica e continuazione non è in grado di rimappare immediatamente.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 che indica 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.

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.

Per abilitare o disabilitare Just My Code per il debug, scegliere Debug, Opzioni e impostazioni.In Debug, la pagina Generale, selezionare o deselezionare Abilita Just My Code.

Per distinguere il codice utente dal codice non utente, gli Just My Code ai file di simboli (PDB) e le ottimizzazioni del programma.

In una build di debug standard, l'ottimizzazione viene disattivata e per tutti i moduli vengono creati simboli di debug.Quando si esegue una build di debug, questi moduli vengono considerati codice utente.Ma una funzione di libreria ottimizzata e non si dispone di simboli di debug non è considerata codice utente.Just My Code impedisce l'interruzione dell'esecuzione nei punti d'interruzione nel codice delle librerie, che non è in genere codice di cui si desidera eseguire il debug.Nella finestra Punti di interruzione, i punti d'interruzione verranno visualizzati con l'icona di disattivazione.

Per visualizzare tutto il codice e interrompere l'esecuzione in tutti i punti di interruzione, è possibile disattivare Just My Code di eseguire il debug utilizzando la finestra di dialogo Options.

Anche tre attributi influiscono sul codice considerato My Code dal debugger: DebuggerNonUserCodeAttribute indica al debugger che il codice al quale è applicato non è My Code.DebuggerHiddenAttribute nasconde il codice al debugger, anche se Just My Code è disattivato.DebuggerStepThroughAttribute indica al debugger di eseguire un'istruzione alla volta il codice a cui viene applicato, anziché eseguire tutto il codice.

Quando Just My Code è attivato, è possibile scegliere Interrompi tutto il menu Debug e interrompere l'esecuzione in una posizione non è presente Codice da visualizzare.In tal caso, non viene visualizzato codice.Inoltre, se si sceglie un comandodi esecuzione, si passerà alla riga di codice utente successiva.

Le istruzioni di interruzione a livello di codice, ad esempio le istruzioni Stop di Visual Basic, vengono gestite in modo diverso.Il debugger si interrompe sempre con queste istruzioni, anche quando Just My Code è attivato.In questa situazione, il codice non utente è visualizzato anziché nascosto, ma l'esecuzione porterà fuori dal codice non utente alla riga di codice utente successiva.

[!NOTA]

Just My Code non è supportato per progetti per dispositivi.

Avanzare nelle chiamate al sistema

Se sono stati caricati i simboli di debug per il codice di sistema e Just My Code non è attivato, è possibile eseguire 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 Utilizzo delle finestre e di altri simboli Microsoft nell'argomento di Trovare file di simboli (.pdb), di origine e binari.

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

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

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

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

3. Scegliere Carica simboli nel menu di scelta rapida.

Avanzare di proprietà e operatori nel codice gestito

Il debugger esegue le proprietà e operatori nel codice gestito per impostazione predefinita.Nella maggior parte dei casi, questo fornisce una migliore esperienza di debug.Per attivare l'esecuzione di istruzioni di proprietà e operatori, scegliere Debug, Opzioni e impostazioni.In Debug, la pagina Generale, deseleziona la casella di controllo Esegui istruzione/routine di proprietà e operatori (solo gestito)

In questo argomento

Interrompere il 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 termina la sessione di debug il processo ma viene spostato in esecuzione.

Interruzione di debug da Visual Studio

Scegliere Debug, Termina debug.

Termina debug termina il processo sottoposto a debug se il programma è stato avviato da Visual Studio.Se si è effettuata la connessione al processo anziché avviarlo da Visual Studio, il processo continua.

Il debug e riavvio di arresto

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

Chiudere l'applicazione che esegue il debug

Quando si esce da un'applicazione che esegue il debug, il debug viene arrestato automaticamente.