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. Se si desidera una visualizzazione di livello superiore delle funzionalità del debugger, vedere Esaminare prima il 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 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 prima di eseguire questo articolo.

Anche se l'app demo è Visual Basic, la maggior parte delle funzionalità è applicabile 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 si eseguiranno le seguenti attività:

• Avviare il debugger e raggiungere 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 aver installato Visual Studio 2019 e il carico di lavoro sviluppo multipiattaforma .NET Core .

Se Visual Studio non è già stato installato, passare alla pagina di download di Visual Studio per installarlo gratuitamente.

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. Viene avviato il programma di installazione di Visual Studio. Scegliere il carico di lavoro Sviluppo di applicazioni desktop .NET, quindi scegliere 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, selezionareFinestra di avvio>.

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 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 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 apre il nuovo progetto.

Creare l'applicazione

In Program.vb sostituire invece 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'app con il debugger collegato al processo dell'app, ma al momento non è stata eseguita alcuna operazione speciale per esaminare il codice. Quindi l'app viene 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. Nel ciclo della funzione Main, imposta 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 delle funzionalità di base e essenziali del debug affidabile. Un punto di interruzione indica dove Visual Studio deve sospendere il codice in esecuzione in modo da poter esaminare i valori delle variabili o il comportamento della memoria o se viene eseguito o meno un ramo di codice.

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

   

   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 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 che è possibile impostare, ad esempio i punti di interruzione condizionali, vedere Uso di punti di interruzione.

Esplorare il codice nel debugger usando i comandi di passaggio

In questo articolo vengono usati i tasti di scelta rapida, perché è un buon modo per eseguire rapidamente l'app nel debugger (i comandi equivalenti, ad esempio i comandi di menu, sono visualizzati tra parentesi).

1. Mentre l'esecuzione del codice For è sospesa nel ciclo del metodo Main, premi F11 (o scegli Esegui debug > Passa all'interno) due volte per passare alla chiamata del metodo SendMessage.

   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 all'interno del metodo SendMessage.

   

   F11 è il comando Passa dentro e avanza l'esecuzione dell'app una dichiarazione alla volta. F11 è un buon modo per esaminare il flusso di esecuzione nel modo più dettagliato. Per spostarsi più velocemente nel codice, vengono visualizzate anche alcune altre opzioni. 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. È possibile farlo usando il comando Esci dal livello.

3. Premere MAIUSC + F11 (o Debug > Uscita).

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

   Dovresti essere tornato al ciclo For nel metodo Main, in pausa alla chiamata del metodo SendMessage.

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.

   

   Nota questa volta che il debugger non entra nel metodo SendMessage. F10 fa avanzare il debugger senza entrare in funzioni o metodi nel codice dell'app (il codice viene ancora eseguito). Premendo F10 sulla chiamata del metodo SendMessage (invece di F11), abbiamo saltato il codice di implementazione per SendMessage, che forse al momento non ci interessa. 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, scorrere verso il basso e posiziona il puntatore del mouse sul metodo all'interno del metodo fino a visualizzare il pulsante Esegui fino a fare clic verde . La descrizione comando per il pulsante mostra "Esegui l'esecuzione 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. Run to Click è utile per spostarsi rapidamente all'interno di una zona visibile del codice dell'app, potendo selezionare qualsiasi file aperto.

Riavviare rapidamente l'app

Per riavviare l'app, premere la combinazione di tasti CTRL + MAIUSC + F5 e 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

Le funzionalità che consentono di controllare le variabili sono una delle funzionalità più utili del debugger e esistono diversi modi per farlo. 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 letters mouse sulla variabile e visualizzarne il valore predefinito, il valore del primo elemento nella matrice . "f"c

2. Passare quindi il puntatore del mouse sulla variabile e 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, 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.

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, aprilo quando l'esecuzione del codice è sospesa 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 (vedere la documentazione relativa al comportamento specifico della lingua).

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 . Guarda 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 (il SendMessage metodo in questa app). 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 IDE 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 al metodo SendMessage, utilizzare il mouse per prendere la freccia gialla o il puntatore di esecuzione (nel margine sinistro) e trascinarlo verso l'alto di una riga fino 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 di codice diversi o rieseguire il codice senza riavviare il debugger.

   Avvertimento

   Spesso è necessario prestare attenzione a questa funzionalità e viene visualizzato un avviso nella descrizione comando. 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.

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