Øvelse – Kjør kode i feilsøkingsmiljøet

8 minutter

Brukergrensesnittet for Visual Studio Code gjør det mulig for utviklere å kjøre koden i et feilsøkingsmiljø. Støtte for feilsøking leveres av utvidelser, og for C#-utviklere leveres feilsøkingsstøtte av samme utvidelse som gir støtte for kodeutvikling og IntelliSense.

Feilsøkingsprogram og programsamhandling

Et kodedebugger kan brukes til å stanse og gjenoppta kjøring av kode midlertidig, undersøke variabel tilstand og til og med endre verdiene som er tilordnet variabler ved kjøring. Du lurer kanskje på hvordan kan feilsøkingskontrollen og endre et program som kjører? Det korte svaret er at feilsøkingsprogrammet har tilgang til programmets kjøretidsmiljø og kjørbar kode.

Merk deg

Feilsøkingssamhandling med kjøretidsmiljøet er et avansert emne. I tillegg er det ikke et krav å forstå hvordan feilsøkingsprogrammet fungerer bak kulissene for å bruke feilsøkingsprogrammet. Beskrivelsen nedenfor kan imidlertid tilfredsstille nysgjerrigheten din.

Visual Studio Code-feilsøkeren for C# bruker .NET-runtime for å starte og samhandle med en applikasjon. Når du starter feilsøkingsprogrammet, oppretter det en ny forekomst av kjøretiden og kjører programmet i denne forekomsten. Kjøretiden inkluderer et programprogrammeringsgrensesnitt (API), som feilsøkingsprogrammet bruker til å knytte til den kjørende prosessen (programmet ditt).

Når applikasjonen din kjører og feilsøkingsmaskinen er koblet til, kommuniserer feilsøkeren med den kjørende prosessen ved hjelp av .NET-runtimes feilsøkings-API-er og en standard feilsøkingsprotokoll. Feilsøkingsprogrammet kan samhandle med prosessen (programmet som kjører i .NET-kjøretidsforekomsten) ved å angi breakpoints, gå gjennom kode og undersøke variabler. Visual Studio Codes feilsøkingsgrensesnitt gjør det mulig å navigere i kildekoden, vise anropsstakker og evaluere uttrykk.

Den vanligste måten å angi en feilsøkingsøkt på, er en startkonfigurasjon i launch.json-filen. Denne fremgangsmåten er standardalternativet som aktiveres av feilsøkingsverktøyene. Hvis du for eksempel oppretter et C#-konsollprogram og velger Start feilsøking fra Kjør-menyen , bruker feilsøkingsprogrammet denne fremgangsmåten til å starte, legge ved og deretter samhandle med programmet.

Opprett et nytt kodeprosjekt

Det første trinnet i å lære feilsøkingsverktøyene er å opprette et kodeprosjekt som du kan kjøre i feilsøkingsprogrammet.

Åpne en ny forekomst av Visual Studio Code.
Velg Åpne mappe på Fil-menyen.
Gå til Windows-skrivebordsmappen i dialogboksen Åpne mappe.
Velg Ny mappe i dialogboksen Åpne mappe.
Gi navn til den nye mappen Debug101, og velg deretter Velg mappe.
Velg Ny terminalpå Terminal-menyen.

En .NET CLI-kommando kan brukes til å opprette en ny konsollapp.
Skriv inn følgende kommando i ledeteksten i TERMINAL-panelet:
```
dotnet new console
```
Lukk TERMINAL-panelet.

Undersøk startkonfigurasjoner for feilsøking

Visual Studio Code bruker en startkonfigurasjonsfil til å angi programmet som kjører i feilsøkingsmiljøet.

Hvis Debug101-mappen ikke inneholder en Debug101.sln fil, velger du Program.cs og kontrollerer deretter at en .sln fil er opprettet.

Når du åpner en C#-kodefil, blir miljøet bedt om å se etter prosjektfiler. Den .sln filen er en løsningsfil som brukes av Visual Studio til å administrere prosjekter, og som regel opprettes automatisk når du oppretter et nytt prosjekt i Visual Studio Code. Den .sln filen brukes av feilsøkingsprogrammet til å identifisere prosjektet som skal kjøres i feilsøkingsmiljøet.
Velg Kommandopalett på Vis-menyen.
Skriv inn .net i ledeteksten: g, og velg deretter .NET: Generer aktiva for bygg og feilsøking.
Legg merke til den nye .vscode mappen som er lagt til i prosjektmappen.

Mappen .vscode inneholder filer som brukes til å konfigurere feilsøkingsmiljøet.
.vscode Utvid mappen, og velg deretter launch.json filen.
Ta deg tid til å undersøke launch.json filen.

Startkonfigurasjonsfilen kan inneholde flere konfigurasjoner. Hver konfigurasjon inneholder en samling attributter som brukes til å definere denne konfigurasjonen.
Legg merke til at prelaunchTask-attributtet angir en byggoppgave .
.vscode Velg tasks.jsoni mappen.
Legg merke til at tasks.json-filen inneholder byggoppgaven for kodeprosjektet.
Lukk filenelaunch.json og tasks.json .

Du tar en nærmere titt på startkonfigurasjonsattributter senere i denne modulen.

Kjør-menyen i Visual Studio Code gir deg muligheten til å kjøre koden med eller uten feilsøkingsprogrammet.

Åpne Program.cs-filen.

Erstatt innholdet i Program.cs-filen med følgende kode:

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

På Fil-menyen, velg Lagre.
Åpne Kjør-menyen .

Legg merke til at Kjør-menyen inneholder alternativer for å kjøre koden med eller uten feilsøking.
Velg Kjør uten feilsøking på Kjør-menyen
Legg merke til at DEBUG CONSOLE-panelet viser konsollutdata, og at feilsøkingsverktøylinjen viser kjøringskontroller.

DEBUG CONSOLE-panelet skal vises under koderedigeringsprogrammet. Som standard er feilsøkingsverktøylinjen (den lille verktøylinjen som viser kodekjøringskontroller) plassert over koderedigeringsprogrammet og vannrett midtstilt i Visual Studio Code-vinduet.
Velg Stopp på feilsøkingsverktøylinjen.

Kjør-menyen inneholder alternativet for å starte en feilsøkingsøkt.

Velg Start feilsøking på Kjør-menyen
Ta deg tid til å se gjennom meldingene som vises i DEBUG CONSOLE-panelet.

Utdataene fra programmet er det samme som når du kjørte uten feilsøking, men andre meldinger relatert til klargjøring av feilsøkingsmiljøet vises.
Legg merke til meldingene om innlasting av .NET-ressurser og Feilsøking101-programmet.

De to første meldingene rapporterer at du laster inn .NET-biblioteket og deretter Debug101-applikasjonen din.
```
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.
```
Feilsøkingsprogrammet bruker en spesiell forekomst av .NET-kjøretiden til å kontrollere kjøringen av programmet og evaluere programtilstanden.
Velg Stopp på feilsøkingsverktøylinjen.

Kjøre koden fra Run- og Debug-visningen

RUN AND DEBUG-visningen i Visual Studio Code støtter en omfattende feilsøkingsopplevelse.

Bytt til RUN AND DEBUG-visningen.
Velg Start feilsøking i RUN AND DEBUG-visningen.

Start feilsøking-knappen er den grønne pilen på kontrollpanelet øverst i visningen.
Legg merke til at DEBUG CONSOLE-panelet viser de samme meldingene om konfigurasjon av feilsøkingsprogrammet som ble vist når du startet en feilsøkingsprosess fra Kjør-menyen .
Velg Stopp på feilsøkingsverktøylinjen.

Undersøk utdataene fra programmet

Før du lukker DEBUG CONSOLE-panelet, kan du ta et minutt å se gjennom utdataene som koden din produserte.
Legg merke til at Andrews hilsen gjentas uventet.

I resten av denne modulen bruker du feilsøkingsverktøyene for Visual Studio Code til å undersøke kodeproblemer.

Oppsummering

Her er noen viktige ting du kan huske fra denne enheten:

Visual Studio Code-feilsøkeren for C# bruker .NET-runtime for å starte og samhandle med en applikasjon.
Kodekjøringsmenyen i Visual Studio har alternativer for å starte et program med og uten feilsøkingsprogrammet vedlagt.
Feilsøkingsverktøylinjen inneholder en knapp for å stoppe en prosess som kjører.
RUN AND DEBUG-visningen inneholder et alternativ for å starte feilsøking av et program.

Tilbakemeldinger

Var denne siden nyttig?