Get-Module

  • Referens
Modul:
Microsoft.PowerShell.Core

Visa en lista över de moduler som importerats i den aktuella sessionen eller som kan importeras från PSModulePath.

Syntax

Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-All]
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-All]
   [-ListAvailable]
   [-PSEdition <String>]
   [-SkipEditionCheck]
   [-Refresh]
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-ListAvailable]
   [-PSEdition <String>]
   [-SkipEditionCheck]
   [-Refresh]
   -PSSession <PSSession>
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-ListAvailable]
   [-SkipEditionCheck]
   [-Refresh]
   -CimSession <CimSession>
   [-CimResourceUri <Uri>]
   [-CimNamespace <String>]
   [<CommonParameters>]

Description

Cmdleten Get-Module visar de PowerShell-moduler som har importerats, eller som kan importeras, till en PowerShell-session. Utan parametrar Get-Module hämtar du moduler som har importerats till den aktuella sessionen. Parametern ListAvailable används för att visa de moduler som är tillgängliga för import från sökvägarna som anges i miljövariabeln PSModulePath ().$env:PSModulePath

Modulobjektet som Get-Module returnerar innehåller värdefull information om modulen. Du kan också skicka modulobjekten till andra cmdletar, till exempel Import-Module cmdletarna och Remove-Module .

Get-Module listar moduler, men importerar dem inte. Från och med Windows PowerShell 3.0 importeras moduler automatiskt när du använder ett kommando i modulen, men ett Get-Module kommando utlöser inte någon automatisk import. Du kan också importera modulerna till sessionen med hjälp av cmdleten Import-Module .

Från och med Windows PowerShell 3.0 kan du hämta och sedan importera moduler från fjärrsessioner till den lokala sessionen. Den här strategin använder funktionen Implicit fjärrkommunikation i PowerShell och motsvarar cmdleten Import-PSSession . När du använder kommandon i moduler som importerats från en annan session körs kommandona implicit i fjärrsessionen. Med den här funktionen kan du hantera fjärrdatorn från den lokala sessionen.

Från och med Windows PowerShell 3.0 kan du också använda Get-Module och Import-Module hämta och importera CIM-moduler (Common Information Model). CIM-moduler definierar cmdletar i CDXML-filer (Cmdlet Definition XML). Med den här funktionen kan du använda cmdletar som implementeras i icke-hanterade kodsammansättningar, till exempel de som skrivits i C++.

Implicit fjärrkommunikation kan användas för att hantera fjärrdatorer som har PowerShell-fjärrkommunikation aktiverat. Skapa en PSSession på fjärrdatorn och använd sedan PSSession-parametern Get-Module för för att hämta PowerShell-modulerna i fjärrsessionen. När du importerar en modul från fjärrsessionen körs de importerade kommandona i sessionen på fjärrdatorn.

Du kan använda en liknande strategi för att hantera datorer som inte har PowerShell-fjärrkommunikation aktiverat. Dessa omfattar datorer som inte kör Windows-operativsystemet och datorer som har PowerShell men som inte har PowerShell-fjärrkommunikation aktiverat.

Börja med att skapa en CIM-session på fjärrdatorn. En CIM-session är en anslutning till Windows Management Instrumentation (WMI) på fjärrdatorn. Använd sedan CIMSession-parametern Get-Module för för att hämta CIM-moduler från CIM-sessionen. När du importerar en CIM-modul med hjälp av cmdleten Import-Module och sedan kör de importerade kommandona körs kommandona implicit på fjärrdatorn. Du kan använda den här WMI- och CIM-strategin för att hantera fjärrdatorn.

Exempel

Exempel 1: Hämta moduler som importerats till den aktuella sessionen

Get-Module

Det här kommandot hämtar moduler som har importerats till den aktuella sessionen.

Exempel 2: Hämta installerade moduler och tillgängliga moduler

Get-Module -ListAvailable

Det här kommandot hämtar de moduler som är installerade på datorn och kan importeras till den aktuella sessionen.

Get-Module söker efter tillgängliga moduler i sökvägen som anges av miljövariabeln $env:PSModulePath . Mer information om PSModulePath finns i about_Modules och about_Environment_Variables.

Exempel 3: Hämta alla exporterade filer

Get-Module -ListAvailable -All

Det här kommandot hämtar alla exporterade filer för alla tillgängliga moduler.

Exempel 4: Hämta en modul med dess fullständigt kvalificerade namn

$FullyQualifiedName = @{ModuleName="Microsoft.PowerShell.Management";ModuleVersion="3.1.0.0"}
Get-Module -FullyQualifiedName $FullyQualifiedName | Format-Table -Property Name,Version

Name                             Version
----                             -------
Microsoft.PowerShell.Management  3.1.0.0

Det här exemplet hämtar modulen Microsoft.PowerShell.Management genom att ange modulens fullständigt kvalificerade namn med parametern FullyQualifiedName . Kommandot skickar sedan resultatet till cmdleten Format-Table för att formatera resultatet som en tabell med Namn och Version som kolumnrubriker.

I ett fullständigt kvalificerat namn för en modul fungerar värdet ModuleVersion som lägsta version. I det här exemplet matchar den därför alla Microsoft.PowerShell.Management-moduler som är version 3.1.0.0 eller högre.

Exempel 5: Hämta egenskaper för en modul

Get-Module | Get-Member -MemberType Property | Format-Table Name

Name
----
AccessMode
Author
ClrVersion
CompanyName
Copyright
Definition
Description
DotNetFrameworkVersion
ExportedAliases
ExportedCmdlets
ExportedCommands
ExportedFormatFiles
ExportedFunctions
ExportedTypeFiles
ExportedVariables
ExportedWorkflows
FileList
Guid
HelpInfoUri
LogPipelineExecutionDetails
ModuleBase
ModuleList
ModuleType
Name
NestedModules
OnRemove
Path
PowerShellHostName
PowerShellHostVersion
PowerShellVersion
PrivateData
ProcessorArchitecture
RequiredAssemblies
RequiredModules
RootModule
Scripts
SessionState
Version

Det här kommandot hämtar egenskaperna för PSModuleInfo-objektet som Get-Module returneras. Det finns ett objekt för varje modulfil.

Du kan använda egenskaperna för att formatera och filtrera modulobjekten. Mer information om egenskaperna finns i PSModuleInfo-egenskaper.

Utdata innehåller de nya egenskaperna, till exempel Author och CompanyName, som introducerades i Windows PowerShell 3.0.

Exempel 6: Gruppera alla moduler efter namn

Get-Module -ListAvailable -All | Format-Table -Property Name, Moduletype, Path -Groupby Name

Name: AppLocker

Name      ModuleType Path
----      ---------- ----
AppLocker   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\AppLocker\AppLocker.psd1


   Name: Appx

Name ModuleType Path
---- ---------- ----
Appx   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\en-US\Appx.psd1
Appx   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\Appx.psd1
Appx     Script C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\Appx.psm1


   Name: BestPractices

Name          ModuleType Path
----          ---------- ----
BestPractices   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\BestPractices\BestPractices.psd1


   Name: BitsTransfer

Name         ModuleType Path
----         ---------- ----
BitsTransfer   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\BitsTransfer\BitsTransfer.psd1

Det här kommandot hämtar alla modulfiler, både importerade och tillgängliga, och grupperar dem sedan efter modulnamn. På så sätt kan du se de modulfiler som varje skript exporterar.

Exempel 7: Visa innehållet i ett modulmanifest

Dessa kommandon visar innehållet i modulmanifestet för Windows PowerShell BitsTransfer-modulen .

Moduler krävs inte för att ha manifestfiler. När de har en manifestfil krävs manifestfilen endast för att inkludera ett versionsnummer. Manifestfiler ger dock ofta användbar information om en modul, dess krav och dess innehåll.

# First command
$m = Get-Module -list -Name BitsTransfer

# Second command
Get-Content $m.Path

@ {
    GUID               = "{8FA5064B-8479-4c5c-86EA-0D311FE48875}"
    Author             = "Microsoft Corporation"
    CompanyName        = "Microsoft Corporation"
    Copyright          = "Microsoft Corporation. All rights reserved."
    ModuleVersion      = "1.0.0.0"
    Description        = "Windows PowerShell File Transfer Module"
    PowerShellVersion  = "2.0"
    CLRVersion         = "2.0"
    NestedModules      = "Microsoft.BackgroundIntelligentTransfer.Management"
    FormatsToProcess   = "FileTransfer.Format.ps1xml"
    RequiredAssemblies = Join-Path $psScriptRoot "Microsoft.BackgroundIntelligentTransfer.Management.Interop.dll"
}

Det första kommandot hämtar PSModuleInfo-objektet som representerar BitsTransfer-modulen. Objektet sparas i variabeln $m .

Det andra kommandot använder cmdleten Get-Content för att hämta innehållet i manifestfilen i den angivna sökvägen. Den använder punkt notation för att hämta sökvägen till manifestfilen, som lagras i path-egenskapen för objektet. Utdata visar innehållet i modulmanifestet.

Exempel 8: Lista filer i modulkatalogen

dir (Get-Module -ListAvailable FileTransfer).ModuleBase

Directory: C:\Windows\system32\WindowsPowerShell\v1.0\Modules\FileTransfer
Mode                LastWriteTime     Length Name
----                -------------     ------ ----
d----        12/16/2008  12:36 PM            en-US
-a---        11/19/2008  11:30 PM      16184 FileTransfer.Format.ps1xml
-a---        11/20/2008  11:30 PM       1044 FileTransfer.psd1
-a---        12/16/2008  12:20 AM     108544 Microsoft.BackgroundIntelligentTransfer.Management.Interop.dll

Det här kommandot visar filerna i katalogen i modulen. Det här är ett annat sätt att avgöra vad som finns i en modul innan du importerar den. Vissa moduler kan ha hjälpfiler eller ReadMe-filer som beskriver modulen.

Exempel 9: Hämta moduler installerade på en dator

$s = New-PSSession -ComputerName Server01

Get-Module -PSSession $s -ListAvailable

Dessa kommandon hämtar de moduler som är installerade på Server01-datorn.

Det första kommandot använder cmdleten New-PSSession för att skapa en PSSession på Server01-datorn. Kommandot sparar PSSession i variabeln $s .

Det andra kommandot använder parametrarna PSSession och ListAvailable för för att hämta modulerna i PSSession i variabeln$s.Get-Module

Om du dirigerar moduler från andra sessioner till cmdleten Import-ModuleImport-Module importerar du modulen till den aktuella sessionen med hjälp av den implicita fjärrkommunikationsfunktionen. Detta motsvarar att använda cmdleten Import-PSSession . Du kan använda cmdletarna från modulen i den aktuella sessionen, men kommandon som använder dessa cmdletar kör faktiskt fjärrsessionen. Mer information finns i Import-Module och Import-PSSession.

Exempel 10: Hantera en dator som inte kör Windows-operativsystemet

Med kommandona i det här exemplet kan du hantera lagringssystemen på en fjärrdator som inte kör Windows-operativsystemet. I det här exemplet kan CIM-kommandona använda standardvärdena, som är utformade för providern, eftersom administratören för datorn har installerat WMI-providern Module Discovery.

$cs = New-CimSession -ComputerName RSDGF03
Get-Module -CimSession $cs -Name Storage | Import-Module
Get-Command Get-Disk

CommandType     Name                  ModuleName
-----------     ----                  ----------
Function        Get-Disk              Storage

Get-Disk

Number Friendly Name              OperationalStatus          Total Size Partition Style
------ -------------              -----------------          ---------- ---------------
0      Virtual HD ATA Device      Online                          40 GB MBR

Det första kommandot använder cmdleten New-CimSession för att skapa en session på RSDGF03 fjärrdatorn. Sessionen ansluter till WMI på fjärrdatorn. Kommandot sparar CIM-sessionen i variabeln $cs .

Det andra kommandot använder CIM-sessionen i variabeln $cs för att köra ett Get-Module kommando på den RSDGF03 datorn. Kommandot använder parametern Namn för att ange storage-modulen. Kommandot använder en pipelineoperator (|) för att skicka Storage-modulen till cmdleten Import-Module , som importerar den till den lokala sessionen.

Det tredje kommandot kör cmdleten Get-CommandGet-Disk på kommandot i storage-modulen. När du importerar en CIM-modul till den lokala sessionen konverterar PowerShell DE CDXML-filer som representerar CIM-modulen till PowerShell-skript, som visas som funktioner i den lokala sessionen.

Det fjärde kommandot kör Get-Disk kommandot. Även om kommandot skrivs i den lokala sessionen körs det implicit på fjärrdatorn som det importerades från. Kommandot hämtar objekt från fjärrdatorn och returnerar dem till den lokala sessionen.

Parametrar

-All

Anger att den här cmdleten hämtar alla moduler i varje modulmapp, inklusive kapslade moduler, manifestfiler (.psd1) filer, skriptmodulfiler (.psm1) och binära modulfiler (.dll). Utan den här parametern Get-Module hämtar endast standardmodulen i varje modulmapp.

Type:SwitchParameter
Position:Named
Default value:False
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-CimNamespace

Anger namnområdet för en alternativ CIM-provider som exponerar CIM-moduler. Standardvärdet är namnområdet för Module Discovery WMI-providern.

Använd den här parametern för att hämta CIM-moduler från datorer och enheter som inte kör Windows-operativsystemet.

Den här parametern introducerades i Windows PowerShell 3.0.

Type:String
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-CimResourceUri

Anger en alternativ plats för CIM-moduler. Standardvärdet är resurs-URI:n för Module Discovery WMI-providern på fjärrdatorn.

Använd den här parametern för att hämta CIM-moduler från datorer och enheter som inte kör Windows-operativsystemet.

Den här parametern introducerades i Windows PowerShell 3.0.

Type:Uri
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-CimSession

Anger en CIM-session på fjärrdatorn. Ange en variabel som innehåller CIM-sessionen eller ett kommando som hämtar CIM-sessionen, till exempel ett Get-CimSession-kommando .

Get-Module använder CIM-sessionsanslutningen för att hämta moduler från fjärrdatorn. När du importerar modulen med hjälp av cmdleten Import-Module och använder kommandona från den importerade modulen i den aktuella sessionen körs kommandona faktiskt på fjärrdatorn.

Du kan använda den här parametern för att hämta moduler från datorer och enheter som inte kör Windows-operativsystemet och datorer som har PowerShell, men som inte har PowerShell-fjärrkommunikation aktiverat.

CimSession-parametern hämtar alla moduler i CIMSession. Du kan dock endast importera CIM-baserade och CDXML-baserade moduler (Cmdlet Definition XML).

Type:CimSession
Position:Named
Default value:None
Required:True
Accept pipeline input:False
Accept wildcard characters:False

-FullyQualifiedName

Värdet kan vara ett modulnamn, en fullständig modulspecifikation eller en sökväg till en modulfil.

När värdet är en sökväg kan sökvägen vara fullständigt kvalificerad eller relativ. En relativ sökväg matchas i förhållande till skriptet som innehåller instruktionen using.

När värdet är ett namn eller en modulspecifikation söker PowerShell i PSModulePath efter den angivna modulen.

En modulspecifikation är en hashtable som har följande nycklar.

  • ModuleName - Obligatoriskt Anger modulnamnet.
  • GUID - Valfritt Anger GUID för modulen.
  • Det är också Obligatoriskt att ange minst en av de tre nycklarna nedan.
    • ModuleVersion – Anger en lägsta godtagbar version av modulen.
    • MaximumVersion – Anger den maximala godkända versionen av modulen.
    • RequiredVersion – Anger en exakt, nödvändig version av modulen. Detta kan inte användas med de andra versionsnycklarna.

Du kan inte ange parametern FullyQualifiedName i samma kommando som en namnparameter .

Type:ModuleSpecification[]
Position:Named
Default value:None
Required:False
Accept pipeline input:True
Accept wildcard characters:False

-ListAvailable

Anger att den här cmdleten hämtar alla installerade moduler. Get-Module hämtar moduler i sökvägar som anges i miljövariabeln PSModulePath . Utan den här parametern Get-Module hämtar endast de moduler som båda visas i miljövariabeln PSModulePath och som läses in i den aktuella sessionen. ListAvailable returnerar inte information om moduler som inte finns i miljövariabeln PSModulePath , även om dessa moduler läses in under den aktuella sessionen.

Type:SwitchParameter
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-Name

Anger namn eller namnmönster för moduler som den här cmdleten hämtar. Jokertecken tillåts. Du kan också skicka namnen till Get-Module. Du kan inte ange parametern FullyQualifiedName i samma kommando som en namnparameter .

Namnet kan inte acceptera ett modul-GUID som ett värde. Om du vill returnera moduler genom att ange ett GUID använder du FullyQualifiedName i stället.

Type:String[]
Position:0
Default value:None
Required:False
Accept pipeline input:True
Accept wildcard characters:True

-PSEdition

Hämtar modulerna som stöder den angivna versionen av PowerShell.

De acceptabla värdena för den här parametern är:

  • Desktop
  • Core

Cmdleten Get-Module kontrollerar egenskapen CompatiblePSEditions för PSModuleInfo-objektet för det angivna värdet och returnerar endast de moduler som har angetts.

Kommentar

  • Desktop Edition: bygger på .NET Framework och ger kompatibilitet med skript och moduler för versioner av PowerShell som körs på fullständiga utgåvor av Windows, till exempel Server Core och Windows Desktop.
  • Core Edition: bygger på .NET Core och ger kompatibilitet med skript och moduler för versioner av PowerShell som körs på begränsade utgåvor av Windows som Nano Server och Windows IoT.
Type:String
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-PSSession

Hämtar modulerna i den angivna användarhanterade PowerShell-sessionen (PSSession). Ange en variabel som innehåller sessionen, ett kommando som hämtar sessionen, till exempel ett Get-PSSession kommando eller ett kommando som skapar sessionen, till exempel ett New-PSSession kommando.

När sessionen är ansluten till en fjärrdator måste du ange parametern ListAvailable .

Ett Get-Module kommando som använder PSSession-parametern motsvarar att använda cmdleten Invoke-Command för att köra ett Get-Module -ListAvailable kommando i en PSSession.

Den här parametern introducerades i Windows PowerShell 3.0.

Type:PSSession
Position:Named
Default value:None
Required:True
Accept pipeline input:False
Accept wildcard characters:False

-Refresh

Anger att den här cmdleten uppdaterar cacheminnet för installerade kommandon. Kommandocachen skapas när sessionen startas. Det gör att cmdleten Get-Command kan hämta kommandon från moduler som inte importeras till sessionen.

Den här parametern är utformad för utvecklings- och testscenarier där innehållet i moduler har ändrats sedan sessionen startade.

När du anger parametern Uppdatera i ett kommando måste du ange ListAvailable.

Den här parametern introducerades i Windows PowerShell 3.0.

Type:SwitchParameter
Position:Named
Default value:False
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-SkipEditionCheck

Hoppar över kontrollen av fältet CompatiblePSEditions .

Som standard Get-Module utelämnar moduler i katalogen %windir%\System32\WindowsPowerShell\v1.0\Modules som inte anges Core i fältet CompatiblePSEditions . När den här växeln har angetts ingår moduler utan Core , så att moduler under Windows PowerShell-modulsökvägen som är inkompatibla med PowerShell v6 och senare returneras.

I macOS och Linux gör den här parametern ingenting.

Mer information finns i about_PowerShell_Editions .

Type:SwitchParameter
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

Indata

String

Du kan skicka modulnamn till den här cmdleten.

Utdata

PSModuleInfo

Den här cmdleten returnerar objekt som representerar moduler. När du anger parametern Get-Module ListAvailable returnerar ett ModuleInfoGrouping-objekt, vilket är en typ av PSModuleInfo-objekt som har samma egenskaper och metoder.

Kommentarer

PowerShell innehåller följande alias för Get-Module:

  • Alla plattformar:

    • gmo

  • Från och med Windows PowerShell 3.0 paketeras de kärnkommandon som ingår i PowerShell i moduler. Undantaget är Microsoft.PowerShell.Core, som är en snapin-modul (PSSnapin). Som standard läggs endast snapin-modulen Microsoft.PowerShell.Core till i sessionen. Moduler importeras automatiskt vid första användningen och du kan använda cmdleten Import-Module för att importera dem.

  • I Windows PowerShell 2.0 och i värdprogram som skapar äldre sessioner i senare versioner av PowerShell paketeras kärnkommandona i snapin-moduler (PSSnapins). Undantaget är Microsoft.PowerShell.Core, som alltid är en snapin-modul. Fjärrsessioner, till exempel de som startas av cmdleten New-PSSession , är också äldre sessioner som innehåller kärn snapin-moduler.

    Information om metoden CreateDefault2 som skapar nyare sessioner med kärnmoduler finns i CreateDefault2-metoden.

  • Get-Module hämtar endast moduler på platser som lagras i värdet för MILJÖvariabeln PSModulePath ($env:PSModulePath). Cmdleten Import-Module kan importera moduler på andra platser, men du kan inte använda cmdleten Get-Module för att hämta dem.

  • Från och med PowerShell 3.0 har nya egenskaper lagts till i objektet som Get-Module returnerar som gör det enklare att lära sig mer om moduler redan innan de importeras. Alla egenskaper fylls i innan du importerar. Dessa inkluderar egenskaperna ExportedCommands, ExportedCmdlets och ExportedFunctions som visar de kommandon som modulen exporterar.

  • Parametern ListAvailable hämtar endast välformade moduler, dvs. mappar som innehåller minst en fil vars basnamn är samma som namnet på modulmappen. Basnamnet är namnet utan filnamnstillägget. Mappar som innehåller filer som har olika namn anses vara containrar, men inte moduler.

    Om du vill hämta moduler som implementeras som DLL-filer, men inte omges av en modulmapp, anger du både parametrarna ListAvailable och Alla .

  • Om du vill använda CIM-sessionsfunktionen måste fjärrdatorn ha WS-Management-fjärrkommunikation och Windows Management Instrumentation (WMI), vilket är Microsoft-implementeringen av CIM-standarden (Common Information Model). Datorn måste också ha WMI-providern module discovery eller en alternativ WMI-provider som har samma grundläggande funktioner.

    Du kan använda CIM-sessionsfunktionen på datorer som inte kör Windows-operativsystemet och på Windows-datorer som har PowerShell, men som inte har PowerShell-fjärrkommunikation aktiverat.

    Du kan också använda CIM-parametrarna för att hämta CIM-moduler från datorer som har PowerShell-fjärrkommunikation aktiverat. Detta inkluderar den lokala datorn. När du skapar en CIM-session på den lokala datorn använder PowerShell DCOM i stället för WMI för att skapa sessionen.