Informazioni su suggerimenti e consigli per la produttività per il debugger in Visual Studio

Leggere questo argomento per informazioni su alcuni suggerimenti e consigli per la produttività per il debugger di Visual Studio. Per un'analisi delle funzionalità di base del debugger, vedere Prima di tutto esaminare il debugger. In questo argomento vengono illustrate alcune aree non incluse nel tour delle funzionalità.

Scelte rapide da tastiera

Per un elenco dei tasti di scelta rapida più comuni correlati al debug, vedere la sezione Debug in Tasti di scelta rapida.

Aggiungere suggerimenti per i dati

Se si passa spesso il puntatore del mouse sui suggerimenti per i dati durante il debug, è consigliabile aggiungere il suggerimento per i dati per la variabile per concedere a se stessi l'accesso rapido. La variabile rimane bloccata anche dopo il riavvio. Per aggiungere la descrizione dati, fare clic sull'icona a forma di puntina mentre si passa il puntatore del mouse su di esso. È possibile aggiungere più variabili.

È anche possibile personalizzare i suggerimenti per i dati in diversi altri modi, ad esempio mantenere un suggerimento dati espanso (una descrizione dati permanente) o rendere trasparente un suggerimento per i dati. Per altre informazioni, vedere Visualizzare i valori dei dati in Data Suggerimenti nell'editor di codice.

Modificare il codice e continuare il debug (C#, VB, C++)

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 della funzionalità e sulle limitazioni delle funzionalità, vedere Modifica e continuazione.

Modificare il codice XAML e continuare il debug

Per modificare il codice XAML durante una sessione di debug, vedi Scrivere ed eseguire il debug di codice XAML con Ricaricamento rapido XAML.

Problemi di debug difficili da riprodurre

Se è difficile o dispendioso in termini di tempo ricreare uno stato specifico nell'app, valutare se l'uso di un punto di interruzione condizionale può essere utile. Puoi usare punti di interruzione condizionali e punti di interruzione dei filtri per evitare l'interruzione nel codice dell'app fino a quando l'app non entra nello stato desiderato( ad esempio uno stato in cui una variabile archivia dati non valido). È possibile impostare condizioni usando espressioni, filtri, hit counts e così via.

Per creare un punto di interruzione condizionale

1. Fare clic con il pulsante destro del mouse su un'icona del punto di interruzione (la sfera rossa) e scegliere Condizioni.

2. Nella finestra Punto di interruzione Impostazioni digitare un'espressione.

   

3. Se si è interessati a un altro tipo di condizione, selezionare Filtro anziché Espressione condizionale nella finestra di dialogo Punto di interruzione Impostazioni e quindi seguire i suggerimenti per i filtri.

Configurare i dati da visualizzare nel debugger

Per C#, Visual Basic e C++ (solo codice C++/CLI), è possibile indicare al debugger quali informazioni mostrare usando l'attributo DebuggerDisplay . Per il codice C++, è possibile eseguire le stesse operazioni usando le visualizzazioni Natvis.

Collegarsi ripetutamente alla stessa applicazione

Quando si usa la funzionalità di collegamento a processo, è possibile ricollegare rapidamente a un processo a cui è stato precedentemente collegato scegliendo Debug>Ricollegamento al processo (MAIUSC+ALT+P). Quando si sceglie questo comando, il debugger tenterà immediatamente di connettersi all'ultimo processo a cui si è collegato provando prima a trovare la corrispondenza con l'ID del processo precedente e, in caso di errore, corrispondendo al nome del processo precedente. Se non vengono trovate corrispondenze o se più processi hanno lo stesso nome, verrà aperta la finestra di dialogo Connetti a processo in modo da poter selezionare il processo corretto.

Tenere traccia di un oggetto out-of-scope (C#, Visual Basic)

È facile visualizzare le variabili usando finestre del debugger come la finestra Espressioni di controllo . Tuttavia, quando una variabile esce dall'ambito nella finestra Espressioni di controllo , è possibile notare che è disattivata. In alcuni scenari dell'app, il valore di una variabile può cambiare anche quando la variabile non rientra nell'ambito e può essere utile osservarla attentamente( ad esempio, una variabile potrebbe ottenere il Garbage Collection). È possibile tenere traccia della variabile creando un ID oggetto nella finestra Espressione di controllo .

Per creare un ID oggetto

1. Impostare un punto di interruzione vicino a una variabile da tenere traccia.

2. Avviare il debugger (F5) e arrestarlo in corrispondenza del punto di interruzione.

3. Trovare la variabile nella finestra Variabili locali (Debug > variabili locali di Windows>), fare clic con il pulsante destro del mouse sulla variabile e scegliere Crea ID oggetto.

   

4. Nella finestra $ verrà visualizzato il simbolo Variabili locali . Questa variabile è l'ID oggetto.

5. Fare clic con il pulsante destro del mouse sulla variabile ID oggetto e scegliere Aggiungi espressione di controllo.

Per altre informazioni, vedere Creare un ID oggetto.

Visualizzare i valori restituiti per le funzioni

Per visualizzare i valori restituiti per le funzioni, esaminare le funzioni visualizzate nella finestra Auto durante l'esecuzione del codice. Per visualizzare il valore restituito per una funzione, assicurarsi che la funzione a cui si è interessati sia già stata eseguita (premere F10 una volta se si è attualmente arrestati nella chiamata di funzione). Se la finestra è chiusa, usare Debug > di Windows > Auto per aprire la finestra Auto.

Inoltre, è possibile immettere le funzioni nella finestra Immediata per visualizzare i valori restituiti. (Aprirlo usando Debug > immediato di Windows>.

È anche possibile usare pseudovariabili nella finestra Espressione di controllo e controllo immediato , ad esempio $ReturnValue.

Esaminare le stringhe in un visualizzatore

Quando si utilizzano stringhe, può essere utile visualizzare l'intera stringa formattata. Per visualizzare un testo normale, XML, HTML o stringa JSON, fare clic sull'icona della lente di ingrandimento mentre si passa il puntatore del mouse su una variabile contenente un valore stringa.

Un visualizzatore di stringhe può aiutare a determinare se una stringa è in formato non corretto, a seconda del tipo di stringa. Ad esempio, un campo Valore vuoto indica che la stringa non viene riconosciuta dal tipo di visualizzatore. Per altre informazioni, vedere Finestra di dialogo Visualizzatore di stringhe.

Per alcuni altri tipi, ad esempio DataSet e Oggetti DataTable visualizzati nelle finestre del debugger, è anche possibile aprire un visualizzatore predefinito.

Analizzare l'utilizzo della memoria

È possibile acquisire e confrontare snapshot dell'heap, ottimizzare l'utilizzo della memoria e trovare una perdita di memoria usando gli strumenti di utilizzo della memoria. Per altre informazioni, vedere Scegliere uno strumento di analisi della memoria.

Creare un file dump

Un file di dump è uno snapshot che mostra il processo in esecuzione e i moduli caricati per un'app in un momento specifico. Un dump con informazioni sull'heap include anche uno snapshot della memoria dell'app a quel punto. I dump vengono usati principalmente per eseguire il debug dei problemi dai computer a cui gli sviluppatori non hanno accesso.

Se è necessario salvare un file di dump, selezionare Debug > Salva dump con nome.

Per analizzare un file dump, scegliere Apri file > in Visual Studio. Per avviare il debug usando il file di dump, selezionare Debug con solo gestito, Debug con solo nativo, Debug con misto o Debug con memoria gestita.

Per altre informazioni, vedere File di dump.

Suddividere il codice nelle eccezioni gestite

Il debugger si suddivide nel codice in caso di eccezioni non gestite. Tuttavia, le eccezioni gestite (ad esempio le eccezioni che si verificano all'interno di un try/catch blocco) possono anche essere una fonte di bug e può essere utile analizzare quando si verificano. È possibile configurare il debugger per suddividere il codice anche per le eccezioni gestite configurando le opzioni nella finestra di dialogo Eccezione Impostazioni . Aprire questa finestra di dialogo scegliendo Debug > eccezione windows > Impostazioni.

La finestra di dialogo Eccezione Impostazioni consente di indicare al debugger di suddividere il codice in eccezioni specifiche. Nella figura seguente il debugger si suddivide nel codice ogni volta che si verifica un oggetto System.NullReferenceException . Per altre informazioni, vedere Gestione delle eccezioni.

Modificare il flusso di esecuzione

Con il debugger sospeso su una riga di codice, usare il mouse per afferrare il puntatore freccia gialla a sinistra. Spostare il puntatore a freccia gialla in un punto diverso nel percorso di esecuzione del codice. Usare quindi F5 o un comando step per continuare a eseguire l'app.

Modificando il flusso di esecuzione è possibile eseguire operazioni come testare percorsi di esecuzione del codice diversi o rieseguire il codice senza riavviare il debugger. Per altre informazioni, vedere Spostare il puntatore di esecuzione.

Avviso

Spesso questa funzionalità deve essere usata con attenzione. Nella descrizione comando viene visualizzato un avviso. È anche possibile che vengano visualizzati altri avvisi. Lo spostamento del puntatore non può ripristinare lo stato precedente dell'applicazione.

Eseguire il debug di deadlock e race condition

Se è necessario eseguire il debug dei tipi di problemi comuni alle app multithreading, spesso consente di visualizzare la posizione dei thread durante il debug. È possibile farlo facilmente usando il pulsante Mostra thread nell'origine .

Per visualizzare i thread nel codice sorgente:

1. Durante il debug, fare clic sul pulsante Mostra thread nell'origine nella barra degli strumenti Debug.

2. All'estrema sinistra della finestra, In questa riga viene visualizzata un'icona del marcatore di filo simile a due fili di panno. Il marcatore del thread indica l'interruzione di un thread in questa posizione.

   Si noti che un marcatore di thread può essere parzialmente nascosto da un punto di interruzione.

3. Posizionare il puntatore del mouse sul marcatore del thread. Viene visualizzato un suggerimento dati. in cui è indicato il nome e il numero ID di ciascun thread interrotto.

   È anche possibile visualizzare la posizione dei thread nella finestra Stack paralleli.

Acquisire familiarità con il modo in cui il debugger si collega all'app (C#, C++, Visual Basic, F#)

Per connettersi all'app in esecuzione, il debugger carica i file di simboli (con estensione pdb) generati per la stessa compilazione dell'app che si sta tentando di eseguire il debug. In alcuni scenari, può essere utile conoscere poco i file di simboli. È possibile esaminare il modo in cui Visual Studio carica i file di simboli usando la finestra Moduli .

Aprire la finestra Moduli durante il debug selezionando Debug > moduli Windows>. La finestra Moduli può indicare i moduli che il debugger considera come codice utente o Codice personale e lo stato di caricamento dei simboli per il modulo. Nella maggior parte degli scenari, il debugger trova automaticamente i file di simboli per il codice utente, ma se si vuole eseguire il debug di codice .NET, il codice di sistema o il codice della libreria di terze parti, sono necessari passaggi aggiuntivi per ottenere i file di simboli corretti.

È possibile caricare le informazioni sui simboli direttamente dalla finestra Moduli facendo clic con il pulsante destro del mouse e scegliendo Carica simboli.

In alcuni casi, gli sviluppatori di app spediscono app senza i file di simboli corrispondenti (per ridurre il footprint), ma mantengono una copia dei file di simboli corrispondenti per la compilazione in modo che possano eseguire il debug di una versione rilasciata in un secondo momento.

Per informazioni su come il debugger classifica il codice come codice utente, vedere Just My Code. Per altre informazioni sui file di simboli, vedere Specificare i file di simboli (con estensione pdb) e di origine nel debugger di Visual Studio.

Altre informazioni

Per ulteriori suggerimenti e trucchi e informazioni più dettagliate, vedere questi post di blog:

• 7 hack meno noti per il debug in Visual Studio
• 7 gemme nascoste in Visual Studio

Contenuto correlato

Tasti di scelta rapida