Delen via

11. Modulen

Redactionele notitie

Belangrijk

De Windows PowerShell Language Specification 3.0 is gepubliceerd in december 2012 en is gebaseerd op Windows PowerShell 3.0. Deze specificatie geeft niet de huidige status van PowerShell weer. Er is geen plan om deze documentatie bij te werken om de huidige status weer te geven. Deze documentatie wordt hier gepresenteerd voor historische naslaginformatie.

Het specificatiedocument is beschikbaar als een Microsoft Word-document in het Microsoft Downloadcentrum op: https://www.microsoft.com/download/details.aspx?id=36389 Dat Word-document hier is geconverteerd voor presentatie in Microsoft Learn. Tijdens de conversie zijn enkele redactionele wijzigingen aangebracht om opmaak voor het Docs-platform mogelijk te maken. Sommige typfouten en kleine fouten zijn gecorrigeerd.

11.1 Inleiding

Zoals vermeld in §3.14, is een module een zelfstandige herbruikbare eenheid waarmee PowerShell-code kan worden gepartitioneerd, georganiseerd en geabstraheerd. Een module kan een of meer moduleledenbevatten. Dit zijn opdrachten (zoals cmdlets en functies) en items (zoals variabelen en aliassen). De namen van deze leden kunnen privé worden gehouden aan de module of ze kunnen worden geëxporteerd naar de sessie waarin de module wordt geïmporteerd.

Er zijn drie verschillende moduletypen: manifest, script en binair. Een manifestmodule is een bestand met informatie over een module en bepaalt bepaalde aspecten van het gebruik van die module. Een scriptmodule is een PowerShell-scriptbestand met een bestandsextensie van .psm1 in plaats van .ps1. Een binaire module bevat klassetypen die cmdlets en providers definiëren. In tegenstelling tot scriptmodules worden binaire modules geschreven in gecompileerde talen. Binaire modules vallen niet onder deze specificatie.

Een binaire module is een .NET-assembly (d.w.w.v. een DLL) die is gecompileerd op basis van de PowerShell-bibliotheken.

Modules kunnen nesten; Dat wil gezegd, één module kan een andere module importeren. Een module die geneste modules heeft verbonden, is een hoofdmodule.

Wanneer een PowerShell-sessie wordt gemaakt, worden standaard geen modules geïmporteerd.

Wanneer modules worden geïmporteerd, wordt het zoekpad dat wordt gebruikt om ze te vinden gedefinieerd door de omgevingsvariabele PSModulePath.

De volgende cmdlets hebben betrekking op modules:

11.2 Een scriptmodule schrijven

Een scriptmodule is een scriptbestand. Houd rekening met de volgende scriptmodule:

function Convert-CentigradeToFahrenheit ([double]$tempC) {
    return ($tempC * (9.0 / 5.0)) + 32.0
}
New-Alias c2f Convert-CentigradeToFahrenheit

function Convert-FahrenheitToCentigrade ([double]$tempF) {
    return ($tempF - 32.0) * (5.0 / 9.0)
}
New-Alias f2c Convert-FahrenheitToCentigrade

Export-ModuleMember -Function Convert-CentigradeToFahrenheit
Export-ModuleMember -Function Convert-FahrenheitToCentigrade
Export-ModuleMember -Alias c2f, f2c

Deze module bevat twee functies, die elk een alias hebben. Standaard worden alle functienamen en alleen functienamen geëxporteerd. Zodra de cmdlet Export-ModuleMember is gebruikt om iets te exporteren, worden alleen de geëxporteerde items expliciet geëxporteerd. Een reeks opdrachten en items kan worden geëxporteerd in één aanroep of een aantal aanroepen naar deze cmdlet; dergelijke aanroepen zijn cumulatief voor de huidige sessie.

11.3 Een scriptmodule installeren

Een scriptmodule wordt gedefinieerd in een scriptbestand en modules kunnen in elke map worden opgeslagen. De omgevingsvariabele PSModulePath verwijst naar een set mappen die moeten worden doorzocht wanneer modulegerelateerde cmdlets zoeken naar modules waarvan de namen geen volledig gekwalificeerd pad bevatten. Er kunnen aanvullende opzoekpaden worden opgegeven; bijvoorbeeld

$Env:PSModulePath = $Env:PSModulePath + ";<additional-path>"

Eventuele extra paden die worden toegevoegd, zijn alleen van invloed op de huidige sessie.

U kunt ook een volledig gekwalificeerd pad opgeven wanneer een module wordt geïmporteerd.

11.4 Een scriptmodule importeren

Voordat de resources in een module kunnen worden gebruikt, moet die module worden geïmporteerd in de huidige sessie met behulp van de cmdlet Import-Module. Import-Module kan de resources beperken die het daadwerkelijk importeert.

Wanneer een module wordt geïmporteerd, wordt het scriptbestand uitgevoerd. Dit proces kan worden geconfigureerd door een of meer parameters in het scriptbestand te definiëren en bijbehorende argumenten door te geven via de parameter ArgumentList van Import-Module.

Houd rekening met het volgende script dat gebruikmaakt van deze functies en aliassen die zijn gedefinieerd in §11.2:

Import-Module 'E:\Scripts\Modules\PSTest_Temperature' -Verbose

"0 degrees C is " + (Convert-CentigradeToFahrenheit 0) + " degrees F"
"100 degrees C is " + (c2f 100) + " degrees F"
"32 degrees F is " + (Convert-FahrenheitToCentigrade 32) + " degrees C"
"212 degrees F is " + (f2c 212) + " degrees C"

Het importeren van een module veroorzaakt een naamconflict wanneer opdrachten of items in de module dezelfde namen hebben als opdrachten of items in de sessie. Een naamconflict resulteert in een naam die wordt verborgen of vervangen. De parameter Voorvoegsel van Import-Module kan worden gebruikt om naamconflicten te voorkomen. Bovendien kunnen de parameters Alias, Cmdlet, Functionen parameters Variabele de selectie van opdrachten beperken, waardoor de kans op naamconflicten wordt verminderd.

Zelfs als een opdracht is verborgen, kan deze worden uitgevoerd door de naam ervan te kwalificeren met de naam van de module waarin deze is ontstaan. & M\F 100 roept bijvoorbeeld de functie aan F- in module Men geeft het argument 100 door.

Wanneer de sessie opdrachten van hetzelfde type bevat met dezelfde naam, zoals twee cmdlets met dezelfde naam, wordt standaard de laatst toegevoegde opdracht uitgevoerd.

Zie §3.5.6 voor een bespreking van het bereik in verband met modules.

11.5 Een scriptmodule verwijderen

Een of meer modules kunnen worden verwijderd uit een sessie via de cmdlet Remove-Module.

Als u een module verwijdert, wordt de module niet verwijderd.

In een scriptmodule is het mogelijk om code op te geven die moet worden uitgevoerd voordat de module wordt verwijderd, als volgt:

$MyInvocation.MyCommand.ScriptBlock.Module.OnRemove = { *on-removal-code* }

11.6 Modulemanifesten

Zoals vermeld in §11.1, is een manifestmodule een bestand met informatie over een module en bepaalt bepaalde aspecten van het gebruik van die module.

Een module hoeft geen corresponderend manifest te hebben, maar als dat het geval is, heeft dat manifest dezelfde naam als de module die wordt beschreven, maar met een .psd1 bestandsextensie.

Een manifest bevat een beperkte subset van een PowerShell-script, dat een hashtabel retourneert die een set sleutels bevat. Deze sleutels en de bijbehorende waarden bepalen de manifestelementen voor die module. Dat wil gezegd, ze beschrijven de inhoud en kenmerken van de module, definiëren eventuele vereisten en bepalen hoe de onderdelen worden verwerkt.

In wezen is een manifest een gegevensbestand; Het kan echter verwijzingen bevatten naar gegevenstypen, de if-instructie en de rekenkundige en vergelijkingsoperatoren. (Toewijzingen, functiedefinities en -lussen zijn niet toegestaan.) Een manifest heeft ook leestoegang tot omgevingsvariabelen en kan aanroepen naar de cmdlet Join-Pathbevatten, zodat paden kunnen worden samengesteld.

Notitie

Opmerking van editor: het oorspronkelijke document bevat een lijst met sleutels die zijn toegestaan in een modulemanifestbestand. Deze lijst is verouderd en onvolledig. Zie New-ModuleManifestvoor een volledige lijst met sleutels in een modulemanifest.

De enige sleutel die vereist is, is ModuleVersion.

Hier volgt een voorbeeld van een eenvoudig manifest:

@{
ModuleVersion = '1.0'
Author = 'John Doe'
RequiredModules = @()
FunctionsToExport = 'Set*','Get*','Process*'
}

De sleutel GUID- heeft een string waarde. Hiermee geeft u een GUID (Globally Unique IDentifier) voor de module op. De GUID- kan worden gebruikt om onderscheid te maken tussen modules met dezelfde naam. Als u een nieuwe GUID wilt maken, roept u de methode aan [guid]::NewGuid().

11.7 Dynamische modules

Een dynamische module is een module die tijdens runtime in het geheugen wordt gemaakt door de cmdlet New-Module; het is niet geladen vanaf schijf. Bekijk het volgende voorbeeld:

$sb = {
    function Convert-CentigradeToFahrenheit ([double]$tempC) {
        return ($tempC * (9.0 / 5.0)) + 32.0
    }

    New-Alias c2f Convert-CentigradeToFahrenheit

    function Convert-FahrenheitToCentigrade ([double]$tempF) {
        return ($tempF - 32.0) * (5.0 / 9.0)
    }

    New-Alias f2c Convert-FahrenheitToCentigrade

    Export-ModuleMember -Function Convert-CentigradeToFahrenheit
    Export-ModuleMember -Function Convert-FahrenheitToCentigrade
    Export-ModuleMember -Alias c2f, f2c
}

New-Module -Name MyDynMod -ScriptBlock $sb
Convert-CentigradeToFahrenheit 100
c2f 100

Het scriptblok $sb definieert de inhoud van de module, in dit geval twee functies en twee aliassen voor deze functies. Net als bij een module op schijf worden alleen functies standaard geëxporteerd, dus Export-ModuleMember cmdlets-aanroepen bestaan om zowel de functies als de aliassen te exporteren.

Zodra New-Module wordt uitgevoerd, zijn de vier geëxporteerde namen beschikbaar voor gebruik in de sessie, zoals wordt weergegeven door de aanroepen naar de Convert-CentigradeToFahrenheit en c2f.

Net als alle modules worden de leden van dynamische modules uitgevoerd in een private modulescope die een onderliggend element van de globale scope is. Get-Module kan geen dynamische module ophalen, maar Get-Command kunnen de geëxporteerde leden ophalen.

Als u een dynamische module beschikbaar wilt maken voor Get-Module, geeft u een New-Module opdracht door om Import-Moduleof sluist u het moduleobject dat New-Module retourneert, door naar Import-Module. Met deze actie wordt de dynamische module toegevoegd aan de Get-Module lijst, maar de module wordt niet op de schijf opgeslagen of permanent gemaakt.

11.8 Sluitingen

Een dynamische module kan worden gebruikt om een sluitingte maken, een functie met gekoppelde gegevens. Bekijk het volgende voorbeeld:

function Get-NextID ([int]$StartValue = 1) {
    $nextID = $StartValue
    {
        ($Script:nextID++)
    }.GetNewClosure()
}

$v1 = Get-NextID      # get a scriptblock with $StartValue of 0
& $v1                 # invoke Get-NextID getting back 1
& $v1                 # invoke Get-NextID getting back 2

$v2 = Get-NextID 100  # get a scriptblock with $StartValue of 100
& $v2                 # invoke Get-NextID getting back 100
& $v2                 # invoke Get-NextID getting back 101

De intentie hier is dat Get-NextID de volgende id in een reeks retourneert waarvan de beginwaarde kan worden opgegeven. Er moeten echter meerdere reeksen worden ondersteund, elk met een eigen $StartValue en $nextID context. Dit wordt bereikt door de aanroep van de methode [scriptblock]::GetNewClosure (§4.3.7).

Telkens wanneer er een nieuwe sluiting wordt gemaakt door GetNewClosure, wordt er een nieuwe dynamische module gemaakt en worden de variabelen in het bereik van de aanroeper (in dit geval het scriptblok met de increment) gekopieerd naar deze nieuwe module. Om ervoor te zorgen dat de nextId die is gedefinieerd in de bovenliggende functie (maar buiten het scriptblok) wordt verhoogd, is het expliciete Script: scope-prefix nodig.

Natuurlijk hoeft het scriptblok geen benoemde functie te zijn; bijvoorbeeld:

$v3 = & {      # get a scriptblock with $StartValue of 200
    param ([int]$StartValue = 1)
    $nextID = $StartValue
    {
        ($Script:nextID++)
    }.GetNewClosure()
} 200

& $v3          # invoke script getting back 200
& $v3          # invoke script getting back 201
  • Last updated on