Presentazione del debugger di Visual Studio

Questo argomento presenta gli strumenti debugger disponibili in Visual Studio. Nel contesto di Visual Studio il debug di un'app implica in genere l'esecuzione dell'applicazione con il debugger collegato, ovvero in modalità debugger. Durante il debug, il debugger offre diversi modi per vedere le operazioni eseguite dal codice durante l'esecuzione. È possibile esaminare il codice ed esaminare i valori archiviati nelle variabili. È possibile impostare watches sulle variabili per vedere quando i valori cambiano, è possibile esaminare il percorso di esecuzione del codice, et al. Se questa è la prima volta che si è tentato di eseguire il debug del codice, è consigliabile leggere Debug per principianti assoluti prima di eseguire questo argomento. Se si sta tentando di eseguire un'attività specifica ed è necessario conoscere la funzionalità da usare, vedere Ricerca delle funzionalità del debugger. Per provare il debug assistito dall'intelligenza artificiale, vedere Eseguire il debug con Copilot.

Le funzionalità qui descritte sono applicabili a C#, C++, Visual Basic, JavaScript e ad altri linguaggi supportati da Visual Studio (se non diversamente specificato).

Impostare un punto di interruzione e avviare il debugger

I punti di interruzione sono una funzionalità utile quando si conosce la riga di codice o la sezione del codice da esaminare in dettaglio in fase di esecuzione. Per altre informazioni sui diversi tipi di punti di interruzione, ad esempio punti di interruzione condizionali e punti di interruzione delle funzioni, vedere Uso di punti di interruzione.

Per eseguire il debug è necessario avviare l'app con il debugger collegato al processo dell'app. A questo scopo, è necessario:

• Premere F5 (Debug > Avvia debug), che è il metodo più comune.

Tuttavia, è possibile che non sia ancora stato impostato alcun punto di interruzione per esaminare il codice dell'app, quindi si eseguirà prima questa operazione e quindi si avvierà il debug. I punti di interruzione sono la caratteristica più basilare ed essenziale di un debug affidabile. Un punto di interruzione indica il punto in cui Visual Studio dovrebbe sospendere l'esecuzione del codice in modo da poter esaminare i valori delle variabili, il comportamento della memoria o lo stato di esecuzione di un ramo del codice.

Se si ha un file aperto nell'editor del codice, è possibile impostare un punto di interruzione facendo clic sul margine a sinistra di una riga di codice.

Premere F5 (Debug > Avvia debug) o il pulsante Avvia debug nella barra degli strumenti debug e il debugger viene eseguito al primo punto di interruzione rilevato. Se l'app non è ancora in esecuzione, F5 avvia il debugger e lo arresta in corrispondenza del primo punto di interruzione.

Esplorare il codice nel debugger tramite i comandi di esecuzione

Per la maggior parte dei comandi è possibile usare tasti di scelta rapida per esplorare velocemente il codice dell'app. I comandi equivalenti, ad esempio i comandi di menu, vengono visualizzati tra parentesi. Per altre informazioni sull'uso dei comandi del passaggio, vedere Esplorare il codice nel debugger.

Per avviare l'app con il debugger collegato, premere F11 (Passaggio di debug>). F11 corrisponde al comando Esegui istruzione e consente di eseguire l'app un'istruzione alla volta. Quando si avvia l'app con F11, il debugger si interrompe alla prima istruzione che viene eseguita.

La freccia gialla rappresenta l'istruzione in cui il debugger è in pausa e in cui viene anche sospesa l'esecuzione di app (l'istruzione non è ancora stata eseguita).

F11 è un buon metodo per esaminare il flusso di esecuzione nel dettaglio. Per spostarsi più velocemente nel codice, vengono visualizzate anche alcune altre opzioni. Per impostazione predefinita, il debugger ignora il codice non utente (se si vogliono altri dettagli, vedere Just My Code).

Eseguire le istruzione del codice per ignorare le funzioni

Quando si usa una riga di codice che è una funzione o una chiamata al metodo, è possibile premere F10 (Passaggio di debug>) anziché F11.

F10 fa avanzare il debugger senza eseguire le istruzioni di funzioni o metodi presenti nel codice dell'app (il codice viene comunque eseguito). Premendo F10, è possibile ignorare il codice a cui non si è interessati. In questo modo si può raggiungere rapidamente il codice a cui si è più interessati. Per altre informazioni sull'uso dei comandi del passaggio, vedere Esplorare il codice nel debugger.

Raggiungere rapidamente un punto del codice usando il mouse

L'uso del pulsante Esegui per fare clic è simile all'impostazione di un punto di interruzione temporaneo. Questo comando è utile anche per spostarsi rapidamente all'interno di un'area visibile del codice dell'app. È possibile usare il pulsante per l'esecuzione fino alla riga selezionata in qualsiasi file aperto. Per altri dettagli su questa funzionalità e funzionalità di spostamento simili, vedere Eseguire in una posizione specifica nel codice.

Mentre nel debugger passare il puntatore del mouse su una riga di codice fino a quando non viene visualizzato il pulsante Esegui fino a fare clic (Esegui esecuzione fino a qui) a sinistra.

Fare clic sul pulsante per l'esecuzione fino alla riga selezionata (Continua l'esecuzione fino a qui). Il debugger avanza fino alla riga di codice in cui si è fatto clic.

Far avanzare il debugger all'esterno della funzione corrente

In alcuni casi può essere necessario continuare la sessione di debug facendo tuttavia avanzare il debugger all'esterno della funzione corrente.

Premere MAIUSC + F11 (o Esegui debug > istruzione/routine).

Questo comando riprende l'esecuzione dell'app e fa avanzare il debugger fino alla fine della funzione corrente.

Esecuzione fino al cursore

Quando si modifica il codice (anziché essere sospeso nel debugger), fare clic con il pulsante destro del mouse su una riga di codice nell'app e scegliere Esegui al cursore (o premere CTRL + F10). Questo comando avvia il debug e imposta un punto di interruzione temporaneo nella riga di codice corrente. Per altri dettagli su questa funzionalità e funzionalità di spostamento simili, vedere Eseguire in una posizione specifica nel codice.

Se sono stati impostati punti di interruzione, il debugger viene sospeso in corrispondenza del primo punto di interruzione.

Premere F5 fino a raggiungere la riga di codice in cui è stato selezionato Esegui fino al cursore.

Questo comando è utile quando si modifica il codice e si vuole impostare rapidamente un punto di interruzione temporaneo e avviare allo stesso tempo il debugger.

Riavviare rapidamente l'app

Fare clic sul pulsante Riavvia nella barra degli strumenti di debug (oppure premere CTRL+ MAIUSC + F5).

Il pulsante Riavvia consente di risparmiare tempo rispetto all'arresto dell'app e al riavvio del debugger. Il debugger viene messo in pausa in corrispondenza del primo punto di interruzione raggiunto eseguendo il codice.

Se si vuole arrestare il debugger e tornare all'editor di codice, è possibile premere il pulsante di arresto rosso anziché Riavviare.

Esaminare le variabili con i suggerimenti dati

Dopo aver acquisito una conoscenza generale si può iniziare a esaminare lo stato dell'app (variabili) con il debugger. Le funzionalità che consentono di esaminare le variabili sono tra le più utili del debugger e sono disponibili diversi modi per eseguire questa operazione. Quando si prova a eseguire il debug di un problema, spesso si tenta di determinare se le variabili includono i valori previsti in un particolare stato dell'app. Per informazioni dettagliate sull'uso dei suggerimenti per i dati, vedere Visualizzare i valori dei dati nei suggerimenti per i dati.

Mentre è in pausa nel debugger, passare il puntatore del mouse su un oggetto con il mouse e visualizzarne il valore o il valore predefinito della proprietà.

Se la variabile ha proprietà, è possibile espandere l'oggetto per visualizzarne tutte le proprietà.

Spesso durante il debug è utile avere a disposizione un modo rapido per controllare i valori delle proprietà negli oggetti e i suggerimenti dati sono un ottimo strumento per eseguire questa operazione.

Esaminare le variabili con le finestre Auto e Variabili locali

Nella finestra Auto vengono visualizzate le variabili con il relativo valore corrente e il tipo. La finestra Auto mostra tutte le variabili usate nella riga corrente o nella riga precedente (In C++, la finestra mostra le variabili nelle tre righe di codice precedenti. Controllare la documentazione relativa al comportamento specifico della lingua. Per altre informazioni sull'uso di queste finestre, vedere Esaminare le variabili nelle finestre Auto e Variabili locali.

Durante il debug, osservare la finestra Auto nella parte inferiore dell'editor del codice.

Osservare quindi la finestra Variabili locali. La finestra Variabili locali contiene le variabili presenti attualmente nell'ambito.

In questo esempio l'oggetto this e l'oggetto f rientrano nell'ambito. Per altre informazioni, vedere Inspect Variables in the Autos and Locals Windows (Esaminare le variabili nelle finestre Auto e Variabili locali).

Impostare un'espressione di controllo

È possibile usare una finestra Espressione di controllo per specificare una variabile (o un'espressione) che si vuole controllare. Per informazioni dettagliate, vedere Impostare un'espressione di controllo usando Le finestre Espressione di controllo e Controllo immediato.

Durante il debug, fare clic con il pulsante destro del mouse su un oggetto e scegliere Aggiungi espressione di controllo.

In questo esempio è stata impostata un'espressione di controllo sull'oggetto ed è possibile vederne le modifiche al valore mentre ci si sposta nel debugger. A differenza di altre finestre delle variabili, la finestra Espressione di controllo visualizza sempre le variabili controllate (che appaiono disattivate quando non rientrano nell'ambito).

Analisi dello stack di chiamate

La finestra Stack di chiamate visualizza l'ordine in cui vengono chiamati metodi e funzioni. La riga superiore mostra la funzione corrente. La seconda riga mostra la funzione o la proprietà da cui è stato chiamato e così via. Lo stack di chiamate è un ottimo modo per esaminare e comprendere il flusso di esecuzione di un'app. Per informazioni dettagliate, vedere Procedura: Esaminare lo stack di chiamate.

Durante il debug, fare clic sulla finestra Stack di chiamate aperta, per impostazione predefinita, nel riquadro inferiore destro.

È possibile fare doppio clic su una riga di codice per visualizzare il codice sorgente e modificare anche l'ambito corrente controllato dal debugger. Ciò non determina l'avanzamento del debugger.

È anche possibile usare i menu di scelta rapida dalla finestra Stack di chiamate per eseguire altre operazioni. Ad esempio, è possibile inserire punti di interruzione in funzioni specifiche, riavviare l'app usando Esegui fino al cursore e passare a esaminare il codice sorgente.

Esaminare un'eccezione

Quando l'app genera un'eccezione, il debugger passa alla riga di codice che ha generato l'eccezione. Per informazioni dettagliate, vedere Esaminare un'eccezione usando l'helper eccezioni.

L'Helper eccezioni è un'ottima funzionalità che può facilitare il debug degli errori. La funzionalità consente di eseguire anche altre operazioni, ad esempio visualizzare i dettagli dell'errore e aggiungere un'espressione di controllo. Oppure, se necessario, è possibile modificare le condizioni che determinano la generazione di una particolare eccezione. Per altre informazioni su come gestire le eccezioni nel codice, vedere Tecniche e strumenti di debug.

Espandere il nodo Impostazioni eccezioni per vedere altre opzioni relative alla gestione di questo tipo di eccezione, ma non apportare alcuna modifica per questa presentazione.

Configurare il debug

È possibile configurare il progetto per la compilazione come configurazione debug o versione, configurare le proprietà del progetto per il debug o configurare le impostazioni generali per il debug. Inoltre, è possibile configurare il debugger per visualizzare informazioni personalizzate usando funzionalità come l'attributo DebuggerDisplay o, per C/C++, il framework NatVis.

Le proprietà di debug sono specifiche di ogni tipo di progetto. Ad esempio, è possibile specificare un argomento da passare all'applicazione al momento dell'avvio. È possibile accedere alle proprietà specifiche del progetto facendo clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliendo Proprietà. Le proprietà di debug vengono in genere visualizzate nella scheda Compilazione o Debug , a seconda del tipo di progetto specifico.

Debug di app ASP.NET attive nel servizio app di Azure

Per eseguire il debug nel servizio app Azure, vedere Eseguire il debug di app di Azure.

Per Visual Studio Enterprise (solo), snapshot debugger crea uno snapshot delle app in produzione quando viene eseguito il codice a cui si è interessati. Per indicare al debugger di creare uno snapshot, impostare punti di ancoraggio e punti di registrazione nel codice. Il debugger consente di vedere esattamente cosa non ha funzionato, senza alcun impatto sul traffico dell'applicazione di produzione. Snapshot Debugger può essere utile per ridurre notevolmente il tempo necessario per risolvere i problemi che si verificano negli ambienti di produzione.

La raccolta di snapshot è disponibile per le applicazioni ASP.NET in esecuzione nel servizio app di Azure. Per le applicazioni ASP.NET è necessario .NET Framework 4.6.1 o versione successiva, mentre per le applicazioni ASP.NET Core è necessario .NET Core 2.0 o versione successiva in Windows.

Per altre informazioni, vedere Debug live ASP.NET apps using the Snapshot Debugger (Eseguire il debug di app ASP.NET attive usando Snapshot Debugger).

Visualizzare snapshot con la funzionalità per tornare indietro di IntelliTrace (Visual Studio Enterprise)

La funzionalità per tornare indietro di IntelliTrace crea automaticamente uno snapshot dell'applicazione in corrispondenza di ogni evento di punto di interruzione ed esecuzione di passaggio del debugger. Gli snapshot registrati consentono di tornare indietro ai punti di interruzione o ai passaggi precedenti e visualizzare stati passati dell'applicazione. La funzionalità per tornare indietro di IntelliTrace può consentire di risparmiare tempo quando si vuole visualizzare uno stato precedente dell'applicazione senza riavviare il debug o ricreare lo stato dell'app desiderato.

È possibile esplorare e visualizzare gli snapshot tramite i pulsanti Vai indietro e Vai avanti sulla barra degli strumenti di Debug. Questi pulsanti consentono di spostarsi tra gli eventi visualizzati nella scheda Eventi della finestra Strumenti di diagnostica.

Per altre informazioni, vedere la pagina Visualizzare lo stato precedente dell'applicazione con IntelliTrace.

Problemi di prestazioni di debug

Se l'app viene eseguita troppo lentamente o usa una quantità eccessiva di memoria, potrebbe essere necessario testare l'app con gli strumenti di profilatura all'inizio. Per altre informazioni sugli strumenti di profilatura, ad esempio lo strumento Utilizzo CPU e Memory Analyzer, vedere Prima di tutto gli strumenti di profilatura.

Contenuto correlato

In questa esercitazione è stata offerta una breve panoramica di molte funzionalità del debugger. È possibile esaminare in modo più approfondito una di queste funzionalità, i punti di interruzione.