Freigeben über

Informationen zu Debuggern

KURZE BESCHREIBUNG

Beschreibt den PowerShell-Debugger.

LANGE BESCHREIBUNG

Debuggen ist der Prozess, bei dem ein Skript während der Ausführung untersucht wird, um Fehler in den Skriptanweisungen zu identifizieren und zu korrigieren. Der PowerShell-Debugger kann Ihnen dabei helfen, Fehler und Ineffizienzen in Ihren Skripts, Funktionen, Befehlen, PowerShell-Workflows, PowerShell-DSC-Konfigurationen (Desired State Configuration) oder Ausdrücken zu untersuchen und zu identifizieren.

Ab PowerShell 5.0 wurde der PowerShell-Debugger aktualisiert, um Skripts, Funktionen, Workflows, Befehle, Konfigurationen oder Ausdrücke zu debuggen, die entweder in der Konsole oder auf Windows PowerShell 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 debuggen können. Enter-PSSession Die Funktionalität wurde aktualisiert, sodass Sie die Verbindung zu einer getrennten Sitzung, in der ein Skript oder ein Befehl auf einem Remotecomputer ausgeführt wird, wiederherstellen und in eine getrennte Sitzung eintreten können. Wenn das ausgeführte Skript auf einen Haltepunkt trifft, startet Ihre Clientsitzung automatisch den Debugger. Wenn die getrennte Sitzung, in der ein Skript ausgeführt wird, bereits einen Haltepunkt erreicht hat und am Haltepunkt gestoppt wird, wird der Befehlszeilendebugger automatisch gestartet, Enter-PSSession nachdem Sie die Verbindung mit der Sitzung wiederhergestellt haben.

Der PowerShell-Debugger kann auch zum Debuggen von PowerShell-Workflows verwendet werden, entweder in der PowerShell-Konsole oder in Windows PowerShell ISE. Ab PowerShell 5.0 können Sie innerhalb ausgeführter Aufträge oder Prozesse entweder lokal oder remote debuggen.

Sie können die Features des PowerShell-Debuggers verwenden, um ein PowerShell-Skript, eine Funktion, einen Befehl, einen Workflow oder einen Ausdruck während der Ausführung zu untersuchen. Der PowerShell-Debugger enthält eine Reihe von Cmdlets, mit denen Sie Haltepunkte festlegen, Haltepunkte verwalten und die Aufrufliste anzeigen können.

Debugger-Cmdlets

Der PowerShell-Debugger enthält die folgenden Cmdlets:

  • Set-PSBreakpoint: Legt Haltepunkte für Linien, Variablen und Befehle fest.
  • Get-PSBreakpoint: Ruft Haltepunkte in der aktuellen Sitzung ab.
  • Disable-PSBreakpoint: Deaktiviert Haltepunkte in der aktuellen Sitzung.
  • Enable-PSBreakpoint: Aktiviert Haltepunkte in der aktuellen Sitzung erneut.
  • Remove-PSBreakpoint: Löscht Haltepunkte aus der aktuellen Sitzung.
  • Get-PSCallStack: Zeigt den aktuellen Aufrufstapel an.

Starten und Beenden des Debuggers

Um den Debugger zu starten, legen Sie einen oder mehrere Haltepunkte fest. Führen Sie dann das Skript, den Befehl oder die Funktion aus, die Sie debuggen möchten.

Wenn Sie einen Haltepunkt erreichen, wird die Ausführung beendet und die Steuerung an den Debugger übergeben.

Um den Debugger zu beenden, führen Sie das Skript, den Befehl oder die Funktion aus, bis der Vorgang abgeschlossen ist. Oder geben Sie stop oder tein.

Debuggerbefehle

Wenn Sie den Debugger in der PowerShell-Konsole verwenden, verwenden Sie die folgenden Befehle, um die Ausführung zu steuern. Verwenden Sie in Windows PowerShell ISE Befehle im Menü "Debuggen".

Hinweis: Informationen zur Verwendung des Debuggers in anderen Hostanwendungen finden Sie in der Dokumentation zur Hostanwendung.

  • s, StepInto: Führt die nächste Anweisung aus und stoppt dann.

  • v, StepOver: Führt die nächste Anweisung aus, überspringt jedoch Funktionen und Aufrufe. Die übersprungenen Anweisungen werden ausgeführt, aber nicht durchlaufen.

  • Ctrl+Break: (Alle in ISE unterbrechen) bricht in ein ausgeführtes Skript in der PowerShell-Konsole oder windows PowerShell ISE auf. Beachten Sie, dass Strg+Unterbrechen in Windows PowerShell 2.0, 3.0 und 4.0 das Programm schließt. "Alle unterbrechen" funktioniert sowohl auf lokalen als auch auf Remote-Skripts, die interaktiv ausgeführt werden.

  • o, StepOut: Schritte aus der aktuellen Funktion; eine Ebene nach oben, wenn geschachtelt. Wenn sich der Haupttext befindet, wird er bis zum Ende oder zum nächsten Haltepunkt fortgesetzt. Die übersprungenen Anweisungen werden ausgeführt, aber nicht durchlaufen.

  • c, Continue: Wird weiter ausgeführt, bis das Skript abgeschlossen ist oder bis der nächste Haltepunkt erreicht ist. Die übersprungenen Anweisungen werden ausgeführt, aber nicht durchlaufen.

  • l, List: Zeigt den Teil des Skripts an, der gerade ausgeführt wird. Standardmäßig werden die aktuelle Zeile, fünf vorherige Zeilen und 10 nachfolgende Zeilen angezeigt. Um mit der Auflistung des Skripts fortzufahren, drücken Sie die EINGABETASTE.

  • l <m>, List: Zeigt 16 Zeilen des Skripts an, beginnend mit der Zeilennummer, die durch <m>angegeben wird.

  • l <m> <n>, List: Zeigt <n> Zeilen des Skripts an, beginnend mit der Zeilennummer, die durch <m>angegeben wird.

  • q, Stop, Exit: Beendet die Ausführung des Skripts und beendet den Debugger. Wenn Sie einen Auftrag debuggen, indem Sie das cmdlet Debug-Job ausführen, trennt der befehl Exit den Debugger und ermöglicht dem Auftrag die Fortsetzung der Ausführung.

  • k, Get-PsCallStack: Zeigt den aktuellen Aufrufstapel an.

  • <Enter>: Wiederholt den letzten Befehl, wenn es sich um Schritt (s), Übersprung (v) oder Liste (l) handelt. Andernfalls stellt eine Sendeaktion dar.

  • ?, h: Zeigt die Hilfe zum Debuggerbefehl an.

Um den Debugger zu beenden, können Sie Stopp (q) verwenden.

Ab PowerShell 5.0 können Sie den Befehl "Beenden" ausführen, um eine geschachtelte Debugsitzung zu beenden, die Sie gestartet haben, indem Sie entweder Debug-Job oder Debug-Runspaceausführen.

Mithilfe dieser Debuggerbefehle können Sie ein Skript ausführen, an einem Problempunkt anhalten, die Werte von Variablen und den Zustand des Systems untersuchen und das Skript so lange ausführen, bis Sie ein Problem identifiziert haben.

Hinweis: Wenn Sie eine Anweisung mit einem Umleitungsoperator wie ">" ausführen, übertritt der PowerShell-Debugger alle verbleibenden Anweisungen im Skript.

Anzeigen der Werte von Skriptvariablen

Während Sie sich im Debugger befinden, können Sie auch Befehle eingeben, den Wert von Variablen anzeigen, Cmdlets verwenden und Skripts an der Befehlszeile ausführen.

Sie können den aktuellen Wert aller Variablen in dem Skript anzeigen, das debuggt wird, mit Ausnahme der folgenden automatischen Variablen:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Wenn Sie versuchen, den Wert einer dieser Variablen anzuzeigen, erhalten Sie den Wert dieser Variablen für eine interne Pipeline, die der Debugger verwendet, und nicht den Wert der Variablen im Skript.

Um den Wert dieser Variablen für das Skript anzuzeigen, das debuggt wird, weisen Sie im Skript den Wert der automatischen Variablen einer neuen Variablen zu. Anschließend können Sie den Wert der neuen Variablen anzeigen.

Beispiel:

$scriptArgs = $Args
$scriptArgs

Im Beispiel in diesem Thema wird der Wert der $MyInvocation Variablen wie folgt neu zugewiesen:

$scriptname = $MyInvocation.MyCommand.Path

Die Debugger-Umgebung

Wenn Sie einen Haltepunkt erreichen, geben Sie die Debuggerumgebung ein. Die Eingabeaufforderung ändert sich so, dass sie mit "[DBG]:"beginnt. Wenn Sie einen Workflow debuggen, lautet die Eingabeaufforderung "[WFDBG]". Sie können die Eingabeaufforderung anpassen.

Weitere Informationen zum Anpassen der Eingabeaufforderung finden Sie unter about_Prompts.

Außerdem wird in einigen Hostanwendungen, z. B. der PowerShell-Konsole (aber nicht in Windows PowerShell Integrated Scripting Environment [ISE]), eine geschachtelte Eingabeaufforderung zum Debuggen geöffnet. Sie können die geschachtelte Eingabeaufforderung erkennen, indem Sie die wiederholten größer als Zeichen (ASCII 62) erkennen, die an der Eingabeaufforderung angezeigt werden.

Im Folgenden finden Sie z. B. die standardmäßige Debugeingabeaufforderung in der PowerShell-Konsole:

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

Sie finden die Schachtelungsebene mithilfe der $NestedPromptLevel automatischen Variablen.

Zusätzlich wird eine automatische Variable, $PSDebugContext, im lokalen Gültigkeitsbereich definiert. Sie können das Vorhandensein der $PsDebugContext Variablen verwenden, um zu bestimmen, ob Sie sich im Debugger befinden.

Beispiel:

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

Sie können den Wert der $PSDebugContext Variablen im Debugging verwenden.

[DBG]: PS>>> $PSDebugContext.InvocationInfo

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

Debuggen und Umfang

Durch das Unterbrechen des Debuggers wird der Bereich, in dem Sie arbeiten, nicht geändert, aber wenn Sie einen Haltepunkt in einem Skript erreichen, wechseln Sie in den Skriptbereich. Der Skriptbereich ist ein untergeordnetes Element des Bereichs, in dem Sie den Debugger ausgeführt haben.

Um die Variablen und Aliase zu finden, die im Skriptbereich definiert sind, verwenden Sie den Bereichsparameter der cmdlets Get-Alias oder Get-Variable.

Beispielsweise ruft der folgende Befehl die Variablen im lokalen Bereich (Skript) ab:

Get-Variable -scope 0

Sie können den Befehl abkürten als:

gv -s 0

Dies ist eine nützliche Möglichkeit, nur die Variablen anzuzeigen, die Sie im Skript definiert haben und die Sie beim Debuggen definiert haben.

Debuggen auf der Kommandozeile

Wenn Sie einen variablen Haltepunkt oder einen Befehlshaltepunkt festlegen, können Sie den Haltepunkt nur in einer Skriptdatei festlegen. Standardmäßig ist der Haltepunkt jedoch für alle Elemente festgelegt, die in der aktuellen Sitzung ausgeführt werden.

Wenn Sie beispielsweise einen Haltepunkt für die $name Variable festlegen, wird der Debugger für jede $name Variable in allen Skripts, Befehlen, Funktionen, Skript-Cmdlets oder Ausdrücken unterbrochen, die Sie ausführen, bis Sie den Haltepunkt deaktivieren oder entfernen.

Auf diese Weise können Sie Ihre Skripts in einem realistischeren Kontext debuggen, in dem sie möglicherweise von Funktionen, Variablen und anderen Skripts in der Sitzung und im Benutzerprofil betroffen sind.

Zeilenhaltepunkte sind spezifisch für Skriptdateien, daher werden sie nur in Skriptdateien gesetzt.

Debuggen von Workflows

Der PowerShell 4.0-Debugger kann zum Debuggen von PowerShell-Workflows verwendet werden, entweder in der PowerShell-Konsole oder in Windows PowerShell ISE. Es gibt einige Einschränkungen bei der Verwendung des PowerShell-Debuggers zum Debuggen von Workflows.

  • Sie können Workflowvariablen anzeigen, während Sie sich im Debugger befinden, aber das Festlegen von Workflowvariablen im Debugger wird nicht unterstützt.
  • Die Vervollständigung der Aktivatortaste beim Beenden im Workflowdebugger ist nicht verfügbar.
  • Workflowdebugging funktioniert nur bei synchroner Ausführung von Workflows aus einem PowerShell-Skript. Sie können Workflows nicht debuggen, wenn sie als Auftrag ausgeführt werden (mit dem AsJob-Parameter ).
  • Andere geschachtelte Debugszenarien, z. B. ein Workflow, der einen anderen Workflow aufruft, oder ein Workflow, der ein Skript aufruft, werden nicht implementiert.

Im folgenden Beispiel wird das Debuggen eines Workflows veranschaulicht. Wenn der Debugger in die Workflowfunktion eintritt, ändert sich die Eingabeaufforderung des Debuggers in "[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:"
# +!INCLUDE[]~~~~~

[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
# +!INCLUDE[]~

[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:"
# +!INCLUDE[]~~~~~~~~~

[WFDBG:localhost]: PS C:>> stepOut
Get PowerShell process:

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

Workflow function complete.

Debuggen von Funktionen

Wenn Sie einen Haltepunkt für eine Funktion mit Begin, Processund End Abschnitten festlegen, wird der Debugger an der ersten Zeile jedes Abschnitts umgebrochen.

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

Ab PowerShell 5.0 können Sie den PowerShell-Debugger in einer Remotesitzung ausführen, entweder in der Konsole oder auf der Windows PowerShell ISE. Enter-PSSession Die Funktionalität wurde aktualisiert, sodass Sie die Verbindung zu einer getrennten Sitzung, die auf einem Remotecomputer ausgeführt wird und derzeit ein Skript ausführt, wiederherstellen und in eine getrennte Sitzung eintreten können. Wenn das ausgeführte Skript auf einen Haltepunkt trifft, startet Ihre Clientsitzung automatisch den Debugger.

Im Folgenden finden Sie ein Beispiel, das zeigt, wie dies funktioniert, wobei Haltepunkte in einem Skript in den Zeilen 6, 11, 22 und 25 festgelegt werden. Beachten Sie, dass im Beispiel beim Starten des Debuggers zwei identifizierende Eingabeaufforderungen vorhanden sind: der Name des Computers, auf dem die Sitzung ausgeführt wird, und die DBG-Eingabeaufforderung, 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 systementsprechende Meldung an. Sie enthält eine Funktion, einen Funktionsaufruf und eine Variable.

Der folgende Befehl zeigt den Inhalt der Testskriptdatei an:

PS C:\PS-test>  Get-Content test.ps1

function psversion {
  "PowerShell " + $PSVersionTable.PSVersion
  if ($PSVersionTable.PSVersion.Major -lt 6) {
    "Upgrade to PowerShell 6.0!"
  }
  else {
    "Have you run a background job today (start-job)?"
  }
}

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

Um zu beginnen, legen Sie einen Haltepunkt an einem interessanten Punkt für das Skript fest, z. B. eine Zeile, einen Befehl, eine Variable oder eine Funktion.

Erstellen Sie zunächst einen Zeilenumbruchpunkt in der ersten Zeile des skripts Test.ps1 im aktuellen Verzeichnis.

PS C:\ps-test> Set-PSBreakpoint -line 1 -script test.ps1

Sie können diesen Befehl wie folgt kü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. Er beschreibt den Haltepunkt und zeigt eine Vorschau der ersten Zeile des Skripts an, bei der es sich um eine Funktionsdeklaration handelt. Die Eingabeaufforderung ändert sich auch, um anzugeben, dass der Debugger über Kontrolle verfügt.

Die Vorschauzeile enthält den Skriptnamen und die Zeilennummer des vorschauierten Befehls.

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 Befehl "Schritt" (s), um die erste Anweisung im Skript auszuführen und eine Vorschau der nächsten Anweisung anzuzeigen. Die nächste Anweisung verwendet die $MyInvocation automatische Variable, um den Wert der $scriptName Variablen auf den Pfad und Dateinamen der Skriptdatei festzulegen.

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

Zu diesem Zeitpunkt ist die $scriptName Variable noch nicht ausgefüllt, aber Sie können den Wert der Variablen überprüfen, indem Sie ihren Wert anzeigen. In diesem Fall handelt es sich um den Wert $null.

DBG> $scriptname
# DBG>

Verwenden Sie weitere Schrittbefehle, um die aktuelle Anweisung auszuführen und eine Vorschau der nächsten Anweisung im Skript anzuzeigen. Die nächste Anweisung ruft die PsVersion-Funktion auf.

DBG> s
test.ps1:12  psversion

An diesem Punkt wird die $scriptName Variable aufgefüllt, aber Sie überprüfen den Wert der Variablen, indem Sie dessen Wert anzeigen. In diesem Fall wird der Wert auf den Skriptpfad festgelegt.

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

Verwenden Sie einen anderen Schritt-Befehl, um den Funktionsaufruf auszuführen. Drücken Sie die EINGABETASTE, oder geben Sie "s" für Schritt ein.

DBG> s
test.ps1:2       "PowerShell " + $PSVersionTable.PSVersion

Die Debugnachricht 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. Verwenden Sie in diesem Fall jedoch einen StepOut-Befehl (o). Sie schließt die Ausführung der Funktion ab (es sei denn, sie erreicht einen Haltepunkt) und die Schritte zur nächsten Anweisung im Skript.

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

Da wir uns bei der letzten Anweisung im Skript befinden, haben die Befehle Step, StepOut und Continue die gleiche Wirkung. Verwenden Sie in diesem Fall StepOut (o).

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

Der Befehl "StepOut" führt den letzten Befehl aus. Die Standard-Eingabeaufforderung gibt an, dass der Debugger das Steuerelement beendet und an den Befehlsprozessor zurückgegeben hat.

Führen Sie nun den Debugger erneut aus. Verwenden Sie zunächst zum Löschen des aktuellen Haltepunkts die cmdlets Get-PSBreakpoint und Remove-PSBreakpoint. (Wenn Sie denken, dass Sie den Haltepunkt möglicherweise wiederverwenden, 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 kürzen:

PS C:\ps-test> gbp | rbp

Oder führen Sie den Befehl aus, indem Sie eine Funktion schreiben, z. B. die folgende Funktion:

function delbr { gbp | rbp }

Erstellen Sie nun einen Haltepunkt für die variable $scriptname.

PS C:\ps-test> Set-PSBreakpoint -variable scriptname -script test.ps1

Sie können den Befehl abkürten als:

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

Starten Sie nun das Skript. Das Skript erreicht den variablen Haltepunkt. Der Standardmodus ist "Schreiben", sodass die Ausführung unmittelbar vor der Anweisung beendet wird, 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>

Zeigt den aktuellen Wert der variablen $scriptName an, die $nullist.

DBG> $scriptName
# DBG>

Verwenden Sie einen oder mehrere Schrittbefehle, 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
```powershell

Use a Step command (s) to preview the next statement in the script.

```powershell
DBG> s
test.ps1:12  psversion

Die nächste Anweisung ist ein Aufruf der PsVersion-Funktion. Um die Funktion zu überspringen, sie aber dennoch auszuführen, verwenden Sie den Befehl StepOver (v). Wenn Sie sich bereits in der Funktion befinden, wenn Sie StepOver verwenden, ist dies nicht wirksam. Der Funktionsaufruf wird zwar angezeigt, aber nicht ausgeführt.

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

Der StepOver-Befehl führt die Funktion aus und zeigt eine Vorschau der nächsten Anweisung im Skript an, die die letzte Zeile ausgibt.

Verwenden Sie den Stoppbefehl (t), um den Debugger zu beenden. Die Eingabeaufforderung wird auf die Standard-Eingabeaufforderung zurückgesetzt.

C:\ps-test>

Verwenden Sie zum Löschen der Haltepunkte die Cmdlets Get-PSBreakpoint und Remove-PSBreakpoint.

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

Erstellen Sie einen neuen Befehlshaltepunkt für die PsVersion-Funktion.

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

Sie können diesen Befehl abkürden wie folgt:

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

Führen Sie nun das Skript 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 beim Funktionsaufruf. Zu diesem Zeitpunkt wurde die Funktion noch nicht aufgerufen. Auf diese Weise können Sie den Aktionsparameter von Set-PSBreakpoint verwenden, um Bedingungen für die Ausführung des Haltepunkts festzulegen oder vorbereitende oder Diagnoseaufgaben auszuführen, z. B. das Starten eines Protokolls oder das Aufrufen eines Diagnose- oder Sicherheitsskripts.

Verwenden Sie zum Festlegen einer Aktion einen Befehl "Weiter" (c), um das Skript zu beenden, und einen Remove-PSBreakpoint Befehl, um den aktuellen Haltepunkt zu löschen. (Haltepunkte sind schreibgeschützt, sodass Sie dem aktuellen Haltepunkt keine Aktion hinzufügen können.)

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 nun einen neuen Befehlshaltepunkt mit einer Aktion. Der folgende Befehl legt einen Befehlshaltepunkt mit einer Aktion fest, die den Wert der $scriptName Variablen protokolliert, wenn die Funktion aufgerufen wird. Da das Schlüsselwort Break in der Aktion nicht verwendet wird, wird die Ausführung nicht gestoppt. (Der Backtick (') ist das Zeichen der Zeilenfortsetzung.)

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, die restriktivste Richtlinie, mit der Sie weiterhin Skripts ausführen können. (Der Backtick (') ist das Fortsetzungszeichen.)

PS C:\ps-test> Set-PSBreakpoint -script test.ps1 -command psversion `
-action { if ((Get-ExecutionPolicy) -eq "RemoteSigned") { break }}

Das Break-Schlüsselwort in der Aktion weist den Debugger an, den Haltepunkt auszuführen. Sie können auch das Continue-Schlüsselwort verwenden, um den Debugger so anzuweisen, dass er ohne Unterbrechung ausgeführt wird. Da das Standardschlüsselwort Continue ist, müssen Sie Break angeben, um die Ausführung zu stoppen.

Führen Sie nun das Skript 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 den Aufrufstapel überprüfen. Verwenden Sie das Get-PsCallStack Cmdlet oder den Get-PsCallStack Debuggerbefehl (k). Der folgende Befehl ruft den aktuellen Aufrufstapel ab.

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

In diesem Beispiel werden nur einige der vielen Möglichkeiten zum Verwenden des PowerShell-Debuggers veranschaulicht.

Geben Sie den folgenden Befehl ein, um weitere Informationen zu den Debugger-Cmdlets zu erhalten:

help <cmdlet-name> -full

Geben Sie beispielsweise Folgendes ein:

help Set-PSBreakpoint -full

Weitere Debugfeatures in PowerShell

Zusätzlich zum PowerShell-Debugger enthält PowerShell mehrere weitere Features, die Sie zum Debuggen von Skripts und Funktionen verwenden können.

  • Windows PowerShell ISE enthält einen interaktiven grafischen Debugger. Um weitere Informationen zu erhalten, starten Sie Windows PowerShell ISE, und drücken Sie F1.

  • Das Cmdlet Set-PSDebug bietet sehr einfache Skriptdebuggingfeatures, einschließlich Schritt- und Ablaufverfolgung.

  • Verwenden Sie das Set-StrictMode Cmdlet, um Verweise auf nicht initialisierte Variablen, auf Verweise auf nicht vorhandene Eigenschaften eines Objekts und auf ungültige Funktionssyntax zu erkennen.

  • Fügen Sie einem Skript Diagnoseanweisungen hinzu, z. B. Anweisungen, die den Wert von Variablen, Anweisungen anzeigen, die Eingaben aus der Befehlszeile lesen, oder Anweisungen, die die aktuelle Anweisung melden. Verwenden Sie die Cmdlets, die das Verb "Write" für diese Aufgabe enthalten, z. B. Write-Host, Write-Debug, Write-Warningund Write-Verbose.

SIEHE AUCH

  • Last updated on