Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Eine Eingabequelle für ein Cmdlet ist die Befehlszeile. In diesem Thema wird beschrieben, wie Sie dem Cmdlet Get-Proc (das in Creating Your First Cmdlet) beschrieben wird, einen Parameter hinzufügen, damit das Cmdlet Eingaben vom lokalen Computer basierend auf expliziten Objekten verarbeiten kann, die an das Cmdlet übergeben werden. Das hier beschriebene cmdlet Get-Proc ruft Prozesse basierend auf ihren Namen ab und zeigt dann Informationen zu den Prozessen an einer Eingabeaufforderung an.
Definieren der Cmdlet-Klasse
Der erste Schritt bei der Cmdlet-Erstellung ist die Benennung von Cmdlets und die Deklaration der .NET Framework-Klasse, die das Cmdlet implementiert. Dieses Cmdlet ruft Prozessinformationen ab, sodass der hier ausgewählte Verbname "Abrufen" lautet. (Fast jede Art von Cmdlet, das Informationen abrufen kann, kann Befehlszeileneingaben verarbeiten.) Weitere Informationen zu genehmigten Cmdlet-Verben finden Sie unter Cmdlet Verb Names.
Dies ist die Klassendeklaration für das Cmdlet Get-Proc. Details zu dieser Definition werden in Creating Your First Cmdletbereitgestellt.
[Cmdlet(VerbsCommon.Get, "proc")]
public class GetProcCommand: Cmdlet
<Cmdlet(VerbsCommon.Get, "Proc")> _
Public Class GetProcCommand
Inherits Cmdlet
Deklarieren von Parametern
Mit einem Cmdlet-Parameter kann der Benutzer Eingaben für das Cmdlet bereitstellen. Im folgenden Beispiel sind Get-Proc und Get-Member die Namen von weitergeleiteten Cmdlets, und MemberType ist ein Parameter für das cmdlet Get-Member. Der Parameter weist das Argument "property" auf.
PS> Get-Proc ; Get-Member -MemberType-Eigenschaft
Um Parameter für ein Cmdlet zu deklarieren, müssen Sie zuerst die Eigenschaften definieren, die die Parameter darstellen. Im cmdlet Get-Proc ist der einzige Parameter Name, der in diesem Fall den Namen des abzurufenden .NET Framework-Prozessobjekts darstellt. Daher definiert die Cmdlet-Klasse eine Eigenschaft vom Typ Zeichenfolge, um ein Array von Namen zu akzeptieren.
Hier sehen Sie die Parameterdeklaration für den Name-Parameter des Cmdlets Get-Proc.
/// <summary>
/// Specify the cmdlet Name parameter.
/// </summary>
[Parameter(Position = 0)]
[ValidateNotNullOrEmpty]
public string[] Name
{
get { return processNames; }
set { processNames = value; }
}
private string[] processNames;
#endregion Parameters
<Parameter(Position:=0), ValidateNotNullOrEmpty()> _
Public Property Name() As String()
Get
Return processNames
End Get
Set(ByVal value As String())
processNames = value
End Set
End Property
Um die Windows PowerShell-Laufzeit darüber zu informieren, dass diese Eigenschaft der Name-Parameter ist, wird der Eigenschaftendefinition ein System.Management.Automation.ParameterAttribute-Attribut hinzugefügt. Die grundlegende Syntax zum Deklarieren dieses Attributs ist [Parameter()].
Hinweis
Ein Parameter muss explizit als öffentlich markiert werden. Parameter, die nicht als öffentliche Standardeinstellung für "intern" gekennzeichnet sind und von der Windows PowerShell-Laufzeit nicht gefunden werden.
Dieses Cmdlet verwendet ein Array von Zeichenfolgen für den parameter Name. Wenn möglich, sollte ihr Cmdlet auch einen Parameter als Array definieren, da dadurch das Cmdlet mehrere Elemente akzeptieren kann.
Wichtige Informationen zu Parameterdefinitionen
Vordefinierte Windows PowerShell-Parameternamen und Datentypen sollten so weit wie möglich wiederverwendet werden, um sicherzustellen, dass Ihr Cmdlet mit Windows PowerShell-Cmdlets kompatibel ist. Wenn beispielsweise alle Cmdlets den vordefinierten
IdParameternamen verwenden, um eine Ressource zu identifizieren, kann der Benutzer die Bedeutung des Parameters ganz einfach verstehen, unabhängig davon, welches Cmdlet sie verwenden. Im Grunde folgen Parameternamen den gleichen Regeln wie für Variablennamen in der Common Language Runtime (CLR). Weitere Informationen zur Parameterbenennung finden Sie unter Cmdlet Parameter Names.Windows PowerShell behält sich einige Parameternamen vor, um eine konsistente Benutzererfahrung bereitzustellen. Verwenden Sie diese Parameternamen nicht:
WhatIf,Confirm,Verbose,Debug,Warn,ErrorAction,ErrorVariable,OutVariableundOutBuffer. Darüber hinaus sind die folgenden Aliase für diese Parameternamen reserviert:vb,db,ea,ev,ovundob.Nameist ein einfacher und allgemeiner Parametername, der für die Verwendung in Ihren Cmdlets empfohlen wird. Es ist besser, einen Parameternamen wie diesen als einen komplexen Namen auszuwählen, der für ein bestimmtes Cmdlet eindeutig ist und schwer zu merken ist.Bei Parametern wird die Groß-/Kleinschreibung in Windows PowerShell nicht beachtet. Die Shell behält jedoch standardmäßig die Groß-/Kleinschreibung bei. Die Groß-/Kleinschreibung der Argumente hängt vom Vorgang des Cmdlets ab. Argumente werden an einen Parameter übergeben, wie in der Befehlszeile angegeben.
Beispiele für andere Parameterdeklarationen finden Sie unter Cmdlet Parameters.
Deklarieren von Parametern als Positional oder benannt
Ein Cmdlet muss jeden Parameter entweder als positionaler oder benannter Parameter festlegen. Beide Arten von Parametern akzeptieren einzelne Argumente, mehrere durch Kommas getrennte Argumente und boolesche Einstellungen. Ein boolescher Parameter, auch als Switchbezeichnet, behandelt nur boolesche Einstellungen. Der Schalter wird verwendet, um das Vorhandensein des Parameters zu bestimmen. Die empfohlene Standardeinstellung ist false.
Das Beispiel-cmdlet Get-Proc definiert den parameter Name als Positionsparameter mit Position 0. Dies bedeutet, dass das erste Argument, das der Benutzer in die Befehlszeile eingibt, automatisch für diesen Parameter eingefügt wird. Wenn Sie einen benannten Parameter definieren möchten, für den der Benutzer den Parameternamen aus der Befehlszeile angeben muss, lassen Sie das Position Schlüsselwort aus der Attributdeklaration.
Hinweis
Es sei denn, Parameter müssen benannt werden, es wird empfohlen, die am häufigsten verwendeten Parameter positional festzulegen, damit Benutzer den Parameternamen nicht eingeben müssen.
Deklarieren von Parametern als obligatorisch oder optional
Ein Cmdlet muss jeden Parameter entweder als optionaler oder obligatorischer Parameter festlegen. Im Beispiel-Get-Proc Cmdlet ist der parameter Name als optional definiert, da das schlüsselwort Mandatory in der Attributdeklaration nicht festgelegt ist.
Unterstützen der Parameterüberprüfung
Das Cmdlet Get-Proc Beispiel fügt dem Name Parameter ein Eingabeüberprüfungsattribut System.Management.Automation.ValidateNotNullOrEmptyAttributehinzu, um die Überprüfung zu ermöglichen, dass die Eingabe weder null noch leer ist. Dieses Attribut ist eines von mehreren Überprüfungsattributen, die von Windows PowerShell bereitgestellt werden. Beispiele für andere Überprüfungsattribute finden Sie unter Validating Parameter Input.
[Parameter(Position = 0)]
[ValidateNotNullOrEmpty]
public string[] Name
Überschreiben einer Eingabeverarbeitungsmethode
Wenn Ihr Cmdlet die Befehlszeileneingabe verarbeiten soll, muss es die entsprechenden Eingabeverarbeitungsmethoden überschreiben. Die grundlegenden Eingabeverarbeitungsmethoden werden in Creating Your First Cmdleteingeführt.
Das cmdlet Get-Proc setzt die System.Management.Automation.Cmdlet.ProcessRecord Methode außer Kraft, um die vom Benutzer oder einem Skript bereitgestellte Name Parametereingabe zu verarbeiten. Diese Methode ruft die Prozesse für jeden angeforderten Prozessnamen oder alle für Prozesse ab, wenn kein Name angegeben wird. Beachten Sie, dass in System.Management.Automation.Cmdlet.ProcessRecordder Aufruf von System.Management.Automation.Cmdlet.WriteObject der Ausgabemechanismus zum Senden von Ausgabeobjekten an die Pipeline ist. Der zweite Parameter dieses Aufrufs, enumerateCollection, ist auf true festgelegt, um die Windows PowerShell-Laufzeit zu informieren, um das Ausgabearray von Prozessobjekten auflisten und einen Prozess gleichzeitig in die Befehlszeile zu schreiben.
protected override void ProcessRecord()
{
// If no process names are passed to the cmdlet, get all processes.
if (processNames == null)
{
// Write the processes to the pipeline making them available
// to the next cmdlet. The second argument of this call tells
// PowerShell to enumerate the array, and send one process at a
// time to the pipeline.
WriteObject(Process.GetProcesses(), true);
}
else
{
// If process names are passed to the cmdlet, get and write
// the associated processes.
foreach (string name in processNames)
{
WriteObject(Process.GetProcessesByName(name), true);
}
}
}
Protected Overrides Sub ProcessRecord()
'/ If no process names are passed to the cmdlet, get all processes.
If processNames Is Nothing Then
Dim processes As Process()
processes = Process.GetProcesses()
End If
'/ If process names are specified, write the processes to the
'/ pipeline to display them or make them available to the next cmdlet.
For Each name As String In processNames
'/ The second parameter of this call tells PowerShell to enumerate the
'/ array, and send one process at a time to the pipeline.
WriteObject(Process.GetProcessesByName(name), True)
Next
End Sub 'ProcessRecord
Codebeispiel
Den vollständigen C#-Beispielcode finden Sie unter GetProcessSample02 Sample.
Definieren von Objekttypen und Formatierungen
Windows PowerShell übergibt Informationen zwischen Cmdlets mithilfe von .NET Framework-Objekten. Daher muss ein Cmdlet möglicherweise einen eigenen Typ definieren, oder ein Cmdlet muss möglicherweise einen vorhandenen Typ erweitern, der von einem anderen Cmdlet bereitgestellt wird. Weitere Informationen zum Definieren neuer Typen oder zum Erweitern vorhandener Typen finden Sie unter Erweitern von Objekttypen und Formatierungen.
Erstellen des Cmdlets
Nachdem Sie ein Cmdlet implementiert haben, müssen Sie es mit Windows PowerShell mithilfe eines Windows PowerShell-Snap-Ins registrieren. Weitere Informationen zum Registrieren von Cmdlets finden Sie unter Registrieren von Cmdlets, Anbietern und Hostanwendungen.
Testen des Cmdlets
Wenn Ihr Cmdlet mit Windows PowerShell registriert ist, können Sie es testen, indem Sie es in der Befehlszeile ausführen. Hier sind zwei Methoden zum Testen des Codes für das Beispiel-Cmdlet. Weitere Informationen zur Verwendung von Cmdlets über die Befehlszeile finden Sie unter Erste Schritte mit Windows PowerShell.
Verwenden Sie an der Windows PowerShell-Eingabeaufforderung den folgenden Befehl, um den Internet Explorer-Prozess mit dem Namen "IEXPLORE" auflisten zu können.
Get-Proc -Name iexploreDie folgende Ausgabe wird angezeigt.
Handles NPM(K) PM(K) WS(K) VS(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 354 11 10036 18992 85 0.67 3284 iexploreVerwenden Sie den folgenden Befehl, um die Prozesse Internet Explorer, Outlook und Editor mit dem Namen "IEXPLORE", "OUTLOOK" und "NOTEPAD" auflisten zu können. Wenn mehrere Prozesse vorhanden sind, werden alle angezeigt.
Get-Proc -Name iexplore, outlook, notepadDie folgende Ausgabe wird angezeigt.
Handles NPM(K) PM(K) WS(K) VS(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 732 21 24696 5000 138 2.25 2288 iexplore 715 19 20556 14116 136 1.78 3860 iexplore 3917 62 74096 58112 468 191.56 1848 OUTLOOK 39 2 1024 3280 30 0.09 1444 notepad 39 2 1024 356 30 0.08 3396 notepad
Siehe auch
Hinzufügen von Parametern, die die Pipelineeingabe verarbeiten
Erstellen Ihres ersten Cmdlets
Erweitern von Objekttypen und Formatierungen
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
