Uso di Visual Studio Code per eseguire il debug dei cmdlet compilati

2025-05-20

Questa guida illustra come eseguire il debug interattivo del codice sorgente C# per un modulo di PowerShell compilato usando Visual Studio Code (VS Code) e l'estensione C#.

Si presuppone una certa familiarità con il debugger di Visual Studio Code.

Per un'introduzione generale al debugger di VS Code, vedere Debug in Visual Studio Code.
Per esempi di debug di moduli e file di script di PowerShell, vedere Uso di Visual Studio Code per la modifica remota e il debug.

Questa guida presuppone che siano state lette e seguite le istruzioni nella guida Scrittura di moduli portabili .

Creazione di un'attività di compilazione

Compilare automaticamente il progetto prima di avviare una sessione di debug. La ricompilazione garantisce il debug della versione più recente del codice.

Configurare un'attività di compilazione:

Nel riquadro comandi eseguire il comando Configura attività di compilazione predefinita .

Esegui Configura Attività di Compilazione Predefinita
Nella finestra di dialogo Selezionare un'attività da configurare scegliere Crea tasks.json file dal modello.
Nella finestra di dialogo Seleziona un modello di attività scegliere .NET Core.

Se non esiste ancora, viene creato un nuovo tasks.json file.

Per testare l'attività di compilazione:

Nel riquadro comandi eseguire il comando Esegui attività di compilazione .
Nella finestra di dialogo Selezionare l'attività di compilazione da eseguire scegliere Compila.

Informazioni sui file DLL bloccati

Per impostazione predefinita, una compilazione con esito positivo non mostra l'output nel riquadro del terminale. Se viene visualizzato l'output che contiene il file di testo Project non esiste, è necessario modificare il tasks.json file. Includere il percorso esplicito del progetto C# espresso come "${workspaceFolder}/myModule". In questo esempio è myModule il nome della cartella del progetto. Questa voce deve andare dopo la build voce nell'elenco args come indicato di seguito:

    {
        "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"
    }

Durante il debug, la DLL del modulo viene importata nella sessione di PowerShell nel terminale di VS Code. La DLL viene bloccata. Quando si esegue l'attività di compilazione senza chiudere la sessione del terminale, viene visualizzato il messaggio seguente:

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

Prima di ricompilare, è necessario chiudere le sessioni del terminale.

Configurazione del debugger

Per eseguire il debug del cmdlet di PowerShell, è necessario configurare una configurazione di avvio personalizzata. Questa configurazione viene usata per:

Compilare il codice sorgente
Avviare PowerShell con il modulo caricato
Lasciare Aperto PowerShell nel riquadro del terminale

Quando si richiama il cmdlet nella sessione del terminale, il debugger si arresta in qualsiasi punto di interruzione impostato nel codice sorgente.

Configurazione di launch.json per PowerShell

Installare l'estensione C# per Visual Studio Code
Nel riquadro Debug aggiungere una configurazione di debug
Select environment Nella finestra di dialogo scegliere.NET Core
Il launch.json file viene aperto nell'editor. Con il cursore all'interno della configurations matrice, viene visualizzato lo strumento di selezione configuration. Se questo elenco non viene visualizzato, selezionare Aggiungi configurazione.
Per creare una configurazione di debug predefinita, selezionare Avvia app console .NET Core:

Avviare l'app console .NET Core

Modificare i name, program, args e console campi come indicato di seguito:

 {
     "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"
 }

Il program campo viene usato per avviare pwsh in modo che il cmdlet sottoposto a debug possa essere eseguito. L'argomento -NoExit impedisce la chiusura della sessione di PowerShell non appena viene importato il modulo. Il percorso nell'argomento Import-Module è il percorso di output di compilazione predefinito se hai seguito la guida Scrivere moduli portatili. Se è stato creato un manifesto del modulo (.psd1 file), è consigliabile usare il percorso a tale manifesto. Il / separatore di percorso funziona in Windows, Linux e macOS. È necessario usare il terminale integrato per eseguire i comandi di PowerShell di cui si vuole eseguire il debug.

Annotazioni

Se il debugger non si arresta in alcun punto di interruzione, cercare nella console di debug di Visual Studio Code una riga che indica:

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

Se viene visualizzato, aggiungere "justMyCode": false alla configurazione di avvio (allo stesso livello di "console": "integratedTerminal".

Configurazione di launch.json per Windows PowerShell

Questa configurazione di avvio funziona per testare i cmdlet in Windows PowerShell (powershell.exe). Creare una seconda configurazione di avvio con le modifiche seguenti:

name deve essere PowerShell cmdlets: powershell
type deve essere clr

program deve essere powershell

Dovrebbe avere un aspetto simile a questo:

 {
     "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"
 }

Avvio di una sessione di debug

Ora tutto è pronto per iniziare il debug.

Inserire un punto di interruzione nel codice sorgente per il cmdlet di cui si vuole eseguire il debug:

Un punto di interruzione viene visualizzato come punto rosso nella barra
Assicurarsi che la configurazione dei cmdlet di PowerShell pertinente sia selezionata nel menu a discesa della configurazione nella visualizzazione Debug :

Selezionare la configurazione di avvio
Premere F5 o fare clic sul pulsante Avvia debug
Passare al riquadro del terminale e richiamare il cmdlet:

Richiamare il cmdlet
L'esecuzione si arresta in corrispondenza del punto di interruzione:

Le esecuzioni si arrestano in corrispondenza del punto di interruzione

È possibile esaminare il codice sorgente, esaminare le variabili ed esaminare lo stack di chiamate.

Per terminare il debug, fare clic su Arresta sulla barra degli strumenti di debug o premere MAIUSC+F5. La shell usata per il debug esce e rilascia il lock sul file DLL compilato.

Condividi tramite