Aggiunta di parametri che elaborano gli input della pipeline
Un'origine di input per un cmdlet è un oggetto nella pipeline che ha origine da un cmdlet upstream. In questa sezione viene descritto come aggiungere un parametro al cmdlet Get-Proc (descritto in Creazione del primo cmdlet) in modo che il cmdlet possa elaborare oggetti pipeline.
Questo cmdlet Get-Proc usa un parametro Name che accetta l'input da un oggetto pipeline, recupera le informazioni sul processo dal computer locale in base ai nomi forniti e quindi visualizza informazioni sui processi nella riga di comando.
Definizione della classe cmdlet
Il primo passaggio della creazione dei cmdlet è sempre la denominazione del cmdlet e la dichiarazione della classe .NET che implementa il cmdlet . Questo cmdlet recupera le informazioni sul processo, quindi il nome del verbo scelto qui è "Get". Quasi qualsiasi tipo di cmdlet in grado di recuperare informazioni può elaborare l'input della riga di comando. Per altre informazioni sui verbi dei cmdlet approvati, vedere cmdlet Verb Names.
Di seguito è riportata la definizione di questo cmdlet Get-Proc. I dettagli di questa definizione vengono forniti in Creazione del primo cmdlet.
[Cmdlet(VerbsCommon.Get, "proc")]
public class GetProcCommand : Cmdlet
<Cmdlet(VerbsCommon.Get, "Proc")> _
Public Class GetProcCommand
Inherits Cmdlet
Definizione dell'input dalla pipeline
Questa sezione descrive come definire l'input dalla pipeline per un cmdlet. Questo cmdlet Get-Proc definisce una proprietà che rappresenta il parametro Name come descritto in Aggiunta di parametri che elaborano l'input della riga di comando.
Per informazioni generali sulla dichiarazione dei parametri, vedere questo argomento.
Tuttavia, quando un cmdlet deve elaborare l'input della pipeline, deve avere i relativi parametri associati ai valori di input dal runtime di Windows PowerShell. A tale scopo, è necessario aggiungere la parola chiave ValueFromPipeline o aggiungere la parola chiave ValueFromPipelineByProperty alla dichiarazione dell'attributo System.Management.Automation.ParameterAttribute. Specificare la parola chiave ValueFromPipeline se il cmdlet accede all'oggetto di input completo. Specificare il ValueFromPipelineByProperty se il cmdlet accede solo a una proprietà dell'oggetto .
Ecco la dichiarazione di parametro per il parametro Name di questo cmdlet Get-Proc che accetta l'input della pipeline.
[Parameter(
Position = 0,
ValueFromPipeline = true,
ValueFromPipelineByPropertyName = true)]
[ValidateNotNullOrEmpty]
public string[] Name
{
get { return this.processNames; }
set { this.processNames = value; }
}
<Parameter(Position:=0, ValueFromPipeline:=True, _
ValueFromPipelineByPropertyName:=True), ValidateNotNullOrEmpty()> _
Public Property Name() As String()
Get
Return processNames
End Get
Set(ByVal value As String())
processNames = value
End Set
End Property
La dichiarazione precedente imposta la parola chiave ValueFromPipeline su true in modo che il runtime di Windows PowerShell associa il parametro all'oggetto in ingresso se l'oggetto è lo stesso tipo del parametro o se può essere sottoposto a coercizione allo stesso tipo. La parola chiave ValueFromPipelineByPropertyName è impostata anche su true in modo che il runtime di Windows PowerShell controlli l'oggetto in ingresso per una proprietà Name. Se l'oggetto in ingresso ha tale proprietà, il runtime associa il parametro Name alla proprietà Name dell'oggetto in ingresso.
Nota
L'impostazione della parola chiave attributo ValueFromPipeline per un parametro ha la precedenza sull'impostazione per la parola chiave ValueFromPipelineByPropertyName.
Override di un metodo di elaborazione di input
Se il cmdlet deve gestire l'input della pipeline, deve eseguire l'override dei metodi di elaborazione di input appropriati. I metodi di elaborazione di input di base vengono introdotti in Creazione del primo cmdlet.
Questo cmdlet Get-Proc esegue l'override del metodo System.Management.Automation.Cmdlet.ProcessRecord per gestire l'input del parametro Name fornito dall'utente o da uno script. Questo metodo otterrà i processi per ogni nome di processo richiesto o tutti i processi se non viene specificato alcun nome. Si noti che all'interno di System.Management.Automation.Cmdlet.ProcessRecord, la chiamata a WriteObject(System.Object,System.Boolean) è il meccanismo di output per l'invio di oggetti di output alla pipeline. Il secondo parametro di questa chiamata, enumerateCollection, è impostato su true per indicare al runtime di Windows PowerShell di enumerare la matrice di oggetti processo e scrivere un processo alla volta nella riga di comando.
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);
} // End foreach (string name...).
}
}
Protected Overrides Sub ProcessRecord()
Dim processes As Process()
'/ If no process names are passed to the cmdlet, get all processes.
If processNames Is Nothing Then
processes = Process.GetProcesses()
Else
'/ 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 If
End Sub 'ProcessRecord
Codice di esempio
Per il codice di esempio C# completo, vedere Esempio getProcessSample03.
Definizione di tipi di oggetto e formattazione
Windows PowerShell passa informazioni tra i cmdlet usando oggetti .NET. Di conseguenza, un cmdlet potrebbe dover definire il proprio tipo oppure potrebbe essere necessario estendere un tipo esistente fornito da un altro cmdlet. Per altre informazioni sulla definizione di nuovi tipi o sull'estensione dei tipi esistenti, vedere Estensione dei tipi di oggetto e formattazione.
Compilazione del cmdlet
Dopo aver implementato un cmdlet deve essere registrato con Windows PowerShell tramite uno snap-in di Windows PowerShell. Per altre informazioni sulla registrazione dei cmdlet, vedere Come registrare cmdlet, provider e applicazioni host.
Test del cmdlet
Quando il cmdlet è stato registrato con Windows PowerShell, testarlo eseguendolo nella riga di comando. Ad esempio, testare il codice per il cmdlet di esempio. Per altre informazioni sull'uso dei cmdlet dalla riga di comando, vedere l'Introduzione a Windows PowerShell.
Al prompt di Windows PowerShell immettere i comandi seguenti per recuperare i nomi dei processi tramite la pipeline.
PS> type ProcessNames | Get-ProcViene visualizzato l'output seguente.
Handles NPM(K) PM(K) WS(K) VS(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 809 21 40856 4448 147 9.50 2288 iexplore 737 21 26036 16348 144 22.03 3860 iexplore 39 2 1024 388 30 0.08 3396 notepad 3927 62 71836 26984 467 195.19 1848 OUTLOOKImmettere le righe seguenti per ottenere gli oggetti processo con una proprietà
Namedai processi denominati "IEXPLORE". Questo esempio usa il cmdletGet-Process(fornito da Windows PowerShell) come comando upstream per recuperare i processi "IEXPLORE".PS> Get-Process iexplore | Get-ProcViene visualizzato l'output seguente.
Handles NPM(K) PM(K) WS(K) VS(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 801 21 40720 6544 142 9.52 2288 iexplore 726 21 25872 16652 138 22.09 3860 iexplore 801 21 40720 6544 142 9.52 2288 iexplore 726 21 25872 16652 138 22.09 3860 iexplore
Vedere anche
Aggiunta di parametri che elaborano l'input della riga di comando
l'estensione dei tipi di oggetto e la formattazione
Come registrare cmdlet, provider e applicazioni host
