Oefening: code uitvoeren in de foutopsporingsomgeving

8 minuten

Met de gebruikersinterface van Visual Studio Code kunnen ontwikkelaars hun code uitvoeren in een foutopsporingsomgeving. Ondersteuning voor foutopsporing wordt geleverd door extensies en voor C#-ontwikkelaars wordt ondersteuning voor foutopsporingsprogramma's geboden door dezelfde extensie die ondersteuning biedt voor codeontwikkeling en IntelliSense.

Foutopsporingsprogramma en interactie met toepassingen

Een codeopsporingsprogramma kan worden gebruikt om de uitvoering van code te onderbreken en hervatten, de variabelestatus te onderzoeken en zelfs de waarden te wijzigen die tijdens runtime zijn toegewezen aan variabelen. U vraagt zich misschien af hoe het foutopsporingsprogramma een actieve toepassing kan besturen en wijzigen. Het korte antwoord is dat het foutopsporingsprogramma toegang heeft tot de runtime-omgeving en uitvoerbare code van de toepassing.

Opmerking

Interactie van de foutopsporing met de runtime-omgeving is een geavanceerd onderwerp. Daarnaast is het niet vereist om te begrijpen hoe het foutopsporingsprogramma achter de schermen werkt om het te gebruiken. De volgende beschrijving kan echter uw nieuwsgierigheid bevredigen.

Het foutopsporingsprogramma van Visual Studio Code voor C# maakt gebruik van de .NET-runtime om een toepassing te starten en ermee te communiceren. Wanneer u het foutopsporingsprogramma start, wordt er een nieuw exemplaar van de runtime gemaakt en wordt de toepassing in dat exemplaar uitgevoerd. De runtime bevat een API (Application Programming Interface), die door het foutopsporingsprogramma wordt gebruikt om te koppelen aan het actieve proces (uw toepassing).

Zodra uw toepassing wordt uitgevoerd en het foutopsporingsprogramma is gekoppeld, communiceert het foutopsporingsprogramma met het actieve proces met behulp van de foutopsporings-API's van de .NET-runtime en een standaard foutopsporingsprotocol. Het foutopsporingsprogramma kan communiceren met het proces (de toepassing die wordt uitgevoerd in het .NET Runtime-exemplaar) door onderbrekingspunten in te stellen, code te doorlopen en variabelen te inspecteren. Met de interface voor foutopsporingsprogramma's van Visual Studio Code kunt u door de broncode navigeren, aanroepstacks weergeven en expressies evalueren.

De meest voorkomende manier om een foutopsporingssessie op te geven, is een opstartconfiguratie in het launch.json-bestand. Deze methode is de standaardoptie die is ingeschakeld door de hulpprogramma's voor foutopsporingsprogramma's. Als u bijvoorbeeld een C#-consoletoepassing maakt en Start Debugging selecteert in het menu Uitvoeren , gebruikt het foutopsporingsprogramma deze methode om te starten, bij te voegen en vervolgens te communiceren met uw toepassing.

Een nieuw codeproject maken

De eerste stap bij het leren van de hulpprogramma's voor foutopsporing is het maken van een codeproject dat u kunt uitvoeren in het foutopsporingsprogramma.

Open een nieuw exemplaar van Visual Studio Code.
Selecteer in het menu Bestand de optie Map openen.
Navigeer in het Open Folder dialoogvenster naar uw Windows Desktop map.
Selecteer in het dialoogvenster Map openen de optie Nieuwe map.
Geef de nieuwe map de naam Debug101 en selecteer vervolgens Map selecteren.
Selecteer Nieuwe terminal in het menu Terminal.

Een .NET CLI-opdracht kan worden gebruikt om een nieuwe console-app te maken.
Voer bij de opdrachtprompt van het TERMINAL-deelvenster de volgende opdracht in:
```
dotnet new console
```
Sluit het TERMINAL-deelvenster.

Startconfiguraties onderzoeken voor foutopsporing

Visual Studio Code maakt gebruik van een startconfiguratiebestand om de toepassing op te geven die wordt uitgevoerd in de foutopsporingsomgeving.

Als de map Debug101 geen Debug101.sln bestand bevat, selecteert u Program.cs en controleert u of er een .sln-bestand is gemaakt.

Als u een C#-codebestand opent, wordt de omgeving gevraagd om te controleren op projectbestanden. Het .sln-bestand is een oplossingsbestand dat door Visual Studio wordt gebruikt voor het beheren van projecten en wordt meestal automatisch gemaakt wanneer u een nieuw project maakt in Visual Studio Code. Het .sln-bestand wordt door het foutopsporingsprogramma gebruikt om het project te identificeren dat moet worden uitgevoerd in de foutopsporingsomgeving.
Selecteer Opdrachtpalet in het menu Beeld.
Voer bij de opdrachtprompt .net in: g en selecteer vervolgens .NET: Assets genereren voor build en foutopsporing.
Let op de nieuwe .vscode map die is toegevoegd aan uw projectmap.

De .vscode map bevat bestanden die worden gebruikt om de foutopsporingsomgeving te configureren.
Vouw de .vscode map uit en selecteer vervolgens het launch.json bestand.
Neem even de tijd om het bestand launch.json te bekijken.

Het opstartconfiguratiebestand kan meerdere configuraties bevatten. Elke configuratie bevat een verzameling kenmerken die worden gebruikt om die configuratie te definiëren.
U ziet dat het prelaunchTask-kenmerk een build-taak aangeeft.
In de .vscode map, selecteer tasks.json.
U ziet dat het bestand tasks.json de build-taak voor uw codeproject bevat.
Sluit de launch.json en tasks.json bestanden.

Verderop in deze module bekijkt u de kenmerken van de startconfiguratie.

Het menu Uitvoeren in Visual Studio Code biedt de optie om uw code uit te voeren met of zonder het foutopsporingsprogramma.

Open het bestand Program.cs .

Vervang de inhoud van uw Program.cs bestand door de volgende code:

/* 
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.";
}

Selecteer Opslaan in het menu Bestand.
Open het menu Uitvoeren .

U ziet dat het menu Uitvoeren opties biedt voor het uitvoeren van uw code met of zonder foutopsporing.
Selecteer Uitvoeren zonder foutopsporing in het menu Uitvoeren
U ziet dat in het deelvenster DEBUG CONSOLE console-uitvoer wordt weergegeven en dat op de werkbalk Foutopsporing uitvoeringsbesturingselementen worden weergegeven.

Het deelvenster DEBUG CONSOLE moet worden weergegeven onder de code-editor. Standaard bevindt de werkbalk Foutopsporing (de kleine werkbalk met besturingselementen voor het uitvoeren van code) zich boven de code-editor en horizontaal gecentreerd in het Visual Studio Code-venster.
Selecteer Stoppen op de werkbalk Foutopsporing.

Het menu Uitvoeren bevat de optie om een foutopsporingssessie te starten.

Selecteer in het menu Uitvoeren de foutopsporing starten
Neem even de tijd om de berichten te bekijken die worden weergegeven in het deelvenster DEBUG CONSOLE.

De uitvoer van uw toepassing is hetzelfde als wanneer u zonder foutopsporing hebt uitgevoerd, maar andere berichten met betrekking tot het voorbereiden van de foutopsporingsomgeving worden weergegeven.
U ziet de berichten over het laden van .NET-resources en uw Debug101-toepassing.

De eerste twee berichten rapporteren over het laden van de .NET-bibliotheek en vervolgens uw Debug101-toepassing.
```
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.
```
Het foutopsporingsprogramma maakt gebruik van een speciaal exemplaar van de .NET-runtime om de uitvoering van uw toepassing te beheren en de toepassingsstatus te evalueren.
Selecteer Stoppen op de werkbalk Foutopsporing.

Uw code uitvoeren vanuit de weergave Uitvoeren en foutopsporing

De weergave RUN AND DEBUG in Visual Studio Code biedt ondersteuning voor een uitgebreide foutopsporingservaring.

Schakel over naar de weergave Run en Debug.
In de weergave UITVOEREN EN FOUTOPSPORING, selecteer Foutopsporing starten.

De knop "Start Debugging" is de groene pijl op het bedieningspaneel bovenaan in de weergave.
U ziet dat in het deelvenster DEBUG CONSOLE dezelfde berichten worden weergegeven over het configureren van het foutopsporingsprogramma dat werd weergegeven bij het starten van een foutopsporingsproces vanuit het menu Uitvoeren .
Selecteer Stoppen op de werkbalk Foutopsporing.

De uitvoer van uw toepassing onderzoeken

Voordat u het paneel DEBUG CONSOLE sluit, neemt u een minuut de tijd om de uitvoer te bekijken die uw code heeft geproduceerd.
U ziet dat het begroetingsbericht van Andrew onverwacht wordt herhaald.

In de rest van deze module gebruikt u de hulpprogramma's voor foutopsporingsprogramma's van Visual Studio Code om coderingsproblemen te onderzoeken.

Samenvatting

Hier volgen enkele belangrijke dingen die u in deze les moet onthouden:

Het foutopsporingsprogramma van Visual Studio Code voor C# maakt gebruik van de .NET-runtime om een toepassing te starten en ermee te communiceren.
Het menu Uitvoeren van Visual Studio Code bevat opties om een toepassing te starten met en zonder dat het foutopsporingsprogramma is gekoppeld.
De werkbalk Foutopsporing bevat een knop om een actief proces te stoppen .
De weergave RUN AND DEBUG bevat een optie om een toepassing te debuggen.

Feedback

Is deze pagina nuttig?