Skriva en binär PowerShell-modul

En binär modul kan vara valfri sammansättning (.dll) som innehåller cmdlet-klasser. Som standard importeras alla cmdletar i sammansättningen när den binära modulen importeras. Du kan dock begränsa de cmdletar som importeras genom att skapa ett modulmanifest vars rotmodul är sammansättningen. (Till exempel kan nyckeln CmdletsToExport i manifestet endast användas för att exportera de cmdletar som behövs.) Dessutom kan en binär modul innehålla ytterligare filer, en katalogstruktur och andra användbara hanteringsinformationer som en enda cmdlet inte kan.

Följande procedur beskriver hur du skapar och installerar en Binär PowerShell-modul.

Så här skapar och installerar du en Binär PowerShell-modul

1. Skapa en binär PowerShell-lösning (till exempel en cmdlet skriven i C#), med de funktioner du behöver och se till att den körs korrekt.

   Ur ett kodperspektiv är kärnan i en binär modul helt enkelt en cmdlet-sammansättning. I själva verket behandlar PowerShell en enda cmdlet-sammansättning som en modul, när det gäller inläsning och avlastning, utan ytterligare arbete från utvecklarens sida. Mer information om hur du skriver en cmdlet finns i Skriva en Windows PowerShell-cmdlet.

2. Om det behövs skapar du resten av lösningen: (ytterligare cmdletar, XML-filer och så vidare) och beskriver dem med ett modulmanifest.

   Förutom att beskriva cmdlet-sammansättningarna i lösningen kan ett modulmanifest beskriva hur du vill att modulen ska exporteras och importeras, vilka cmdletar som ska exponeras och vilka ytterligare filer som ska gå in i modulen. Som tidigare nämnts kan PowerShell dock behandla en binär cmdlet som en modul utan ytterligare ansträngning. Därför är ett modulmanifest användbart främst för att kombinera flera filer till ett enda paket, eller för att uttryckligen styra publiceringen för en viss sammansättning. Mer information finns i Skriva ett PowerShell-modulmanifest.

   Följande kod är ett extremt enkelt C#-kodblock som innehåller tre cmdletar i samma fil som kan användas som en modul.

   using System.Management.Automation;           // Windows PowerShell namespace.
   
   namespace ModuleCmdlets
   {
     [Cmdlet(VerbsDiagnostic.Test,"BinaryModuleCmdlet1")]
     public class TestBinaryModuleCmdlet1Command : Cmdlet
     {
       protected override void BeginProcessing()
       {
         WriteObject("BinaryModuleCmdlet1 exported by the ModuleCmdlets module.");
       }
     }
   
     [Cmdlet(VerbsDiagnostic.Test, "BinaryModuleCmdlet2")]
     public class TestBinaryModuleCmdlet2Command : Cmdlet
     {
         protected override void BeginProcessing()
         {
             WriteObject("BinaryModuleCmdlet2 exported by the ModuleCmdlets module.");
         }
     }
   
     [Cmdlet(VerbsDiagnostic.Test, "BinaryModuleCmdlet3")]
     public class TestBinaryModuleCmdlet3Command : Cmdlet
     {
         protected override void BeginProcessing()
         {
             WriteObject("BinaryModuleCmdlet3 exported by the ModuleCmdlets module.");
         }
     }
   
   }
   

3. Paketera lösningen och spara paketet någonstans i PowerShell-modulsökvägen.

   Den PSModulePath globala miljövariabeln beskriver de standardsökvägar som PowerShell använder för att hitta modulen. En vanlig sökväg för att spara en modul i ett system skulle till exempel vara %SystemRoot%\Users\<user>\Documents\WindowsPowerShell\Modules\<moduleName>. Om du inte använder standardsökvägarna måste du uttryckligen ange platsen för modulen under installationen. Se till att skapa en mapp för att spara modulen i, eftersom du kan behöva mappen för att lagra flera sammansättningar och filer för din lösning.

   Observera att du tekniskt sett inte behöver installera modulen någonstans på PSModulePath – det är bara standardplatserna som PowerShell letar efter din modul på. Det anses dock vara bästa praxis att göra det, såvida du inte har en bra anledning att lagra modulen någon annanstans. Mer information finns i Installera en PowerShell-modul och about_PSModulePath.

4. Importera modulen till PowerShell med ett anrop till Import-Module.

   Om du anropar Import-Module läses modulen in i aktivt minne. Om du använder PowerShell 3.0 och senare importeras även namnet på din modul i koden. Mer information finns i Importera en PowerShell-modul.

Importera snapin-sammansättningar som moduler

Cmdletar och leverantörer som finns i snapin-sammansättningar kan läsas in som binära moduler. När snapin-modulsammansättningarna läses in som binära moduler är cmdletarna och leverantörerna i snapin-modulen tillgängliga för användaren, men snapin-klassen i sammansättningen ignoreras och snapin-modulen registreras inte. Därför kan snapin-cmdletarna som tillhandahålls av Windows PowerShell inte identifiera snapin-modulen trots att cmdletarna och leverantörerna är tillgängliga för sessionen.

Dessutom kan formatering eller typer av filer som refereras till av snapin-modulen inte importeras som en del av en binär modul. Om du vill importera formaterings- och typerna av filer måste du skapa ett modulmanifest. Se Skriva ett PowerShell-modulmanifest.

Se även

Skriva en Windows PowerShell-modul