Esercitazione: Informazioni sul debug del codice Visual Basic 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 si esegue l'applicazione con il debugger collegato. Durante il debug, il debugger offre diversi 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 è la prima volta che si esegue il debug del codice, può essere utile leggere Debug per principianti prima di procedere con 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 sono in Visual Basic.

In questa esercitazione si apprenderà 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
  • Esaminare lo stack di chiamate

Prerequisiti

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

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

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

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

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

Se è necessario installare il carico di lavoro ma 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.

Creare un progetto

In primo luogo, si creerà un progetto di applicazione console .NET Core. Il tipo di progetto include fin dall'inizio tutti i file modello necessari.

  1. Aprire Visual Studio 2017.

  2. Nella barra dei menu superiore scegliere File > nuovo > progetto.

  3. Nel riquadro sinistro della finestra di dialogo Nuovo progetto espandere Visual Basic, quindi selezionare .NET Core. Nel riquadro centrale scegliere Console App (.NET Core) (App console (.NET Core)). Assegnare quindi al progetto il nome get-started-debugging.

    Se non viene visualizzato il modello di progetto Applicazione console (.NET Core), fare clic sul collegamento Apri il programma di installazione di Visual Studio nel riquadro a sinistra della finestra di dialogo Nuovo progetto.

    Verrà avviato il Programma di installazione di Visual Studio. Scegliere il carico di lavoro Sviluppo multipiattaforma .NET Core, quindi scegliere Modifica.

  1. Aprire Visual Studio.

    Se la finestra iniziale non è aperta, scegliere Finestra > iniziale file.

  2. Nella finestra iniziale scegliere Crea un nuovo progetto.

  3. Nella finestra Crea un nuovo progetto immettere o digitare console nella casella di ricerca. Quindi scegliere Visual Basic dall'elenco Linguaggio e Windows dall'elenco Piattaforma.

    Dopo aver applicato il linguaggio e i filtri della piattaforma, scegliere il modello App console per .NET Core e quindi scegliere Avanti.

    Scegliere il Visual Basic modello per l'app console

    Nota

    Se il modello App console non viene visualizzato, è 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.

  4. Nella finestra Configura il nuovo progetto digitare o immettere get-started-debugging nella casella Nome progetto . Scegliere quindi Avanti.

  5. Scegliere il framework di destinazione consigliato (.NET Core 3.1) o .NET 5 e quindi scegliere Crea.

    Visual Studio aprirà il nuovo progetto.

Creazione dell'applicazione

  1. 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 il pulsante Avvia debug 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. Di conseguenza, viene semplicemente avviata l'app 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 viene esaminata l'app usando il debugger e vengono descritte le funzionalità del debugger.

  2. Arrestare il debugger premendo il pulsante rosso Arresta debug (MAIUSC + F5).

  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 For della funzione Main impostare un punto di interruzione facendo clic sul margine sinistro della riga di codice seguente:

    name += letters(i)

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

    I punti di interruzione sono una delle funzionalità di base ed 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 Avvia debug ,l'app viene avviata e il debugger viene eseguito sulla riga di codice in cui è stato impostato il punto di interruzione.

    Impostare e raggiungere un punto di interruzione

    La freccia gialla rappresenta l'istruzione in corrispondenza della quale il debugger si è interrotto e il punto in cui anche l'esecuzione dell'app viene sospesa (l'istruzione non è ancora stata eseguita).

    Se l'app non è ancora in esecuzione, F5 avvia il debugger e lo arresta in corrispondenza del 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 dei 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. Durante la sospensione nel ciclo nel metodo, premere For Main F11 (o scegliere Debug > Esegui istruzione ) due volte per passare alla chiamata SendMessage al metodo.

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

    SendMessage(name, a(i))

  2. Premere F11 ancora una volta per eseguire un'istruzione al SendMessage metodo.

    Il puntatore giallo avanza nel SendMessage metodo .

    Usare F11 per eseguire un'istruzione al codice

    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 spostarsi più velocemente nel codice, vengono mostrate anche alcune altre opzioni. Per impostazione predefinita, il debugger ignora il codice non utente (per altri dettagli, vedere Just My Code).

    Si immagini di aver esaminato il metodo e di voler uscire dal metodo ma rimanere SendMessage nel debugger. Questa operazione può essere eseguita usando il comando Esci da istruzione/routine.

  3. Premere MAIUSC + F11 (o Eseguire il debug > istruzione/uscita).

    Questo comando riprende l'esecuzione dell'app (e fa avanzare il debugger) finché non viene restituito il metodo o la funzione corrente.

    È necessario tornare nel For ciclo nel metodo , sospeso alla chiamata al metodo Main SendMessage .

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

  5. Mentre è in pausa durante la chiamata al metodo, premere F10 (o scegliere Debug > esegui istruzione/istruzione) una sola volta.

    Usare F10 per eseguire il passaggio del codice

    Si noti che questa volta il debugger non esegue un'istruzione nel SendMessage metodo . F10 fa avanzare il debugger senza eseguire le istruzioni nelle funzioni o nei metodi del codice dell'app (il codice rimane in esecuzione). Premendo F10 nella chiamata al metodo SendMessage anziché F11, è stato ignorato il codice di implementazione per SendMessage (non d'interesse ai fini dell'esercitazione). Per altre informazioni sui diversi modi per spostarsi nel codice, vedere Esplorare il codice nel debugger.

  1. Premere 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 metodo fino a quando a sinistra non viene visualizzato il pulsante Verde Esegui per fare clic Console.WriteLine sul pulsante Esegui per fare SendMessage clic. La descrizione comando per il pulsante è "Continua l'esecuzione fino a qui".

    Usare la funzionalità Esegui per fare clic

    Nota

    Il pulsante per l'esecuzione fino alla riga selezionata dall'utente è una nuova funzionalità di Visual Studio 2017. Se il pulsante freccia verde non è visualizzato, usare F11 in questo esempio per far avanzare il debugger nella posizione giusta.

  3. Fare clic sul pulsante Esegui per fare clic sul pulsante Esegui per fare clic su.

    Il debugger passa al Console.WriteLine metodo .

    L'uso di questo pulsante è simile all'impostazione di un punto di interruzione temporaneo. Il pulsante per l'esecuzione fino alla riga selezionata dall'utente è uno strumento pratico per l'esplorazione rapida all'interno di un'area visibile del codice dell'app (è possibile fare clic in qualsiasi file aperto).

Riavviare rapidamente l'app

Fare clic sul pulsante Riavvia riavvia app sulla 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 nuovamente in corrispondenza del punto di interruzione impostato in precedenza all'interno del For ciclo.

Esaminare le variabili con i suggerimenti dati

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 determinare se le variabili includono i valori previsti in un determinato momento.

  1. Durante la sospensione dell'istruzione, passare il puntatore del mouse sulla variabile e viene visualizzato il valore predefinito, il valore del primo name += letters[i] letters elemento della matrice, "f"c .

  2. Passare quindi il puntatore del mouse sulla variabile e name visualizzare il relativo valore corrente, una stringa vuota.

  3. Premere F5 (o Continua debug ) più volte per scorrere più volte il ciclo, sospendere nuovamente in corrispondenza del punto di interruzione e passare il puntatore sulla variabile ogni volta per verificarne il > For name valore.

    Visualizzare un suggerimento dati

    Il valore della variabile cambia a ogni iterazione del ciclo, visualizzando i For valori di , quindi , e così f fr fre via.

    Spesso, durante il debug, è necessario controllare rapidamente i valori delle proprietà sulle variabili, per vedere se si stanno archiviando i valori previsti, e i suggerimenti dati costituiscono un valido strumento per questa operazione.

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 > di Windows > Autos.

    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 in essa contenuti.

    Esaminare le variabili nella finestra Variabili locali

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

Impostare un'espressione di controllo

  1. Nella finestra principale dell'editor di codice fare clic con il pulsante destro del mouse sulla name variabile e scegliere Aggiungi espressioni 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, è disponibile un'orologio impostato sulla variabile ed è possibile visualizzarne il valore name mentre si passa attraverso il debugger. A differenza di altre finestre delle variabili, la finestra Espressione di controllo mostra sempre le variabili controllate (che appaiono disattivate quando sono fuori ambito).

Esaminare lo stack di chiamate

  1. Mentre l'esecuzione è in pausa nel ciclo For, fare clic sulla finestra Stack di chiamate, visualizzata per impostazione predefinita nel riquadro inferiore destro.

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

  2. Fare clic su F11 alcune volte fino a quando il debugger non viene sospeso nel SendMessage metodo . Osservare la finestra Stack di chiamate.

    Esaminare lo stack di chiamate

    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 visualizzare il codice sorgente e modificare anche l'ambito corrente controllato dal debugger. Questa azione non fa avanzare il debugger.

    È anche possibile usare i menu di scelta rapida nella 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.

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 , usare il mouse per afferrare la freccia gialla (il puntatore di esecuzione) a sinistra e spostare la freccia gialla verso l'alto di una riga, di nuovo SendMessage su Console.WriteLine .

  3. Premere F11.

    Il debugger esegue nuovamente il metodo Console.WriteLine (visualizzato 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.

Passaggi successivi

In questa esercitazione si è appreso come avviare il debugger, eseguire il codice ed esaminare le variabili. Sono disponibili una panoramica delle funzionalità del debugger e collegamenti a ulteriori informazioni.