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 Integrated Scripting Environment (ISE) auf Remotecomputern ausgeführt werden.

Hinweis

Die Windows PowerShell ISE unterstützt nur Windows PowerShell. Für PowerShell 6 und höher müssen Sie Visual Studio Code mit der Erweiterung für PowerShell verwenden. Weitere Informationen finden Sie unter Debuggen mit Visual Studio Code.

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, und 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 er (s), (v) StepOver oder List (l) war Step . Andernfalls stellt eine Übermittlungsaktion dar.

  • ?, h: Zeigt den Debuggerbefehl Hilfe an.

Zum Beenden des Debuggers können Sie (q) verwenden Stop .

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.

Mit diesen Debuggerbefehlen 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 erkannt haben.

Hinweis

Wenn Sie eine Anweisung mit einem Umleitungsoperator ausführen, z >. B. , 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 debuggen wird, mit Ausnahme der folgenden automatischen Variablen:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Wenn Sie den Wert einer dieser Variablen anzeigen, 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 debuggen wird, fügen Sie Ihrem Skript Zeilen hinzu, um diese Werte in einer neuen Variablen zu speichern. Legen Sie Ihren Haltepunkt nach diesen neuen Zeilen fest. Anschließend können Sie den Wert der neuen Variablen anzeigen.

Beispiel:

$scriptArgs = $Args
$scriptname = $MyInvocation.PSCommandPath

Die Debuggerumgebung

Wenn Sie einen Haltepunkt erreichen, geben Sie die Debuggerumgebung ein. Die Eingabeaufforderung ändert sich, sodass sie mit "[DBG]:" beginnt. Außerdem wird in einigen Hostanwendungen, z. B. der PowerShell-Konsole, 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.

Weitere Informationen zum Anpassen der Eingabeaufforderung finden Sie unter about_Prompts.

Sie können die Schachtelungsebene mithilfe der $NestedPromptLevel automatischen Variablen ermitteln. Die automatische Variable , $PSDebugContextwird im lokalen Bereich definiert. Sie können das Vorhandensein der $PSDebugContext Variablen verwenden, um zu bestimmen, ob Sie im Debugger ausgeführt werden.

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

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 über die 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.

Debuggen von Funktionen

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

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 ermöglicht es Ihnen, eine nicht verbundene Sitzung, die ein Skript oder einen Befehl auf einem Remotecomputer ausführt, wiederherzustellen. Wenn das ausgeführte Skript einen Haltepunkt erreicht, startet Ihre Clientsitzung automatisch den Debugger. Wenn die getrennte Sitzung, in der ein Skript ausgeführt wird, bereits einen Haltepunkt erreicht hat, Enter-PSSession startet automatisch den Befehlszeilendebugger, wenn Sie sich wieder mit der Sitzung verbinden.

Das folgende Beispiel zeigt, wie dies funktioniert. Haltepunkte wurden auf zeilen 6, 11, 22 und 25 des Skripts festgelegt. Wenn der Debugger gestartet wird, gibt es zwei identifizierende Änderungen an der Eingabeaufforderung:

  • Der Name des Computers, auf dem die Sitzung ausgeführt wird
  • 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 von PowerShell und zeigt eine versionsgemäße 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 7) {
    "Upgrade to PowerShell 7!"
  }
  else {
    "Have you run a background job today (start-job)?"
  }
}

$scriptName = $MyInvocation.PSCommandPath
psversion
"Done $scriptName."

Legen Sie zunächst einen Haltepunkt an einem interessanten Punkt 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

Der Befehl gibt ein System.Management.Automation.LineBreakpoint-Objekt 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 ändert sich auch, 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 den Schrittbefehl(n), 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 den Dateinamen der Skriptdatei festzulegen.

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

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 Step Befehl (s), 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 Schrittbefehl, 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 die letzte Anweisung im Skript verwenden, 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 StepOut-Befehl führt den letzten Befehl aus. Die Standardeingabeaufforderung gibt an, dass der Debugger die Steuerung beendet und 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 glauben, 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 als Kürzen abkürten:

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

Starten Sie nun das Skript. Das Skript erreicht den Variablen-Haltepunkt. Der Standardmodus ist Schreibmodus, 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.PSCommandPath
DBG>

Zeigt den aktuellen Wert der $scriptName Variablen an, d. h $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 an $scriptName .

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

Verwenden Sie einen Schrittbefehl(en), um eine Vorschau der nächsten Anweisung im Skript anzuzeigen.

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 verwenden StepOver, 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 StepOver Befehl führt die Funktion aus, und es wird eine Vorschau der nächsten Anweisung im Skript angezeigt, 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 Aktionsparameter von Set-PSBreakpoint zu 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.

Um eine Aktion festzulegen, verwenden Sie einen Continue-Befehl (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 die break Schlüsselwort (keyword) in der Aktion nicht verwendet wird, wird die Ausführung nicht beendet. Der Backtick (`) ist das Zeilenfortführungszeichen.

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, die weiterhin das Ausführen von Skripts ermöglicht.

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 continue Schlüsselwort (keyword) verwenden, um den Debugger anweisen, ohne unterbrechungsfrei auszuführen. Da die Standardeinstellung Schlüsselwort (keyword) istcontinue, müssen Sie angebenbreak, 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 Anrufliste ü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 veranschaulicht, den PowerShell-Debugger zu verwenden.

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.

  • Das Set-PSDebug Cmdlet bietet sehr einfache Skriptdebuggingfunktionen, 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 Schreiben für diese Aufgabe enthalten, z Write-Host. B. , Write-Debug, Write-Warningund Write-Verbose.

Weitere Informationen