Visual Studio Code gebruiken om fouten in gecompileerde cmdlets op te sporen

  • Artikel
  • 4 minuten om te lezen

Deze handleiding laat zien hoe u interactief fouten in C#-broncode kunt opsporen voor een gecompileerde PowerShell-module met behulp van Visual Studio Code (VS Code) en de C#-extensie.

Enige bekendheid met het foutopsporingsprogramma van Visual Studio Code wordt aangenomen.

In deze handleiding wordt ervan uitgegaan dat u de instructies in de handleiding Schrijfbare modules hebt gelezen en gevolgd.

Een build-taak maken

Bouw uw project automatisch voordat u een foutopsporingssessie start. Herbouwen zorgt ervoor dat u fouten opssport in de nieuwste versie van uw code.

Een build-taak configureren:

  1. Voer in het opdrachtpalet de opdracht Standaard buildtaak configureren uit.

    Standaard buildtaak configureren uitvoeren

  2. Kies in het dialoogvenster Een taak selecteren die u wilt configureren het bestand Tasks.json maken op basis van de sjabloon.

  3. Kies .NET Core in het dialoogvenster Een taaksjabloon selecteren.

Er wordt een nieuw tasks.json bestand gemaakt als er nog geen bestand bestaat.

Uw build-taak testen:

  1. Voer in het opdrachtpalet de opdracht Build-taak uitvoeren uit.

  2. Kies build in het dialoogvenster De te uitvoeren build-taak selecteren.

Informatie over DLL-bestanden die worden vergrendeld

Standaard wordt in een geslaagde build geen uitvoer weergegeven in het terminalvenster. Als de uitvoer met het tekstbestand Project niet bestaat, moet u het tasks.json bestand bewerken. Neem het expliciete pad naar het C#-project op dat wordt uitgedrukt als "${workspaceFolder}/myModule". In dit voorbeeld myModule is dit de naam van de projectmap. Deze vermelding moet als volgt na de build vermelding in de args lijst gaan:

    {
        "label": "build",
        "command": "dotnet",
        "type": "shell",
        "args": [
            "build",
            "${workspaceFolder}/myModule",
            // Ask dotnet build to generate full paths for file names.
            "/property:GenerateFullPaths=true",
            // Do not generate summary otherwise it leads to duplicate errors in Problems panel
            "/consoleloggerparameters:NoSummary",
        ],
        "group": "build",
        "presentation": {
            "reveal": "silent"
        },
        "problemMatcher": "$msCompile"
    }

Bij foutopsporing wordt uw module-DLL geïmporteerd in de PowerShell-sessie in de VS Code-terminal. Het DLL-bestand wordt vergrendeld. Het volgende bericht wordt weergegeven wanneer u de build-taak uitvoert zonder de terminalsessie te sluiten:

Could not copy "obj\Debug\netstandard2.0\myModule.dll" to "bin\Debug\netstandard2.0\myModule.dll"`.

Terminalsessies moeten worden gesloten voordat u opnieuw bouwt.

Het foutopsporingsprogramma instellen

Als u fouten in de PowerShell-cmdlet wilt opsporen, moet u een aangepaste startconfiguratie instellen. Deze configuratie wordt gebruikt voor het volgende:

  • Uw broncode bouwen
  • PowerShell starten met uw module geladen
  • Laat PowerShell geopend in het terminalvenster

Wanneer u uw cmdlet aanroept in de terminalsessie, stopt het foutopsporingsprogramma bij onderbrekingspunten die zijn ingesteld in uw broncode.

Launch.json configureren voor PowerShell

  1. De C#-extensie voor Visual Studio Code installeren

  2. Voeg in het deelvenster Foutopsporing een foutopsporingsconfiguratie toe

  3. Kies in het Select environment dialoogvenster .NET Core

  4. Het launch.json bestand wordt geopend in de editor. Met de cursor in de configurations matrix ziet u de configuration kiezer. Als u deze lijst niet ziet, selecteert u Configuratie toevoegen.

  5. Als u een standaardconfiguratie voor foutopsporing wilt maken, selecteert u .NET Core Console-app starten:

    .NET Core-console-app starten

  6. Bewerk de namevelden , programargsen console de velden als volgt:

     {
     "name": "PowerShell cmdlets: pwsh",
     "type": "coreclr",
     "request": "launch",
     "preLaunchTask": "build",
     "program": "pwsh",
     "args": [
         "-NoExit",
         "-NoProfile",
         "-Command",
         "Import-Module ${workspaceFolder}/myModule/bin/Debug/netstandard2.0/myModule.dll",
     ],
     "cwd": "${workspaceFolder}",
     "stopAtEntry": false,
     "console": "integratedTerminal"
 }

Het program veld wordt gebruikt om te starten pwsh , zodat de cmdlet die wordt opgespoord, kan worden uitgevoerd. Het -NoExit argument voorkomt dat de PowerShell-sessie wordt afgesloten zodra de module wordt geïmporteerd. Het pad in het Import-Module argument is het standaardpad voor build-uitvoer wanneer u de handleiding Schrijfbare modules hebt gevolgd. Als u een modulemanifest (.psd1 bestand) hebt gemaakt, moet u in plaats daarvan het pad naar dat bestand gebruiken. Het / padscheidingsteken werkt in Windows, Linux en macOS. U moet de geïntegreerde terminal gebruiken om de PowerShell-opdrachten uit te voeren die u wilt opsporen.

Notitie

Als het foutopsporingsprogramma niet stopt bij onderbrekingspunten, kijkt u in de Visual Studio Code Debug Console voor een regel met de volgende tekst:

Loaded '/path/to/myModule.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.

Als u dit ziet, voegt u deze toe "justMyCode": false aan uw startconfiguratie (op hetzelfde niveau als "console": "integratedTerminal".

Launch.json configureren voor Windows PowerShell

Deze startconfiguratie werkt voor het testen van uw cmdlets in Windows PowerShell (powershell.exe). Maak een tweede startconfiguratie met de volgende wijzigingen:

  1. name moet zijn PowerShell cmdlets: powershell

  2. type moet zijn clr

  3. program moet zijn powershell

    Dit ziet er als volgt uit:

     {
     "name": "PowerShell cmdlets: powershell",
     "type": "clr",
     "request": "launch",
     "preLaunchTask": "build",
     "program": "powershell",
     "args": [
         "-NoExit",
         "-NoProfile",
         "-Command",
         "Import-Module ${workspaceFolder}/myModule/bin/Debug/netstandard2.0/myModule.dll",
     ],
     "cwd": "${workspaceFolder}",
     "stopAtEntry": false,
     "console": "integratedTerminal"
 }

Een foutopsporingssessie starten

Nu is alles klaar om te beginnen met foutopsporing.

  • Plaats een onderbrekingspunt in de broncode voor de cmdlet die u wilt opsporen:

    Een onderbrekingspunt wordt weergegeven als een rode stip in de rugmarge

  • Zorg ervoor dat de relevante configuratie van PowerShell-cmdlets is geselecteerd in de vervolgkeuzelijst configuratie in de weergave Foutopsporing :

    Selecteer de startconfiguratie

  • Druk op F5 of klik op de knop Foutopsporing starten

  • Schakel over naar het terminalvenster en roep de cmdlet aan:

    De cmdlet aanroepen

  • Uitvoering stopt op het onderbrekingspunt:

    Uitvoeringen worden gestopt op onderbrekingspunt

U kunt de broncode doorlopen, variabelen inspecteren en de aanroepstack inspecteren.

Als u foutopsporing wilt beëindigen, klikt u op Stoppen in de werkbalk voor foutopsporing of drukt u op Shift-F5. De shell die wordt gebruikt voor foutopsporing, wordt afgesloten en de vergrendeling op het gecompileerde DLL-bestand wordt vrijgegeven.