about_Debuggers

Aplica-se a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0

Insira a introdução aqui.

TÓPICO

about_Debuggers

DESCRIÇÃO BREVE

Descreve o depurador do Windows PowerShell®.

DESCRIÇÃO LONGA

A depuração é o processo de examinar um script enquanto ele é executado para identificar e corrigir erros nas instruções do script. O depurador do Windows PowerShell foi projetado para ajudar você a examinar e identificar erros e ineficiências em seus scripts, funções, comandos, fluxos de trabalho do Windows PowerShell ou expressões.

No Windows PowerShell 4.0, o depurador do Windows PowerShell foi atualizado para depurar scripts, funções, fluxos de trabalho, comandos ou expressões que estejam em execução no console do Windows PowerShell (não ISE) em computadores remotos. Você pode executar Enter-PSSession para iniciar uma sessão interativa remota do PowerShell na qual pode configurar pontos de interrupção e depurar arquivos e comandos de scripts no computador remoto. A funcionalidade ENTER-PSSession foi atualizada para permitir que você se reconecte e entre em uma sessão desconectada que esteja executando um comando ou script em um computador remoto. Se o script em execução atingir um ponto de interrupção, sua sessão do cliente iniciará o depurador automaticamente. Se a sessão desconectada que estiver executando um script já tiver atingido um ponto de interrupção e for interrompida no ponto de interrupção, a Enter-PSSession iniciará automaticamente o depurador de linha de comando depois que você se reconectar à sessão.

O depurador do Windows PowerShell 4.0 também pode ser usado para depurar os fluxos de trabalho do Windows PowerShell, seja no console do Windows PowerShell ou no ISE do Windows PowerShell.

Você pode usar os recursos do depurador do Windows PowerShell para examinar um script, função, comando, fluxo de trabalho ou expressão do Windows PowerShell enquanto ele estiver em execução. O depurador do Windows PowerShell inclui um conjunto de cmdlets que permite que você configure pontos de interrupção, gerencie pontos de interrupção e exiba a pilha de chamadas.

CMDLETS DO DEPURADOR

O depurador do Windows PowerShell inclui o seguinte conjunto de cmdlets:

          Set-PsBreakpoint:     Sets breakpoints on lines, variables, and
                                commands. 

          Get-PsBreakpoint:     Gets breakpoints in the current session.

          Disable-PsBreakpoint: Turns off breakpoints in the current session.

          Enable-PsBreakpoint:  Re-enables breakpoints in the current session.

          Remove-PsBreakpoint:  Deletes breakpoints from the current session.

          Get-PsCallStack:      Displays the current call stack. 

INÍCIO E INTERRUPÇÃO DO DEPURADOR

Para iniciar o depurador, configure um ou mais pontos de interrupção. Em seguida, execute o script, comando ou função que deseja depurar.

Quando você atingir um ponto de interrupção, a execução será interrompida e o controle será transferido ao depurador.

Para interromper o depurador, execute o script, comando ou função até sua conclusão. Ou digite "stop" ou "t".

COMANDOS DO DEPURADOR

Quando você usa o depurador no console do Windows PowerShell, use os seguintes comandos para controlar a execução. No ISE do Windows PowerShell, use os comandos no menu Depurar.

Observação: Para obter informações sobre como usar o depurador em outros aplicativos host, consulte a documentação sobre aplicativos host.

s, Step-into        Executes the next statement and then stops.


 v, Step-over        Executes the next statement, but skips functions
                            and invocations. The skipped statements are
                            executed, but not stepped through.


 o, Step-out         Steps out of the current function; up one level
                            if nested. If in the main body, it continues to
                            the end or the next breakpoint. The skipped
                            statements are executed, but not stepped through.


 c, Continue         Continues to run until the script is complete or
                            until the next breakpoint is reached. The skipped
                            statements are executed, but not stepped through.


        l, List             Displays the part of the script that is executing.
                            By default, it displays the current line, five
                            previous lines, and 10 subsequent lines. To continue
                            listing the script, press ENTER.
                        

        l <m>, List         Displays 16 lines of the script beginning with the
                            line number specified by <m>.                           

        l <m> <n>, List     Displays <n> lines of the script, beginning with the
                            line number specified by <m>.                           

        q, Stop             Stops executing the script, and exits the debugger.


        k, Get-PsCallStack  Displays the current call stack.


<Enter>             Repeats the last command if it was Step (s), 
                            Step-over (v), or List (l). Otherwise, represents a
                            submit action.  
                           

?, h                Displays the debugger command Help.


      To exit the debugger, use Stop (q).

Usando esses comandos do depurador, você pode executar um script, interromper a execução em um ponto de interesse, examinar os valores das variáveis e o estado do sistema, e continuar executando o script até identificar um problema.

OBSERVAÇÃO:

Se você entrar em uma instrução com um operador de redirecionamento, como ">", o depurador do Windows PowerShell ignorará todas as instruções restantes no script.

EXIBIÇÃO DOS VALORES DAS VARIÁVEIS DOS SCRIPTS

Enquanto você estiver no depurador, também pode inserir comandos, exibir o valor das variáveis, usar os cmdlets e executar scripts na linha de comando.

Você pode exibir o valor atual de todas as variáveis do script que está sendo depurado, exceto as seguintes variáveis automáticas:

          $_
          $Args
          $Input
          $MyInvocation
          $PSBoundParameters

Se você tentar exibir o valor de qualquer uma dessas variáveis, obterá o valor dessa variável em um pipeline interno usado pelo depurador, e não o valor da variável no script.

Para exibir o valor dessas variáveis para o script que está sendo depurado, no script, atribua o valor da variável automática a uma nova variável. Em seguida, você pode exibir o valor da nova variável.

Por exemplo,

          $scriptArgs = $Args
          $scriptArgs

No exemplo deste tópico, o valor da variável $MyInvocation é reatribuído da seguinte maneira:

          $scriptname = $MyInvocation.MyCommand.Path

O AMBIENTE DO DEPURADOR

Quando você atingir um ponto de interrupção, poderá entrar no ambiente do depurador. O prompt de comando muda para começar com "[DBG]:". Se você estiver depurando um fluxo de trabalho, o prompt é "[WFDBG]". Você pode personalizar o prompt.

Além disso, em alguns aplicativos host, como o console do Windows PowerShell (mas não no ISE (Ambiente de Scripting Integrado) do Windows PowerShell), um prompt aninhado é aberto para depuração. Você pode detectar o prompt aninhado repetindo os caracteres 'maior que' (ASCII 62) que aparecem no prompt de comando.

Por exemplo, o seguinte é o prompt padrão de depuração no console do Windows PowerShell:

[DBG]: PS (get-location)>>>

Você pode encontrar o nível de aninhamento usando a variável automática $NestedPromptLevel.

Além disso, uma variável automática, $PSDebugContext, é definida no escopo local. Você pode usar a presença da variável $PsDebugContext para determinar se você está no depurador.

Por exemplo:

          if ($psdebugcontext) {"Debugging"} else {"Not Debugging"}

Você pode usar o valor da variável $PSDebugContext em sua depuração.

[DBG]: PS>>> $psdebugcontext.invocationinfo

        Name   CommandLineParameters  UnboundArguments  Location
        ----   ---------------------  ----------------  --------
        =      {}                     {}                C:\ps-test\vote.ps1 (1)

DEPURAÇÃO E ESCOPO

Interromper o depurador não altera o escopo no qual você está operando, mas, quando você atingir um ponto de interrupção em um script, você será movido para o escopo do script. O escopo do script é um filho do escopo no qual você executou o depurador.

Para localizar as variáveis e os aliases que são definidos no escopo do script, use o parâmetro Scope dos cmdlets Get-Alias ou Get-Variable.

Por exemplo, o comando a seguir obtém as variáveis do escopo local (script):

  get-variable -scope 0

Você pode abreviar o comando como:

gv -s 0

Essa é uma maneira útil de ver somente as variáveis definidas no script e que foram definidas durante a depuração.

DEPURAÇÃO NA LINHA DE COMANDO

Quando você configura um ponto de interrupção de variável ou um ponto de interrupção de comando, você só pode configurar o ponto de interrupção em um arquivo de script. No entanto, por padrão, o ponto de interrupção é configurado em qualquer coisa que seja executada na sessão atual.

Por exemplo, se você configurar um ponto de interrupção na variável $name, o depurador será interrompido em qualquer variável $name de qualquer script, comando, função, cmdlet de script ou expressão que você executar até que o ponto de interrupção seja desabilitado ou removido.

Isso permite que você depure seus scripts em um contexto mais realista no qual eles podem ser afetados pela funções, variáveis e outros scripts da sessão e do perfil do usuário.

Os pontos de interrupção de linha são específicos dos arquivos de script, para que eles sejam definidos apenas em arquivos de script.

DEPURAÇÃO DE FLUXOS DE TRABALHO

O depurador do Windows PowerShell 4.0 também pode ser usado para depurar os fluxos de trabalho do Windows PowerShell, seja no console do Windows PowerShell ou no ISE do Windows PowerShell. Existem algumas limitações ao uso do depurador do Windows PowerShell para a depuração de fluxos de trabalho.

-- You can view workflow variables while you are in the debugger, but
         setting workflow variables from within the debugger is not supported.
      -- Tab completion when stopped in the workflow debugger is not
         available.
      -- Workflow debugging works only with synchronous running of workflows from
         a Windows PowerShell script. You cannot debug workflows if they are
         running as a job (with the –AsJob parameter).
      -- Other nested debugging scenarios--such as a workflow calling another
         workflow, or a workflow calling a script--are not implemented.

O exemplo a seguir demonstra a depuração de um fluxo de trabalho. Observe que, quando o depurador avança para a função de fluxo de trabalho, o prompt do depurador muda para [WFDBG].

          PS C:\> Set-PSBreakpoint -Script C:\TestWFDemo1.ps1 -Line 8

          ID Script           Line Command    Variable     Action
          -- ------           ---- -------    --------     ------
          0 TestWFDemo1.ps1   8

          PS C:\> C:\TestWFDemo1.ps1
          Entering debug mode. Use h or ? for help.

          Hit Line breakpoint on 'C:\TestWFDemo1.ps1:8'

          At C:\TestWFDemo1.ps1:8 char:5
          +     Write-Output -InputObject "Now writing output:"
          +     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          [WFDBG:localhost]: PS C:\>> list

              3:
              4:  workflow SampleWorkflowTest
              5:  {
              6:      param ($MyOutput)
              7:
              8:*     Write-Output -InputObject "Now writing output:"
              9:      Write-Output -Input $MyOutput
             10:
             11:      Write-Output -InputObject "Get PowerShell process:"
             12:      Get-Process -Name powershell
             13:
             14:      Write-Output -InputObject "Workflow function complete."
             15:  }
             16:
             17:  # Call workflow function
             18:  SampleWorkflowTest -MyOutput "Hello"

          [WFDBG:localhost]: PS C:\>> $MyOutput
          Hello
          [WFDBG:localhost]: PS C:\>> stepOver
          Now writing output:
          At C:\TestWFDemo1.ps1:9 char:5
          +     Write-Output -Input $MyOutput
          +     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          [WFDBG:localhost]: PS C:\>> list

              4:  workflow SampleWorkflowTest
              5:  {
              6:      param ($MyOutput)
              7:
              8:      Write-Output -InputObject "Now writing output:"
              9:*     Write-Output -Input $MyOutput
             10:
             11:      Write-Output -InputObject "Get PowerShell process:"
             12:      Get-Process -Name powershell
             13:
             14:      Write-Output -InputObject "Workflow function complete."
             15:  }
             16:
             17:  # Call workflow function
             18:  SampleWorkflowTest -MyOutput "Hello"
             19:

          [WFDBG:localhost]: PS C:\>> stepOver
          Hello
          At C:\TestWFDemo1.ps1:11 char:5
          +     Write-Output -InputObject "Get PowerShell process:"
          +     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          [WFDBG:localhost]: PS C:\>> stepOut
          Get PowerShell process:

          Handles  NPM(K)    PM(K)   WS(K) VM(M)   CPU(s)     Id ProcessName    PSComputerName
          -------  ------    -----   ----- -----   ------     -- -----------    --------------
              433      35   106688   128392   726     2.67   7124 powershell    localhost
              499      44   134244   172096   787     2.79   7452 powershell    localhost
          Workflow function complete.

FUNÇÕES DE DEPURAÇÃO

Quando você configura um ponto de interrupção em uma função que tem seções Begin, Process e End, o depurador fará a interrupção na primeira linha de cada seção.

Por exemplo:

              function test-cmdlet
              {
                  begin
                  {
                      write-output "Begin"
                  }
                  process
                  {
                      write-output "Process"
                  }
                  end
                  {
                      write-output "End"
                  }
              }
        
          C:\PS> set-psbreakpoint -command test-cmdlet

          C:\PS> test-cmdlet
    
          Begin
          Entering debug mode. Use h or ? for help.

          Hit Command breakpoint on 'prompt:test-cmdlet'

          test-cmdlet

          [DBG]: C:\PS> c
          Process
          Entering debug mode. Use h or ? for help.

          Hit Command breakpoint on 'prompt:test-cmdlet'

          test-cmdlet

          [DBG]: C:\PS> c
          End
          Entering debug mode. Use h or ? for help.

          Hit Command breakpoint on 'prompt:test-cmdlet'

          test-cmdlet

          [DBG]: C:\PS> 

DEPURAÇÃO DE SCRIPTS REMOTOS

No Windows PowerShell 4.0, você pode executar o depurador do Windows PowerShell em uma sessão remota, no console do Windows PowerShell 4.0. A funcionalidade ENTER-PSSession foi atualizada para permitir que você se reconecte e entre em uma sessão desconectada que esteja em execução em um computador remoto e, no momento, executando um script. Se o script em execução atingir um ponto de interrupção, sua sessão do cliente iniciará o depurador automaticamente. A seguir, há um exemplo que mostra como isso funciona, com pontos de interrupção configurados em um script nas linhas 6, 11, 22 e 25. Observe que, no exemplo, quando o depurador é iniciado, há dois prompts de identificação: o nome do computador no qual a sessão está em execução, e o prompt DBG que permite saber que você está no modo de depuração.

          Enter-Pssession -Cn localhost
          [localhost]: PS C:\psscripts> Set-PSBreakpoint .\ttest19.ps1 6,11,22,25

          ID Script          Line     Command          Variable          Action
          -- ------          ----     -------          --------          ------
          0 ttest19.ps1          6
          1 ttest19.ps1          11
          2 ttest19.ps1          22
          3 ttest19.ps1          25

           [localhost]: PS C:\psscripts> .\ttest19.ps1
          Hit Line breakpoint on 'C:\psscripts\ttest19.ps1:11'

          At C:\psscripts\ttest19.ps1:11 char:1
          + $winRMName = "WinRM"
          + ~
           [localhost]: [DBG]: PS C:\psscripts>> list


          6:      1..5 | foreach { sleep 1; Write-Output "hello2day $_" }
          7:  }
          8:
          9:  $count = 10
          10:  $psName = "PowerShell"
          11:* $winRMName = "WinRM"
          12:  $myVar = 102
          13:
          14:  for ($i=0; $i -lt $count; $i++)
          15:  {
          16:      sleep 1
          17:      Write-Output "Loop iteration is: $i"
          18:      Write-Output "MyVar is $myVar"
          19:
          20:      hello2day
          21:

           [localhost]: [DBG]: PS C:\psscripts>> stepover
          At C:\psscripts\ttest19.ps1:12 char:1
          + $myVar = 102
          + ~
           [localhost]: [DBG]: PS C:\psscripts>> quit
           [localhost]: PS C:\psscripts> Exit-PSSession
          PS C:\psscripts>

EXEMPLOS

Esse script de teste detecta a versão do sistema operacional e exibe uma mensagem adequada ao sistema. Ele inclui uma função, uma chamada de função e uma variável.

O comando a seguir exibe o conteúdo do arquivo de script de teste:

  c:>\PS-test>  get-content test.ps1


  function psversion {
             "Windows PowerShell " + $psversiontable.psversion
              if ($psversiontable.psversion.major -lt 2) {
                  "Upgrade to Windows PowerShell 2.0!"
              }
              else {
                  "Have you run a background job today (start-job)?"
              }
          }

  $scriptname = $MyInvocation.MyCommand.Path
  psversion
  "Done $scriptname."

Para começar, configure um ponto de interrupção em um ponto de interesse do script, como uma linha, comando, variável ou função.

Comece criando um ponto de interrupção na primeira linha do script Test.ps1 na pasta atual.

PS C:\ps-test> set-psbreakpoint -line 1 -script test.ps1 

Você pode abreviar esse comando como:

PS C:\ps-test> spb 1 -s test.ps1

O comando retorna um objeto de ponto de interrupção (System.Management.Automation.LineBreakpoint).

      Column     : 0
            Line       : 1
            Action     :
            Enabled    : True
            HitCount   : 0
            Id         : 0
            Script     : C:\ps-test\test.ps1
            ScriptName : C:\ps-test\test.ps1

Agora, inicie o script.

PS C:\ps-test> .\test.ps1

Quando o script atingir o primeiro ponto de interrupção, a mensagem do ponto de interrupção indica que o depurador está ativo. Ele descreve o ponto de interrupção e visualiza a primeira linha do script, que é uma declaração de função. O prompt de comando também muda para indicar que o depurador tem controle.

A linha de visualização inclui o nome do script e o número de linha do comando visualizado.

          Entering debug mode. Use h or ? for help.

          Hit Line breakpoint on 'C:\ps-test\test.ps1:1'

          test.ps1:1   function psversion {
          DBG>

Use o comando Step (s) para executar a primeira instrução no script e visualizar a próxima instrução. A próxima instrução usa a variável automática $MyInvocation para configurar o valor da variável $ScriptName o caminho e o nome do arquivo de script.

          DBG> s
          test.ps1:11  $scriptname = $MyInvocation.MyCommand.Path

Neste ponto, a variável $ScriptName não está preenchida, mas você pode verificar o valor da variável exibindo seu valor. Nesse caso, o valor é $null.

          DBG> $scriptname
          DBG>

Use outro comando Step (s) para executar a instrução atual e visualizar a próxima instrução no script. A próxima instrução chama a função PsVersion.

  DBG> s
  test.ps1:12  psversion

Neste ponto, a variável $ScriptName está preenchida, mas você pode verificar o valor da variável exibindo seu valor. Nesse caso, o valor é configurado como o caminho do script.

          DBG> $scriptname
          C:\ps-test\test.ps1

Use outro comando Step para executar a chamada de função. Pressione ENTER ou digite "s" para Step.

  DBG> s
  test.ps1:2       "Windows PowerShell " + $psversiontable.psversion

A mensagem de depuração inclui uma visualização da instrução na função. Para executar essa instrução e visualizar a próxima instrução na função, você pode usar um comando Step. Mas, nesse caso, use um comando Step-Out (o). Ele conclui a execução da função (a menos que atinja um ponto de interrupção) e as etapas para a próxima instrução do script.

  DBG> o
  Windows PowerShell 2.0
  Have you run a background job today (start-job)?
  test.ps1:13  "Done $scriptname"

Como estamos na última instrução no script, os comandos Step, Step-Out e Continue têm o mesmo efeito. Nesse caso, use Step-Out (o).

  Done C:\ps-test\test.ps1
  PS C:\ps-test>

O comando Step-Out executa o último comando. O prompt de comando padrão indica que o depurador foi encerrado e retorna o controle para o processador de comando.

Agora, execute o depurador novamente. Primeiro, para excluir o ponto de interrupção atual, use os cmdlets Get-PsBreakpoint e Remove-PsBreakpoint. (Se você acha que você pode reutilizar o ponto de interrupção, use o cmdlet Disable-PsBreakpoint em vez de Remove-PsBreakpoint.)

  PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint

Você pode abreviar esse comando como:

  PS C:\ps-test> gbp | rbp

Ou execute o comando gravando uma função como a seguir:

  function delbr { gbp | rbp }

Agora, crie um ponto de interrupção na variável $scriptname.

  PS C:\ps-test> set-psbreakpoint -variable scriptname -script test.ps1

Você pode abreviar o comando como:

  PS C:\ps-test> sbp -v scriptname -s test.ps1

Agora, inicie o script. O script atinge o ponto de interrupção da variável. O modo padrão é Write; portanto, a execução é interrompida logo antes da instrução que altera o valor da variável.

  PS C:\ps-test> .\test.ps1
  Hit Variable breakpoint on 'C:\ps-test\test.ps1:$scriptname'
          (Write access)

  test.ps1:11  $scriptname = $MyInvocation.mycommand.path
  DBG>

Exiba o valor atual da variável $scriptname, que é $null.

          DBG> $scriptname
          DBG>

Use um Step (s) para executar a instrução que preenche a variável. Em seguida, exiba o novo valor da variável $scriptname.

  DBG> $scriptname
  C:\ps-test\test.ps1

Use um comando Step (s) para visualizar a próxima instrução do script.

  DBG> s
  test.ps1:12  psversion

A próxima instrução é uma chamada para a função PsVersion. Para ignorar a função, mas ainda executá-la, use um comando Step-Over (v). Se você já estiver na função ao usar o Step-Over, o comando não será eficaz. A chamada de função é exibida, mas não será executada.

  DBG> v
  Windows PowerShell 2.0
  Have you run a background job today (start-job)?
  test.ps1:13  "Done $scriptname"   

O comando Step-Over executa a função e visualiza a próxima instrução no script, que imprime a linha final.

Use um comando Stop (t) para sair do depurador. O prompt de comando será revertido para o prompt padrão de comando.

  C:\ps-test>

Para excluir os pontos de interrupção, use os cmdlets Get-PsBreakpoint e Remove-PsBreakpoint.

  PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint

Crie um novo ponto de interrupção do comando na função PsVersion.

          PS C:\ps-test> Set-PsBreakpoint -command psversion -script test.ps1 

Você pode abreviar esse comando como:

          PS C:\ps-test> sbp -c psversion -s test.ps1 

Agora, execute o script.

          PS C:\ps-test> .\test.ps1
          Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'

          test.ps1:12  psversion
          DBG>

O script atinge o ponto de interrupção na chamada de função. Nesse ponto, a função ainda não foi chamada. Isso oferece a oportunidade de usar o parâmetro Action do Set-PsBreakpoint para configurar as condições para a execução do ponto de interrupção ou para executar tarefas de diagnóstico ou preparatórias, como iniciar um log ou acionar um script de diagnóstico ou segurança.

Para configurar uma ação, use um comando Continue (c) para sair do script e um comando Remove-PsBreakpoint para excluir o ponto de interrupção atual. (Os pontos de interrupção são somente leitura; portanto, você não pode adicionar uma ação ao ponto de interrupção atual.)

  DBG> c
  Windows PowerShell 2.0
  Have you run a background job today (start-job)?
  Done C:\ps-test\test.ps1

  PS C:\ps-test> get-psbreakpoint | remove-psbreakpoint
  PS C:\ps-test>

Agora, crie um novo ponto de interrupção de comando com uma ação. O comando a seguir configura um ponto de interrupção de comando com uma ação que registra o valor da variável $scriptname quando a função for chamada. Já que a palavra-chave Break não é usada na ação, a execução não é interrompida. (O backtick (`) é o caractere de continuação de linha.)

         PS C:\ps-test> set-psbreakpoint -command psversion -script test.ps1  `
         -action { add-content "The value of `$scriptname is $scriptname." `
         -path action.log}

Você também pode adicionar ações que configuram condições para o ponto de interrupção. No comando a seguir, o ponto de interrupção do comando é executado apenas se a política de execução for configurada como RemoteSigned, a política mais restritiva que ainda permite a execução de scripts. (O backtick (`) é o caractere de continuação.)

          PS C:\ps-test> set-psbreakpoint -script test.ps1 -command psversion `
          -action { if ((get-executionpolicy) -eq "RemoteSigned") { break }}

A palavra-chave Break da ação instrui o depurador a executar o ponto de interrupção. Você também pode usar a palavra-chave Continue para direcionar o depurador a executar sem interrupções. Já que a palavra-chave default é Continue, você deve especificar Break para interromper a execução.

Agora, execute o script.

  PS C:\ps-test> .\test.ps1
  Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'

  test.ps1:12  psversion

Já que a política de execução está configurada como RemoteSigned, a execução será interrompida na chamada de função.

Nesse ponto, convém verificar a pilha de chamadas. Use o cmdlet Get-PsCallStack ou o comando Get-PsCallStack (k) do depurador. O comando a seguir obtém a pilha de chamadas atual.

  DBG> k
  2: prompt
  1: .\test.ps1: $args=[]
  0: prompt: $args=[]

Este exemplo demonstra algumas das diversas formas de usar o depurador do Windows PowerShell.

Para obter mais informações sobre os cmdlets do depurador, digite o seguinte comando:

          help <cmdlet-name> -full

Por exemplo, digite:

          help set-psbreakpoint -full

OUTROS RECURSOS DE DEPURAÇÃO NO WINDOWS POWERSHELL

Além do depurador do Windows PowerShell, o Windows PowerShell inclui vários outros recursos que podem ser usados para depurar scripts e funções.

    -- Windows PowerShell Integrated Scripting Environment (ISE) includes
       an interactive graphical debugger. For more information, start Windows
       PowerShell ISE and press F1.

    -- The Set-PSDebug cmdlet offers very basic script debugging features,
       including stepping and tracing. 

    -- Use the Set-StrictMode cmdlet to detect references to 
       uninitialized variables, to references to non-existent properties
       of an object, and to function syntax that is not valid. 

    -- Add diagnostic statements to a script, such as statements that
       display the value of variables, statements that read input from
       the command line, or statements that report the current 
       instruction. Use the cmdlets that contain the Write verb for 
       this task, such as Write-Host, Write-Debug, Write-Warning, and
       Write-Verbose.          

CONSULTE TAMBÉM

Disable-PsBreakpoint

Enable-PsBreakpoint

Get-PsBreakpoint

Get-PsCallStack

Remove-PsBreakpoint

Set-PsBreakpoint

Set-PsDebug

Set-Strictmode

Write-Debug

Write-Verbose