Esercitazione: Informazioni sul debug del codice C# tramite Visual Studio

Questo articolo descrive le funzionalità del debugger di Visual Studio con una procedura dettagliata. Per una panoramica di alto livello delle funzionalità del debugger, vedere Presentazione del debugger. Quando si esegue il debug dell'app, in genere significa che si esegue l'applicazione con il debugger collegato. Quando si esegue questa attività, il debugger offre molti modi per vedere le operazioni eseguite dal codice durante l'esecuzione. È possibile rivedere il codice ed esaminare i valori archiviati nelle variabili, impostare espressioni di controllo nelle variabili per rilevare le modifiche dei valori, esaminare il percorso di esecuzione del codice, verificare l'esecuzione di un ramo del codice e così via. Se questo esercizio è la prima volta che si è tentato di eseguire il debug del codice, è possibile leggere Debug per principianti prima di eseguire questo articolo.

Anche se l'app demo è C#, la maggior parte delle funzionalità è applicabile a C++, Visual Basic, F#, Python, JavaScript e altri linguaggi supportati da Visual Studio (F# non supporta Modifica e continuazione). F# e JavaScript non supportano la finestra Auto . Gli screenshot sono in linguaggio C#.

Questa esercitazione illustra come:

• Avvio del debugger e raggiungimento dei punti di interruzione
• Uso dei comandi per esaminare il codice nel debugger
• Ispezione delle variabili nelle finestre dei suggerimenti dati e del debugger
• Analisi dello stack di chiamate

Prerequisiti

È necessario avere installato Visual Studio 2022 e il carico di lavoro Sviluppo di applicazioni desktop .NET.

Se non è ancora stato installato Visual Studio, accedere alla pagina Download di Visual Studio per installarlo gratuitamente.

Se Visual Studio è già installato, ma il carico di lavoro Sviluppo di applicazioni desktop .NET non è installato, passare a Strumenti Get Tools>and Features..., che avvia il Programma di installazione di Visual Studio. Nella Programma di installazione di Visual Studio scegliere il carico di lavoro Sviluppo di applicazioni desktop .NET e quindi scegliere Modifica.

Creare un progetto

Prima di tutto, si crea un progetto di applicazione console .NET Core. Il tipo di progetto include fin dall'inizio tutti i file di modello necessari.

1. Aprire Visual Studio. Se la finestra iniziale non è aperta, selezionare Finestra di avvio file>.

2. Nella finestra iniziale selezionare Crea un nuovo progetto.

3. Nella finestra Crea un nuovo progetto immettere la console nella casella di ricerca. Scegliere quindi C# dall'elenco Linguaggio e Windows dall'elenco Piattaforma.

   Dopo aver applicato i filtri lingua e piattaforma, scegliere il modello App console e quindi selezionare Avanti.

   

   Nota

   Se non viene visualizzato il modello app console, è possibile installarlo dalla finestra Crea un nuovo progetto . Nel messaggio L'elemento cercato non è stato trovato? scegliere il collegamento Installa altri strumenti e funzionalità. Quindi, nel Programma di installazione di Visual Studio scegliere il carico di lavoro Sviluppo di applicazioni desktop .NET.

4. Nella finestra Configura il nuovo progetto immettere GetStartedDebugging nella casella Nome progetto. Quindi seleziona Avanti.

5. Nella finestra Informazioni aggiuntive verificare che .NET 8.0 sia selezionato nel menu a discesa Framework e quindi selezionare Crea.

Visual Studio aprirà il nuovo progetto.

Creare l'applicazione

In Program.cs sostituire tutto il codice predefinito con il codice seguente:

using System;

class ArrayExample
{
   static void Main()
   {
      char[] letters = { 'f', 'r', 'e', 'd', ' ', 's', 'm', 'i', 't', 'h'};
      string name = "";
      int[] a = new int[10];
      for (int i = 0; i < letters.Length; i++)
      {
         name += letters[i];
         a[i] = i + 1;
         SendMessage(name, a[i]);
      }
      Console.ReadKey();
   }

   static void SendMessage(string name, int msg)
   {
      Console.WriteLine("Hello, " + name + "! Count to " + msg);
   }
}

Avviare il debugger.

Per lo più, in questo caso si usano i tasti di scelta rapida, perché è un modo rapido per eseguire i comandi del debugger. Vengono inoltre annotati comandi equivalenti, ad esempio i comandi della barra degli strumenti o dei menu.

1. Per avviare il debugger, selezionare F5 o scegliere il pulsante Debug destinazione nella barra degli strumenti Standard oppure scegliere il pulsante Avvia debug sulla barra degli strumenti Debug oppure scegliere Debug>Avvia debug dalla barra dei menu.

   

   F5 avvia l'app con il debugger collegato al processo dell'app. Poiché non è stato fatto nulla di speciale per esaminare il codice, l'app viene eseguita fino al completamento e viene visualizzato l'output della console.

   Hello, f! Count to 1
   Hello, fr! Count to 2
   Hello, fre! Count to 3
   Hello, fred! Count to 4
   Hello, fred ! Count to 5
   Hello, fred s! Count to 6
   Hello, fred sm! Count to 7
   Hello, fred smi! Count to 8
   Hello, fred smit! Count to 9
   Hello, fred smith! Count to 10
   

2. Per arrestare il debugger, selezionare MAIUSC+F5 oppure scegliere il pulsante Arresta debug sulla barra degli strumenti Debug oppure scegliere Debug>Arresta debug dalla barra dei menu.

   

3. Nella finestra della console selezionare qualsiasi chiave per chiudere la finestra della console.

Impostare un punto di interruzione e avviare il debugger

1. for Nel ciclo della Main funzione impostare un punto di interruzione facendo clic sul margine sinistro sulla riga di codice seguente:

   name += letters[i];

   Quando viene impostato il punto di interruzione viene visualizzato un cerchio rosso.

   

   I punti di interruzione sono una funzionalità essenziale del debug affidabile. È possibile impostare punti di interruzione in cui si vuole che Visual Studio sospende il codice in esecuzione in modo da poter esaminare i valori delle variabili o il comportamento della memoria oppure sapere se un ramo di codice sta per essere eseguito.

2. Per avviare il debug, selezionare F5 o scegliere il pulsante Debug destinazione nella barra degli strumenti Standard oppure scegliere il pulsante Avvia debug sulla barra degli strumenti Debug oppure scegliere Debug>Avvia debug dalla barra dei menu. L'app viene avviata e il debugger viene eseguito alla riga di codice in cui si imposta il punto di interruzione.

   

   La freccia gialla punta all'istruzione in cui è stato sospeso il debugger. L'esecuzione dell'app viene sospesa allo stesso punto, con l'istruzione non ancora eseguita.

   Quando l'app non è in esecuzione, F5 avvia il debugger, che esegue l'app fino a raggiungere il primo punto di interruzione. Se l'app viene sospesa in corrispondenza di un punto di interruzione, F5 continuerà a eseguire l'app fino a raggiungere il punto di interruzione successivo.

   I punti di interruzione sono una funzionalità utile quando si conosce la riga o la sezione del codice da esaminare in dettaglio. Per altre informazioni sui diversi tipi di punti di interruzione che è possibile impostare, ad esempio i punti di interruzione condizionali, vedere Uso di punti di interruzione.

Esplorare il codice ed esaminare i dati usando i suggerimenti per i dati

1. Mentre l'esecuzione del codice viene sospesa nell'istruzione name += letters[i] , passare il puntatore del mouse sulla letters variabile per visualizzare una descrizione dati che mostra le dimensioni della matrice e il tipo di elemento, char[10].

   Nota

   Una delle funzionalità più utili del debugger è la possibilità di esaminare una variabile. Spesso, quando si tenta di eseguire il debug di un problema, si sta tentando di verificare se le variabili hanno valori previsti in un determinato momento. La visualizzazione dei suggerimenti per i dati è un buon modo per verificarlo.

2. Espandere la letters variabile per visualizzare tutti gli elementi della matrice e i relativi valori.

   

3. Passare il puntatore del mouse sulla variabile per visualizzarne il name valore corrente, ovvero una stringa vuota.

4. Per passare al debugger all'istruzione successiva, selezionare F10 oppure scegliere il pulsante Esegui istruzione/routine sulla barra degli strumenti Debug oppure scegliere Esegui debug>istruzione/routine dalla barra dei menu. Selezionare F10 due volte più per spostarsi oltre la chiamata al SendMessage metodo.

   F10 fa avanzare il debugger senza eseguire istruzioni in metodi o funzioni, anche se il codice viene ancora eseguito. In questo modo, è stato ignorato il debug del codice nel SendMessage metodo , che non è interessato al momento.

5. Per scorrere il for ciclo alcune volte, selezionare F10 ripetutamente. Durante ogni iterazione del ciclo, sospendere il punto di interruzione e quindi passare il puntatore del mouse sulla variabile per controllarne il name valore nella descrizione dati.

   

   Il valore della variabile cambia con ogni iterazione del for ciclo, mostrando i valori di f, quindi fr, e frecosì via. Per accelerare il debugger attraverso il ciclo, selezionare invece F5 , che passa al punto di interruzione anziché all'istruzione successiva.

6. Mentre l'esecuzione del codice è sospesa nel ciclo del Main metodo, selezionare F11 oppure scegliere il pulsante Esegui istruzione dalla barra degli strumenti Debug oppure scegliere Esegui debug> nella barra dei menu fino a raggiungere la chiamata al SendMessage metodo.for

   Il debugger deve essere sospeso in corrispondenza di questa riga di codice:

   SendMessage(name, a[i]);

7. Per eseguire l'istruzione nel SendMessage metodo, selezionare di nuovo F11 .

   Il puntatore giallo avanza nel SendMessage metodo .

   

   F11 consente di esaminare in modo più approfondito il flusso di esecuzione del codice. Per eseguire un'istruzione in un metodo da una chiamata al metodo, selezionare F11. Per impostazione predefinita, il debugger ignora l'esecuzione di istruzioni nei metodi non utente. Per informazioni sul debug di codice non utente, vedere Just My Code.

   Dopo aver completato il debug del SendMessage metodo, è possibile tornare al for ciclo del main metodo.

8. Per lasciare il SendMessage metodo, selezionare MAIUSC+F11 oppure scegliere il pulsante Esci da istruzione/routine nella barra degli strumenti Debug oppure scegliere Esegui debug>esci dalla barra dei menu.

   Step Out riprende l'esecuzione dell'app e sposta il debugger fino a quando non viene restituito il metodo o la funzione corrente.

   Viene visualizzato di nuovo il puntatore giallo nel for ciclo del Main metodo, sospeso alla chiamata al SendMessage metodo. Per altre informazioni sui diversi modi per spostarsi nel codice, vedere Esplorare il codice nel debugger.

Esplorare il codice con il pulsante per l'esecuzione fino alla riga selezionata dall'utente

1. Selezionare F5 per passare di nuovo al punto di interruzione.

2. Nell'editor di codice passare il puntatore del mouse sulla chiamata al Console.WriteLineSendMessage metodo nel metodo fino a quando non viene visualizzato il pulsante Esegui a clic . La descrizione comando per il pulsante mostra "Esegui l'esecuzione qui".

   

3. Scegliere il pulsante Esegui per fare clic . In alternativa, con il cursore in corrispondenza dell'istruzione Console.WriteLine, selezionare CTRL+F10. In alternativa, fare clic con il pulsante destro del mouse sulla Console.WriteLine chiamata al metodo e scegliere Esegui in cursore dal menu di scelta rapida.

   Il debugger passa alla chiamata al Console.WriteLine metodo.

   L'uso del pulsante Esegui per fare clic è simile all'impostazione di un punto di interruzione temporaneo ed è utile per spostarsi rapidamente all'interno di un'area visibile del codice dell'app in un file aperto.

Riavviare rapidamente l'app

Per rieseguire l'app dall'inizio del debugger, selezionare CTRL+MAIUSC+F5 oppure scegliere il pulsante Riavvia sulla barra degli strumenti Debug oppure scegliere Debug>Riavvia dalla barra dei menu.

Il riavvio arresta il debugger e quindi lo riavvia in un unico passaggio. Quando il debugger viene riavviato, viene eseguito al primo punto di interruzione, ovvero il punto di interruzione impostato in precedenza all'interno del for ciclo, quindi viene sospeso.

Esaminare le variabili con le finestre Auto e Variabili locali

Le finestre Auto e Variabili locali mostrano i valori delle variabili durante il debug. Le finestre sono disponibili solo durante una sessione di debug. Nella finestra Auto vengono visualizzate le variabili usate nella riga corrente in cui si trova il debugger e nella riga precedente. La finestra Variabili locali mostra le variabili definite nell'ambito locale, che è in genere la funzione o il metodo corrente.

1. Mentre il debugger è in pausa, visualizzare la finestra Auto nella parte inferiore dell'editor di codice.

   Se la finestra Auto è chiusa, selezionare CTRL+D, A o scegliere Debug>di Windows>Auto dalla barra dei menu.

2. Con il debugger ancora sospeso, visualizzare la finestra Variabili locali , in una scheda accanto alla finestra Auto .

   Se la finestra Variabili locali è chiusa, selezionare CTRL+D, L o scegliere Debug>variabili locali di Windows.>

3. Nella finestra Variabili locali espandere la variabile per visualizzare gli elementi della letters matrice e i relativi valori.

   

Per altre informazioni sulle finestre Auto e Variabili locali, vedere Controllare le variabili nelle finestre Auto e Variabili locali.

Impostare un'espressione di controllo

È possibile specificare una variabile o un'espressione che si vuole tenere d'occhio mentre si esegue il codice aggiungendolo alla finestra Espressione di controllo.

1. Mentre il debugger è in pausa, fare clic con il pulsante destro del mouse sulla name variabile e scegliere Aggiungi espressione di controllo.

   La finestra Espressione di controllo viene aperta per impostazione predefinita nella parte inferiore dell'editor di codice.

2. Dopo aver impostato un'espressione di controllo sulla name variabile, esaminare il codice per visualizzare il valore della name variabile modificata con ogni for iterazione del ciclo.

   A differenza delle altre finestre delle variabili, la finestra Espressione di controllo mostra sempre le variabili che si sta osservando. Le variabili che non rientrano nell'ambito vengono visualizzate come non disponibili.

Per altre informazioni sulla finestra Espressioni di controllo, vedere Controllare le variabili con le finestre Espressioni di controllo.

Analisi dello stack di chiamate

Lo stack di chiamate consente di comprendere il flusso di esecuzione dell'app, mostrando l'ordine in cui vengono chiamati i metodi e le funzioni.

1. Mentre il debugger è sospeso nel for ciclo, visualizzare la finestra Stack di chiamate, che viene aperta per impostazione predefinita nel riquadro inferiore destro dell'editor di codice.

   Se la finestra Stack di chiamate è chiusa, selezionare CTRL+D, C o scegliere Debug>stack di chiamate di Windows>dalla barra dei menu.

   Nella finestra Stack di chiamate viene visualizzato il puntatore giallo nel metodo correnteMain.

2. Selezionare F11 alcune volte fino a quando non viene visualizzata la sospensione del debugger nel SendMessage metodo .

   La riga superiore della finestra Stack di chiamate mostra la funzione corrente, ovvero il SendMessage metodo . La seconda riga mostra che il SendMessage metodo è stato chiamato dal Main metodo .

   

   Nota

   La finestra Stack di chiamate è simile alla prospettiva Debug in alcuni IDE, ad esempio Eclipse.

   Nella finestra Stack di chiamate è possibile fare doppio clic su una riga di codice per passare a tale codice sorgente, che modifica l'ambito corrente sottoposto a ispezione dal debugger. Questa azione non fa avanzare il 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 nelle funzioni specificate, passare al debugger usando Esegui su cursore o passare al codice sorgente.

Per altre informazioni sullo stack di chiamate, vedere Procedura: Esaminare lo stack di chiamate.

Modificare il flusso di esecuzione

È possibile spostare il puntatore di esecuzione per modificare il flusso dell'app durante il debug.

1. Con il debugger sospeso alla chiamata al SendMessage metodo nel for ciclo, selezionare F11 tre volte per eseguire l'istruzione nel SendMessage metodo e passare oltre il Console.WriteLine metodo dopo l'esecuzione.

   Il debugger viene ora sospeso alla parentesi graffa di chiusura finale del SendMessage metodo.

2. Usare il mouse per afferrare la freccia gialla o il puntatore di esecuzione (nel margine sinistro) e quindi trascinare il puntatore verso l'alto di una riga.

   Il debugger è ora di nuovo sull'istruzione Console.WriteLine .

3. Selezionare F11.

   Il debugger esegue nuovamente il Console.WriteLine metodo e viene visualizzata una riga duplicata nell'output della finestra della console.

4. Selezionare F5 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.

Avviso

Usare questa funzionalità con attenzione. Nella descrizione comando del puntatore di esecuzione verrà visualizzato un avviso sulla possibilità di conseguenze impreviste. Potrebbero essere visualizzati anche altri avvisi. Lo spostamento del puntatore di esecuzione non può ripristinare lo stato precedente dell'applicazione.

Per altre informazioni sulla modifica del flusso di esecuzione, vedere Spostare il puntatore per modificare il flusso di esecuzione.

L'esercitazione è stata completata.

Passaggi successivi

In questa esercitazione si è appreso come avviare il debugger, eseguire il codice ed esaminare le variabili. È possibile ottenere un'analisi generale delle funzionalità del debugger insieme ai collegamenti ad altre informazioni.

Presentazione del debugger