Esercizio - Eseguire il codice nell'ambiente di debug

8 minuti

L'interfaccia utente di Visual Studio Code consente agli sviluppatori di eseguire il codice in un ambiente di debug. Il supporto per il debug viene fornito dalle estensioni e, per gli sviluppatori C#, il supporto del debugger viene fornito dalla stessa estensione che fornisce supporto per lo sviluppo di codice e IntelliSense.

Interazione del debugger e dell'applicazione

È possibile usare un debugger del codice per sospendere e riprendere l'esecuzione del codice, esaminare lo stato della variabile e modificare anche i valori assegnati alle variabili in fase di esecuzione. Ci si potrebbe chiedere, come può il debugger controllare e modificare un'applicazione in esecuzione? La risposta breve è che il debugger ha accesso all'ambiente di runtime dell'applicazione e al codice eseguibile.

Annotazioni

L'interazione del debugger con l'ambiente di runtime è un argomento avanzato. Inoltre, comprendere il funzionamento del debugger in background non è un requisito per l'uso del debugger. Tuttavia, la descrizione seguente può soddisfare la vostra curiosità.

Il debugger di Visual Studio Code per C# usa il runtime .NET per avviare e interagire con un'applicazione. Quando si avvia il debugger, crea una nuova istanza del runtime ed esegue l'applicazione all'interno di tale istanza. Il runtime include un'API (Application Programming Interface), che il debugger usa per connettersi al processo in esecuzione (l'applicazione).

Dopo che l'applicazione è in esecuzione e il debugger è collegato, il debugger comunica con il processo in esecuzione usando le API di debug del runtime .NET e un protocollo di debug standard. Il debugger può interagire con il processo (l'applicazione in esecuzione all'interno dell'istanza di runtime .NET) impostando punti di interruzione, eseguendo il codice ed esaminando le variabili. L'interfaccia del debugger di Visual Studio Code consente di esplorare il codice sorgente, visualizzare gli stack di chiamate e valutare le espressioni.

Il modo più comune per specificare una sessione di debug è una configurazione di avvio nel file launch.json. Questo approccio è l'opzione predefinita abilitata dagli strumenti del debugger. Ad esempio, se si crea un'applicazione console C# e si seleziona Avvia debug dal menu Esegui , il debugger usa questo approccio per avviare, collegarsi e quindi interagire con l'applicazione.

Creare un nuovo progetto di codice

Il primo passaggio per apprendere gli strumenti del debugger consiste nel creare un progetto di codice che è possibile eseguire nel debugger.

Aprire una nuova istanza di Visual Studio Code.
Nel menu File selezionare Apri cartella.
Nella finestra di dialogo Apri cartella passare alla cartella Desktop di Windows.
Nella finestra di dialogo Apri cartella selezionare Nuova cartella.
Assegnare alla nuova cartella il nome Debug101 e quindi selezionare Seleziona cartella.
Dal menu Terminale scegliere Nuovo terminale.

È possibile usare un comando dell'interfaccia della riga di comando di .NET per creare una nuova app console.
Al prompt dei comandi del pannello TERMINAL immettere il comando seguente:
```
dotnet new console
```
Chiudere il pannello TERMINALE.

Esaminare le configurazioni di avvio per il debug

Visual Studio Code usa un file di configurazione di avvio per specificare l'applicazione eseguita nell'ambiente di debug.

Se la cartella Debug101 non include un file Debug101.sln, selezionare Program.cs e quindi verificare che venga creato un file .sln.

L'apertura di un file di codice C# richiede all'ambiente di verificare la presenza di file di progetto. Il file .sln è un file di soluzione usato da Visual Studio per gestire i progetti e viene in genere creato automaticamente quando si crea un nuovo progetto in Visual Studio Code. Il file .sln viene usato dal debugger per identificare il progetto che deve essere eseguito nell'ambiente di debug.
Nel menu Visualizza, seleziona Palette comandi.
Al prompt dei comandi immettere .net: g e quindi selezionare .NET: Generare asset per la compilazione e il debug.
Si noti la nuova .vscode cartella aggiunta alla cartella del progetto.

La .vscode cartella contiene file usati per configurare l'ambiente di debug.
Espandere la .vscode cartella e quindi selezionare il file launch.json .
Prenditi un momento per esaminare il file launch.json.

Il file di configurazioni di avvio può includere più configurazioni. Ogni configurazione include una raccolta di attributi usati per definire tale configurazione.
Si noti che l'attributo prelaunchTask specifica un'attività di compilazione .
.vscode Nella cartella selezionare tasks.json.
Si noti che il file di tasks.json contiene l'attività di compilazione per il progetto di codice.
Chiudere i file launch.json e tasks.json.

Più avanti in questo modulo verranno esaminati gli attributi di configurazione di avvio.

Il menu Esegui in Visual Studio Code offre l'opzione per eseguire il codice con o senza il debugger.

Aprire il file Program.cs.

Sostituire il contenuto del file Program.cs con il codice seguente:

/* 
This code uses a names array and corresponding methods to display
greeting messages
*/

string[] names = new string[] { "Sophia", "Andrew", "AllGreetings" };

string messageText = "";

foreach (string name in names)
{
    if (name == "Sophia")
        messageText = SophiaMessage();
    else if (name == "Andrew")
        messageText = AndrewMessage();
    else if (name == "AllGreetings")
        messageText = SophiaMessage();
        messageText = messageText + "\n\r" + AndrewMessage();

    Console.WriteLine(messageText + "\n\r");
}

bool pauseCode = true;
while (pauseCode == true);

static string SophiaMessage()
{
    return "Hello, my name is Sophia.";
}

static string AndrewMessage()
{
    return "Hi, my name is Andrew. Good to meet you.";
}

Nel menu File, selezionare Salva.
Aprire il menu Esegui .

Si noti che il menu Esegui fornisce opzioni per l'esecuzione del codice con o senza debug.
Nel menu Esegui selezionare Esegui senza eseguire debug
Si noti che il pannello DEBUG CONSOLE visualizza l'output della console e che nella barra degli strumenti Debug vengono visualizzati i controlli di esecuzione.

Il pannello DEBUG CONSOLE deve essere visualizzato sotto l'editor di codice. Per impostazione predefinita, la barra degli strumenti Debug (la piccola barra degli strumenti che visualizza i controlli di esecuzione del codice) si trova sopra l'Editor del codice e centrata orizzontalmente nella finestra di Visual Studio Code.
Sulla barra degli strumenti Debug selezionare Arresta.

Il menu Esegui include l'opzione per avviare una sessione di debug.

Nel menu Esegui selezionare Avvia debug
Prenditi un momento per esaminare i messaggi visualizzati nel pannello DEBUG CONSOLE.

L'output dell'applicazione è identico a quello dell'esecuzione senza eseguire il debug, ma vengono visualizzati altri messaggi relativi alla preparazione dell'ambiente di debug.
Si notino i messaggi relativi al caricamento di risorse .NET e all'applicazione Debug101.

I primi due messaggi segnalano il caricamento della libreria .NET e quindi dell'applicazione Debug101.
```
Loaded 'C:\Program Files\dotnet\shared\Microsoft.NETCore.App\10.0.0\System.Private.CoreLib.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
Loaded 'C:\Users\someuser\Desktop\Debug101\bin\Debug\net10.0\Debug101.dll'. Symbols loaded.
```
Il debugger usa un'istanza speciale del runtime .NET per controllare l'esecuzione dell'applicazione e valutare lo stato dell'applicazione.
Sulla barra degli strumenti Debug selezionare Arresta.

Esegui il codice dalla vista Esegui e Debug

La visualizzazione RUN AND DEBUG in Visual Studio Code supporta un'esperienza di debug avanzata.

Passare alla visualizzazione RUN AND DEBUG.
Nella visualizzazione ESEGUI E DEBUGGA selezionare Avvia il debug.

Il pulsante Avvia debug è la freccia verde nel pannello di controllo nella parte superiore della visualizzazione.
Si noti che il pannello DEBUG CONSOLE mostra gli stessi messaggi relativi alla configurazione del debugger visualizzato all'avvio di un processo di debug dal menu Esegui .
Sulla barra degli strumenti Debug selezionare Arresta.

Esaminare l'output dell'applicazione

Prima di chiudere il pannello DEBUG CONSOLE, prendi un minuto per esaminare l'output prodotto dal tuo codice.
Si noti che il messaggio di saluto di Andrew viene ripetuto in modo imprevisto.

Durante il resto di questo modulo si useranno gli strumenti del debugger di Visual Studio Code per analizzare i problemi di codifica.

Riepilogo

Ecco i concetti più importanti di questa unità da ricordare:

Il debugger di Visual Studio Code per C# usa il runtime .NET per avviare e interagire con un'applicazione.
Il menu Esegui di Visual Studio Code include opzioni per avviare un'applicazione con e senza il debugger collegato.
La barra degli strumenti Debug include un pulsante per arrestare un processo in esecuzione.
La visualizzazione RUN AND DEBUG include un'opzione per avviare il debug di un'applicazione.

Commenti e suggerimenti

Questa pagina è stata utile?