Skapa en cmdlet utan parametrar

Artikel
03/25/2025

I det här avsnittet beskrivs hur du skapar en cmdlet som hämtar information från den lokala datorn utan att använda parametrar och sedan skriver informationen till pipelinen. Cmdleten som beskrivs här är en Get-Proc cmdlet som hämtar information om processer på den lokala datorn och sedan visar den informationen på kommandoraden.

Anmärkning

Tänk på att när du skriver cmdletar laddas Windows PowerShell-referenssammansättningarna® ned till disken (som standard på C:\Program Files\Reference Assemblies\Microsoft\WindowsPowerShell\v1.0). De är inte installerade i den globala sammansättningscachen (GAC).

Namnge cmdleten

Ett cmdlet-namn består av ett verb som anger vilken åtgärd cmdleten tar och ett substantiv som anger de objekt som cmdleten agerar på. Eftersom det här exemplet Get-Proc cmdlet hämtar processobjekt använder det verbet "Get", som definieras av System.Management.Automation.VerbsCommon uppräkning och substantivet "Proc" för att indikera att cmdleten fungerar på processobjekt.

När du namnger cmdletar ska du inte använda något av följande tecken: # , () {} [] & - /\ $ ; : " "<> | ? @ ` .

Välja ett substantiv

Du bör välja ett substantiv som är specifikt. Det är bäst att använda ett unikt substantiv prefix med en förkortad version av produktnamnet. Ett exempel på cmdletnamnet för den här typen är "Get-SQLServer".

Välja ett verb

Du bör använda ett verb från uppsättningen med godkända cmdlet-verbnamn. Mer information om de godkända cmdlet-verben finns i Cmdlet-verbnamn.

Definiera cmdlet-klassen

När du har valt ett cmdlet-namn definierar du en .NET-klass för att implementera cmdleten. Här är klassdefinitionen för det här exemplet Get-Proc cmdlet:

[Cmdlet(VerbsCommon.Get, "Proc")]
  public class GetProcCommand : Cmdlet

<Cmdlet(VerbsCommon.Get, "Proc")> _
Public Class GetProcCommand
    Inherits Cmdlet

Observera att tidigare än klassdefinitionen används attributet System.Management.Automation.CmdletAttribute, med syntaxen [Cmdlet(verb, noun, ...)], för att identifiera den här klassen som en cmdlet. Det här är det enda obligatoriska attributet för alla cmdletar och gör att Windows PowerShell-körningen kan anropa dem korrekt. Du kan ange attributnyckelord för att ytterligare deklarera klassen om det behövs. Tänk på att attributdeklarationen för vår getProcCommand-exempelklass endast deklarerar substantiv- och verbnamnen för cmdleten Get-Proc.

Anmärkning

För alla Windows PowerShell-attributklasser motsvarar de nyckelord som du kan ange egenskaper för attributklassen.

När du namnger klassen för cmdleten är det en bra idé att återspegla cmdlet-namnet i klassnamnet. Det gör du genom att använda formuläret "VerbNounCommand" och ersätta "Verb" och "Substantiv" med verbet och substantivet som används i cmdletens namn. Som visas i föregående klassdefinition definierar exempel-cmdleten Get-Proc en klass med namnet GetProcCommand, som härleds från System.Management.Automation.Cmdlet basklass.

Viktigt!

Om du vill definiera en cmdlet som kommer åt Windows PowerShell-körningen direkt bör .NET-klassen härledas från System.Management.Automation.PSCmdlet basklass. Mer information om den här klassen finns i Skapa en cmdlet som definierar parameteruppsättningar.

Anmärkning

Klassen för en cmdlet måste uttryckligen markeras som offentlig. Klasser som inte är markerade som offentliga kommer som standard att vara interna och kommer inte att hittas av Windows PowerShell-körningen.

Windows PowerShell använder Microsoft.PowerShell.Commands namnrymd för sina cmdlet-klasser. Vi rekommenderar att du placerar dina cmdlet-klasser i ett kommandonamnområde i ditt API-namnområde, till exempel xxx.PS. Kommandon.

Åsidosätta en indatabearbetningsmetod

Klassen System.Management.Automation.Cmdlet innehåller tre huvudsakliga indatabearbetningsmetoder, varav minst en måste åsidosättas av cmdleten. Mer information om hur Windows PowerShell bearbetar poster finns i Hur Windows PowerShell fungerar.

För alla typer av indata anropar Windows PowerShell-körningen System.Management.Automation.Cmdlet.BeginProcessing för att aktivera bearbetning. Om din cmdlet måste utföra viss förbearbetning eller konfiguration kan den göra detta genom att åsidosätta den här metoden.

Anmärkning

Windows PowerShell använder termen "post" för att beskriva den uppsättning parametervärden som anges när en cmdlet anropas.

Om cmdleten accepterar pipelineindata måste den åsidosätta metoden System.Management.Automation.Cmdlet.ProcessRecord och eventuellt metoden System.Management.Automation.Cmdlet.EndProcessing. En cmdlet kan till exempel åsidosätta båda metoderna om den samlar in alla indata med hjälp av System.Management.Automation.Cmdlet.ProcessRecord och sedan fungerar på indata som helhet i stället för ett element i taget, som cmdleten Sort-Object gör.

Om cmdleten inte tar pipelineindata bör den åsidosätta metoden System.Management.Automation.Cmdlet.EndProcessing. Tänk på att den här metoden ofta används i stället för System.Management.Automation.Cmdlet.BeginProcessing när cmdleten inte kan köras på ett element i taget, vilket är fallet för en sorterings-cmdlet.

Eftersom det här exemplet Get-Proc cmdlet måste ta emot pipelineindata åsidosätter den metoden System.Management.Automation.Cmdlet.ProcessRecord och använder standardimplementeringarna för System.Management.Automation.Cmdlet.BeginProcessing och System.Management.Automation.Cmdlet.EndProcessing. System.Management.Automation.Cmdlet.ProcessRecord åsidosätter hämtar processer och skriver dem till kommandoraden med hjälp av metoden System.Management.Automation.Cmdlet.WriteObj ect.

protected override void ProcessRecord()
{
  // Get the current processes
  Process[] processes = Process.GetProcesses();

  // Write the processes to the pipeline making them available
  // to the next cmdlet. The second parameter of this call tells
  // PowerShell to enumerate the array, and send one process at a
  // time to the pipeline.
  WriteObject(processes, true);
}

Protected Overrides Sub ProcessRecord()

    '/ Get the current processes.
    Dim processes As Process()
    processes = Process.GetProcesses()

    '/ Write the processes to the pipeline making them available
    '/ to the next cmdlet. The second parameter of this call tells
    '/ PowerShell to enumerate the array, and send one process at a
    '/ time to the pipeline.
    WriteObject(processes, True)

End Sub 'ProcessRecord

Saker att komma ihåg om indatabearbetning

Standardkällan för indata är ett explicit objekt (till exempel en sträng) som tillhandahålls av användaren på kommandoraden. Mer information finns i Skapa en cmdlet för att bearbeta kommandoradsindata.
En indatabearbetningsmetod kan också ta emot indata från utdataobjektet för en överordnad cmdlet på pipelinen. Mer information finns i Skapa en cmdlet för att bearbeta pipelineindata. Tänk på att din cmdlet kan ta emot indata från en kombination av kommandorads- och pipelinekällor.
Den underordnade cmdleten kanske inte returneras under en längre tid, eller inte alls. Därför bör indatabearbetningsmetoden i cmdleten inte innehålla lås under anrop till System.Management.Automation.Cmdlet.WriteObject, särskilt lås som omfånget sträcker sig utanför cmdlet-instansen.

Viktigt!

Cmdletar ska aldrig anropa System.Console.Writeline* eller motsvarande.

Din cmdlet kan ha objektvariabler som ska rensas när bearbetningen är klar (till exempel om den öppnar en filreferens i metoden System.Management.Automation.Cmdlet.BeginProcessing och håller handtaget öppet för användning av System.Management.Automation.Cmdlet.ProcessRecord). Det är viktigt att komma ihåg att Windows PowerShell-körningen inte alltid anropar metoden System.Management.Automation.Cmdlet.EndProcessing som ska utföra objektrensning.

Till exempel kanske System.Management.Automation.Cmdlet.EndProcessing kanske inte anropas om cmdleten avbryts halvvägs eller om ett avslutande fel inträffar i någon del av cmdleten. Därför bör en cmdlet som kräver objektrensning implementera det fullständiga System.IDisposable- mönster, inklusive finalizern, så att körningen kan anropa både System.Management.Automation.Cmdlet.EndProcessing och System.IDisposable.Dispose* i slutet av bearbetningen.

Kodexempel

Den fullständiga C#-exempelkoden finns i GetProcessSample01 Sample.

Definiera objekttyper och formatering

Windows PowerShell skickar information mellan cmdletar med hjälp av .NET-objekt. Därför kan en cmdlet behöva definiera sin egen typ, eller så kan cmdleten behöva utöka en befintlig typ som tillhandahålls av en annan cmdlet. Mer information om hur du definierar nya typer eller utökar befintliga typer finns i Utöka objekttyper och formatering.

Skapa cmdleten

När du har implementerat en cmdlet måste du registrera den med Windows PowerShell via en Windows PowerShell-snapin-modul. Mer information om hur du registrerar cmdletar finns i Så här registrerar du cmdletar, leverantörer och värdprogram.

Testa cmdleten

När din cmdlet har registrerats med Windows PowerShell kan du testa den genom att köra den på kommandoraden. Koden för vårt exempel Get-Proc cmdlet är liten, men den använder fortfarande Windows PowerShell-körningen och ett befintligt .NET-objekt, vilket räcker för att göra det användbart. Vi testar det för att bättre förstå vad Get-Proc kan göra och hur dess utdata kan användas. Mer information om hur du använder cmdletar från kommandoraden finns i Komma igång med Windows PowerShell.

Starta Windows PowerShell och få de aktuella processerna att köras på datorn.

Get-Proc

Följande utdata visas.

Handles  NPM(K)  PM(K)  WS(K)  VS(M)  CPU(s)  Id   ProcessName
-------  ------  -----  -----  -----  ------  --   ----------
254      7       7664   12048  66     173.75  1200  QCTRAY
32       2       1372   2628   31       0.04  1860  DLG
271      6       1216   3688   33       0.03  3816  lg
27       2       560    1920   24       0.01  1768  TpScrex
...

Tilldela en variabel till cmdlet-resultaten för enklare manipulering.
```
$p=Get-Proc
```
Hämta antalet processer.
```
$p.Length
```
Följande utdata visas.
```
63
```

Hämta en specifik process.

$p[6]

Följande utdata visas.

Handles  NPM(K)  PM(K)  WS(K)  VS(M)  CPU(s)  Id    ProcessName
-------  ------  -----  -----  -----  ------  --    -----------
1033     3       2400   3336   35     0.53    1588  rundll32

Hämta starttiden för den här processen.

$p[6].StartTime

Följande utdata visas.

Tuesday, July 26, 2005 9:34:15 AM

$p[6].StartTime.DayOfYear

Hämta de processer som referensantalet är större än 500 för och sortera resultatet.

$p | Where-Object {$_.HandleCount -gt 500 } | Sort-Object HandleCount

Följande utdata visas.

Handles  NPM(K)  PM(K)  WS(K)  VS(M)  CPU(s)  Id   ProcessName
-------  ------  -----  -----  -----  ------  --   ----------
568      14      2164   4972   39     5.55    824  svchost
716       7      2080   5332   28    25.38    468  csrss
761      21      33060  56608  440  393.56    3300 WINWORD
791      71      7412   4540   59     3.31    492  winlogon
...

Använd cmdleten Get-Member för att visa de egenskaper som är tillgängliga för varje process.

$p | Get-Member -MemberType Property

    TypeName: System.Diagnostics.Process

Följande utdata visas.

Name                     MemberType Definition
----                     ---------- ----------
BasePriority             Property   System.Int32 BasePriority {get;}
Container                Property   System.ComponentModel.IContainer Conta...
EnableRaisingEvents      Property   System.Boolean EnableRaisingEvents {ge...
...