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).
Nota
Nel codice gestito verrà visualizzata una finestra di dialogo in cui si chiede all'utente se vuole ricevere una notifica quando vengono eseguite automaticamente istruzioni di proprietà e operatori (comportamento predefinito). Se si vuole modificare l'impostazione in un secondo momento, disabilitare l'impostazione Esegui istruzione su proprietà e operatori nel menu Opzioni strumenti > in Debug.
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.
Nota
Il pulsante Run to Click (Esegui esecuzione fino a qui) è disponibile a partire da Visual Studio 2017.
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.
Nota
È possibile usare Esegui fino al cursore nella finestra Stack di chiamate durante il debug.
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.
Modifica del codice in tempo reale
Visual Studio 2022 supporta la modifica del codice in tempo reale durante il debug. Per informazioni dettagliate, vedere:
Modificare il codice e continuare il debug (C#, VB, C++, XAML)
Nella maggior parte dei linguaggi supportati da Visual Studio è possibile modificare il codice durante una sessione di debug e continuare il debug. Per usare questa funzionalità, fare clic sul codice con il cursore mentre è in pausa nel debugger, apportare modifiche e premere F5, F10 o F11 per continuare il debug. Per altre informazioni sull'uso di questa funzionalità e sulle limitazioni delle funzionalità, vedere Modifica e continuazione.
Per modificare il codice XAML durante una sessione di debug, vedi Scrivere ed eseguire il debug di codice XAML con Ricaricamento rapido XAML.
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.
Nota
In JavaScript è supportata la finestra Variabili locali ma non la finestra Auto.
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.
Nota
La finestra Stack di chiamate è simile alla prospettiva di debug di alcuni IDE come Eclipse.
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.
In questo esempio, l'helper eccezioni mostra un'eccezione System.NullReferenceException e un messaggio di errore che indica che il riferimento all'oggetto non è impostato su un'istanza dell'oggetto . E indica che il valore stringa è null quando si tenta di chiamare il Trim metodo .
In questo esempio l'Helper eccezioni visualizza un'eccezione System.Argument e un messaggio di errore che indica che il formato del percorso non è valido. È chiaro quindi che l'errore si è verificato in un argomento di metodo o funzione.
In questo esempio l'errore è stato restituito dalla chiamata di DirectoryInfo a causa di una stringa vuota archiviata nella variabile value.
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.
Suggerimento
Se si ha Copilot, è possibile ottenere assistenza per l'intelligenza artificiale durante il debug delle eccezioni. Basta cercare il pulsante Ask Copilot
. Per altre informazioni, vedere Debug con Copilot.
Ottenere assistenza per l'intelligenza artificiale
Se si ha Copilot, è possibile ottenere assistenza per l'intelligenza artificiale durante il debug. Per altre informazioni, vedere Debug con Copilot. Durante il debug, è anche possibile cercare il pulsante Ask Copilot. In questi scenari Copilot conosce già il contesto per le domande, quindi non è necessario fornire il contesto in chat di Copilot.
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.
A partire da Visual Studio 2022, la scheda Debug per i progetti .NET fornisce un collegamento all'interfaccia utente dei profili di avvio di debug, in cui è possibile impostare le proprietà correlate al debug.
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.