Een binaire PowerShell-module schrijven

Een binaire module kan elke assembly (.dll) zijn die cmdlet-klassen bevat. Standaard worden alle cmdlets in de assembly geïmporteerd wanneer de binaire module wordt geïmporteerd. U kunt echter de cmdlets beperken die worden geïmporteerd door een modulemanifest te maken waarvan de hoofdmodule de assembly is. (De sleutel CmdletsToExport van het manifest kan bijvoorbeeld worden gebruikt om alleen de benodigde cmdlets te exporteren.) Bovendien kan een binaire module extra bestanden, een mapstructuur en andere nuttige beheerinformatie bevatten die niet door één cmdlet kan worden gebruikt.

In de volgende procedure wordt beschreven hoe u een binaire PowerShell-module maakt en installeert.

Een binaire PowerShell-module maken en installeren

1. Maak een binaire PowerShell-oplossing (zoals een cmdlet die is geschreven in C#), met de mogelijkheden die u nodig hebt en zorg ervoor dat deze correct wordt uitgevoerd.

   Vanuit codeperspectief is de kern van een binaire module gewoon een cmdlet-assembly. In feite behandelt PowerShell één cmdlet-assembly als een module, wat betreft het laden en lossen, zonder extra inspanningen van de ontwikkelaar. Zie Een Windows PowerShell-cmdlet schrijvenvoor meer informatie over het schrijven van een cmdlet.

2. Maak indien nodig de rest van uw oplossing: (extra cmdlets, XML-bestanden, enzovoort) en beschrijf deze met een modulemanifest.

   Naast het beschrijven van de cmdlet-assembly's in uw oplossing, kan een modulemanifest beschrijven hoe u de module wilt exporteren en importeren, welke cmdlets worden weergegeven en welke extra bestanden in de module worden opgenomen. Zoals eerder vermeld, kan PowerShell echter een binaire cmdlet behandelen zoals een module zonder extra inspanning. Een modulemanifest is daarom vooral handig voor het combineren van meerdere bestanden in één pakket of voor het expliciet beheren van de publicatie voor een bepaalde assembly. Zie Een PowerShell-modulemanifest schrijvenvoor meer informatie.

   De volgende code is een uiterst eenvoudig C#-codeblok met drie cmdlets in hetzelfde bestand dat kan worden gebruikt als een module.

   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. Pak uw oplossing in en sla het pakket ergens in het PowerShell-modulepad op.

   De PSModulePath globale omgevingsvariabele beschrijft de standaardpaden die powerShell gebruikt om uw module te vinden. Een algemeen pad voor het opslaan van een module op een systeem zou bijvoorbeeld %SystemRoot%\Users\<user>\Documents\WindowsPowerShell\Modules\<moduleName>zijn. Als u de standaardpaden niet gebruikt, moet u tijdens de installatie expliciet de locatie van uw module aangeven. Zorg ervoor dat u een map maakt waarin u de module wilt opslaan, omdat u mogelijk de map nodig hebt om meerdere assembly's en bestanden voor uw oplossing op te slaan.

   Houd er rekening mee dat u uw module technisch gezien niet hoeft te installeren op de PSModulePath. Dit zijn gewoon de standaardlocaties waar PowerShell naar uw module zoekt. Het wordt echter aanbevolen dit te doen, tenzij u een goede reden hebt om uw module ergens anders op te slaan. Zie Een PowerShell-module installeren en about_PSModulePathvoor meer informatie.

4. Importeer uw module in PowerShell met een aanroep naar Import-Module-.

   Als u aanroept naar importmodule, wordt uw module in het actieve geheugen geladen. Als u PowerShell 3.0 en hoger gebruikt, wordt deze ook geïmporteerd door de naam van uw module in code aan te roepen; Zie Een PowerShell-module importerenvoor meer informatie.

Module-assembly's importeren als modules

Cmdlets en providers die bestaan in moduleassembly's kunnen worden geladen als binaire modules. Wanneer de moduleassembly's als binaire modules worden geladen, zijn de cmdlets en providers in de module beschikbaar voor de gebruiker, maar wordt de moduleklasse in de assembly genegeerd en wordt de module niet geregistreerd. Als gevolg hiervan kunnen de module-cmdlets die worden geleverd door Windows PowerShell, de module niet detecteren, ook al zijn de cmdlets en providers beschikbaar voor de sessie.

Bovendien kunnen opmaakbestanden of typen bestanden waarnaar wordt verwezen door de module, niet worden geïmporteerd als onderdeel van een binaire module. Als u de opmaak en typen bestanden wilt importeren, moet u een modulemanifest maken. Zie Een PowerShell-modulemanifest schrijven.

Zie ook

een Windows PowerShell-module schrijven