Usando o Visual Studio Code para depurar cmdlets compilados

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

Presume-se alguma familiaridade com o depurador do Visual Studio Code.

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

Criando uma tarefa de compilação

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

Configurar uma tarefa de compilação:

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

    Executar Configurar Tarefa de Build Padrão

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

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

Um novo arquivo tasks.json será 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. No diálogo Selecionar a tarefa de build a executar, escolha build.

Informações sobre arquivos DLL sendo bloqueados

Por padrão, um build bem-sucedido não mostra a saída no painel do terminal. Se for exibida a saída com o texto O arquivo de projeto não existe, edite o arquivo tasks.json. Inclua o caminho explícito para o projeto C# expresso como "${workspaceFolder}/myModule". Neste exemplo, myModule é o nome da pasta do projeto. Essa entrada deve ir após a entrada build na lista de args da seguinte maneira:

    {
        "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 build 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 de terminal devem ser fechadas antes de recompilar.

Configurando o depurador

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

  • Criar seu código-fonte
  • Iniciar o PowerShell com o módulo carregado
  • Deixar o PowerShell aberto no painel do terminal

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

Configurando launch.json para o PowerShell

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

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

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

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

  5. Para criar uma configuração de depuração padrão, selecione Iniciar Aplicativo de Console do .NET Core:

    Iniciar Aplicativo de Console do .NET Core

  6. Edite os campos name, program, argse console da 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 campo program é usado para iniciar pwsh para que o cmdlet que está sendo depurado possa ser executado. O argumento -NoExit impede que a sessão do PowerShell saia assim que o módulo é importado. O caminho no argumento Import-Module é o caminho de saída de build padrão quando você seguiu o guia Como Escrever Módulos Portáteis. Se você tiver criado um manifesto de módulo (arquivo .psd1), use o caminho para ele em vez disso. O separador de caminho / funciona no 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 console de depuração do Visual Studio Code 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 à configuração de inicialização (no mesmo nível que "console": "integratedTerminal".

Configurando launch.json para o 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

    Ele deve ter esta aparência:

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

Como iniciar 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 depuração é encerrado e libera o bloqueio no arquivo DLL compilado.

  • Last updated on