Freigeben über

about_Debuggers

  • Artikel

Kurze Beschreibung

Beschreibt den PowerShell-Debugger.

Lange Beschreibung

Beim Debuggen wird ein Skript während der Ausführung untersucht, um Fehler in den Skriptanweisungen zu identifizieren und zu korrigieren. Mit dem PowerShell-Debugger können Sie Fehler und Ineffizienzen in Ihren Skripts, Funktionen, Befehlen, PowerShell-Desired State Configuration-Konfigurationen (DSC) oder Ausdrücken untersuchen und identifizieren.

Ab PowerShell 5.0 wurde der PowerShell-Debugger aktualisiert, um Skripts, Funktionen, Befehle, Konfigurationen oder Ausdrücke zu debuggen, die entweder in der Konsole oder Windows PowerShell ISE auf Remotecomputern ausgeführt werden. Sie können ausführen Enter-PSSession , 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, damit Sie sich wieder mit einer getrennten Sitzung verbinden und eingeben können, in der ein Skript oder ein Befehl auf einem Remotecomputer ausgeführt wird. Wenn das ausgeführte Skript einen Haltepunkt erreicht, startet Ihre Clientsitzung automatisch den Debugger. Wenn die getrennte Sitzung, die ein Skript ausführt, bereits einen Haltepunkt erreicht hat und am Haltepunkt beendet wird, Enter-PSSession startet automatisch den Befehlszeilendebugger, nachdem Sie die Verbindung mit der Sitzung wiederhergestellt haben.

Sie können die Features des PowerShell-Debuggers verwenden, um ein PowerShell-Skript, eine Funktion, einen Befehl oder einen Ausdruck zu untersuchen, während er ausgeführt wird. 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 Zeilen, Variablen und Befehle fest.
  • Get-PSBreakpoint: Ruft Haltepunkte in der aktuellen Sitzung ab.
  • Disable-PSBreakpoint: Deaktiviert Haltepunkte in der aktuellen Sitzung.
  • Enable-PSBreakpoint: Aktiviert Breakpoints 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 mindestens einen Haltepunkt 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 wird an den Debugger übergeben.

Um den Debugger zu beenden, führen Sie das Skript, den Befehl oder die Funktion aus, bis er abgeschlossen ist. Oder geben Sie oder ein stopt.

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 wird dann beendet.

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

  • Ctrl+Break: (Alle in ISE unterbrechen) Wird in ein ausgeführtes Skript in der PowerShell-Konsole oder Windows PowerShell ISE unterteilt. Beachten Sie, dass dieSTRG-Umbruch+ in Windows PowerShell 2.0, 3.0 und 4.0 das Programm schließt. Break All funktioniert sowohl für lokale skripts als auch für Remoteskripts, die interaktiv ausgeführt werden.

  • o, StepOut: Tritt aus der aktuellen Funktion heraus; nach oben um eine Ebene, wenn geschachtelt. Wenn sich im Standard Textkörpers befindet, wird er bis zum Ende oder zum nächsten Haltepunkt fortgesetzt. Die übersprungenen Anweisungen werden ausgeführt, aber nicht in Einzelschritten durchlaufen.

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

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

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

  • l <m> <n>, List: Zeigt <n> Zeilen des Skripts ab der durch <m>angegebenen Zeilennummer an.

  • q, Stop, Exit: Beendet die Ausführung des Skripts und beendet den Debugger. Wenn Sie einen Auftrag debuggen, indem Sie das Debug-Job Cmdlet ausführen, trennt der Exit Befehl den Debugger, und der Auftrag kann weiterhin ausgeführt werden.

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

  • <Enter>: Wiederholt den letzten Befehl, wenn es sich um Schritt(en), StepOver (v) oder List (l) handelt. Andernfalls stellt eine Übermittlungsaktion dar.

  • ?, h: Zeigt den Debuggerbefehl Hilfe an.

Zum Beenden des Debuggers können Sie Stop (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 problembehafteten Punkt anhalten, die Werte von Variablen und den Zustand des Systems untersuchen und das Skript so lange ausführen, bis Sie ein Problem erkannt haben.

HINWEIS: Wenn Sie eine Anweisung mit einem Umleitungsoperator wie ">" ausführen, führt der PowerShell-Debugger schritte über alle verbleibenden Anweisungen im Skript aus.

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 im Skript anzeigen, das debuggt wird, mit Ausnahme der folgenden automatischen Variablen:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Wenn Sie den Wert von einer dieser Variablen anzeigen, erhalten Sie den Wert, den diese Variablen für eine interne, vom Debugger verwendete Pipeline hat, nicht den Wert der Variablen im Skript.

Um den Wert dieser Variablen für das Zu debuggende Skript anzuzeigen, 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

Debuggerumgebung

Wenn Sie einen Haltepunkt erreichen, geben Sie die Debuggerumgebung ein. Die Eingabeaufforderung ändert sich, sodass sie mit "[DBG]:" beginnt.

Weitere Informationen zum Anpassen der Eingabeaufforderung finden Sie unter about_Prompts.

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

So lautet beispielsweise die Standard-Debugaufforderung in der PowerShell-Konsole:

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

Sie können die Schachtelungsebene mithilfe der $NestedPromptLevel automatischen Variablen ermitteln.

Darüber hinaus wird im lokalen Bereich eine automatische Variable definiert $PSDebugContext. 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 beim Debuggen verwenden.

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

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

Debuggen und Bereich

Das Durchbrechen in den Debugger ändert nicht den Bereich, in dem Sie arbeiten, 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 Scope-Parameter der Get-Alias Cmdlets oder Get-Variable .

Der folgende Befehl ruft beispielsweise die Variablen im lokalen Bereich (Skriptbereich) ab:

Get-Variable -scope 0

Sie können den Befehl als Kürzen abkürten:

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 an der Befehlszeile

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

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

Dadurch 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 beeinflusst werden.

Zeilenhaltepunkte sind spezifisch für Skriptdateien, sodass sie nur in Skriptdateien festgelegt werden.

Debugfunktionen

Wenn Sie einen Haltepunkt für eine Funktion festlegen, die BeginAbschnitte , Processund End enthält, wird der Debugger in der ersten Zeile jedes Abschnitts unterbrochen.

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 in der Konsole oder Windows PowerShell ISE ausführen. Enter-PSSession Die Funktionalität wurde aktualisiert, sodass Sie sich wieder mit einer getrennten Sitzung verbinden und eingeben können, die auf einem Remotecomputer ausgeführt wird und derzeit ein Skript ausführt. Wenn das ausgeführte Skript einen Haltepunkt erreicht, startet Ihre Clientsitzung automatisch den Debugger.

Im Folgenden sehen Sie ein Beispiel, das zeigt, wie dies funktioniert, wobei in einem Skript in den Zeilen 6, 11, 22 und 25 Haltepunkte festgelegt sind. Beachten Sie, dass im Beispiel, wenn der Debugger gestartet wird, 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 systemgerechte 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."

Legen Sie zunächst einen Haltepunkt an einem Punkt von Interesse im Skript fest, z. B. eine Zeile, einen Befehl, eine Variable oder eine Funktion.

Erstellen Sie zunächst einen Zeilenhaltepunkt in der ersten Zeile des Test.ps1 skripts 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 Breakpointmeldung an, dass der Debugger aktiv ist. Es beschreibt den Haltepunkt und zeigt eine Vorschau der ersten Zeile des Skripts an, bei der es sich um eine Funktionsdeklaration handelt. Die Eingabeaufforderung wird ebenfalls geändert, um anzugeben, dass der Debugger über die Steuerung verfügt.

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

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 die Schrittbefehle, 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

An diesem Punkt wird die $scriptName Variable nicht aufgefü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 einen anderen Schrittbefehl(n), 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 ihren Wert anzeigen. In diesem Fall wird 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 Schritt ein.

DBG> s
test.ps1:2       "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. Verwenden Sie in diesem Fall jedoch einen StepOut-Befehl (o). Es schließt die Ausführung der Funktion ab (es sei denn, sie erreicht einen Haltepunkt) und führt schritte zur nächsten Anweisung im Skript aus.

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

Da wir uns mit der letzten Anweisung im Skript befinden, haben die Befehle Step, StepOut und Continue die gleiche Auswirkung. 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 Standardeingabeaufforderung gibt an, dass der Debugger beendet wurde und die Steuerung an den Befehlsprozessor zurückgegeben hat.

Führen Sie nun den Debugger erneut aus. Verwenden Sie zunächst die Cmdlets undRemove-PSBreakpoint, um den Get-PSBreakpoint aktuellen Haltepunkt zu löschen. (Wenn Sie der Meinung sind, dass Sie den Haltepunkt wiederverwenden könnten, verwenden Sie das Disable-PSBreakpoint Cmdlet 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 schreiben, z. B. die folgende Funktion:

function delbr { gbp | rbp }

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

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

Sie können den Befehl folgendermaßen abkürten:

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

Starten Sie nun das Skript. Das Skript erreicht den Variablenhaltepunkt. Der Standardmodus ist Write, sodass die Ausführung kurz 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 $scriptName Variablen an, nämlich $null.

DBG> $scriptName
# DBG>

Verwenden Sie einen Schrittbefehl(n), um die Anweisung auszuführen, die die Variable auffüllt. Zeigen Sie dann den neuen Wert der Variablen an $scriptName .

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, aber trotzdem auszuführen, verwenden Sie einen StepOver-Befehl (v). Wenn Sie sich bereits in der Funktion befinden, wenn Sie StepOver verwenden, ist dies nicht effektiv. Der Funktionsaufruf wird 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 Befehl StepOver führt die Funktion aus und gibt eine Vorschau der nächsten Anweisung im Skript aus, die die letzte Zeile ausgibt.

Verwenden Sie einen Stop-Befehl (t), um den Debugger zu beenden. Die Eingabeaufforderung wird zur Standardeingabeaufforderung zurückgesetzt.

C:\ps-test>

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

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

Create einen neuen Befehlshaltepunkt für die PsVersion-Funktion.

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

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

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. Dadurch haben Sie die Möglichkeit, den Action-Parameter von Set-PSBreakpoint zu verwenden, um Bedingungen für die Ausführung des Haltepunkts festzulegen oder vorbereitende oder diagnoserelevante Aufgaben auszuführen, z. B. das Starten eines Protokolls oder das Aufrufen eines Diagnose- oder Sicherheitsskripts.

Um eine Aktion festzulegen, verwenden Sie den Befehl Continue (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 der break-Schlüsselwort (keyword) in der Aktion nicht verwendet wird, wird die Ausführung nicht beendet. (Das Backtick (`) 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, die restriktivste Richtlinie, mit der Sie Weiterhin Skripts ausführen können. (Das Backtick (`) ist das Fortsetzungszeichen.)

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

Der break Schlüsselwort (keyword) in der Aktion weist den Debugger an, den Haltepunkt auszuführen. Sie können auch die Schlüsselwort (keyword) weiter verwenden, um den Debugger anweisen, ohne unterbrechungsfrei auszuführen. Da die Standard-Schlüsselwort (keyword) Weiter ist, müssen Sie Break angeben, um die Ausführung zu beenden.

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 die Aufrufliste überprüfen. Verwenden Sie das Get-PsCallStack Cmdlet oder den Get-PsCallStack Debuggerbefehl (k). Der folgende Befehl ruft die aktuelle Aufrufliste ab.

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

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

Um weitere Informationen zu den Debugger-Cmdlets zu erfahren, geben Sie den folgenden Befehl ein:

help <cmdlet-name> -full

Beispiel:

help Set-PSBreakpoint -full

Andere 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 erfahren, starten Sie Windows PowerShell ISE, und drücken Sie F1.

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

  • Verwenden Sie das Set-StrictMode Cmdlet, um Verweise auf nicht initialisierte Variablen, 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 anzeigen, Anweisungen, 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 Write-Host. B. , Write-Debug, Write-Warningund Write-Verbose.

Weitere Informationen