Esercitazione: Imparare a debuggare il codice C# con Visual Studio

Questo articolo presenta le funzionalità del debugger di Visual Studio in una procedura dettagliata. Se si desidera una visualizzazione di livello superiore delle funzionalità del debugger, vedere Esaminare prima il debugger. Quando si eseguire 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 esaminare il codice ed esaminare i valori archiviati nelle variabili, è possibile impostare espressioni di controllo sulle variabili per vedere quando i valori cambiano, è possibile esaminare il percorso di esecuzione del codice, verificare se un ramo di codice è in esecuzione e così via. Se questo esercizio è la prima volta che si è tentato di eseguire il debug del codice, è possibile leggere Debug per principianti assoluti 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 di auto). Gli screenshot si trovano in C#.

In questa esercitazione si eseguiranno le seguenti attività:

• Avviare il debugger e raggiungere i punti di interruzione.
• Informazioni sui comandi per scorrere il codice nel debugger
• Esaminare le variabili nelle finestre dei suggerimenti per i dati e del debugger
• Esaminare lo stack di chiamate

Prerequisiti

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

Se non hai ancora installato Visual Studio, vai alla pagina download di Visual Studio per installarlo gratuitamente.

Se hai già Visual Studio ma il carico di lavoro di sviluppo desktop .NET non è installato, vai a Strumenti >Ottieni strumenti e funzionalità, che avvia il programma di installazione di Visual Studio. Nel programma di installazione di Visual Studio, scegli il workload sviluppo desktop .NET, quindi scegli Modifica.

Creare un progetto

Prima di tutto, si crea un progetto di applicazione console .NET Core. Il tipo di progetto viene fornito con tutti i file di modello necessari, prima di aver aggiunto qualsiasi elemento.

1. Apri Visual Studio. Se la finestra iniziale non è aperta, selezionare File>Finestra iniziale.

2. Nella finestra iniziale selezionare Crea un nuovo progetto.

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

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

   

   Nota

   Se non vedi il modello App Console, puoi installarlo dalla finestra Crea un nuovo progetto. Nella Non trovi quello che stai cercando? nel messaggio, scegli 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, inserisci GetStartedDebugging nella casella Nome progetto. Selezionare quindi Avanti.

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

Visual Studio apre il nuovo progetto.

Creare l'applicazione

In Program.cssostituire 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 F5oppure scegliere il pulsante destinazione debug 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'applicazione con il debugger collegato al processo dell'applicazione. 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 Interrompi Debug nella barra degli strumenti Debug oppure scegliere Debug>Interrompi 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. Nel ciclo for della funzione Main impostare un punto di interruzione facendo clic sul margine sinistro sulla riga di codice seguente:

   name += letters[i];

   Viene visualizzato un cerchio rosso in cui si imposta il punto di interruzione.

   

   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 F5oppure scegliere il pulsante Target di Debug nella barra degli strumenti Standard, o il pulsante Avvia Debugging sulla barra degli strumenti Debug, oppure scegliere Debug>Avvia Debugging dalla barra dei Menu. L'app viene avviata e il debugger si avvia sulla riga di codice dove hai impostato 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 è sospesa nell'istruzione name += letters[i], passare il puntatore del mouse sulla variabile letters 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 variabile letters per visualizzare tutti gli elementi della matrice e i relativi valori.

   

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

4. Per far avanzare il debugger all'istruzione successiva, selezionare F10, oppure scegliere il pulsante Step Over nella barra degli strumenti di Debug, oppure scegliere Debug>Step Over dal menu. Selezionare F10 due volte più per passare oltre la chiamata al metodo SendMessage.

   F10 avanza il debugger senza entrare nelle funzioni o nei metodi, anche se il loro codice viene comunque eseguito. In questo modo, abbiamo ignorato il debug del codice nel metodo SendMessage, che al momento non ci interessa.

5. Per scorrere il ciclo di for alcune volte, selezionare F10 ripetutamente. Durante ogni iterazione del ciclo, fermati al punto di interruzione e poi passa il puntatore del mouse sulla variabile name per controllarne il valore nel tooltip.

   

   Il valore della variabile viene modificato con ogni iterazione del ciclo for, che mostra i valori di f, quindi fr, quindi free così via. Per passare più velocemente il debugger attraverso il ciclo, selezionare F5, che passa al punto di interruzione anziché all'istruzione successiva.

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

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

   SendMessage(name, a[i]);

7. Per accedere al metodo SendMessage, selezionare di nuovo F11.

   Il puntatore giallo avanza nel metodo SendMessage.

   

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

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

8. Per uscire dal metodo SendMessage, selezionare Shift+F11, oppure scegliere il pulsante Step Out nella barra degli strumenti Debug, oppure scegliere Debug>Step Out dalla barra dei menu.

   Passo fuori riprende l'esecuzione dell'app e sposta il debugger fino a quando il metodo o la funzione corrente non ritorna.

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

Spostarsi nel codice usando Esegui per fare clic

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

2. Nell'editor di codice passare il puntatore del mouse sulla chiamata al metodo Console.WriteLine nel metodo SendMessage fino a quando non viene visualizzato il pulsante Esegui per fare clic su. La tooltip per il pulsante mostra "Esegui l'operazione fino a qui".

   

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

   Il debugger avanza alla chiamata del metodo Console.WriteLine.

   L'uso del pulsante Esegui per fare clic su è 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 eseguire nuovamente l'app dall'inizio del debugger, selezionare CTRL+MAIUSC+F5oppure scegliere il pulsante Riavvia nella barra degli strumenti Debug oppure scegliere Debug>Riavvia dalla barra dei menu.

Riavvia arresta il debugger e quindi lo riavvia in un unico passaggio. Quando il debugger viene riavviato, raggiunge il primo punto di interruzione, ovvero il punto di interruzione impostato in precedenza all'interno del ciclo for e si sospende.

Esaminare le variabili con le finestre Auto e Variabili locali

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

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

   Se la finestra di auto è chiusa, selezionare Ctrl+D, Aoppure scegliere Debug>Windows>Autos 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 di è chiusa, selezionare CTRL+D, Loppure scegliere Debug>Variabili locali di Windows>.

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

   

Per ulteriori informazioni sulle finestre Auto e Locali, vedere Esaminare le variabili nelle finestre Auto e Locali.

Configurare un orologio

È possibile specificare una variabile o un'espressione che si desidera monitorare durante l'esecuzione del codice, aggiungendola alla finestra di osservazione Watch.

1. Mentre il debugger è in pausa, fare clic con il tasto destro sulla variabile name e scegliere Aggiungi controllo.

   La finestra di controllo si apre automaticamente nella parte inferiore dell'editor di codice.

2. Dopo aver impostato un'espressione di controllo sulla variabile name, esamina il tuo codice per vedere il valore della variabile name cambiare con ogni iterazione del ciclo for.

   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 ulteriori informazioni sulla finestra Osservazione, vedere Variabili di osservazione con finestre di osservazione .

Esaminare lo stack di chiamate

Il Stack di chiamate consente di comprendere il flusso di esecuzione dell'app, mostrando l'ordine in cui vengono chiamati metodi e funzioni.

1. Mentre il debugger è sospeso nel ciclo for, visualizzare la finestra dello 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, oppure scegliere Debug>Windows>Stack di chiamate dalla barra dei menu.

   Nella finestra stack di chiamate viene visualizzato il puntatore giallo nel metodo Main corrente.

2. Selezionare F11 alcune volte finché il debugger non viene sospeso nel metodo SendMessage.

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

   

   Nota

   La finestra Call Stack è simile alla prospettiva di debug in alcuni IDE come 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 utilizzare i menu contestuali con il clic destro del mouse dalla finestra stack di chiamate per eseguire altre operazioni. Ad esempio, è possibile inserire punti di interruzione nelle funzioni specificate, avanzare il debugger usando Esegui fino al cursoreo passare al codice sorgente.

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

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.

Esaminare prima il debugger