Sie sind auf Seite 1von 13

THEMA

about_Debuggers
KURZBESCHREIBUNG
Beschreibt den Windows PowerShell-Debugger.
DETAILBESCHREIBUNG
Als Debuggen wird die Untersuchung eines Skripts whrend dessen
Ausfhrung bezeichnet, bei der Fehler in den Skriptanweisungen
erkannt und korrigiert werden. Der Windows PowerShell-Debugger
wurde entworfen, um Ihnen das Untersuchen und Erkennen von
Fehlern und Ineffizienzen in den Skripts zu erleichtern.

Hinweis: Der Windows PowerShell-Debugger wird nicht remote
ausgefhrt. Zum Debuggen eines Skripts auf einem Remotecomputer
kopieren Sie das Skript auf den lokalen Computer.
Mit den Features des Windows PowerShell-Debuggers knnen Sie
Windows PowerShell-Skripts, Funktionen, Befehle oder Ausdrcke
whrend der Ausfhrung untersuchen. Der Windows PowerShell-Debugger
umfasst einen Satz von Cmdlets, mit denen Sie Haltepunkte
festlegen und verwalten sowie die Aufrufliste anzeigen knnen.

Windows PowerShell bietet mehrere Methoden, mit denen Sie
Skripts, Funktionen und Befehle debuggen knnen.
Methode 1: Das Cmdlet "Set-PsDebug" bietet einfache Debugfeatures
fr Skripts, z. B. Durchlaufen und Ablaufverfolgung.
Weitere Informationen erhalten Sie mit folgendem Befehl:
"get-help set-psdebug".
Methode 2: Verwenden Sie das Cmdlet "Set-StrictMode", um Verweise
auf nicht initialisierte Variablen, Verweise auf nicht
vorhandene Eigenschaften eines Objekts sowie Verweise
auf ungltige Funktionssyntax zu erkennen.
Methode 3: Fgen Sie einem Skript Diagnoseanweisungen hinzu, z. B.
Anweisungen zum Anzeigen von Variablenwerten, Anweisungen zum
Lesen der Eingabe in der Befehlszeile oder Anweisungen zum Melden

der aktuellen Anweisung. Verwenden Sie die Cmdlets, die das Verb
"Write" fr diese Aufgabe enthalten, z. B. Write-Host,
Write-Debug, Write-Warning und Write-Verbose.
Methode 4: Debuggen Sie ein Skript mit dem Windows PowerShell-Debugger.
Sie knnen den Debugger auch zum Debuggen einer Funktion
oder eines Skriptblocks verwenden, den Sie an der Eingabeaufforde
r
ung eingegeben haben. Sie knnen Haltepunkte festlegen, das
Skript durchlaufen, die Werte von Variablen untersuchen,
Diagnosen und Protokollierungsbefehle ausfhren sowie die
Aufrufliste anzeigen.

Debugger-Cmdlets
Der Windows PowerShell-Debugger umfasst den folgenden Satz von Cmdlets:

Set-PsBreakpoint: Legt Haltepunkte fr 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 Haltepunkte in der aktuellen
Sitzung erneut.
Remove-PsBreakpoint: Lscht Haltepunkte in der aktuellen
Sitzung.
Get-PsCallStack: Zeigt die aktuelle Aufrufliste an.
Starten und Beenden des Debuggers
Zum Starten des Debuggers legen Sie einen oder mehrere
Haltepunkte fest. Fhren Sie dann das Skript, den Befehl oder
die Funktion fr den Debugvorgang aus.
Wenn Sie einen Haltepunkt erreichen, wird die Ausfhrung
beendet, und die Steuerung wird an den Debugger bergeben.
Zum Beenden des Debuggers fhren Sie das Skript, den Befehl oder die
Funktion vollstndig aus. Sie knnen auch "stop" oder "t" eingeben.

Debuggerbefehle
Wenn Sie den Debugger an der Windows PowerShell-Konsole
verwenden, steuern Sie die Ausfhrung mit den folgenden Befehlen.

Hinweis: Informationen zum Verwenden des Debuggers in anderen
Hostanwendungen finden Sie in der Dokumentation der Hostanwendung.
s, Step-into Fhrt die nchste Anweisung aus und
wird dann beendet.
V, Step-over Fhrt die nchste Anweisung aus,
berspringt jedoch Funktionen und Aufrufe.
Die bersprungenen Anweisungen werden
ausgefhrt, jedoch nicht durchlaufen.
o, Step-out Verlsst die aktuelle Funktion, setzt den
Vorgang bei Schachtelung eine Ebene hher fort.
Wird im Haupttext bis zum Ende oder zum nchsten
Haltepunkt fortgesetzt. Die bersprungenen
Anweisungen werden ausgefhrt, jedoch nicht durchlaufe
n.
c, Continue Setzt die Ausfhrung fort, bis das
Skript abgeschlossen ist oder der nchste Haltepunkt e
rreicht
wurde. Die bersprungenen Anweisungen werden ausgefhrt,
jedoch
nicht durchlaufen.
l, List Zeigt den Teil des Skripts an, der
derzeit ausgefhrt wird. Standardmig werden die aktuelle

Zeile, fnf vorangehende Zeilen und 10 nachfolgende Ze
ilen
angezeigt. Drcken Sie EINGABETASTE, um die Ausfhrung d
es
Skripts fortzusetzen.

l <m>, List Zeigt 16 Zeilen des Skripts an,
beginnend mit der durch <m> angegebenen Zeilennummer
.
l <m> <n>, List Zeigt <n> Zeilen des Skripts an, beginnend
mit der durch <m> angegebenen Zeilennummer.

q, Stop Beendet die Skriptausfhrung und den Debugger.

k, Get-PsCallStack Zeigt die aktuelle Aufrufliste an.
<Eingabetaste> Wiederholt den letzten Befehl, wenn
es sich dabei um "Step (s)", "Step-over (v)" oder "L
ist (l)"
handelte. Stellt andernfalls eine Sendeaktion dar.

?, h Zeigt den Hilfebefehl des Debuggers an.
Zum Beenden des Debuggers verwenden Sie "Stop (q)".
Im Debugger knnen Sie auch Befehle eingeben, den Wert von
Variablen anzeigen, Cmdlets verwenden und Skripts ausfhren.
Mit diesen Debuggerbefehlen knnen Sie ein Skript ausfhren, an
einem wichtigen Punkt anhalten, die Werte von Variablen und den
Status des Systems untersuchen sowie die Ausfhrung des Skripts
fortsetzen, bis Sie ein Problem erkannt haben.
Die Debuggerumgebung
Wenn Sie einen Haltepunkt erreichen, greifen Sie auf die
Debuggerumgebung zu. Die Eingabeaufforderung wird so gendert,
dass sie mit "[DBG]:" beginnt. Sie knnen die Eingabeaufforderung
anpassen.

In einigen Hostanwendungen, z. B. der Windows PowerShell-Konsole
(nicht jedoch in der Windows PowerShell Integrated Scripting
Environment [ISE]) wird zudem eine geschachtelte
Eingabeaufforderung zum Debuggen geffnet. Die geschachtelte
Eingabeaufforderung erkennen Sie an den sich wiederholenden
Grer-als-Zeichen (ASCII 62), die an der Eingabeaufforderung
angezeigt werden.
Beispielsweise ist Folgendes die Standardeingabeaufforderung
fr das Debuggen in der Windows PowerShell-Konsole:
[DBG]: PS (get-location)>>>
Die Schachtelungsebene finden Sie mit der automatischen
Variable "$NestedPromptLevel".
Darber hinaus wird die automatische Variable "$PSDebugContext"
im lokalen Bereich definiert. Anhand des Vorhandenseins der
Variablen "$PsDebugContext" knnen Sie ermitteln, ob Sie sich
im Debugger befinden.
Beispiel:

if ($psdebugcontext) {"Debugging"} else {"Not Debugging"}
Sie knnen den Wert der Variablen "$PSDebugContext" beim
Debuggen verwenden.
[DBG]: PS>>> $psdebugcontext.invocationinfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
Debuggen und Bereich
Der Bereich, in dem Sie arbeiten, wird durch Unterbrechen des
Debuggers nicht gendert, wenn Sie jedoch einen Haltepunkt in
einem Skript erreichen, bewegen Sie sich in den Skriptbereich.
Der Skriptbereich bildet ein untergeordnetes Element des
Bereichs, in dem Sie den Debugger ausgefhrt haben.
Zum Suchen der im Skriptbereich definierten Variablen und
Aliase verwenden Sie den Scope-Parameter des Cmdlets
"Get-Alias" oder "Get-Variable".
Mit dem folgenden Befehl werden beispielsweise die Variablen im
lokalen Bereich (Skriptbereich) abgerufen:
get-variable -scope 0
Sie knnen den Befehl wie folgt abkrzen:
gv -s 0
Dies ist eine ntzliche Mglichkeit, nur die Variablen zu
sehen, die Sie im Skript definiert haben und die Sie beim
Debuggen definiert haben.
Debuggen in der Befehlszeile
Wenn Sie einen Variablenhaltepunkt oder einen Befehlshaltepunkt
festgelegt haben, knnen Sie den Haltepunkt nur in einer
Skriptdatei festlegen. Der Haltepunkt wird jedoch standardmig
auf ein beliebiges Element festgelegt, das in der aktuellen
Sitzung ausgefhrt wird.
Wenn Sie z. B. einen Haltepunkt fr die Variable "$name"
festlegen, wird der Debugger bei jeder Variablen "$name" in
allen derzeit ausgefhrten Skripts, Befehlen, Funktionen,
Skript-Cmdlets und Ausdrcken unterbrochen, bis Sie den
Haltepunkt deaktivieren oder entfernen.
Dadurch knnen Sie die Skripts in einem realistischeren Kontext
debuggen, in dem sich Funktionen, Variablen und andere Skripts
in der Sitzung und im Benutzerprofil auswirken knnen.
Zeilenhaltepunkte gelten nur fr Skriptdateien, daher werden
diese nur in Skriptdateien festgelegt.
Debuggen von Funktionen
Wenn Sie einen Haltepunkt fr eine Funktion festlegen, die die
Abschnitte "Begin", "Process" und "End" umfasst, wird der
Debugger an 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
Starten von Debugmodus. Zum Aufrufen von Hilfe "h'" oder
"?" verwenden.
Erreichen von Befehlshaltepunkt in 'prompt:test-Cmdlet'
test-cmdlet
[DBG]: C:\PS> c
Process
Starten von Debugmodus. Zum Aufrufen von Hilfe "h'" oder
"?" verwenden.
Erreichen von Befehlshaltepunkt in 'prompt:test-Cmdlet'
test-cmdlet
[DBG]: C:\PS> c
End
Starten von Debugmodus. Zum Aufrufen von Hilfe "h'" oder
"?" verwenden.
Erreichen von Befehlshaltepunkt in 'prompt:test-Cmdlet'
test-cmdlet
[DBG]: C:\PS>
Debuggen von Remoteskripts
Sie knnen den Windows PowerShell-Debugger nicht in einer
Remotesitzung ausfhren. Zum Debuggen eines Skripts auf einem
Remotecomputer kopieren Sie das Skript auf den lokalen Computer.
Mit dem folgenden Befehl wird das Skript "Test.ps1" vom
Remotecomputer "Server01" auf den lokalen Computer kopiert:
invoke-command -computername Server01 ` {get-content
c:\ps-test\test.ps1} | set-location c:\ps-test\test.ps1
Beispiele
Dieses Testskript erkennt die Version des Betriebssystems und
zeigt eine dem System entsprechende Meldung an. Es umfasst eine
Funktion, einen Funktionsaufruf und eine Variable.
Mit dem folgenden Befehl wird der Inhalt der Testskriptdatei
angezeigt:
c:>\PS-test> get-content test.ps1
function psversion {
"Windows Powershell " + $psversiontable.psversion if
($psversiontable.psversion.major -lt 2) {
"Update zu Windows PowerShell 2.0!"
}
else {
"Haben Sie heute schon einen Hintergrundauftrag
ausgefhrt (start-job)?" }
}
$scriptname = $MyInvocation.MyCommand.Path
psversion
"Done $scriptname."
Legen Sie zunchst einen Haltepunkt an einem wichtigen Punkt
des Skripts fest, z. B. einer Zeile, einem Befehl, einer
Variable oder einer Funktion.

Beginnen Sie, indem Sie einen Zeilenhaltepunkt auf der ersten
Zeile des Skripts "Test.ps1" im aktuellen Verzeichnis erstellen.
PS C:\ps-test> set-psbreakpoint -line 1 -script test.ps1
Sie knnen diesen Befehl wie folgt abkrzen:
PS C:\ps-test> spb 1 -s test.ps1

Der Befehl gibt ein Zeilenhaltepunktobjekt (System.Management.
Automation.LineBreakpoint) zurck.
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 jetzt das Skript.
PS C:\ps-test> .\test.ps1
Wenn das Skript den ersten Haltepunkt erreicht, gibt die
Haltepunktmeldung an, dass der Debugger aktiv ist. Es
beschreibt den Haltepunkt und zeigt die erste Zeile des
Skripts, eine Funktionsdeklaration, als Vorschau an. Die
Eingabeaufforderung wird auch gendert, um anzugeben, dass die
Steuerung beim Debugger liegt.
Die Vorschauzeile umfasst den Skriptnamen und die Zeilennummer
des in der Vorschau angezeigten Befehls.
Starten von Debugmodus. Zum Aufrufen von Hilfe "h'" oder
"?" verwenden.
Zeilenhaltepunkt fr 'C:\ps-test\test.ps1: 1' erreicht
test.ps1:1 function psversion {
DBG>
Verwenden Sie den Befehl "Step" (s), um die erste Anweisung im
Skript auszufhren und die nchste Anweisung als Vorschau
anzuzeigen. In der nchsten Anweisung wird die automatische
Variable "$MyInvocation" verwendet, um den Wert der Variablen
"$ScriptName" auf den Pfad und Dateinamen der Skriptdatei
festzulegen.
DBG> s
test.ps1:11 $scriptname = $MyInvocation.MyCommand.Path
Zu diesem Zeitpunkt wird die Variable "$ScriptName" nicht
aufgefllt, doch knnen Sie den Wert der Variablen berprfen,
indem Sie deren Wert anzeigen. In diesem Fall ist der Wert $null.
DBG> $scriptname
DBG>

Verwenden Sie einen anderen Befehl "Step" (s), um die aktuelle
Anweisung auszufhren und die nchste Anweisung im Skript als
Vorschau anzuzeigen. Mit der nchsten Anweisung wird die
Funktion " PsVersion" aufgerufen.
DBG> s
test.ps1:12 psversion
Zu diesem Zeitpunkt wird die Variable "$ScriptName" aufgefllt,
doch berprfen Sie den Wert der Variablen, indem Sie deren
Wert anzeigen. In diesem Fall wird der Wert auf den Skriptpfad
festgelegt.
DBG> $scriptname
C:\ps-test\test.ps1

Verwenden Sie einen anderen Befehl "Step", um den Funktionsaufruf
auszufhren. Drcken Sie EINGABETASTE, oder geben Sie "s" fr Step ein.
DBG> s
test.ps1:2 "Windows PowerShell " + $psversiontable.psversion
Die Debugmeldung enthlt eine Vorschau der Anweisung in der Funktion.
Zum Ausfhren dieser Anweisung und Anzeigen der nchsten
Anweisung in der Funktion als Vorschau knnen Sie den Befehl "Step"
verwenden. Verwenden Sie in diesem Fall jedoch den Befehl "Step-Out" (o).
Dieser schliet die Ausfhrung der Funktion ab (sofern kein
Haltepunkt erreicht wird) und springt zur nchsten Anweisung im Skript.
DBG> o
Windows Powershell 2.0
Haben Sie heute schon einen Hintergrundauftrag ausgefhrt (start-job)?
test.ps1:13 "Done $scriptname"
Da Sie sich bei der letzten Anweisung im Skript befinden, haben
die Befehle "Step", "Step-Out" und "Continue" die gleiche
Auswirkung. Verwenden Sie in diesem Fall Step-Out (o).
Done C:\ps-test\test.ps1
PS C:\ps-test>
Mit dem Befehl "Step-Out" wird der letzte Befehl ausgefhrt.
Die Standardeingabeaufforderung gibt an, dass der Debugger
beendet wurde und die Steuerung an den Befehlsprozessor
zurckgegeben hat.
Fhren Sie den Debugger jetzt erneut aus. Verwenden Sie zuerst,
um den aktuellen Haltepunkt zu lschen, die Cmdlets
"Get-PsBreakpoint" und "Remove-PsBreakpoint".
(Wenn Sie den Haltepunkt mglicherweise wiederverwenden
mchten, verwenden Sie statt Remove-PsBreakpoint das Cmdlet
"Disable-PsBreakpoint".)
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Sie knnen diesen Befehl wie folgt abkrzen:
PS C:\ps-test> gbp | rbp
Sie knnen den Befehl durch Schreiben einer Funktion ausfhren,
beispielsweise der folgenden:
function delbr { gbp | rbp }
Erstellen Sie nun einen Haltepunkt fr die Variable "$scriptname".
PS C:\ps-test> set-psbreakpoint -variable Skriptname -script test.ps1
Sie knnen den Befehl wie folgt abkrzen:
PS C:\ps-test> sbp -v Skriptname -s test.ps1
Starten Sie jetzt das Skript. Das Skript erreicht den
Variablenhaltepunkt. Der Standardmodus ist "Write", daher wird
die Ausfhrung genau vor der Anweisung beendet, von der der
Wert der Variablen gendert wird.
PS C:\ps-test> .\test.ps1
Erreichen von Variablenhaltepunkt bei 'C:\ps-test\test.ps1:$scriptname
'
(Schreibzugriff)
test.ps1:11 $scriptname = $MyInvocation.mycommand.path
DBG>
Zeigen Sie den aktuellen Wert der Variablen "$scriptname",
$null, an.
DBG> $scriptname
DBG>
Verwenden Sie den Befehl "Step" (s), um die Anweisung
auszufhren, mit der die Variable aufgefllt wird. Zeigen Sie
dann den neuen Wert der Variablen "$scriptname" an.
DBG> $scriptname
C:\ps-test\test.ps1
Verwenden Sie den Befehl "Step" (s), um die nchste Anweisung
im Skript als Vorschau anzuzeigen.
DBG> s
test.ps1:12 psversion

Die nchste Anweisung besteht in einem Aufruf der Funktion
"PsVersion". Wenn die Funktion bersprungen, aber dennoch
ausgefhrt werden soll, verwenden Sie den Befehl "Step-Over"
(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 ausgefhrt.
DBG> v
Windows Powershell 2.0
Haben Sie heute schon einen Hintergrundauftrag ausgefhrt (start-job)?
test.ps1:13 "Done $scriptname"
Mit dem Befehl "Step-Over" wird die Funktion ausgefhrt und die
nchste Anweisung im Skript, mit dem die letzte Zeile gedruckt
wird, als Vorschau angezeigt.
Beenden Sie den Debugger mit dem Befehl "Stop" (t). Die
Eingabeaufforderung wird auf die Standardanzeige zurckgesetzt.
C:\ps-test>
Zum Lschen der Haltepunkte verwenden Sie die Cmdlets
"Get-PsBreakpoint" und "Remove-PsBreakpoint".
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Erstellen Sie fr die Funktion "PsVersion" einen neuen
Befehlshaltepunkt.
PS C:\ps-test> Set-PsBreakpoint -command psversion -script test.ps1
Sie knnen diesen Befehl wie folgt abkrzen:
PS C:\ps-test> sbp -c psversion -s test.ps1
Fhren Sie jetzt das Skript aus.
PS C:\ps-test> .\test.ps1
Erreichen von Befehlshaltepunkt bei '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. Dies gibt Ihnen
die Gelegenheit, mit dem Action-Parameter "Set-PsBreakpoint"
Bedingungen fr die Ausfhrung des Haltepunkts festzulegen oder
vorbereitende oder Diagnoseaufgaben auszufhren, z. B. ein Protokoll
zu starten oder eine Diagnose oder ein Sicherheitsskript aufzurufen.
Zum Festlegen einer Aktion verwenden Sie den Befehl "Continue"
(c), um das Skript zu beenden, und den Befehl "Remove-PsBreakpoint",
um den aktuellen Haltepunkt zu lschen. (Haltepunkte sind
schreibgeschtzt, deshalb knnen Sie dem aktuellen Haltepunkt
keine Aktion hinzufgen.)
DBG> c
Windows PowerShell 2.0
Haben Sie heute schon einen Hintergrundauftrag ausgefhrt (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. Mit dem folgenden Befehl wird einen Befehlshaltepunkt
mit einer Aktion festgelegt, die beim Aufruf der Funktion den
Wert der Variablen "$scriptname" protokolliert. Da das
Break-Schlsselwort in der Aktion nicht verwendet wird, wird
die Ausfhrung nicht beendet. (Das Graviszeichen [`] wird als
Zeilenfortsetzungszeichen verwendet.)
PS C:\ps-test> set-psbreakpoint -command psversion -script test.ps1 `
-action { add-content "Der Wert von `$scriptname ist $scriptname." `
-path action.log}
Sie knnen auch Aktionen hinzufgen, mit denen Bedingungen fr den
Haltepunkt festgelegt werden. Im folgenden Befehl wird der
Befehlshaltepunkt nur ausgefhrt, wenn die Ausfhrungsrichtlinie
auf RemoteSigned festgelegt ist, die restriktivste Richtlinie, unter der
Sie Skripts ausfhren knnen. (Das Graviszeichen [`]
wird als Fortsetzungszeichen verwendet.)
PS C:\ps-test> set-psbreakpoint -script test.ps1 -command psversion `
-action { if ((get-executionpolicy) -eq "RemoteSigned") { break }}

Mit dem Break-Schlsselwort in der Aktion wird der Debugger
angewiesen, den Haltepunkt auszufhren. Mit dem Continue-Schlssel-
wort knnen Sie den Debugger auch anweisen, die Ausfhrung
ohne Unterbrechung vorzunehmen. Da als Standardschlsselwort
"Continue" festgelegt ist, mssen Sie Break angeben, um die
Ausfhrung zu beenden.
Fhren Sie jetzt das Skript aus.
PS C:\ps-test> .\test.ps1
Erreichen von Befehlshaltepunkt bei 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion

Da die Ausfhrungsrichtlinie auf RemoteSigned festgelegt ist,
wird die Ausfhrung beim Funktionsaufruf beendet.
Zu diesem Zeitpunkt mchten Sie die Aufrufliste mglicherweise
berprfen. Verwenden Sie das Cmdlet "Get-PsCallStack" oder den
Debuggerbefehl "Get-PsCallStack" (k).
Mit dem folgenden Befehl wird die aktuelle Aufrufliste abgerufen.
DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]
In diesem Beispiel werden nur einige der zahlreichen
Verwendungsmglichkeiten des Windows PowerShell-Debuggers
veranschaulicht.
Weitere Informationen zu den Debugger-Cmdlets erhalten Sie,
wenn Sie den folgenden Befehl eingeben:
help <Cmdlet-Name> -full
Geben Sie beispielsweise Folgendes ein:
help set-psbreakpoint -full
SIEHE AUCH
Disable-PsBreakpoint
Get-PsBreakpoint
Remove-PsBreakpoint
Set-PsBreakpoint
Set-PsDebug
Set-Strictmode
Write-Debug
Write-Verbose
Enable-PsBreakpoint
Get-PsCallStack