Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Informazioni sui set di parametri
Windows PowerShell definisce un set di parametri come gruppo di parametri che operano insieme. Raggruppando i parametri di un cmdlet, è possibile creare un singolo cmdlet in grado di modificarne le funzionalità in base al gruppo di parametri specificato dall'utente.
Un esempio di cmdlet che usa due set di parametri per definire funzionalità diverse è il cmdlet Get-EventLog fornito da Windows PowerShell. Questo cmdlet restituisce informazioni diverse quando l'utente specifica il parametro List o LogName. Se viene specificato il parametro LogName, il cmdlet restituisce informazioni sugli eventi in un determinato registro eventi. Se viene specificato il parametro List, il cmdlet restituisce informazioni sui file di log stessi (non sulle informazioni sugli eventi che contengono). In questo caso, i parametri List e LogName identificano due set di parametri separati.
Due aspetti importanti da ricordare sui set di parametri è che il runtime di Windows PowerShell usa un solo set di parametri per un determinato input e che ogni set di parametri deve avere almeno un parametro univoco per tale set di parametri.
Per illustrare l'ultimo punto, questo cmdlet Stop-Proc usa tre set di parametri: ProcessName, ProcessIde InputObject. Ognuno di questi set di parametri ha un parametro che non si trova negli altri set di parametri. I set di parametri possono condividere altri parametri, ma il cmdlet usa i parametri univoci ProcessName, ProcessIde InputObject per identificare quale set di parametri deve usare il runtime di Windows PowerShell.
Dichiarazione 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 . Per questo cmdlet viene usato il verbo "Stop" del ciclo di vita perché il cmdlet arresta i processi di sistema. Il nome sostantivo "Proc" viene usato perché il cmdlet funziona sui processi. Nella dichiarazione seguente si noti che il verbo del cmdlet e il nome sostantivo si riflettono nel nome della classe cmdlet.
Nota
Per altre informazioni sui nomi dei verbi dei cmdlet approvati, vedere Cmdlet Verb Names.
Il codice seguente è la definizione della classe per questo cmdlet Stop-Proc.
[Cmdlet(VerbsLifecycle.Stop, "Proc",
DefaultParameterSetName = "ProcessId",
SupportsShouldProcess = true)]
public class StopProcCommand : PSCmdlet
<Cmdlet(VerbsLifecycle.Stop, "Proc", DefaultParameterSetName:="ProcessId", _
SupportsShouldProcess:=True)> _
Public Class StopProcCommand
Inherits PSCmdlet
Dichiarazione dei parametri del cmdlet
Questo cmdlet definisce tre parametri necessari come input per il cmdlet (questi parametri definiscono anche i set di parametri), nonché un parametro Force che gestisce le operazioni del cmdlet e un parametro PassThru che determina se il cmdlet invia un oggetto di output tramite la pipeline. Per impostazione predefinita, questo cmdlet non passa un oggetto attraverso la pipeline. Per altre informazioni su questi ultimi due parametri, vedere Creazione di un cmdlet che modifica l'di sistema.
Dichiarazione del parametro Name
Questo parametro di input consente all'utente di specificare i nomi dei processi da arrestare. Si noti che la parola chiave dell'attributo ParameterSetName dell'attributo System.Management.Automation.ParameterAttribute specifica il parametro ProcessName impostato per questo parametro.
[Parameter(
Position = 0,
ParameterSetName = "ProcessName",
Mandatory = true,
ValueFromPipeline = true,
ValueFromPipelineByPropertyName = true,
HelpMessage = "The name of one or more processes to stop. Wildcards are permitted."
)]
[Alias("ProcessName")]
public string[] Name
{
get { return processNames; }
set { processNames = value; }
}
private string[] processNames;
<Parameter(Position:=0, ParameterSetName:="ProcessName", _
Mandatory:=True, _
ValueFromPipeline:=True, ValueFromPipelineByPropertyName:=True, _
HelpMessage:="The name of one or more processes to stop. " & _
"Wildcards are permitted."), [Alias]("ProcessName")> _
Public Property Name() As String()
Get
Return processNames
End Get
Set(ByVal value As String())
processNames = value
End Set
End Property
Private processNames() As String
Si noti anche che all'alias "ProcessName" viene assegnato questo parametro.
Dichiarazione del parametro ID
Questo parametro di input consente all'utente di specificare gli identificatori dei processi da arrestare. Si noti che la parola chiave dell'attributo ParameterSetName dell'attributo System.Management.Automation.ParameterAttribute specifica il set di parametri ProcessId.
[Parameter(
ParameterSetName = "ProcessId",
Mandatory = true,
ValueFromPipelineByPropertyName = true,
ValueFromPipeline = true
)]
[Alias("ProcessId")]
public int[] Id
{
get { return processIds; }
set { processIds = value; }
}
private int[] processIds;
<Parameter(ParameterSetName:="ProcessId", _
Mandatory:=True, _
ValueFromPipelineByPropertyName:=True, _
ValueFromPipeline:=True), [Alias]("ProcessId")> _
Public Property Id() As Integer()
Get
Return processIds
End Get
Set(ByVal value As Integer())
processIds = value
End Set
End Property
Private processIds() As Integer
Si noti anche che l'alias "ProcessId" viene assegnato a questo parametro.
Dichiarazione del parametro InputObject
Questo parametro di input consente all'utente di specificare un oggetto di input che contiene informazioni sui processi da arrestare. Si noti che la parola chiave dell'attributo ParameterSetName dell'attributo System.Management.Automation.ParameterAttribute specifica il parametro InputObject impostato per questo parametro.
[Parameter(
ParameterSetName = "InputObject",
Mandatory = true,
ValueFromPipeline = true)]
public Process[] InputObject
{
get { return inputObject; }
set { inputObject = value; }
}
private Process[] inputObject;
<Parameter(ParameterSetName:="InputObject", _
Mandatory:=True, ValueFromPipeline:=True)> _
Public Property InputObject() As Process()
Get
Return myInputObject
End Get
Set(ByVal value As Process())
myInputObject = value
End Set
End Property
Private myInputObject() As Process
Si noti anche che questo parametro non ha alias.
Dichiarazione di parametri in più set di parametri
Anche se deve essere presente un parametro univoco per ogni set di parametri, i parametri possono appartenere a più set di parametri. In questi casi assegnare al parametro condiviso un dichiarazione di attributo System.Management.Automation.ParameterAttribute per ogni set a cui appartiene il parametro. Se un parametro si trova in tutti i set di parametri, è necessario dichiarare l'attributo del parametro una sola volta e non è necessario specificare il nome del set di parametri.
Override di un metodo di elaborazione di input
Ogni cmdlet deve eseguire l'override di un metodo di elaborazione di input, spesso si tratta del metodo System.Management.Automation.Cmdlet.ProcessRecord. In questo cmdlet viene eseguito l'override del metodo System.Management.Automation.Cmdlet.ProcessRecord in modo che il cmdlet possa elaborare un numero qualsiasi di processi. Contiene un'istruzione Select che chiama un metodo diverso in base al parametro specificato dall'utente.
protected override void ProcessRecord()
{
switch (ParameterSetName)
{
case "ProcessName":
ProcessByName();
break;
case "ProcessId":
ProcessById();
break;
case "InputObject":
foreach (Process process in inputObject)
{
SafeStopProcess(process);
}
break;
default:
throw new ArgumentException("Bad ParameterSet Name");
} // switch (ParameterSetName...
} // ProcessRecord
Protected Overrides Sub ProcessRecord()
Select Case ParameterSetName
Case "ProcessName"
ProcessByName()
Case "ProcessId"
ProcessById()
Case "InputObject"
Dim process As Process
For Each process In myInputObject
SafeStopProcess(process)
Next process
Case Else
Throw New ArgumentException("Bad ParameterSet Name")
End Select
End Sub 'ProcessRecord ' ProcessRecord
I metodi helper chiamati dall'istruzione Select non sono descritti qui, ma è possibile visualizzare la relativa implementazione nell'esempio di codice completo nella sezione successiva.
Codice di esempio
Per il codice di esempio C# completo, vedere esempio StopProcessSample04.
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, è necessario registrarlo 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. Di seguito sono riportati alcuni test che illustrano come usare i parametri ProcessId e InputObject per testare i set di parametri per arrestare un processo.
Con Windows PowerShell avviato, eseguire il cmdlet Stop-Proc con il parametro
ProcessIdimpostato per arrestare un processo in base al relativo identificatore. In questo caso, il cmdlet usa il parametroProcessIdimpostato per arrestare il processo.PS> Stop-Proc -Id 444 Confirm Are you sure you want to perform this action? Performing operation "Stop-Proc" on Target "notepad (444)". [Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"): YCon Windows PowerShell avviato, eseguire il cmdlet Stop-Proc con il parametro
InputObjectimpostato per arrestare i processi nell'oggetto Blocco note recuperato dal comandoGet-Process.PS> Get-Process notepad | Stop-Proc Confirm Are you sure you want to perform this action? Performing operation "Stop-Proc" on Target "notepad (444)". [Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"): N
Vedere anche
Creazione di un cmdlet che modifica il di sistema
Come creare un cmdlet di Windows PowerShell
l'estensione dei tipi di oggetto e la formattazione
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
