Guida rapida: Navigazione nel debugger (XAML e C#)

Questa guida introduttiva illustra come spostarsi nelle sessioni di debug di Visual Studio e come visualizzare e modificare lo stato del programma in una sessione.

La guida è destinata agli sviluppatori che non hanno familiarità con il debug in Visual Studio e a coloro che desiderano avere maggiori informazioni su come spostarsi in una sessione di debug di Visual Studio, ma non insegna l'arte stessa del debug. I metodi inclusi nel codice di esempio sono concepiti solo per illustrare le procedure di debug descritte in questo argomento. Non usano procedure consigliate per la progettazione di app o funzioni. In realtà, come scoprirai presto, i metodi e l'app stessa non hanno alcuna finalità pratica.

Le sezioni di questa guida introduttiva sono state progettate nell'ottica della massima indipendenza per consentirti di ignorare le eventuali sezioni contenenti informazioni che già conosci. Non sei inoltre obbligato a creare un'app di esempio, anche se te lo consigliamo e abbiamo fatto in modo da rendere il processo più semplice possibile.

Tasti di scelta rapida del debugger. La navigazione nel debugger di Visual Studio è ottimizzata sia per il mouse che per la tastiera. In molti passaggi di questo argomento è indicato il tasto di scelta rapida in un commento racchiuso tra parentesi. Ad esempio, (tastiera: F5) indica che premendo il tasto F5 si avvia o si continua l'esecuzione del debugger.

In questo argomento

Potrai apprendere come:

• Create the sample app

• Set and run to a breakpoint, step into a method, and examine program data

• Step into, over, and out of methods

• Set a conditional breakpoint, run to the cursor, and visualize a variable

• Edit and continue, recover from an exception

Creare un'app di esempio

Il debug viene eseguito sul codice. L'app di esempio usa quindi il framework dell'app di Windows Store solo per creare un file di origine in cui puoi vedere come funziona la navigazione in una sessione di debug e come esaminare e modificare lo stato del programma. Tutto il codice che richiamerai viene chiamato dal costruttore della pagina principale. Non vengono aggiunti controlli, né gestiti eventi.

Creare un'app di Windows Store C# predefinita. Apri Visual Studio. Nella home page scegli il link Nuovo progetto. Nella finestra di dialogo Nuovo progetto scegli Visual C# nell'elenco Installato e scegli Windows Store. Nell'elenco di modelli di progetto scegli Applicazione. Visual Studio crea una nuova soluzione e il progetto, visualizzando la finestra di progettazione del file MainPage.xaml e l'editor di codice XAML.

Aprire il file di origine MainPage.xaml.cs. Fai clic con il pulsante destro del mouse in un punto qualsiasi dell'editor XAML e scegli Visualizza codice. Viene visualizzato il file code-behind MainPage.xaml.cs. Come puoi notare, nel file è elencato un solo metodo, il costruttore MainPage().

Sostituire il costruttore MainPage con il codice di esempio. Elimina il metodo MainPage(). Visita il link Esempio di codice di navigazione nel debugger (XAML e C#), quindi copia negli Appunti il codice riportato nella sezione C#. Scegli Indietro nel browser o nel visualizzatore della Guida per tornare a questa pagina della guida introduttiva. Nell'editor di Visual Studio incolla il codice nel blocco partial class MainPage. Scegli CTRL + S per salvare il file.

A questo punto puoi proseguire con gli esempi di questo argomento.

Impostare e raggiungere un punto di interruzione, eseguire un'istruzione in un metodo ed esaminare i dati del programma

Il modo più comune per avviare una sessione di debug consiste nello scegliere Avvia debug dal menu Debug (tastiera: F5). L'esecuzione inizia e continua fino a raggiungere un punto di interruzione. Sospendi manualmente l'esecuzione e si verifica un'eccezione o l'app termina.

Dopo la sospensione dell'esecuzione nel debugger, puoi visualizzare il valore di una variabile attiva in un suggerimento dati passando il mouse sulla variabile. Puoi anche aprire le finestre Variabili locali e Auto per vedere gli elenchi delle variabili attive e i relativi valori correnti. Aggiungendo una o più variabili a una finestra Espressioni di controllo, puoi concentrarti sul valore delle variabili mentre l'esecuzione dell'app continua.

Dopo la sospensione dell'esecuzione dell'app, un'operazione detta anche interruzione del debugger, puoi controllare in che modo viene eseguito il resto del codice programma. Puoi continuare riga per riga, passando da una chiamata al metodo al metodo stesso, o eseguire un metodo chiamato in un singolo passaggio. Queste procedure sono dette esecuzione dell'app un'istruzione alla volta. Puoi anche riprendere la normale esecuzione dell'app, continuandola fino al successivo punto di interruzione impostato o fino alla riga in cui hai posizionato il cursore. Puoi arrestare la sessione di debug in qualsiasi momento. Il debugger è progettato per eseguire le necessarie operazioni di pulizia e per uscire dall'esecuzione.

Esempio 1

In questo esempio potrai impostare un punto di interruzione nel costruttore MainPage del file MainPage.xaml.cs, eseguire un'istruzione nel primo metodo, visualizzare i valori delle variabili, quindi arrestare il debug.

Impostare un punto di interruzione. Imposta un punto di interruzione in corrispondenza dell'istruzione methodTrack = "Main Page"; nel costruttore MainPage. Scegli la riga nella barra di navigazione ombreggiata dell'editor del codice sorgente (tastiera: posiziona il cursore sulla riga e premi F9).

L'icona del punto di interruzione viene visualizzata nella barra di navigazione.

Eseguire fino al punto di interruzione. Avvia la sessione di debug scegliendo Avvia debug dal menu Debug (tastiera: F5).

L'esecuzione dell'app inizia e viene sospesa immediatamente prima dell'istruzione in cui hai impostato il punto di interruzione. L'icona della riga corrente nella barra di navigazione identifica la posizione e l'istruzione corrente risulta evidenziata.

A questo punto puoi controllare l'esecuzione dell'app ed esaminare lo stato del programma mentre esegui il codice un'istruzione alla volta.

Eseguire un'istruzione nel metodo. Scegli Esegui istruzione dal menu Debug (tastiera: F11).

Come puoi notare il debugger passa alla riga successiva, che corrisponde a una chiamata al metodo Example1. Scegli di nuovo Esegui istruzione. Il debugger passa al punto di ingresso del metodo Example1. Ciò indica che il metodo è stato caricato nello stack di chiamate e che è stata allocata la memoria per le variabili locali.

Quando esegui un'istruzione in una riga di codice, il debugger esegue una delle seguenti azioni:

• Se l'istruzione successiva non è una chiamata a una funzione nella soluzione, il debugger esegue l'istruzione, passa all'istruzione successiva, quindi sospende l'esecuzione.

• Se l'istruzione è una chiamata a una funzione nella soluzione, il debugger passa al punto di ingresso della funzione chiamata, quindi sospende l'esecuzione.

Continua a eseguire le istruzioni in Example1 finché non avrai raggiunto il punto di uscita. Il debugger evidenzia la parentesi graffa chiusa del metodo.

Esaminare i valori delle variabili nei suggerimenti dati. Se passi il mouse sul nome di una variabile, vedrai il nome, il valore e il tipo in un suggerimento dati.

Passa il mouse sulla variabile a. Osserva il nome, il valore e il tipo di dati. Passa il mouse sulla variabile methodTrack. Anche in questo caso sono indicati il nome, il valore e il tipo di dati.

Esaminare i valori delle variabili nella finestra Variabili locali. Scegli Finestre dal menu Debug, quindi Variabili locali. (Tastiera: ALT+4).

La finestra Variabili locali è una visualizzazione albero dei parametri e delle variabili della funzione. Le proprietà di una variabile oggetto sono nodi figlio dell'oggetto stesso. La variabile this è un parametro nascosto in ogni metodo dell'oggetto che rappresenta l'oggetto stesso. In questo caso, rappresenta la classe MainPage. Poiché methodTrack è un membro della classe MainPage, il valore e il tipo di dati corrispondenti vengono elencati in una riga al di sotto di this. Per visualizzare le informazioni relative a methodTrack, espandi il nodo this.

Aggiungere un'espressione di controllo per la variabile methodTrack. La variabile methodWatch viene utilizzata in tutta la guida introduttiva per illustrare i metodi chiamati negli esempi. Per visualizzare più facilmente il valore della variabile, aggiungila a una finestra Espressioni di controllo. Fai clic con il pulsante destro del mouse sul nome della variabile nella finestra Variabili locali, quindi scegli Aggiungi espressione di controllo.

In una finestra Espressioni di controllo puoi controllare più variabili. I valori delle variabili controllate, come i valori nelle finestre Variabili locali e Suggerimenti dati, vengono aggiornati a ogni sospensione dell'esecuzione. Puoi anche aggiungere variabili nella finestra Espressioni di controllo dall'editor di codice. Seleziona la variabile da controllare, fai clic con il pulsante destro del mouse, quindi scegli Aggiungi espressione di controllo.

Eseguire un'istruzione, eseguire un'istruzione/routine e uscire da un'istruzione/routine dei metodi

A differenza dell'esecuzione di un'istruzione in un metodo chiamato da un metodo padre, l'esecuzione di un'istruzione/routine in un metodo comporta l'esecuzione del metodo figlio e la successiva sospensione dell'esecuzione nel metodo chiamante alla ripresa del metodo padre. Prima di eseguire un'istruzione/routine di un metodo, dovrai avere acquisito familiarità con il funzionamento del metodo e avere la certezza che questa operazione non influirà sul problema che stai analizzando.

L'esecuzione di un'istruzione/routine in una riga di codice che non contiene una chiamata al metodo ha lo stesso effetto della semplice esecuzione di un'istruzione nella riga.

All'uscita da un'istruzione/routine di un metodo figlio, l'esecuzione del metodo continua, quindi viene sospesa dopo che il metodo sarà ritornato al relativo metodo chiamante. Puoi uscire da un'istruzione/routine di una funzione lunga dopo aver stabilito che il resto della funzione non è significativo.

Sia l'esecuzione che l'uscita da un'istruzione/routine di una funzione comporta l'esecuzione della funzione.

Esempio 2

In questo esempio proverai a eseguire un'istruzione, eseguire un'istruzione/routine e uscire da un'istruzione/routine dei metodi.

Chiamare il metodo Example2 nel costruttore MainPage. Modifica il costruttore MainPage e sostituisci la riga dopo methodTrack = String.Empty; con Example2();.

Eseguire fino al punto di interruzione. Avvia la sessione di debug scegliendo Avvia debug dal menu Debug (tastiera: F5). Il debugger sospende l'esecuzione nel punto di interruzione.

Eseguire un'istruzione/routine della riga di codice. Scegli Esegui istruzione/routine dal menu Debug (tastiera: F10). Il debugger esegue l'istruzione methodTrack = "MainPage"; nello stesso modo in cui procede all'esecuzione dell'istruzione.

Eseguire un'istruzione in Example2 e in Example2_A. Premi F11 per eseguire un'istruzione nel metodo Example2. Continua a eseguire le istruzioni in Example2 fino a raggiungere la riga int x = Example2_A();. Esegui quindi l'istruzione in questa riga per passare al punto di ingresso di Example2_A. Continua a eseguire ogni istruzione di Example2_A fino a tornare a Example2.

Eseguire un'istruzione/routine di una funzione. Come noterai, la riga successiva in Example2, int y = Example2_A(); è fondamentalmente uguale alla riga precedente. Puoi tranquillamente eseguire l'istruzione/routine in questa riga. Premi F10 per passare dalla ripresa di Example2 a questa seconda chiamata a Example2_A. Premi F10 per eseguire l'istruzione/routine di questo metodo. La stringa methodTrack indica che il metodo Example2_A è stato eseguito due volte. Noterai anche che il debugger passa immediatamente alla riga successiva. Non sospende l'esecuzione nel punto in cui riprende Example2.

Uscire dall'istruzione/routine di una funzione. Premi F11 per eseguire l'istruzione nel metodo Example2_B. Come puoi notare, Example2_B non è molto diverso da Example2_A. Per uscire dall'istruzione/routine del metodo, scegli Esci da istruzione/routine dal menu Debug (tastiera: MAIUSC + F11). La variabile methodTrack indica che Example2_B è stato eseguito e che il debugger è ritornato al punto in cui riprende Example2.

Arrestare il debug. Scegli Termina debug dal menu Debug (tastiera: MAIUSC+F5). La sessione di debug viene terminata.

Impostare un punto di interruzione condizionale, eseguire fino al cursore e visualizzare una variabile

Un punto di interruzione condizionale specifica una condizione che determina la sospensione dell'esecuzione da parte del debugger. La condizione viene specificata da una qualsiasi espressione di codice che possa restituire true o false. Puoi utilizzare un punto di interruzione, ad esempio, per esaminare lo stato del programma in un metodo chiamato di frequente solo quando una variabile raggiunge un determinato valore.

L'esecuzione fino al cursore corrisponde all'impostazione di un punto di interruzione unico. Quando l'esecuzione viene sospesa, puoi selezionare una riga nell'origine e riprendere l'esecuzione fino a raggiungere la riga selezionata. Ad esempio, stai eseguendo un ciclo in un metodo e determini che il codice nel ciclo viene eseguito correttamente. Anziché eseguire ogni singola iterazione del ciclo, puoi scegliere di eseguire fino al cursore che viene posizionato dopo l'esecuzione del ciclo.

A volte è difficile visualizzare il valore di una variabile nella riga della finestra del suggerimento dati o delle variabili. Il debugger consente di visualizzare stringhe, HTML e XML in un visualizzatore di testo che presenta una visualizzazione formattata del valore in una finestra scorrevole.

Esempio 3

In questo esempio imposterai un punto di interruzione condizionale che interrompe un'iterazione specifica di un ciclo, quindi procede all'esecuzione fino al cursore inserito dopo il ciclo. Puoi anche vedere il valore di una variabile in un visualizzatore di testo.

Chiamare il metodo Example3 nel costruttore MainPage. Modifica il costruttore MainPage e sostituisci la riga dopo methodTrack = String.Empty; con la riga Example3();.

Eseguire fino al punto di interruzione. Avvia la sessione di debug scegliendo Avvia debug dal menu Debug (tastiera: F5). Il debugger sospende l'esecuzione nel punto di interruzione del metodo MainPage.

Eseguire un'istruzione nel metodo Example3. Scegli Esegui istruzione dal menu Debug (tastiera: F11) per passare al punto di ingresso del metodo Example3. Continua a eseguire istruzioni nel metodo finché non avrai iterato uno o due cicli del blocco for. Tieni presente che l'esecuzione di tutte e 1000 le iterazioni richiede molto tempo.

Impostare un punto di interruzione condizionale. Nella barra di navigazione a sinistra della finestra del codice fai clic con il pulsante destro del mouse sulla riga x += i;, quindi scegli Condizione. Seleziona la casella di controllo Condizione, quindi digita i == 500; nella casella di testo. Scegli l'opzione È true, quindi OK. Il punto di interruzione consente di controllare il valore alla 500a iterazione del ciclo for.

Puoi identificare un punto di interruzione condizionale dalla relativa icona con una croce bianca.

Eseguire fino al punto di interruzione. Scegli Continua dal menu Debug (tastiera: F5). Nella finestra Variabili locali verifica che il valore corrente di i sia 500. Come noterai, la variabile s è rappresentata come singola riga ed è molto più lunga della finestra.

Visualizzare una variabile di tipo stringa. Fai clic sull'icona a forma di lente di ingrandimento nella colonna Valore di s.

Viene visualizzata la finestra del Visualizzatore testo con il valore della stringa presentato come una stringa con più righe.

Eseguire fino al cursore. Fai clic con il pulsante destro del mouse sulla riga methodTrack += "->Example3";, quindi scegli Esegui fino al cursore (tastiera: spostare il cursore sulla riga; CTRL + F10). Il debugger completa le iterazioni del ciclo, quindi sospende l'esecuzione in corrispondenza della riga.

Arrestare il debug. Scegli Termina debug dal menu Debug (tastiera: MAIUSC+F5). La sessione di debug viene terminata.

Modifica e continuazione per il recupero da un'eccezione

In alcuni casi, quando interrompi il codice nel debugger di Visual Studio, hai la possibilità di modificare il valore delle variabili e addirittura la logica delle istruzioni. Questa funzionalità è detta Modifica e continuazione.

Modifica e continuazione può essere particolarmente utile quando interrompi il codice in corrispondenza di un'eccezione. Anziché arrestare e riavviare il debug di una routine lunga e necessaria per evitare l'eccezione, puoi "rimuovere" l'eccezione per spostare l'esecuzione nel punto che precede immediatamente la posizione in cui si è verificata l'eccezione. Puoi quindi modificare la variabile o l'istruzione che crea il problema e continuare la sessione di debug corrente in uno stato che non generi un'eccezione.

Anche se puoi utilizzare Modifica e continuazione in molteplici situazioni, è difficile specificare le particolari condizioni che non supportano questa funzionalità. Tali condizioni dipendono infatti dal linguaggio di programmazione, dallo stato corrente dello stack del programma e dalla capacità del debugger di modificare lo stato senza danneggiare il processo. Il modo migliore per determinare se una modifica è supportata è semplicemente quello di provarla. Il debugger indicherà immediatamente se la modifica non è supportata.

Esempio 4

In questo esempio proverai a eseguire il debugger fino a un'eccezione, rimuovere l'eccezione, correggere la logica del metodo, quindi modificare il valore di una variabile in modo da poter continuare l'esecuzione del metodo.

Chiamare il metodo Example4 nel costruttore MainPage. Modifica il costruttore MainPage() e sostituisci la riga dopo methodTrack = String.Empty; con la riga Example4();.

Eseguire fino all'eccezione. Avvia la sessione di debug scegliendo Avvia debug dal menu Debug (tastiera: F5). Premi di nuovo F5 per riprendere l'esecuzione. Il debugger sospende l'esecuzione in corrispondenza dell'eccezione nel metodo Example4 e visualizza una finestra di dialogo dell'eccezione.

Modificare la logica di programma. È chiaro che l'errore si trova nella condizione if: il valore di x deve essere modificato quando x è uguale a 0. Non deve essere modificato quando x non è uguale a zero. Scegli Interrompi per correggere la logica del metodo. Quando tenti di modificare la riga, viene visualizzata un'altra finestra di dialogo.

Scegli Modifica, quindi modifica la riga if (x != 0) in if (x == 0). Il debugger salva in modo permanente le modifiche alla logica di programma nel file di origine.

Modificare il valore della variabile. Esamina il valore di x in un suggerimento dati o nella finestra Variabili locali. È ancora pari a 0 (zero). Se tenti di eseguire l'istruzione che ha causato l'eccezione originale, verrà semplicemente generata di nuovo. Puoi modificare il valore di x. Nella finestra Variabili locali fai doppio clic sulla colonna Valore della riga x. Modifica il valore da 0 in 1.

Premi F11 per eseguire l'istruzione che in precedenza ha generato un'eccezione. Come noterai, la riga viene eseguita senza errori. Premi di nuovo F11.

Arrestare il debug. Scegli Termina debug dal menu Debug (tastiera: MAIUSC+F5). La sessione di debug viene terminata.

Vedere anche

Concetti

Come avviare una sessione di debug (Visual C++, Visual C# e Visual Basic)

Come attivare eventi di sospensione, ripresa e background nelle app di Windows Store

Debug di app di Windows Store