Get-Module

  • Referens
Modul:
Microsoft.PowerShell.Core

Hämtar de moduler som har importerats eller som kan importeras till den aktuella sessionen.

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 hämtar De PowerShell-moduler som har importerats, eller som kan importeras, till en PowerShell-session. 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 .

Utan parametrar Get-Module hämtar moduler som har importerats till den aktuella sessionen. Om du vill hämta alla installerade moduler anger du parametern ListAvailable .

Get-Module hämtar moduler, men de importeras 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 för att hämta och importera CIM-moduler (Common Information Model), där cmdletarna definieras 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++.

Med dessa nya funktioner Get-Module blir cmdletarna och Import-Module primära verktyg för att hantera heterogena företag som innehåller datorer som kör Windows-operativsystemet och datorer som kör andra operativsystem.

Om du vill hantera fjärrdatorer som kör Windows-operativsystemet som har PowerShell- och PowerShell-fjärrkommunikation aktiverat skapar du en PSSession på fjärrdatorn och använder sedan PSSession-parameternGet-Module för för att hämta PowerShell-modulerna i PSSession. När du importerar modulerna och sedan använder de importerade kommandona i den aktuella sessionen körs kommandona implicit i PSSession på fjärrdatorn. Du kan använda den här strategin för att hantera fjärrdatorn.

Du kan använda en liknande strategi för att hantera datorer som inte har PowerShell-fjärrkommunikation aktiverat. Dessa inkluderar 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-parameternGet-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

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

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

Det här kommandot hämtar modulen Microsoft.PowerShell.Management genom att ange det fullständigt kvalificerade namnet på modulen 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.

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 EGENSKAPER för PSModuleInfo.

Utdata innehåller de nya egenskaperna, till exempel Författare och Företagsnamn, 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 modulen Windows PowerShell BitsTransfer.

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 punktnotation för att hämta sökvägen till manifestfilen, som lagras i objektets sökvägsegenskap. 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 för 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

De här kommandona 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 Get-ModulePSSession och ListAvailable för för att hämta modulerna i PSSession i variabeln$s.

Om du skickar 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, eftersom administratören för datorn har installerat WMI-providern module discovery, kan CIM-kommandona använda standardvärdena, som är utformade för providern.

$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å fjärrdatorn RSDGF03. 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å 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-Command på Get-Disk kommandot i Storage-modulen. När du importerar en CIM-modul till den lokala sessionen konverterar PowerShell CDXML-filerna 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å den fjärrdator som det importerades från. Kommandot hämtar objekt från fjärrdatorn och returnerar dem till den lokala sessionen.

Parametrar

-All

Anger att denna cmdlet hämtar alla moduler i varje modulmapp, inklusive kapslade moduler, manifestfiler (.psd1), 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 för WMI-providern för modulidentifiering 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.

Parametern CimSession 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

Anger moduler med namn som anges i form av ModuleSpecification-objekt . Se avsnittet Anmärkningar i ModuleSpecification Constructor (Hashtable).

Parametern FullyQualifiedModule accepterar till exempel ett modulnamn som anges i något av följande format:

  • @{ModuleName = "modulename"; ModuleVersion = "version_number"}
  • @{ModuleName = "modulename"; ModuleVersion = "version_number"; Guid = "GUID"}

ModuleName och ModuleVersion krävs, men Guid är valfritt. Du kan inte ange parametern FullyQualifiedModule i samma kommando som en modulparameter . de två parametrarna är ömsesidigt uteslutande.

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

-ListAvailable

Anger att denna cmdlet 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 i 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 denna cmdlet hämtar. Jokertecken tillåts. Du kan också skicka namnen till Get-Module. Du kan inte ange parametern FullyQualifiedName i samma kommando som en Name-parameter .

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 de moduler som stöder den angivna versionen av PowerShell.

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

  • Skrivbord
  • Kärna

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

Anteckning

  • 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 denna cmdlet uppdaterar cacheminnet för installerade kommandon. Kommandocachen skapas när sessionen startar. 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 testningsscenarier där innehållet i moduler har ändrats sedan sessionen startades.

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 utelämnar Get-Module 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 inkluderas moduler utanCore, så att moduler under Windows PowerShell modulsökväg som inte är kompatibla med PowerShell Core 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-ModuleListAvailable returneras ett ModuleInfoGrouping-objekt, som är en typ av PSModuleInfo-objekt som har samma egenskaper och metoder.

Kommentarer

  • 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.

  • Från och med Windows PowerShell 3.0 paketeras de kärnkommandon som installeras med PowerShell i moduler. 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 sessioner i nyare format 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). Du kan använda parametern Path för cmdleten Import-Module för att 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 också lagts till i objektet som Get-Module returnerar som gör det enklare att lära sig 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 bara välformulerade 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 med olika namn anses vara containrar, men inte moduler.

    Om du vill hämta moduler som implementeras som .dll filer, men som inte omges av en modulmapp, anger du 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 Microsofts implementering av CIM-standarden (Common Information Model). Datorn måste också ha WMI-providern för modulidentifiering 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.