about_Debuggers
Letzte Aktualisierung: Mai 2014
Betrifft: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Einführung hier einfügen.
THEMA
about_Debuggers
KURZE BESCHREIBUNG
Beschreibt den Windows PowerShell®-Debugger.
LANGE BESCHREIBUNG
Debuggen ist der Prozess, mit dem ein Skript während der Ausführung untersucht wird, um Fehler in den Skriptanweisungen zu identifizieren und zu beheben. Der Windows PowerShell-Debugger hilft dabei, Fehler und Ineffizienzen in Ihren Skripts, Funktionen, Befehlen, Windows PowerShell-Workflows oder Ausdrücken zu untersuchen und zu identifizieren.
In Windows PowerShell 4.0 wurde der Windows PowerShell-Debugger aktualisiert, um Skripts, Funktionen, Workflows, Befehle oder Ausdrücke zu debuggen, die in der Windows PowerShell-Konsole (nicht ISE) auf Remotecomputern ausgeführt werden. Sie können Enter-PSSession ausführen, um eine interaktive PowerShell-Remotesitzung zu starten, in der Sie Haltepunkte festlegen und Skriptdateien und Befehle auf dem Remotecomputer ausführen können. Die Enter-PSSession-Funktionalität wurde aktualisiert, sodass Sie erneut eine Verbindung zu einer getrennten Sitzung herstellen und diese öffnen können, die ein Skript oder einen Befehl auf einem Remotecomputer ausführt. Wenn das ausgeführte Skript einen Haltepunkt erreicht, startet die Clientsitzung automatisch den Debugger. Wenn die getrennte Sitzung, die ein Skript ausführt, bereits einen Haltepunkt erreicht und an diesem angehalten hat, startet Enter-PSSession automatisch den Befehlszeilendebugger, nachdem Sie die Verbindung mit der Sitzung wiederhergestellt haben.
Der Windows PowerShell 4.0-Debugger kann auch zum Debuggen von Windows PowerShell-Workflows verwendet werden, entweder in der Windows PowerShell-Konsole oder in der Windows PowerShell ISE.
Sie können die Funktionen des Windows PowerShell-Debuggers verwenden, um ein Windows PowerShell-Skript, eine Windows PowerShell-Funktion, einen Windows PowerShell-Befehl, einen Windows PowerShell-Workflow oder einen Windows PowerShell-Ausdruck während der Ausführung zu untersuchen. Der Windows PowerShell-Debugger enthält eine Reihe von Cmdlets, mit denen Sie Haltepunkte festlegen und verwalten sowie die Aufrufliste anzeigen können.
DEBUGGER-CMDLETS
Der Windows PowerShell-Debugger enthält den folgenden Satz von 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.
STARTEN UND BEENDEN DES DEBUGGERS
Legen Sie einen oder mehrere Haltepunkte fest, um den Debugger zu starten. Führen Sie dann das Skript, den Befehl oder die Funktion aus, das/den/die Sie debuggen möchten.
Wenn Sie einen Haltepunkt erreichen, wird die Ausführung angehalten, und die Steuerung wird an den Debugger übergeben.
Um den Debugger zu beenden, führen Sie das Skript, den Befehl oder die Funktion bis zum Abschluss aus. Oder geben Sie „stop“ oder „t“ ein.
DEBBUGERBEFEHLE
Wenn Sie den Debugger in der Windows PowerShell-Konsole verwenden, steuern Sie die Ausführung mithilfe der folgenden Befehle. In der Windows PowerShell ISE verwenden Sie Befehle im Menü „Debuggen“.
Hinweis: Informationen zum Verwenden des Debuggers in anderen Hostanwendungen finden Sie in der Dokumentation zur Hostanwendung.
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).
Mithilfe dieser Debuggerbefehle können Sie ein Skript ausführen, an einem kritischen Punkt anhalten, die Werte von Variablen sowie den Systemstatus untersuchen und das Skript weiter ausführen, bis das Problem identifiziert wurde.
HINWEIS:
Wenn Sie eine Anweisung mit einem Umleitungsoperator wie z. B. „>“ schrittweise ausführen, durchläuft der Windows PowerShell-Debugger alle verbleibenden Anweisungen im Skript.
ANZEIGEN DER WERTE VON SKRIPTVARIABLEN
Während Sie sich im Debugger befinden, können Sie auch in der Befehlszeile Befehle eingeben, den Wert von Variablen anzeigen, Cmdlets verwenden und Skripts ausführen.
Sie können den aktuellen Wert aller Variablen in dem Skript anzeigen, in dem das Debugging ausgeführt wird, mit Ausnahme der folgenden automatischen Variablen:
$_
$Args
$Input
$MyInvocation
$PSBoundParameters
Wenn Sie versuchen, den Wert einer dieser Variablen anzuzeigen, erhalten Sie den Variablenwert, der vom Debugger in einer internen Pipeline verwendet, nicht den Wert der Variablen im Skript.
Weisen Sie den Wert der automatischen Variablen einer neuen Variablen zu, um den Wert dieser Variablen für das Skript anzuzeigen, in dem das Debugging ausgeführt wird. Anschließend können Sie den Wert der neuen Variablen anzeigen.
Beispiel:
$scriptArgs = $Args
$scriptArgs
Im Beispiel in diesem Thema wird der Wert der Variablen „$MyInvocation“ wie folgt erneut zugewiesen:
$scriptname = $MyInvocation.MyCommand.Path
DIE DEBUGGERUMGEBUNG
Wenn ein Haltepunkt erreicht wird, wird die Debuggerumgebung geöffnet. Die Eingabeaufforderung wird geändert und beginnt mit „[DBG]:“. Wenn Sie einen Workflow debuggen, beginnt die Eingabeaufforderung mit „[WFDBG]“. Sie können die Eingabeaufforderung anpassen.
In einigen Hostanwendungen, wie z. B. der Windows PowerShell-Konsole (nicht jedoch in der Windows PowerShell ISE [Integrated Scripting Environment]), wird eine geschachtelte Eingabeaufforderung zum Debuggen geöffnet. Sie erkennen eine geschachtelte Eingabeaufforderung an den wiederholten Größerzeichen (ASCII-Code 62), die in der Befehlszeile angezeigt werden.
Hier sehen Sie z. B. die standardmäßige Eingabeaufforderung zum Debuggen in der Windows PowerShell-Konsole:
[DBG]: PS (get-location)>>>
Sie können die Schachtelungsebene mithilfe der automatischen $NestedPromptLevel-Variablen ermitteln.
Darüber hinaus wird im lokalen Gültigkeitsbereich eine automatische Variable definiert: „$PSDebugContext“. Daran, ob die $PSDebugContext-Variable vorhanden ist, können Sie erkennen, ob Sie sich im Debugger befinden.
Zum Beispiel:
if ($psdebugcontext) {"Debugging"} else {"Not Debugging"}
Sie können den Wert der $PSDebugContext-Variablen beim Debuggen verwenden.
[DBG]: PS>>> $psdebugcontext.invocationinfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
DEBUGGEN UND GÜLTIGKEITSBEREICH
Ein Unterbrechen des Debuggers ändert den Bereich nicht, in dem Sie arbeiten, wenn Sie jedoch einen Haltepunkt in einem Skript erreichen, wechseln Sie in den Skriptbereich. Der Skriptbereich ist ein untergeordnetes Element des Bereichs, in dem der Debugger ausgeführt wurde.
Verwenden Sie zum Suchen der im Skriptbereich definierten Variablen und Aliase den Bereichsparameter der Cmdlets „Get-Alias“ oder „Get-Variable“.
Der folgende Befehl ruft beispielsweise die Variablen im lokalen Bereich (Skriptbereich) ab:
get-variable -scope 0
Sie können den Befehl wie folgt abkürzen:
gv -s 0
Dies ist eine hilfreiche Möglichkeit, um nur die Variablen anzuzeigen, die Sie im Skript und während des Debuggens definiert haben.
DEBUGGEN IN DER BEFEHLSZEILE
Wenn Sie einen Variablenhaltepunkt oder einen Befehlshaltepunkt festlegen, können Sie den Haltepunkt nur in einer Skriptdatei festlegen. Allerdings wird der Haltepunkt standardmäßig auf jedes Element festgelegt, das in der aktuellen Sitzung ausgeführt wird.
Wenn Sie einen Haltepunkt auf die Variable „$name“ festlegen, unterbricht der Debugger bei allen $name-Variablen in jedem Skript, jedem Befehl, jeder Funktion, jedem Skript-Cmdlet und jedem Ausdruck, bis Sie den Haltepunkt deaktivieren oder entfernen.
Dadurch können Sie Ihre Skripts in einem realistischeren Kontext debuggen, in dem sich Funktionen, Variablen und andere Skripts in der Sitzung und im Benutzerprofil auswirken können.
Zeilenhaltepunkte sind spezifisch für Skriptdateien und werden daher nur in Skriptdateien festgelegt.
DEBUGGEN VON WORKFLOWS
Der Windows PowerShell 4.0-Debugger kann auch zum Debuggen von Windows PowerShell-Workflows verwendet werden, entweder in der Windows PowerShell-Konsole oder in der Windows PowerShell ISE. Bei der Verwendung des Windows PowerShell-Debuggers zum Debuggen von Workflows gibt es einige Einschränkungen.
-- 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.
Das folgende Beispiel veranschaulicht das Debuggen eines Workflows. Beachten Sie Folgendes: Wenn der Debugger die Workflowfunktion schrittweise ausführt, ändert sich die Eingabeaufforderung des Debuggers zu „[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.
DEBUGGEN VON FUNKTIONEN
Wenn Sie einen Haltepunkt für eine Funktion mit den Abschnitten „Begin“, „Process“ und „End“ festlegen, unterbricht der Debugger bei der ersten Zeile jedes Abschnitts.
Zum Beispiel:
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>
DEBUGGEN VON REMOTESKRIPTS
In Windows PowerShell 4.0 können Sie den Windows PowerShell-Debugger in einer Remotesitzung in der Windows PowerShell 4.0-Konsole ausführen. Die Enter-PSSession-Funktionalität wurde aktualisiert, sodass Sie erneut eine Verbindung zu einer getrennten Sitzung herstellen und diese öffnen können, die auf einem Remotecomputer ausgeführt wird und derzeit ein Skript ausführt. Wenn das ausgeführte Skript einen Haltepunkt erreicht, startet die Clientsitzung automatisch den Debugger. Das folgende Beispiel veranschaulicht die Funktionsweise. Die Haltepunkte im Skript sind in den Zeilen 6, 11, 22 und 25 festgelegt. Beachten Sie, dass es in diesem Beispiel beim Starten des Debuggers zwei Befehlszeilen zur Identifizierung gibt: den Namen des Computers, auf dem die Sitzung ausgeführt wird, und die DBG-Aufforderung, die Sie darüber informiert, dass Sie sich im Debugmodus befinden.
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>
BEISPIELE
Dieses Testskript erkennt die Version des Betriebssystems und zeigt eine entsprechende Systemmeldung an. Sie enthält eine Funktion, einen Funktionsaufruf und eine Variable.
Der folgende Befehl zeigt den Inhalt der Testskriptdatei an:
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."
Legen Sie einen Haltepunkt auf einen bestimmten Punkt im Skript fest, den Sie untersuchen möchten, z. B. eine Zeile, einen Befehl, eine Variable oder eine Funktion.
Erstellen Sie zunächst einen Zeilenhaltepunkt für die erste Zeile im Skript „Test.ps1“ im aktuellen Verzeichnis.
PS C:\ps-test> set-psbreakpoint -line 1 -script test.ps1
Sie können diesen Befehl wie folgt abkürzen:
PS C:\ps-test> spb 1 -s test.ps1
Der Befehl gibt ein Zeilenhaltepunktobjekt (System.Management.Automation.LineBreakpoint) zurück.
Column : 0
Line : 1
Action :
Enabled : True
HitCount : 0
Id : 0
Script : C:\ps-test\test.ps1
ScriptName : C:\ps-test\test.ps1
Starten Sie nun das Skript.
PS C:\ps-test> .\test.ps1
Wenn das Skript den ersten Haltepunkt erreicht, gibt die Haltepunktmeldung an, dass der Debugger aktiv ist. Sie beschreibt den Haltepunkt und zeigt eine Vorschau der ersten Skriptzeile an, bei der es sich um eine Funktionsdeklaration handelt. Die Eingabeaufforderung ändert sich ebenfalls, um darauf hinzuweisen, dass der Debugger die Steuerung übernommen hat.
Die Vorschauzeile enthält den Skriptnamen und die Zeilennummer des Befehls in der Vorschau.
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 'C:\ps-test\test.ps1:1'
test.ps1:1 function psversion {
DBG>
Verwenden Sie den Step-Befehl „(s)“, um die erste Anweisung im Skript auszuführen und die nächste Anweisung in der Vorschau anzuzeigen. Die nächste Anweisung verwendet die automatische Variable „$MyInvocation“, um den Wert der Variablen „$ScriptName“ auf den Pfad und den Namen der Skriptdatei festzulegen.
DBG> s
test.ps1:11 $scriptname = $MyInvocation.MyCommand.Path
Zu diesem Zeitpunkt ist die $ScriptName-Variable nicht aufgefüllt, Sie können jedoch den Wert der Variablen überprüfen, indem Sie ihn anzeigen. In diesem Fall ist der Wert „$null“.
DBG> $scriptname
DBG>
Verwenden Sie den Step-Befehl „(s)“, um die aktuelle Anweisung im Skript auszuführen und die nächste Anweisung in der Vorschau anzuzeigen. Die nächste Anweisung ruft die PsVersion-Funktion auf.
DBG> s
test.ps1:12 psversion
Zu diesem Zeitpunkt ist die $ScriptName-Variable aufgefüllt, Sie überprüfen jedoch den Wert der Variablen, indem Sie ihn anzeigen. In diesem Fall ist der Wert auf den Skriptpfad festgelegt.
DBG> $scriptname
C:\ps-test\test.ps1
Verwenden Sie einen anderen Step-Befehl, um den Funktionsaufruf auszuführen. Drücken Sie die EINGABETASTE, oder geben Sie „s“ für „Step“ ein.
DBG> s
test.ps1:2 "Windows PowerShell " + $psversiontable.psversion
Die Debugmeldung enthält eine Vorschau der Anweisung in der Funktion. Um diese Anweisung auszuführen und eine Vorschau der nächsten Anweisung in der Funktion anzuzeigen, können Sie einen Step-Befehl verwenden. In diesem Fall verwenden Sie jedoch einen Step-Out-Befehl („o“). Dieser Schritt schließt die Ausführung der Funktion ab (sofern kein Haltepunkt erreicht wird) und geht zur nächsten Anweisung im Skript über.
DBG> o
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
Da es sich hier um die letzte Anweisung im Skript handelt, führen die Befehle „Step“, „Step-Out“ und „Continue“ zum gleichen Ergebnis. In diesem Fall verwenden Sie „Step-Out“ („o“).
Done C:\ps-test\test.ps1
PS C:\ps-test>
Der Step-Out-Befehl führt den letzten Befehl aus. Die Standardeingabeaufforderung weist darauf hin, dass der Debugger beendet und die Steuerung an den Befehlsprozessor zurückgegeben wurde.
Führen Sie nun den Debugger erneut aus. Zuerst verwenden Sie die Cmdlets „Get-PsBreakpoint“ und „Remove-PsBreakpoint“, um den aktuellen Haltepunkt zu löschen. (Wenn Sie glauben, dass Sie den Haltepunkt möglicherweise wiederverwenden möchten, verwenden Sie das Cmdlet „Disable-PsBreakpoint“ anstelle von „Remove-PsBreakpoint“.)
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Sie können diesen Befehl wie folgt abkürzen:
PS C:\ps-test> gbp | rbp
Oder führen Sie den Befehl aus, indem Sie eine Funktion wie die folgende schreiben:
function delbr { gbp | rbp }
Erstellen Sie nun einen Haltepunkt in der $scriptname-Variable.
PS C:\ps-test> set-psbreakpoint -variable scriptname -script test.ps1
Sie können den Befehl wie folgt abkürzen:
PS C:\ps-test> sbp -v scriptname -s test.ps1
Starten Sie nun das Skript. Das Skript erreicht den Variablenhaltepunkt. Der Standardmodus lautet „Schreiben“, die Ausführung wird daher unmittelbar vor der Anweisung beendet, die den Wert der Variablen ändert.
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>
Der aktuelle Wert der Variablen „$scriptname“ wird angezeigt: $null.
DBG> $scriptname
DBG>
Verwenden Sie einen Step-Befehl („s“), um die Anweisung auszuführen, die die Variable auffüllt. Zeigen Sie dann den neuen Wert der Variablen „$scriptname“ an.
DBG> $scriptname
C:\ps-test\test.ps1
Verwenden Sie einen Step-Befehl („s“), um eine Vorschau der nächsten Anweisung im Skript anzuzeigen.
DBG> s
test.ps1:12 psversion
Die nächste Anweisung ist ein Aufruf der Funktion „PsVersion“. Um die Funktion zu überspringen, sie aber dennoch auszuführen, verwenden Sie einen Step-Over-Befehl („v“). Wenn Sie sich bei Verwendung von „Step-Over“ bereits in der Funktion befinden, hat der Befehl keine Auswirkungen. Der Funktionsaufruf wird angezeigt, jedoch nicht ausgeführt.
DBG> v
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
Der Step-Over-Befehl führt die Funktion aus und zeigt eine Vorschau der nächsten Anweisung im Skript an, welche die letzte Zeile ausgibt.
Verwenden Sie einen Stop-Befehl („t“), um den Debugger zu beenden. Die Eingabeaufforderung kehrt zur Standardanzeige zurück.
C:\ps-test>
Um die Haltepunkte zu löschen, verwenden Sie die Cmdlets „Get-PsBreakpoint“ und „Remove-PsBreakpoint“.
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Erstellen Sie einen neuen Befehlshaltepunkt in der Funktion „PsVersion“.
PS C:\ps-test> Set-PsBreakpoint -command psversion -script test.ps1
Sie können diesen Befehl wie folgt abkürzen:
PS C:\ps-test> sbp -c psversion -s test.ps1
Führen Sie das Skript jetzt aus.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
DBG>
Das Skript erreicht den Haltepunkt im Funktionsaufruf. An diesem Punkt wurde die Funktion noch nicht aufgerufen. Dies ermöglicht Ihnen die Verwendung des „Set-PsBreakpoint“-Parameters „Action“, um die Bedingungen für die Ausführung des Haltepunkts festzulegen oder Vorbereitungs- oder Diagnoseaufgaben auszuführen, wie z. B. das Starten eines Protokolls oder das Aufrufen eines Diagnose- oder Sicherheitsskripts.
Um eine Aktion festzulegen, verwenden Sie einen Continue-Befehl („c“) zum Beenden des Skripts und einen Remove-PsBreakpoint-Befehl zum Löschen des aktuellen Haltepunkts. (Haltepunkte sind schreibgeschützt, Sie können also dem aktuellen Haltepunkt keine Aktion hinzufügen.)
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>
Erstellen Sie jetzt einen neuen Befehlshaltepunkt mit einer Aktion. Der folgende Befehl legt einen Befehlshaltepunkt mit einer Aktion fest, die den Wert der Variablen „$scriptname“ protokolliert, wenn die Funktion aufgerufen wird. Da das Schlüsselwort „Break“ in der Aktion nicht verwendet wird, wird die Ausführung nicht angehalten. (Das Backtick-Zeichen [`] ist das Zeilenfortsetzungszeichen.)
PS C:\ps-test> set-psbreakpoint -command psversion -script test.ps1 `
-action { add-content "The value of `$scriptname is $scriptname." `
-path action.log}
Sie können auch Aktionen hinzufügen, die Bedingungen für den Haltepunkt festlegen. Im folgenden Befehl wird der Befehlshaltepunkt nur ausgeführt, wenn die Ausführungsrichtlinie auf „RemoteSigned“ festgelegt ist. Dies ist die restriktivste Richtlinie, bei der das Ausführen von Skripts jedoch erlaubt ist. (Das Backtick-Zeichen [`] ist das Fortsetzungszeichen.)
PS C:\ps-test> set-psbreakpoint -script test.ps1 -command psversion `
-action { if ((get-executionpolicy) -eq "RemoteSigned") { break }}
Das Schlüsselwort „Break“ in der Aktion weist den Debugger an, den Haltepunkt auszuführen. Sie können auch das Continue-Schlüsselwort verwenden, um den Debugger anzuweisen, die Ausführung ohne Unterbrechung fortzusetzen. Da das Standardschlüsselwort „Continue“ lautet, müssen Sie „Break“ angeben, um die Ausführung zu beenden.
Führen Sie das Skript jetzt aus.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
Da die Ausführungsrichtlinie auf „RemoteSigned“ festgelegt ist, wird die Ausführung beim Funktionsaufruf beendet.
An diesem Punkt sollten Sie die Aufrufliste überprüfen. Verwenden Sie das Cmdlet „Get-PsCallStack“ oder den Debuggerbefehl „Get-PsCallStack“ („k“). Der folgende Befehl ruft die aktuelle Aufrufliste ab.
DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]
Dieses Beispiel zeigt nur einige der vielen Möglichkeiten, den Windows PowerShell-Debugger zu verwenden.
Um weitere Informationen zu den Debugger-Cmdlets zu erhalten, geben Sie den folgenden Befehl ein:
help <cmdlet-name> -full
Geben Sie zum Beispiel ein:
help set-psbreakpoint -full
WEITERE DEBUGGINGFUNKTIONEN IN WINDOWS POWERSHELL
Zusätzlich zum Windows PowerShell-Debugger umfasst Windows PowerShell viele weitere Features, die Sie zum Debuggen von Skripts und Funktionen verwenden können.
-- 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.
SIEHE AUCH
Disable-PsBreakpoint
Enable-PsBreakpoint
Get-PsBreakpoint
Get-PsCallStack
Remove-PsBreakpoint
Set-PsBreakpoint
Set-PsDebug
Set-Strictmode
Write-Debug
Write-Verbose