Partilhar via

Usando o Visual Studio Code para depurar cmdlets compilados

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 o utilizador leu e seguiu as instruções no guia Writing Portable Modules.

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 Construção Padrão.

    Executar a tarefa Configurar compilação padrão

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

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

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

Para testar sua tarefa de compilação:

  1. No Command Palette, execute o comando Run Build Task.

  2. Na caixa de diálogo Selecione a tarefa de compilação a ser executada, escolha compilação.

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 vires que a saída contém o texto o ficheiro do projeto não existe, deves editar o ficheiro tasks.json. 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 ir após a entrada build na lista de args 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 Visual Studio 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 de serem reconstruídas.

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. Instale o C# para Visual Studio Code extensão

  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ê vê o seletor de configuration. Se não vir esta lista, selecione Adicionar configuração.

  5. Para criar uma configuração de depuração padrão, selecione "Launch .NET Core Console App":

    Iniciar a aplicação de consola .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 a ser 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 compilação padrão se seguir o guia Writing Portable Modules. Se criares um manifesto de módulo (arquivo.psd1), deverás usar o caminho para isso. 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.

Observação

Se o depurador não parar em nenhum ponto de interrupção, procure na Consola 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 à sua configuração de inicialização (no mesmo nível que "console": "integratedTerminal".

A Configuração do 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

    Deve ter a seguinte 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"
 }

Iniciando uma sessão de depuração

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

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

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

  • Last updated on