Usando o Visual Studio Code para depurar cmdlets compilados

  • Artigo

Este guia mostra como depurar interativamente o código-fonte C# para um módulo PowerShell compilado usando o Visual Studio Code (VS Code) e a extensão C#.

Alguma familiaridade com o depurador de código do Visual Studio é assumida.

Este guia pressupõe que você leu e seguiu as instruções no guia Escrevendo módulos portáteis.

Criando uma tarefa de compilação

Crie seu projeto automaticamente antes de iniciar uma sessão de depuração. A reconstrução garante que você depure a versão mais recente do seu código.

Configure uma tarefa de compilação:

  1. Na Paleta de Comandos, execute o comando Configurar Tarefa de Compilação Padrão .

    Executar tarefa Configurar compilação padrão

  2. Na caixa de diálogo Selecione uma tarefa para configurar, escolha Criar tasks.json arquivo a partir do modelo.

  3. Na caixa de diálogo Selecionar um Modelo de Tarefa, escolha .NET Core.

Um novo tasks.json arquivo é criado se ainda não existir.

Para testar sua tarefa de compilação:

  1. Na Paleta de Comandos, execute o comando Executar Tarefa de Compilação .

  2. Na caixa de diálogo Selecione a tarefa de compilação para executar, escolha compilar.

Informações sobre arquivos DLL sendo bloqueados

Por padrão, uma compilação bem-sucedida não mostra a saída no painel do terminal. Se você vir que a saída que contém o arquivo de projeto de texto não existe, você deve editar o tasks.json arquivo. Inclua o caminho explícito para o projeto C# expresso como "${workspaceFolder}/myModule". Neste exemplo, myModule é o nome da pasta do projeto. Esta entrada deve seguir a build entrada na args lista da seguinte forma:

    {
        "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 a depuração, a DLL do módulo é importada para a sessão do PowerShell no terminal do VS Code. A DLL fica bloqueada. A seguinte mensagem é exibida quando você executa a tarefa de compilação sem fechar a sessão do terminal:

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

As sessões do terminal devem ser fechadas antes da reconstrução.

Configurando o depurador

Para depurar o cmdlet do PowerShell, você precisa configurar uma configuração de inicialização personalizada. Esta configuração é usada para:

  • Crie o seu código-fonte
  • Inicie o PowerShell com o módulo carregado
  • Deixe o PowerShell aberto no painel de terminal

Quando você invoca seu cmdlet na sessão do terminal, o depurador para em qualquer ponto de interrupção definido no código-fonte.

Configurando o launch.json para PowerShell

  1. Instalar a extensão C# for Visual Studio Code

  2. No painel Depurar, adicione uma configuração de depuração

  3. Select environment Na caixa de diálogo, escolha.NET Core

  4. O launch.json arquivo é aberto no editor. Com o cursor dentro da configurations matriz, você vê o configuration seletor. Se não vir esta lista, selecione Adicionar Configuração.

  5. Para criar uma configuração de depuração padrão, selecione Iniciar o aplicativo de console .NET Core:

    Iniciar o aplicativo de console .NET Core

  6. Edite os namecampos , program, argse da console seguinte maneira:

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

O program campo é usado para iniciar pwsh para que o cmdlet que está sendo depurado possa ser executado. O -NoExit argumento impede que a sessão do PowerShell saia assim que o módulo é importado. O caminho no argumento é o Import-Module caminho de saída de compilação padrão quando você segue o guia Escrevendo módulos portáteis. Se você criou um manifesto de módulo (.psd1 arquivo), você deve usar o caminho para isso. O / separador de caminho funciona em Windows, Linux e macOS. Você deve usar o terminal integrado para executar os comandos do PowerShell que deseja depurar.

Nota

Se o depurador não parar em nenhum ponto de interrupção, procure no Visual Studio Code Debug Console uma linha que diz:

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

Se você vir isso, adicione "justMyCode": false à sua configuração de inicialização (no mesmo nível que "console": "integratedTerminal".

Configurando o launch.json para Windows PowerShell

Essa configuração de inicialização funciona para testar seus cmdlets no Windows PowerShell (powershell.exe). Crie uma segunda configuração de inicialização com as seguintes alterações:

  1. name deve ser PowerShell cmdlets: powershell

  2. type deve ser clr

  3. program deve ser powershell

    Deverá ter o seguinte aspeto:

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

Iniciando uma sessão de depuração

Agora tudo está pronto para começar a depuração.

Você pode percorrer o código-fonte, inspecionar variáveis e inspecionar a pilha de chamadas.

Para encerrar a depuração, clique em Parar na barra de ferramentas de depuração ou pressione Shift+F5. O shell usado para depurar sai e libera o bloqueio no arquivo DLL compilado.