about_Debuggers
Aggiornamento: maggio 2014
Si applica a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Inserire l'introduzione qui.
ARGOMENTO
about_Debuggers
DESCRIZIONE BREVE
Descrive il debugger di Windows PowerShell®.
DESCRIZIONE LUNGA
Il debug è il processo di analisi di uno script mentre è in esecuzione per identificare e correggere gli errori nelle istruzioni dello script. Il debugger di Windows PowerShell è progettato per esaminare e identificare errori e inefficienze negli script, nelle funzioni, nei comandi, nei flussi di lavoro di Windows PowerShell o nelle espressioni.
In Windows PowerShell 4.0 il debugger di Windows PowerShell è stato aggiornato per eseguire il debug di script, funzioni, flussi di lavoro, comandi o espressioni in esecuzione nella console di Windows PowerShell (non ISE) in computer remoti. Si può eseguire Enter-PSSession per avviare una sessione remota interattiva di PowerShell in cui è possibile impostare punti di interruzione ed eseguire il debug di file di script e comandi nel computer remoto. La funzionalità Enter-PSSession è stata aggiornata per consentire di riconnettere e accedere a una sessione disconnessa che esegue un comando o script in un computer remoto. Se lo script in esecuzione raggiunge un punto di interruzione, la sessione client avvia automaticamente il debugger. Se la sessione disconnessa che esegue uno script ha già raggiunto un punto di interruzione e viene interrotta in tale punto, Enter-PSSession avvia automaticamente il debugger della riga di comando, dopo la riconnessione alla sessione.
Il debugger di Windows PowerShell 4.0 può essere usato anche per eseguire il debug dei flussi di lavoro di Windows PowerShell, nella console di Windows PowerShell o in Windows PowerShell ISE.
Le funzionalità del debugger di Windows PowerShell possono essere usate per esaminare uno script, una funzione, un comando, un flusso di lavoro o un'espressione di Windows PowerShell mentre è in esecuzione. Il debugger di Windows PowerShellinclude un set di cmdlet che consentono di impostare punti di interruzione, gestire punti di interruzione e visualizzare lo stack di chiamate.
CMDLET DEL DEBUGGER
Il debugger di Windows PowerShell include i set di cmdlet seguenti:
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.
AVVIO E ARRESTO DEL DEBUGGER
Per avviare il debugger, impostare uno o più punti di interruzione. Eseguire quindi lo script, il comando o la funzione di cui si vuole eseguire il debug.
Quando si raggiunge un punto di interruzione, l'esecuzione si arresta e il debugger assume il controllo.
Per interrompere il debugger, eseguire lo script, il comando o la funzione fino al termine. In alternativa, digitare "stop" o "t".
COMANDI DEL DEBUGGER
Quando si esegue il debugger nella console di Windows PowerShell, usare i comandi seguenti per controllare l'esecuzione. In Windows PowerShell ISE usare i comandi nel menu Debug.
Nota: per informazioni su come usare il debugger in altre applicazioni host, vedere la documentazione relativa all'applicazione 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).
Tramite questi comandi del debugger è possibile eseguire uno script, interromperlo in un punto di interesse, esaminare i valori delle variabili e lo stato del sistema e continuare l'esecuzione dello script fino al punto in cui viene identificato un problema.
NOTA:
se si esegue un'istruzione con un operatore di reindirizzamento, ad esempio">", il debugger di Windows PowerShell passa tutte le istruzioni rimanenti nello script.
VISUALIZZAZIONE DEI VALORI DELLE VARIABILI DI SCRIPT
Dall'interno del debugger è possibile anche immettere comandi, visualizzare il valore delle variabili, usare i cmdlet ed eseguire script dalla riga di comando.
È possibile visualizzare il valore corrente di tutte le variabili nello script oggetto del debug, eccetto le variabili automatiche seguenti:
$_
$Args
$Input
$MyInvocation
$PSBoundParameters
Se si prova a visualizzare il valore di una di queste variabili, si ottiene il valore della variabile per una pipeline interna usata dal debugger, non il valore della variabile nello script.
Per visualizzare il valore di queste variabili per lo script in fase di debug, nello script assegnare il valore della variabile automatica a una nuova variabile. In seguito è possibile visualizzare il valore della nuova variabile.
Ad esempio:
$scriptArgs = $Args
$scriptArgs
Nell'esempio in questo argomento il valore della variabile $MyInvocation viene riassegnato nel modo seguente:
$scriptname = $MyInvocation.MyCommand.Path
AMBIENTE DEL DEBUGGER
Quando si raggiunge un punto di interruzione, si accede all'ambiente del debugger. Il prompt dei comandi cambia e inizia con "[DBG]:". Se si esegue il debug di un flusso di lavoro, il prompt sarà "[WFDBG]". È possibile personalizzare il prompt.
Inoltre, in alcune applicazioni host come la console di Windows PowerShell, ma non in Windows PowerShell Integrated Scripting Environment (ISE), viene aperto un prompt annidato per il debug. Il prompt annidato può essere rilevato mediante i caratteri di maggiore (ASCII 62) ripetuti presenti nel prompt dei comandi.
Ad esempio, questo è il prompt di debug predefinito nella console di Windows PowerShell:
[DBG]: PS (get-location)>>>
Il livello di annidamento si può trovare usando la variabile automatica $NestedPromptLevel.
Inoltre è definita una variabile automatica $PSDebugContext nell'ambito locale. La presenza della variabile $PsDebugContext consente di determinare se ci si trova nel debugger.
Ad esempio:
if ($psdebugcontext) {"Debugging"} else {"Not Debugging"}
Si può usare il valore della variabile $PSDebugContext durante il debug.
[DBG]: PS>>> $psdebugcontext.invocationinfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
DEBUG E AMBITO
Il passaggio al debugger non cambia l'ambito in cui si opera, ma quando si raggiunge un punto di interruzione in uno script si passa all'ambito di script. L'ambito di script è un ambito figlio di quello in cui era eseguito il debugger.
Per trovare le variabili e gli alias definiti nell'ambito di script, usare il parametro Scope del cmdlet Get-Alias o Get-Variable.
Ad esempio, il comando seguente ottiene le variabili nell'ambito locale (script).
get-variable -scope 0
È possibile abbreviare il comando in:
gv -s 0
Ciò è utile per visualizzare solo le variabili definite nello script e definite durante il debug.
DEBUG NELLA RIGA DI COMANDO
Quando si imposta un punto di interruzione variabile o comando, è possibile impostarlo solo in un file di script. Per impostazione predefinita, però, il punto di interruzione è impostato su tutto ciò che viene eseguito nella sessione corrente.
Ad esempio, se si imposta un punto di interruzione sulla variabile $name, il debugger si interrompe in corrispondenza di qualsiasi variabile $name in qualsiasi script, comando, funzione, cmdlet di script o espressione che si esegue fino a quando il punto di interruzione non viene disabilitato o rimosso.
Questo permette di eseguire il debug degli scripts in un contesto più realistico in cui possono essere influenzati da funzioni, variabili e altri script nella sessione e nel profilo dell'utente.
I punti di interruzione di riga sono specifici dei file di script, quindi vengono impostati solo nei file di script.
DEBUG DEI FLUSSI DI LAVORO
Il debugger di Windows PowerShell 4.0 può essere usato per eseguire il debug dei flussi di lavoro di Windows PowerShell, nella console di Windows PowerShell o in Windows PowerShell ISE. Esistono alcune limitazioni relative all'uso del debugger di Windows PowerShell per eseguire il debug dei flussi di lavoro.
-- 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.
L'esempio seguente illustra il debug di un flusso di lavoro. Si noti che quando il debugger esegue l'istruzione nella funzione del flusso di lavoro, il prompt del debugger diventa [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.
FUNZIONI DI DEBUG
Quando si imposta un punto di interruzione su una funzione con sezioni Begin, Process ed End, il debugger si interrompe alla prima riga di ogni sezione.
Ad esempio:
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>
DEBUG DI SCRIPT REMOTI
In Windows PowerShell 4.0 è possibile eseguire il debugger di Windows PowerShell in una sessione remota, nella console di Windows PowerShell 4.0. La funzionalità Enter-PSSession è stata aggiornata per consentire di riconnettere e accedere a una sessione disconnessa in esecuzione in un computer remoto o che esegue uno script. Se lo script in esecuzione raggiunge un punto di interruzione, la sessione client avvia automaticamente il debugger. Di seguito è riportato un esempio che ne illustra il funzionamento, con punti di interruzione impostati in uno script alle righe 6, 11, 22 e 25. Si noti che nell'esempio, all'avvio del debugger, sono presenti due prompt di identificazione: il nome del computer in cui la sessione è in esecuzione e il prompt DBG che indica che è attiva la modalità di debug.
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>
ESEMPI
Questo script di esempio rileva la versione del sistema operativo e visualizza un messaggio appropriato per il sistema. Include una funzione, una chiamata di funzione e una variabile.
Il comando seguente visualizza il contenuto del file di script di test:
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."
Per iniziare, impostare un punto di interruzione in un punto di interesse nello script, ad esempio una riga, un comando, una variabile o una funzione.
Iniziare creando un punto di interruzione riga nella prima riga dello script Test.ps1 nella directory corrente.
PS C:\ps-test> set-psbreakpoint -line 1 -script test.ps1
È possibile abbreviare il comando in:
PS C:\ps-test> spb 1 -s test.ps1
Il comando restituisce un oggetto processo punto di interruzione riga (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
Avviare lo script.
PS C:\ps-test> .\test.ps1
Quando lo script raggiunge il primo punto di interruzione, il messaggio di interruzione indica che il debugger è attivo. Descrive il punto di interruzione e visualizza in anteprima la prima riga dello script, che è una dichiarazione di funzione. Anche il prompt dei comandi cambia per indicare che il debugger ha il controllo.
La riga di anteprima include il nome dello script e il numero di riga del comando visualizzato in anteprima.
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 'C:\ps-test\test.ps1:1'
test.ps1:1 function psversion {
DBG>
Usare il comando Step (s) per eseguire la prima istruzione nello script e visualizzare in anteprima l'istruzione successiva. L'istruzione successiva usa la variabile automatica $MyInvocation per impostare il valore della variabile $ScriptName sul percorso e nome file del file di script.
DBG> s
test.ps1:11 $scriptname = $MyInvocation.MyCommand.Path
A questo punto la variabile $ScriptName non è popolata ma è possibile visualizzarne il valore per verificarlo. In questo caso, il valore è $null.
DBG> $scriptname
DBG>
Usare un altro comando Step per eseguire l'istruzione corrente e visualizzare in anteprima l'istruzione successiva nello script. L'istruzione successiva chiama la funzione PsVersion.
DBG> s
test.ps1:12 psversion
A questo punto la variabile $ScriptName è popolata ma è possibile visualizzarne il valore per verificarlo. In questo caso, il valore è impostato sul percorso dello script.
DBG> $scriptname
C:\ps-test\test.ps1
Usare un altro comando Step per eseguire la chiamata di funzione. Premere INVIO oppure digitare "s" per Step.
DBG> s
test.ps1:2 "Windows PowerShell " + $psversiontable.psversion
Il messaggio di debug include un'anteprima dell'istruzione nella funzione. Per eseguire questa istruzione e visualizzare in anteprima l'istruzione successiva nella funzione, è possibile usare un comando Step. In questo caso usare invece un comando Step-Out (o). Completa l'esecuzione della funzione (a meno che non raggiunga un punto di interruzione) e passa all'istruzione successiva nello script.
DBG> o
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
Trattandosi dell'ultima istruzione nello script, i comandi Step, Step-Out e Continue hanno lo stesso effetto. In questo caso usare Step-Out (o).
Done C:\ps-test\test.ps1
PS C:\ps-test>
Il comando Step-Out esegue l'ultimo comando. Il prompt dei comandi standard indica che il debugger ha terminato e ha restituito il controllo al processore dei comandi.
A questo punto, eseguire nuovamente il debugger. Prima di tutto, per eliminare il punto di interruzione corrente usare i cmdlet Get-PsBreakpoint e Remove-PsBreakpoint. Se si intende riutilizzare il punto di interruzione, usare il cmdlet Disable-PsBreakpoint invece di Remove-PsBreakpoint.
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
È possibile abbreviare il comando in:
PS C:\ps-test> gbp | rbp
In alternativa, eseguire il comando scrivendo una funzione come la seguente:
function delbr { gbp | rbp }
Creare ora un punto di interruzione sulla variabile $scriptname.
PS C:\ps-test> set-psbreakpoint -variable scriptname -script test.ps1
È possibile abbreviare il comando in:
PS C:\ps-test> sbp -v scriptname -s test.ps1
Avviare lo script. Lo script raggiunge il punto di interruzione variabile. La modalità predefinita è la modalità di scrittura, per cui l'esecuzione si interrompe appena prima dell'istruzione che modifica il valore della variabile.
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>
Visualizzare il valore corrente della variabile $scriptname, ovvero $null
DBG> $scriptname
DBG>
Usare un comando di Step (s) per eseguire l'istruzione che popola la variabile. Visualizzare quindi il nuovo valore della variabile $scriptname.
DBG> $scriptname
C:\ps-test\test.ps1
Usare un comando Step (s) per visualizzare in anteprima l'istruzione successiva nello script.
DBG> s
test.ps1:12 psversion
L'istruzione successiva è una chiamata alla funzione PsVersion. Per ignorare la funzione ma eseguirla comunque, usare un comando Step-Over (v). Se si usa Step-Over quando ci si trova già nella funzione, il comando non ha effetto. La chiamata di funzione viene visualizzata ma non viene eseguita.
DBG> v
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
Il comando Step-Over esegue la funzione e visualizza in anteprima l'istruzione successiva nello script, che stampa la riga finale.
Usare un comando Stop (t) per chiudere il debugger. Viene ripristinato il prompt dei comandi standard.
C:\ps-test>
Per eliminare i punti di interruzione, usare i cmdlet Get-PsBreakpoint e Remove-PsBreakpoint.
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Creare un nuovo punto di interruzione comando sulla funzione PsVersion.
PS C:\ps-test> Set-PsBreakpoint -command psversion -script test.ps1
È possibile abbreviare il comando in:
PS C:\ps-test> sbp -c psversion -s test.ps1
Eseguire lo script.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
DBG>
Lo script raggiunge il punto di interruzione in corrispondenza della chiamata di funzione. A questo punto, la funzione non è ancora stata chiamata. Questo offre l'opportunità di usare il parametro Action di Set PsBreakpoint per impostare le condizioni per l'esecuzione del punto di interruzione o per eseguire operazioni preparatorie o diagnostiche, come l'avvio di un log o la richiamata di uno script di diagnostica o di sicurezza.
Per impostare un'azione, usare un comando Continue (c) per uscire dallo script e un comando Remove-PsBreakpoint per eliminare il punto di interruzione corrente. I punti di interruzione sono di sola lettura, per cui non si può aggiungere un'azione al punto di interruzione corrente.
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>
A questo punto, creare un nuovo punto di interruzione comando con un'azione. Il comando seguente imposta un punto di interruzione con un'azione che registra il valore della variabile $scriptname quando viene chiamata la funzione. Dato che nell'azione non è usata la parola chiave Break, l'esecuzione non si interrompe (l'apice inverso (`) è il carattere di continuazione di riga).
PS C:\ps-test> set-psbreakpoint -command psversion -script test.ps1 `
-action { add-content "The value of `$scriptname is $scriptname." `
-path action.log}
È anche possibile aggiungere azioni che impostano le condizioni per il punto di interruzione. Nel comando seguente, il punto di interruzione comando viene eseguito solo se il criterio di esecuzione è impostato su RemoteSigned, il criterio più restrittivo che permette solo di eseguire script (l'apice inverso (`) è il carattere di continuazione).
PS C:\ps-test> set-psbreakpoint -script test.ps1 -command psversion `
-action { if ((get-executionpolicy) -eq "RemoteSigned") { break }}
La parola chiave Break nell'azione indica al debugger di eseguire il punto di interruzione. Si può anche usare la parola chiave Continue per indicare al debugger di continuare l'esecuzione senza interruzioni. Poiché la parola chiave predefinita è Continue, è necessario specificare Break per arrestare l'esecuzione.
Eseguire lo script.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
Dato che i criteri di esecuzione sono impostati su RemoteSigned, l'esecuzione si arresta in corrispondenza della chiamata di funzione.
A questo punto è possibile controllare lo stack di chiamate. Usare il cmdlet Get-PsCallStack o il comando del debugger Get-PsCallStack (k). Il comando seguente ottiene lo stack di chiamate corrente:
DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]
Questo esempio illustra solo alcuni dei possibili utilizzi del debugger di Windows PowerShell.
Per altre informazioni sui cmdlet del debugger, digitare il comando seguente:
help <cmdlet-name> -full
Ad esempio, digitare:
help set-psbreakpoint -full
ALTRE FUNZIONALITÀ DI DEBUG IN WINDOWS POWERSHELL
Oltre al debugger di Windows PowerShell, in Windows PowerShell sono presenti molte altre funzionalità da usare per eseguire script e funzioni.
-- 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.
VEDERE ANCHE
Disable-PsBreakpoint
Enable-PsBreakpoint
Get-PsBreakpoint
Get-PsCallStack
Remove-PsBreakpoint
Set-PsBreakpoint
Set-PsDebug
Set-Strictmode
Write-Debug
Write-Verbose