Condividi tramite

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

  • Articolo

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.

È necessario aver installato Visual Studio 2019 e il carico di lavoro sviluppo multipiattaforma .NET Core.

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

Se occorre installare il carico di lavoro, ma si ha già Visual Studio, passare a Strumenti>Ottieni strumenti e funzionalità, che apre il programma di installazione di Visual Studio. Verrà avviato il Programma di installazione di Visual Studio. Scegliere il carico di lavoro sviluppo multipiattaforma .NET Core, quindi scegliere Modifica.

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.

  1. 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 di linguaggio e piattaforma, scegliere il modello App console per .NET Core e quindi selezionare Avanti.

    Screenshot of the C# template for the Console App.

    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à. Scegliere quindi il carico di lavoro Sviluppo multipiattaforma .NET Core nel programma di installazione di Visual Studio.

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

  3. Selezionare il framework di destinazione consigliato (supporto a lungo termine o .NET 8.0) e quindi selezionare Crea.

  1. 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.

    Screenshot of the 'Console Application' template in the 'Create a new project' window of Visual Studio 2022.

    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.

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

  3. 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.

  1. Premere F5 (Debug > Avvia debug) o il pulsante Image of the Start Debugging button. Avvia debug sulla barra degli strumenti debug.

    F5 avvia l'app con il debugger collegato al processo dell'app. Fino ad ora, tuttavia, non è stata eseguita alcuna operazione per esaminare il codice. Quindi l'app viene caricata e viene visualizzato questo 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

    In questa esercitazione si esamini più in dettaglio questa app usando il debugger e si esaminino le funzionalità del debugger.

  2. Arrestare il debugger premendo il pulsante di arresto rosso (MAIUSC + F5). Image of the Stop Debugging button.

  3. Nella finestra della console premere un tasto per chiudere la finestra della console.

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.

    Screenshot of the Debug Target button in the Standard toolbar of Visual Studio 2022.

    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.

    Screenshot of the Stop debugging button in the Debug toolbar of Visual Studio 2022.

  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];

    Viene visualizzato un cerchio Image of a breakpoint. rosso in cui si imposta il punto di interruzione.

    I punti di interruzione sono una delle funzionalità di base e essenziali del 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.

  2. Premere F5 o il pulsante Avvia debug . Screenshot of the Start Debugging button. L'app viene avviata e il debugger viene eseguito alla riga di codice in cui si imposta il punto di interruzione.

    Set and hit a breakpoint

    La freccia gialla rappresenta l'istruzione in cui il debugger è stato sospeso, che sospende anche l'esecuzione dell'app nello stesso punto (questa istruzione non è ancora stata eseguita).

    Se l'app non è ancora in esecuzione, F5 avvia il debugger e si arresta al primo punto di interruzione. In caso contrario, F5 continua l'esecuzione dell'app fino al punto di interruzione successivo.

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

  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.

    Screenshot of a breakpoint in Visual Studio 2022.

    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.

    Screenshot showing a breakpoint in the code editor of Visual Studio 2022, with code execution paused at the breakpoint.

    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.

In questa esercitazione nella maggior parte dei casi vengono usati tasti di scelta rapida che rappresentano un modo rapido per eseguire l'app nel debugger (i comandi equivalenti, ad esempio i comandi di menu, sono indicati tra parentesi).

  1. Mentre l'esecuzione del codice è sospesa nell'istruzione name += letters[i] , passare il puntatore del letters mouse sulla variabile e visualizzarne il valore predefinito, il valore del primo elemento nella matrice . char[10]

    Le funzionalità che consentono di esaminare le variabili sono tra le funzionalità più utili del debugger e sono disponibili diversi modi per eseguire questa operazione. Spesso, quando si tenta di eseguire il debug di un problema, si tenta di scoprire se le variabili archiviano i valori previsti per un determinato momento.

  2. Espandere la letters variabile per visualizzarne le proprietà, che includono tutti gli elementi contenuti nella variabile.

    Screenshot of the debugger paused at the 'name+= letters[I]' statement.

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

  4. Premere F10 (o scegliere Debug > Passaggio superiore) due volte per passare alla chiamata al SendMessage metodo e quindi premere F10 un'altra volta.

    F10 sposta il debugger all'istruzione successiva senza eseguire istruzioni in funzioni o metodi nel codice dell'app (il codice viene ancora eseguito). Premendo F10 sulla chiamata al SendMessage metodo, è stato ignorato il codice di implementazione per SendMessage (che potrebbe non essere interessato al momento).

  5. Premere F10 (o Esegui> debug passaggio) alcune volte per scorrere più volte il for ciclo, sospendere nuovamente il punto di interruzione e passare il puntatore del mouse sulla variabile ogni volta per controllarne il name valore.

    An animated screenshot of the Visual Studio Debugger showing the effect of pressing F10 to

    Il valore della variabile cambia con ogni iterazione del for ciclo, mostrando i valori di f, quindi fr, e frecosì via. Per far avanzare il debugger attraverso il ciclo più velocemente in questo scenario, è possibile premere F5 (o scegliere Continua debug>), che consente di passare al punto di interruzione anziché all'istruzione successiva.

    Spesso, quando si esegue il debug, si vuole un modo rapido per controllare i valori delle proprietà sulle variabili, per verificare se archiviano i valori che si prevede di archiviare e i suggerimenti per i dati sono un buon modo per farlo.

  6. Mentre l'esecuzione del for codice rimane sospesa nel ciclo nel Main metodo, premere F11 (o scegliere Debug > Esegui istruzione) fino a quando non si sospende alla chiamata al SendMessage metodo.

    Si dovrebbe essere in questa riga di codice:

    SendMessage(name, a[i]);

  7. Premere F11 un'altra volta per eseguire l'istruzione nel SendMessage metodo .

    Il puntatore giallo avanza nel SendMessage metodo .

    Screenshot of the execution pointer at the SendMessage method.

    F11 corrisponde al comando Esegui istruzione e consente di eseguire l'app un'istruzione alla volta. F11 è un buon metodo per esaminare il flusso di esecuzione nel dettaglio. Per impostazione predefinita, il debugger ignora il codice non utente (se si vogliono altri dettagli, vedere Just My Code).

    Si supponga di aver completato l'analisi del SendMessage metodo e di voler uscire dal metodo, ma rimanere nel debugger. Questa operazione può essere eseguita usando il comando Esci da istruzione/routine.

  8. Premere MAIUSC + F11 (o Esegui debug > istruzione/routine).

    Questo comando riprende l'esecuzione dell'app (e avanza il debugger) fino a quando non viene restituito il metodo o la funzione corrente.

    Si dovrebbe tornare al for ciclo nel Main metodo, sospeso alla chiamata al SendMessage metodo. Per altre informazioni sui diversi modi per spostarsi nel codice, vedere Esplorare il codice nel debugger.

  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.

    Screenshot of a debugger data tip in Visual Studio 2022 that shows the element values for the 'letters' array variable.

  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.

    Screenshot of a debugger data tip in Visual Studio 2022 that shows the string value for the 'name' variable.

    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 .

    Screenshot showing the execution pointer of the debugger within the 'SendMessage' method.

    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.

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

  2. Nell'editor di codice scorrere verso il basso e passare il puntatore del mouse sul metodo nel SendMessage metodo fino a visualizzare il pulsanteImage of the Run to Click button.verde Esegui fino a fare clic.Console.WriteLine La descrizione comando per il pulsante mostra "Esegui l'esecuzione qui".

    Screenshot of the Run to Click button.

    Nota

    Il pulsante Esegui a clic è una novità di Visual Studio 2017. Se non viene visualizzato il pulsante freccia verde, usare F11 in questo esempio per spostare il debugger nella posizione corretta.

  3. Selezionare il pulsante Esegui per fare clic . Image of the Run to Click button.

    Il debugger passa al Console.WriteLine metodo .

    L'uso di questo pulsante è simile all'impostazione di un punto di interruzione temporaneo. Esegui a clic è utile per spostarsi rapidamente all'interno di un'area visibile del codice dell'app (è possibile selezionare in qualsiasi file aperto).

  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".

    Screenshot showing the Run to Click button in Visual Studio 2022.

  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

Selezionare il pulsante Image of the Restart App button. Riavvia nella barra degli strumenti debug (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.

Il debugger si arresta di nuovo nel punto di interruzione impostato in precedenza all'interno del for ciclo.

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.

Screenshot of the Restart button in the Debug toolbar of Visual Studio 2022.

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

  1. Osservare la finestra Auto nella parte inferiore dell'editor di codice.

    Se è chiuso, aprirlo mentre è in pausa nel debugger scegliendo Debug>auto di Windows.>

    Nella finestra Auto vengono visualizzate le variabili e i relativi valori correnti. La finestra Auto mostra tutte le variabili usate nella riga corrente o nella riga precedente (vedere la documentazione per il comportamento specifico del linguaggio).

  2. Osservare quindi la finestra Variabili locali in una scheda accanto alla finestra Auto.

  3. Espandere la letters variabile per visualizzare gli elementi contenuti.

    Screenshot of the Locals Window in Visual Studio.

    La finestra Variabili locali mostra le variabili presenti nell'ambito corrente, ovvero il contesto di esecuzione corrente.

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.

    Screenshot of the Locals window in Visual Studio 2022, with the 'letters' array variable expanded.

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

Impostare un'espressione di controllo

Nella finestra dell'editor di codice principale fare clic con il pulsante destro del mouse sulla name variabile e scegliere Aggiungi espressione di controllo.

Viene visualizzata la finestra Espressione di controllo nella parte inferiore dell'editor di codice. È possibile usare una finestra Espressione di controllo per specificare una variabile (o un'espressione) che si vuole controllare.

A questo punto, è presente un watch impostato sulla name variabile ed è possibile visualizzarne la modifica del valore durante lo spostamento nel debugger. A differenza delle altre finestre delle variabili, la finestra Espressione di controllo mostra sempre le variabili che si stanno osservando (sono disattivate quando non rientrano nell'ambito).

È 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

  1. Mentre l'esecuzione del codice è sospesa nel for ciclo, selezionare la finestra Stack di chiamate, che è per impostazione predefinita aperta nel riquadro in basso a destra.

    Se è chiuso, aprirlo mentre è in pausa nel debugger scegliendo Debug>stack di chiamate di Windows.>

  2. Selezionare F11 alcune volte fino a quando non viene visualizzata la sospensione del debugger nel SendMessage metodo . Osservare la finestra Stack di chiamate.

    Screenshot of the Call Stack window in Visual Studio.

    La finestra Stack di chiamate visualizza l'ordine in cui vengono chiamati metodi e funzioni. La prima riga visualizza la funzione corrente (il metodo SendMessage in questa app). La seconda riga indica che SendMessage è stato chiamato dal metodo Main e così via.

    Nota

    La finestra Stack di chiamate è simile alla prospettiva di debug di alcuni IDE come Eclipse.

    Lo stack di chiamate è un ottimo modo per esaminare e comprendere il flusso di esecuzione di un'app.

    È possibile fare doppio clic su una riga di codice per esaminare il codice sorgente, che modifica anche 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 i punti di interruzione nelle funzioni specificate, far avanzare il debugger usando Esegui fino al cursore e passare a esaminare il codice sorgente. Per altre informazioni, vedere Procedura: Esaminare lo 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 .

    Screenshot of the Call Stack window in Visual Studio 2022.

    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

  1. Premere F11 due volte per eseguire il Console.WriteLine metodo .

  2. Con il debugger sospeso nella chiamata al SendMessage metodo, usare il mouse per afferrare la freccia gialla o il puntatore di esecuzione (nel margine sinistro) e trascinare il puntatore verso l'alto di una riga all'istruzione Console.WriteLine .

  3. Premere F11.

    Il debugger esegue di nuovo il Console.WriteLine metodo (questa azione viene visualizzata nell'output della finestra della console).

    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

    Spesso questa funzionalità deve essere usata con attenzione. Nella descrizione comando viene visualizzato un avviso. È anche possibile che vengano visualizzati altri avvisi. Non è possibile ripristinare uno stato precedente dell'applicazione spostando il cursore.

  4. Premere F5 per continuare a eseguire l'app.

    L'esercitazione è stata completata.

È 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