Esercitazione: Eseguire il debug del codice Visual Basic con Visual Studio

Questo articolo presenta le funzionalità del debugger di Visual Studio in una procedura dettagliata. Per una visualizzazione di livello superiore delle funzionalità del debugger, vedere Panoramica del debugger di Visual Studio. 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.

• Esaminare il codice ed esaminare i valori archiviati nelle variabili.
• Impostare dei controlli sulle variabili per rilevare quando i valori cambiano.
• Esaminare il percorso di esecuzione del codice per verificare se è in esecuzione un ramo di codice.

Se questo esercizio è la prima volta che si è tentato di eseguire il debug del codice, è possibile leggere Debug per principianti assoluti.

Anche se l'app dimostrativa in questo articolo usa Visual Basic, la maggior parte delle funzionalità si applica a C#, C++, 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 si trovano in Visual Basic.

In questa esercitazione, farai:

• Avvia il debugger e tocca i punti di interruzione
• Impara i 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 che Visual Studio sia installato, incluso il componente di sviluppo per lo sviluppo multipiattaforma con .NET Core.

• Se è necessario installare Visual Studio, per una versione gratuita, vedere Download di Visual Studio.
• Se devi installare il carico di lavoro ma hai già Visual Studio, vai su Strumenti>Ottieni strumenti e funzionalità, che apre il programma di installazione di Visual Studio. Scegliere il carico di lavoro Sviluppo di applicazioni desktop .NET, quindi scegliere Modifica.

Creare un progetto

Creare prima di tutto un progetto di applicazione console .NET Core. Il tipo di progetto include tutti i file di modello necessari, prima di aggiungere qualsiasi elemento.

1. Apri Visual Studio. Se la finestra iniziale non è aperta, selezionareFinestra di avvio>.

2. Nella finestra iniziale selezionare Crea un nuovo progetto.

3. Nella casella di ricerca della finestra Crea un nuovo progetto immettere la console. Scegliere quindi Visual Basic dall'elenco Lingua e quindi scegliere 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.

   

   Annotazioni

   Se non vedi il modello App Console, puoi installarlo dalla finestra Crea un nuovo progetto. Nel messaggio Non trovare quello che si sta cercando? 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 get-started-debugging per Nome progetto. Quindi seleziona Avanti.

5. Nella finestra Informazioni aggiuntive verificare che .NET 10.0 sia selezionato per Framework e quindi selezionare Crea.

Visual Studio apre il nuovo progetto.

Creare l'applicazione

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

Imports System

Class ArrayExample
  Public Shared Sub Main()
    Dim letters As Char() = {"f"c, "r"c, "e"c, "d"c, " "c, "s"c, "m"c, "i"c, "t"c, "h"c}
    Dim name As String = ""
    Dim a As Integer() = New Integer(9) {}

    For i As Integer = 0 To letters.Length - 1
      name += letters(i)
      a(i) = i + 1
      SendMessage(name, a(i))
    Next

    Console.ReadKey()
  End Sub

  Private Shared Sub SendMessage(ByVal name As String, ByVal msg As Integer)
    Console.WriteLine("Hello, " & name & "! Count to " & msg)
  End Sub
End Class

Avviare il debugger.

1. Premere F5 (Debug > Avvia debug) o selezionare il pulsante verde Avvia debug sulla barra degli strumenti debug.

   

   F5 avvia l'applicazione con il debugger collegato al processo dell'applicazione. Finora non è stato fatto nulla di speciale per esaminare il codice. L'app viene appena caricata 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
   

   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 (MAIUSC + F5) o selezionando il pulsante rosso Arresta debug sulla barra degli strumenti di debug.

   

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

Impostare un punto di interruzione e avviare il debugger

1. Nella funzione For, nel ciclo Main, imposta un punto di interruzione facendo clic sul margine sinistro della 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 delle funzionalità di base e essenziali del debug affidabile. Un punto di interruzione indica dove Visual Studio sospende il codice in esecuzione. Durante la sospensione, è possibile esaminare i valori delle variabili o il comportamento della memoria. È possibile verificare se viene eseguito un ramo di codice.

2. Premere F5 (Debug > Avvia debug) o il pulsante Avvia debug sulla barra degli strumenti debug. L'app viene avviata e il debugger si ferma alla riga di codice in cui si imposta il punto di interruzione.

   

   La freccia gialla rappresenta l'istruzione su cui il debugger si è fermato, sospendendo 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 a eseguire l'app al punto di interruzione successivo.

   I punti di interruzione sono una funzionalità utile quando si conosce la riga di codice o la sezione del codice da esaminare in dettaglio. Per informazioni sui diversi tipi di punti di interruzione, vedere Uso di punti di interruzione.

Esplorare il codice nel debugger usando i comandi di passaggio

Questo articolo usa i tasti di scelta rapida, perché è un buon modo per accelerare l'esecuzione dell'app nel debugger. Mostra comandi equivalenti, ad esempio i comandi di menu, tra parentesi.

1. Mentre l'esecuzione del codice è sospesa nel metodo For ciclo, premere Main (o scegliere ) due volte per avanzare fino alla chiamata del metodo >.

   Dopo aver premuto F11 due volte, si dovrebbe trovarsi in questa riga di codice:

   SendMessage(name, a(i))

2. Premere F11 un'altra volta per entrare nel SendMessage metodo.

   Il puntatore giallo avanza nel metodo SendMessage.

   

   F11 è il comando Passaggio dentro. Fa avanzare l'esecuzione dell'app un'istruzione alla volta. F11 è un buon modo per esaminare il flusso di esecuzione nel modo più dettagliato. Per impostazione predefinita, il debugger ignora il codice non utente. Per altre informazioni, vedere Just My Code.

   Si supponga di aver completato l'analisi del SendMessage metodo e di voler uscire dal metodo, ma rimanere nel debugger. A tal fine, è possibile utilizzare il comando Esci dall'istruzione.

3. Premere MAIUSC + F11 (o Esegui debug > esci).

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

   Dovresti tornare al For ciclo nel Main metodo e fermarti alla chiamata del SendMessage metodo.

4. Premere F11 più volte finché non si torna alla chiamata al SendMessage metodo.

5. Mentre l'esecuzione del codice viene sospesa alla chiamata al metodo, premere F10 (o scegliere Esegui passaggio di debug>) una sola volta.

   

   Questa volta il debugger non entra nel metodo SendMessage. F10 fa avanzare il debugger senza entrare in funzioni o metodi nel codice della tua app. Il codice viene ancora eseguito. Premendo F10 sulla chiamata al SendMessage metodo invece di F11, è stato ignorato il codice di implementazione per 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. Premere F5 per passare di nuovo al punto di interruzione.

2. Nell'editor di codice, scorri verso il basso e passa il puntatore del mouse sopra il metodo Console.WriteLine nel metodo SendMessage finché non appare il pulsante verde Esegui fino a fare clic. La descrizione comando per il pulsante mostra Esegui fino a qui.

   

3. Selezionare il pulsante Esegui per fare clic .

   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, che è possibile selezionare in qualsiasi file aperto.

Riavviare rapidamente l'app

Per riavviare l'app, premere la combinazione di tasti CTRL + MAIUSC + F5 . Consente di risparmiare tempo rispetto all'arresto dell'app e al riavvio del debugger. Il debugger viene sospeso al 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.

Esaminare le variabili con i suggerimenti sui dati

Il debugger include funzionalità che consentono di controllare le variabili. Esistono diversi modi per controllare le variabili. 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.

1. Mentre l'esecuzione del codice è sospesa nell'istruzione name += letters[i] , passare il puntatore del mouse sulla letters variabile. Viene visualizzato il valore predefinito, il valore del primo elemento nella matrice , "f"c.

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

3. Premere F5 (o Debug>Continua) 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.

   

   Il valore della variabile viene modificato con ogni iterazione del ciclo For, che mostra i valori di f, quindi fr, quindi free così via.

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

Esaminare le variabili con le finestre Variabili automatiche e Variabili locali

1. Esaminare la finestra Autos nella parte inferiore dell'editor di codice.

   Se è chiuso, aprirlo durante la sospensione dell'esecuzione del codice nel debugger scegliendo Debug>Windows>Autos.

   Nella finestra Auto vengono visualizzate le variabili e il relativo valore corrente. Nella finestra Auto vengono visualizzate tutte le variabili usate nella riga corrente o nella riga precedente. Per informazioni sul comportamento specifico della lingua, vedere la documentazione.

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

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

   

   La finestra Variabili Locali mostra le variabili che si trovano nell'ambito corrente , ovvero nel contesto di esecuzione attuale.

Impostare un orologio

È 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 osservazione.

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

2. Dopo aver impostato un watch sulla variabile name, avanzare nel codice per vedere il valore della variabile name modificarsi ad ogni iterazione del ciclo for.

   A differenza delle altre finestre delle variabili, la finestra Watch mostra sempre le variabili che stai osservando. Le variabili che non rientrano nell'ambito vengono visualizzate come non disponibili.

Per ulteriori informazioni sulla finestra Osserva, vedere Osservare le variabili con le finestre Osserva.

Esaminare lo stack di chiamate

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

   Se è chiuso, aprilo mentre l'esecuzione del codice è sospesa nel debugger scegliendo Debug>Windows>Call Stack.

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

   

   La finestra Call Stack mostra l'ordine in cui vengono chiamati i metodi e le funzioni. La riga superiore mostra la funzione corrente. In questo esempio si tratta del SendMessage metodo . La seconda riga mostra che SendMessage è stato chiamato dal Main metodo e così via.

   Annotazioni

   La finestra Stack di chiamate è simile alla prospettiva Debug in alcuni strumenti di programmazione come Eclipse.

   Lo stack di chiamate è un buon 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 e che modifica anche l'ambito corrente sottoposto a ispezione dal debugger. Questa azione non fa avanzare il debugger.

   Nella finestra Call Stack puoi anche usare i menu di clic con il pulsante destro del mouse per fare altre cose. Ad esempio, è possibile inserire punti di interruzione nelle funzioni specificate, avanzare il debugger usando Esegui su cursore ed esaminare il codice sorgente. Per altre informazioni, 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 del metodo SendMessage, usare il mouse per afferrare la freccia gialla o l'indicatore di esecuzione nel margine sinistro e trascinare l'indicatore verso l'alto di una riga all'istruzione Console.WriteLine.

3. Premere F11.

   Il debugger esegue nuovamente il Console.WriteLine metodo . Questa azione viene visualizzata nell'output della finestra della console.

   Modificando il flusso di esecuzione, è possibile testare diversi percorsi di esecuzione del codice o rieseguire il codice senza riavviare il debugger.

   Avvertimento

   Spesso è necessario prestare attenzione a questa funzionalità. Nella descrizione comando è presente un avviso. Potrebbero essere visualizzati anche altri avvisi. Lo spostamento del puntatore non può ripristinare lo stato precedente dell'applicazione.

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

   Congratulazioni per aver completato questa esercitazione.

Contenuti correlati

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.

Panoramica del debugger di Visual Studio