Dela via

Import-Module

  • Referens
Modul:
Microsoft.PowerShell.Core

Lägger till moduler i den aktuella sessionen.

Syntax

Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>] 
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -PSSession <PSSession> 
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -CimSession <CimSession>
      [-CimResourceUri <Uri>]
      [-CimNamespace <String>]
      [<CommonParameters>]
Import-Module
      [-Name] <string[]>
      -UseWindowsPowerShell
      [-Global]
      [-Prefix <string>]
      [-Function <string[]>]
      [-Cmdlet <string[]>]
      [-Variable <string[]>]
      [-Alias <string[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <version>]
      [-MaximumVersion <string>]
      [-RequiredVersion <version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <string>]
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-FullyQualifiedName] <ModuleSpecification[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>] 
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-FullyQualifiedName] <ModuleSpecification[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -PSSession <PSSession> 
      [<CommonParameters>]
Import-Module
      [-FullyQualifiedName] <ModuleSpecification[]>
      -UseWindowsPowerShell
      [-Global]
      [-Prefix <string>]
      [-Function <string[]>]
      [-Cmdlet <string[]>]
      [-Variable <string[]>]
      [-Alias <string[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <string>]
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-Assembly] <Assembly[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>] 
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-ModuleInfo] <PSModuleInfo[]>
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>] 
      [<CommonParameters>]

Description

Cmdleten Import-Module lägger till en eller flera moduler i den aktuella sessionen. Från och med PowerShell 3.0 importeras installerade moduler automatiskt till sessionen när du använder kommandon eller leverantörer i modulen. Du kan dock fortfarande använda Import-Module kommandot för att importera en modul. Du kan inaktivera automatisk modulimport med hjälp av inställningsvariabeln $PSModuleAutoloadingPreference . Mer information om variabeln finns i $PSModuleAutoloadingPreference about_Preference_Variables.

En modul är ett paket som innehåller medlemmar som kan användas i PowerShell. Medlemmar inkluderar cmdletar, leverantörer, skript, funktioner, variabler och andra verktyg och filer. När en modul har importerats kan du använda modulmedlemmarna i sessionen. Mer information om moduler finns i about_Modules.

Som standard Import-Module importerar alla medlemmar som modulen exporterar, men du kan använda parametrarna Alias, Funktion, Cmdlet och Variabel för att begränsa vilka medlemmar som importeras. Parametern NoClobber förhindrar att medlemmar som har samma namn som medlemmar i den aktuella sessionen importeras Import-Module .

Import-Module importerar endast en modul till den aktuella sessionen. Om du vill importera modulen till varje ny session lägger du till ett Import-Module kommando i din PowerShell-profil. Mer information om profiler finns i about_Profiles.

Du kan hantera fjärranslutna Windows-datorer som har PowerShell-fjärrkommunikation aktiverat genom att skapa en PSSession på fjärrdatorn. Använd sedan PSSession-parametern Import-Module för för att importera modulerna som är installerade på fjärrdatorn. När du använder de importerade kommandona i den aktuella sessionen körs kommandona implicit på fjärrdatorn.

Från och med Windows PowerShell 3.0 kan du använda Import-Module för att 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++.

För fjärrdatorer som inte har PowerShell-fjärrkommunikation aktiverat, inklusive datorer som inte kör Windows-operativsystemet, kan du använda CIMSession-parametern Import-Module för för att importera CIM-moduler från fjärrdatorn. De importerade kommandona körs implicit på fjärrdatorn. En CIMSession är en anslutning till Windows Management Instrumentation (WMI) på fjärrdatorn.

Exempel

Exempel 1: Importera medlemmarna i en modul till den aktuella sessionen

I det här exemplet importeras medlemmarna i PSDiagnostics-modulen till den aktuella sessionen.

Import-Module -Name PSDiagnostics

Exempel 2: Importera alla moduler som anges av modulsökvägen

I det här exemplet importeras alla tillgängliga moduler i sökvägen som anges av $env:PSModulePath miljövariabeln till den aktuella sessionen.

Get-Module -ListAvailable | Import-Module

Exempel 3: Importera medlemmarna i flera moduler till den aktuella sessionen

Det här exemplet importerar medlemmarna i MODULERna PSDiagnostics och Dism till den aktuella sessionen.

$m = Get-Module -ListAvailable PSDiagnostics, Dism
Import-Module -ModuleInfo $m

Cmdleten Get-Module hämtar modulerna PSDiagnostics och Dism och sparar objekten i variabeln $m . Parametern ListAvailable krävs när du hämtar moduler som ännu inte har importerats till sessionen.

Parametern Import-Module ModuleInfo används för att importera modulerna till den aktuella sessionen.

Exempel 4: Importera alla moduler som anges av en sökväg

I det här exemplet används en explicit sökväg för att identifiera modulen som ska importeras.

Import-Module -Name c:\ps-test\modules\test -Verbose

VERBOSE: Loading module from path 'C:\ps-test\modules\Test\Test.psm1'.
VERBOSE: Exporting function 'my-parm'.
VERBOSE: Exporting function 'Get-Parameter'.
VERBOSE: Exporting function 'Get-Specification'.
VERBOSE: Exporting function 'Get-SpecDetails'.

Om du använder den utförliga parametern rapporteras Import-Module förloppet när modulen läses in. Utan parametern Import-Module Verbose, PassThru eller AsCustomObject genererar inte några utdata när den importerar en modul.

Exempel 5: Begränsa de modulmedlemmar som importeras till en session

Det här exemplet visar hur du begränsar vilka modulmedlemmar som importeras till sessionen och effekten av det här kommandot på sessionen. Parametern Funktion begränsar de medlemmar som importeras från modulen. Du kan också använda parametrarna Alias, Variabel och Cmdlet för att begränsa andra medlemmar som en modul importerar.

Cmdleten Get-Module hämtar objektet som representerar PSDiagnostics-modulen . Egenskapen ExportedCmdlets visar alla cmdletar som modulen exporterar, även om alla inte importerades.

Import-Module PSDiagnostics -Function Disable-PSTrace, Enable-PSTrace
(Get-Module PSDiagnostics).ExportedCommands

Key                          Value
---                          -----
Disable-PSTrace              Disable-PSTrace
Disable-PSWSManCombinedTrace Disable-PSWSManCombinedTrace
Disable-WSManTrace           Disable-WSManTrace
Enable-PSTrace               Enable-PSTrace
Enable-PSWSManCombinedTrace  Enable-PSWSManCombinedTrace
Enable-WSManTrace            Enable-WSManTrace
Get-LogProperties            Get-LogProperties
Set-LogProperties            Set-LogProperties
Start-Trace                  Start-Trace
Stop-Trace                   Stop-Trace

Get-Command -Module PSDiagnostics

CommandType     Name                 Version    Source
-----------     ----                 -------    ------
Function        Disable-PSTrace      6.1.0.0    PSDiagnostics
Function        Enable-PSTrace       6.1.0.0    PSDiagnostics

Med hjälp av modulparametern i cmdleten Get-Command visas de kommandon som importerades från PSDiagnostics-modulen. Resultatet bekräftar att endast Disable-PSTrace cmdletarna och Enable-PSTrace importerades.

Exempel 6: Importera medlemmarna i en modul och lägg till ett prefix

Det här exemplet importerar PSDiagnostics-modulen till den aktuella sessionen, lägger till ett prefix i medlemsnamnen och visar sedan de prefixerade medlemsnamnen. Prefixparametern Import-Module för lägger till prefixet x till alla medlemmar som importeras från modulen. Prefixet gäller endast för medlemmarna i den aktuella sessionen. Modulen ändras inte. Parametern PassThru returnerar ett modulobjekt som representerar den importerade modulen.

Import-Module PSDiagnostics -Prefix x -PassThru

ModuleType Version    Name               ExportedCommands
---------- -------    ----               ----------------
Script     6.1.0.0    PSDiagnostics      {Disable-xPSTrace, Disable-xPSWSManCombinedTrace, Disable-xW...

Get-Command -Module PSDiagnostics

CommandType     Name                                   Version    Source
-----------     ----                                   -------    ------
Function        Disable-xPSTrace                       6.1.0.0    PSDiagnostics
Function        Disable-xPSWSManCombinedTrace          6.1.0.0    PSDiagnostics
Function        Disable-xWSManTrace                    6.1.0.0    PSDiagnostics
Function        Enable-xPSTrace                        6.1.0.0    PSDiagnostics
Function        Enable-xPSWSManCombinedTrace           6.1.0.0    PSDiagnostics
Function        Enable-xWSManTrace                     6.1.0.0    PSDiagnostics
Function        Get-xLogProperties                     6.1.0.0    PSDiagnostics
Function        Set-xLogProperties                     6.1.0.0    PSDiagnostics
Function        Start-xTrace                           6.1.0.0    PSDiagnostics
Function        Stop-xTrace                            6.1.0.0    PSDiagnostics

Get-Command hämtar de medlemmar som har importerats från modulen. Utdata visar att modulmedlemmarna var korrekt prefixerade.

Exempel 7: Hämta och använd ett anpassat objekt

Det här exemplet visar hur du hämtar och använder det anpassade objektet som returneras av Import-Module.

Anpassade objekt innehåller syntetiska medlemmar som representerar var och en av de importerade modulmedlemmarna. Till exempel konverteras cmdletar och funktioner i en modul till skriptmetoder för det anpassade objektet.

Anpassade objekt är användbara i skript. De är också användbara när flera importerade objekt har samma namn. Att använda skriptmetoden för ett objekt motsvarar att ange det fullständigt kvalificerade namnet på en importerad medlem, inklusive dess modulnamn.

Parametern AsCustomObject kan bara användas när du importerar en skriptmodul. Använd Get-Module för att avgöra vilken av de tillgängliga modulerna som är en skriptmodul.

Get-Module -List | Format-Table -Property Name, ModuleType -AutoSize

Name          ModuleType
----          ----------
Show-Calendar     Script
BitsTransfer    Manifest
PSDiagnostics   Manifest
TestCmdlets       Script
...

$a = Import-Module -Name Show-Calendar -AsCustomObject -PassThru
$a | Get-Member

TypeName: System.Management.Automation.PSCustomObject
Name          MemberType   Definition
----          ----------   ----------
Equals        Method       bool Equals(System.Object obj)
GetHashCode   Method       int GetHashCode()
GetType       Method       type GetType()
ToString      Method       string ToString()
Show-Calendar ScriptMethod System.Object Show-Calendar();

$a."Show-Calendar"()

Skriptmodulen Show-Calendar importeras med parametern AsCustomObject för att begära ett anpassat objekt och parametern PassThru för att returnera objektet. Det resulterande anpassade objektet sparas i variabeln $a .

Variabeln $a skickas till cmdleten Get-Member för att visa egenskaperna och metoderna för det sparade objektet. Utdata visar en Show-Calendar skriptmetod.

Om du vill anropa Show-Calendar skriptmetoden måste metodnamnet omges av citattecken eftersom namnet innehåller ett bindestreck.

Exempel 8: Importera en modul till samma session igen

Det här exemplet visar hur du använder force-parametern Import-Module för när du importerar om en modul till samma session. Parametern Force tar bort den inlästa modulen och importerar den sedan igen.

Import-Module PSDiagnostics
Import-Module PSDiagnostics -Force -Prefix PS

Det första kommandot importerar PSDiagnostics-modulen . Det andra kommandot importerar modulen igen, den här gången med hjälp av parametern Prefix .

Utan force-parametern skulle sessionen innehålla två kopior av varje PSDiagnostics-cmdlet, en med standardnamnet och en med det prefixerade namnet.

Exempel 9: Kör kommandon som har dolts av importerade kommandon

Det här exemplet visar hur du kör kommandon som har dolts av importerade kommandon. TestModule-modulen innehåller en funktion med namnet Get-Date som returnerar året och dagen på året.

Get-Date

Thursday, August 15, 2019 2:26:12 PM

Import-Module TestModule
Get-Date

19227

Get-Command Get-Date -All | Format-Table -Property CommandType, Name, ModuleName -AutoSize

CommandType     Name         ModuleName
-----------     ----         ----------
Function        Get-Date     TestModule
Cmdlet          Get-Date     Microsoft.PowerShell.Utility

Microsoft.PowerShell.Utility\Get-Date

Thursday, August 15, 2019 2:28:31 PM

Den första Get-Date cmdleten returnerar ett DateTime-objekt med aktuellt datum. När du har importerat TestModule-modulen Get-Date returneras året och dagen på året.

Använd parametern Alla för Get-Command att visa alla Get-Date kommandon i sessionen. Resultaten visar att det finns två Get-Date kommandon i sessionen, en funktion från TestModule-modulen och en cmdlet från modulen Microsoft.PowerShell.Utility .

Eftersom funktioner har företräde framför cmdletar Get-Date körs funktionen från TestModule-modulen i stället för cmdleten Get-Date . Om du vill köra den ursprungliga versionen av Get-Datemåste du kvalificera kommandonamnet med modulnamnet.

Mer information om kommandoprioret i PowerShell finns i about_Command_Precedence.

Exempel 10: Importera en lägsta version av en modul

I det här exemplet importeras PowerShellGet-modulen . Den använder parametern Import-Module MinimumVersion för för att endast importera versionen 2.0.0 eller större av modulen.

Import-Module -Name PowerShellGet -MinimumVersion 2.0.0

Du kan också använda parametern RequiredVersion för att importera en viss version av en modul eller använda parametrarna Modul och Version för nyckelordet #Requires för att kräva en viss version av en modul i ett skript.

Exempel 11: Importera med ett fullständigt kvalificerat namn

Det här exemplet importerar en specifik version av en modul med hjälp av FullyQualifiedName.

PS> Get-Module -ListAvailable PowerShellGet | Select-Object Name, Version

Name          Version
----          -------
PowerShellGet 2.2.1
PowerShellGet 2.1.3
PowerShellGet 2.1.2
PowerShellGet 1.0.0.1

PS> Import-Module -FullyQualifiedName @{ModuleName = 'PowerShellGet'; ModuleVersion = '2.1.3' }

Exempel 12: Importera med en fullständigt kvalificerad sökväg

Det här exemplet importerar en specifik version av en modul med hjälp av den fullständigt kvalificerade sökvägen.

PS> Get-Module -ListAvailable PowerShellGet | Select-Object Path

Path
----
C:\Program Files\PowerShell\Modules\PowerShellGet\2.2.1\PowerShellGet.psd1
C:\program files\powershell\6\Modules\PowerShellGet\PowerShellGet.psd1
C:\Program Files\WindowsPowerShell\Modules\PowerShellGet\2.1.2\PowerShellGet.psd1
C:\Program Files\WindowsPowerShell\Modules\PowerShellGet\1.0.0.1\PowerShellGet.psd1

PS> Import-Module -Name 'C:\Program Files\PowerShell\Modules\PowerShellGet\2.2.1\PowerShellGet.psd1'

Exempel 13: Importera en modul från en fjärrdator

Det här exemplet visar hur du använder cmdleten Import-Module för att importera en modul från en fjärrdator. Det här kommandot använder funktionen Implicit fjärrkommunikation i PowerShell.

När du importerar moduler från en annan session kan du använda cmdletarna i den aktuella sessionen. Kommandon som använder cmdletarna körs dock i fjärrsessionen.

$s = New-PSSession -ComputerName Server01
Get-Module -PSSession $s -ListAvailable -Name NetSecurity

ModuleType Name             ExportedCommands
---------- ----             ----------------
Manifest   NetSecurity      {New-NetIPsecAuthProposal, New-NetIPsecMainModeCryptoProposal, New-Ne...

Import-Module -PSSession $s -Name NetSecurity
Get-Command -Module NetSecurity -Name Get-*Firewall*

CommandType     Name                                               ModuleName
-----------     ----                                               ----------
Function        Get-NetFirewallAddressFilter                       NetSecurity
Function        Get-NetFirewallApplicationFilter                   NetSecurity
Function        Get-NetFirewallInterfaceFilter                     NetSecurity
Function        Get-NetFirewallInterfaceTypeFilter                 NetSecurity
Function        Get-NetFirewallPortFilter                          NetSecurity
Function        Get-NetFirewallProfile                             NetSecurity
Function        Get-NetFirewallRule                                NetSecurity
Function        Get-NetFirewallSecurityFilter                      NetSecurity
Function        Get-NetFirewallServiceFilter                       NetSecurity
Function        Get-NetFirewallSetting                             NetSecurity

Get-NetFirewallRule -DisplayName "Windows Remote Management*" |
  Format-Table -Property DisplayName, Name -AutoSize

DisplayName                                              Name
-----------                                              ----
Windows Remote Management (HTTP-In)                      WINRM-HTTP-In-TCP
Windows Remote Management (HTTP-In)                      WINRM-HTTP-In-TCP-PUBLIC
Windows Remote Management - Compatibility Mode (HTTP-In) WINRM-HTTP-Compat-In-TCP

New-PSSession skapar en fjärrsession (PSSession) till Server01 datorn. PSSession sparas i variabeln$s.

När du kör Get-Module med PSSession-parametern visas att NetSecurity-modulen är installerad och tillgänglig på fjärrdatorn. Det här kommandot motsvarar att använda cmdleten Invoke-Command för att köra Get-Module kommandot i fjärrsessionen. Till exempel:

Invoke-Command $s {Get-Module -ListAvailable -Name NetSecurity

När du kör Import-Module med PSSession-parametern importeras NetSecurity-modulen från fjärrdatorn till den aktuella sessionen. Cmdleten Get-Command hämtar kommandon som börjar med Get och inkluderar Firewall från NetSecurity-modulen . Utdata bekräftar att modulen och dess cmdletar importerades till den aktuella sessionen.

Därefter hämtar cmdleten Get-NetFirewallRule Windows Remote Management-brandväggsregler på Server01 datorn. Detta motsvarar att använda cmdleten Invoke-Command för att köras Get-NetFirewallRule på fjärrsessionen.

Exempel 14: Hantera lagring på en fjärrdator utan Windows-operativsystemet

I det här exemplet har administratören för datorn installerat WMI-providern Module Discovery, som gör att du kan använda CIM-kommandon som är utformade för providern.

Cmdleten New-CimSession skapar en session på fjärrdatorn med namnet RSDGF03. Sessionen ansluter till WMI-tjänsten på fjärrdatorn. CIM-sessionen sparas i variabeln $cs . Import-Moduleanvänder CimSession i $cs för att importera CIM-modulen storage från RSDGF03 datorn.

Cmdleten Get-Command Get-Disk visar kommandot i storage-modulen . När du importerar en CIM-modul till den lokala sessionen konverterar PowerShell CDXML-filerna för varje kommando till PowerShell-skript, som visas som funktioner i den lokala sessionen.

Även om Get-Disk den skrivs i den lokala sessionen körs cmdleten implicit på den fjärrdator som den importerades från. Kommandot returnerar objekt från fjärrdatorn till den lokala sessionen.

$cs = New-CimSession -ComputerName RSDGF03
Import-Module -CimSession $cs -Name Storage
# Importing a CIM module, converts the CDXML files for each command into
# PowerShell scripts. These appear as functions in the local session.
Get-Command Get-Disk

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

# Use implicit remoting to query disks on the remote computer from which the
# module was imported.
Get-Disk

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

Parametrar

-Alias

Anger de alias som den här cmdleten importerar från modulen till den aktuella sessionen. Ange en kommaavgränsad lista med alias. Jokertecken tillåts.

Vissa moduler exporterar automatiskt valda alias till sessionen när du importerar modulen. Med den här parametern kan du välja bland de exporterade aliasen.

Typ:String[]
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:True

-ArgumentList

Anger en matris med argument, eller parametervärden, som skickas till en skriptmodul under Import-Module kommandot . Den här parametern är endast giltig när du importerar en skriptmodul.

Du kan också referera till parametern ArgumentList med dess alias, args. Mer information om beteendet för ArgumentList finns i about_Splatting.

Typ:Object[]
Alias:Args
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-AsCustomObject

Anger att den här cmdleten returnerar ett anpassat objekt med medlemmar som representerar de importerade modulmedlemmarna. Den här parametern är endast giltig för skriptmoduler.

När du använder parametern Import-Module AsCustomObject importerar du modulmedlemmarna till sessionen och returnerar sedan ett PSCustomObject-objekt i stället för ett PSModuleInfo-objekt. Du kan spara det anpassade objektet i en variabel och använda medlemsåtkomstuppräkning för att anropa medlemmarna.

Typ:SwitchParameter
Position:Named
Standardvärde:False
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-Assembly

Anger en matris med sammansättningsobjekt. Den här cmdleten importerar de cmdletar och leverantörer som implementerats i de angivna sammansättningsobjekten. Ange en variabel som innehåller sammansättningsobjekt eller ett kommando som skapar sammansättningsobjekt. Du kan också skicka ett sammansättningsobjekt till Import-Module.

När du använder den här parametern importeras endast de cmdletar och leverantörer som implementeras av de angivna sammansättningarna. Om modulen innehåller andra filer importeras de inte och du kanske saknar viktiga medlemmar i modulen. Använd den här parametern för att felsöka och testa modulen, eller när du instrueras att använda den av modulförfattaren.

Typ:Assembly[]
Position:0
Standardvärde:None
Obligatorisk:True
Godkänn pipeline-indata:True
Godkänn jokertecken: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 importera CIM-moduler från datorer och enheter som inte kör ett Windows-operativsystem.

Den här parametern introducerades i Windows PowerShell 3.0.

Typ:String
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken: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 importera CIM-moduler från datorer och enheter som inte kör ett Windows-operativsystem.

Den här parametern introducerades i Windows PowerShell 3.0.

Typ:Uri
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken: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 .

Import-Module använder CIM-sessionsanslutningen för att importera moduler från fjärrdatorn till den aktuella sessionen. När du använder kommandona från den importerade modulen i den aktuella sessionen körs kommandona på fjärrdatorn.

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

Den här parametern introducerades i Windows PowerShell 3.0.

Typ:CimSession
Position:Named
Standardvärde:None
Obligatorisk:True
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-Cmdlet

Anger en matris med cmdletar som den här cmdleten importerar från modulen till den aktuella sessionen. Jokertecken tillåts.

Vissa moduler exporterar automatiskt valda cmdletar till sessionen när du importerar modulen. Med den här parametern kan du välja bland de exporterade cmdletarna.

Typ:String[]
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:True

-DisableNameChecking

Anger att denna cmdlet undertrycker meddelandet som varnar dig när du importerar en cmdlet eller funktion vars namn innehåller ett icke godkänt verb eller ett förbjudet tecken.

När en modul som du importerar exporterar cmdletar eller funktioner som inte har godkända verb i sina namn visas som standard följande varningsmeddelande i PowerShell:

VARNING! Vissa importerade kommandonamn innehåller verb som inte har godkänts, vilket kan göra dem mindre identifierbara. Använd parametern Verbose för mer information eller skriv Get-Verb för att se listan över godkända verb.

Detta meddelande är bara en varning. Den fullständiga modulen importeras fortfarande, inklusive kommandon som inte överensstämmer. Även om meddelandet visas för modulanvändare bör namngivningsproblemet åtgärdas av modulförfattaren.

Typ:SwitchParameter
Position:Named
Standardvärde:False
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-Force

Den här parametern gör att en modul läses in, eller läses in igen, ovanpå den aktuella. Vissa moduler läser in externa sammansättningar. Importen misslyckas om du importerar en modul som läser in en nyare version av en sammansättning. Force-parametern kan inte åsidosätta felet. Du måste starta en ny session för att läsa in den nya versionen.

Typ:SwitchParameter
Position:Named
Standardvärde:False
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken: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.
Typ:ModuleSpecification[]
Position:0
Standardvärde:None
Obligatorisk:True
Godkänn pipeline-indata:True
Godkänn jokertecken:False

-Function

Anger en matris med funktioner som den här cmdleten importerar från modulen till den aktuella sessionen. Jokertecken tillåts. Vissa moduler exporterar automatiskt valda funktioner till sessionen när du importerar modulen. Med den här parametern kan du välja bland de exporterade funktionerna.

Typ:String[]
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:True

-Global

Anger att den här cmdleten importerar moduler till det globala sessionstillståndet så att de är tillgängliga för alla kommandon i sessionen.

När cmdleten anropas från kommandotolken, skriptfilen eller skriptblocket importeras som standard Import-Module alla kommandon till det globala sessionstillståndet.

När cmdleten anropas från en annan modul Import-Module importeras kommandona i en modul, inklusive kommandon från kapslade moduler, till den anropande modulens sessionstillstånd.

Dricks

Du bör undvika att anropa Import-Module inifrån en modul. Deklarera i stället målmodulen som en kapslad modul i den överordnade modulens manifest. Om du deklarerar kapslade moduler blir beroendena lättare att identifiera.

Parametern Global motsvarar parametern Omfång med värdet Global.

Om du vill begränsa de kommandon som en modul exporterar använder du ett Export-ModuleMember kommando i skriptmodulen.

Typ:SwitchParameter
Position:Named
Standardvärde:False
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-MaximumVersion

Anger en maximal version. Den här cmdleten importerar endast en version av modulen som är mindre än eller lika med det angivna värdet. Om ingen version kvalificerar sig returneras Import-Module ett fel.

Typ:String
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-MinimumVersion

Anger en lägsta version. Den här cmdleten importerar endast en version av modulen som är större än eller lika med det angivna värdet. Använd parameternamnet MinimumVersion eller dess alias Version. Om ingen version kvalificerar Import-Module sig genererar ett fel.

Om du vill ange en exakt version använder du parametern RequiredVersion . Du kan också använda parametrarna Modul och Version för nyckelordet #Requires för att kräva en specifik version av en modul i ett skript.

Den här parametern introducerades i Windows PowerShell 3.0.

Typ:Version
Alias:Version
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-ModuleInfo

Anger en matris med modulobjekt som ska importeras. Ange en variabel som innehåller modulobjekten eller ett kommando som hämtar modulobjekten, till exempel följande kommando: Get-Module -ListAvailable. Du kan också skicka modulobjekt till Import-Module.

Typ:PSModuleInfo[]
Position:0
Standardvärde:None
Obligatorisk:True
Godkänn pipeline-indata:True
Godkänn jokertecken:False

-Name

Anger namnen på de moduler som ska importeras. Ange namnet på modulen eller namnet på en fil i modulen, till exempel en .psd1, .psm1, .dlleller .ps1 fil. Filsökvägar är valfria. Jokertecken tillåts inte. Du kan också skicka modulnamn och filnamn till Import-Module.

Om du utelämnar en sökväg Import-Module letar du efter modulen i sökvägarna som sparats i $env:PSModulePath miljövariabeln.

Ange endast modulnamnet när det är möjligt. När du anger ett filnamn importeras endast de medlemmar som implementeras i filen. Om modulen innehåller andra filer importeras de inte och du kanske saknar viktiga medlemmar i modulen.

Kommentar

Även om det är möjligt att importera en skriptfil (.ps1) som en modul är skriptfiler vanligtvis inte strukturerade som skriptmodulfilen (.psm1). Att importera en skriptfil garanterar inte att den kan användas som en modul. Mer information finns i about_Modules.

Typ:String[]
Position:0
Standardvärde:None
Obligatorisk:True
Godkänn pipeline-indata:True
Godkänn jokertecken:True

-NoClobber

Förhindrar import av kommandon som har samma namn som befintliga kommandon i den aktuella sessionen. Som standard Import-Module importerar alla exporterade modulkommandon.

Kommandon som har samma namn kan dölja eller ersätta kommandon i sessionen. Om du vill undvika konflikter med kommandonamn i en session använder du parametrarna Prefix eller NoClobber . Mer information om namnkonflikter och kommandopriorens finns i "Moduler och namnkonflikter" i about_Modules och about_Command_Precedence.

Den här parametern introducerades i Windows PowerShell 3.0.

Typ:SwitchParameter
Alias:NoOverwrite
Position:Named
Standardvärde:False
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-PassThru

Returnerar ett objekt som representerar den importerade modulen. Som standard genererar den här cmdleten inga utdata.

Typ:SwitchParameter
Position:Named
Standardvärde:False
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-Prefix

Anger ett prefix som den här cmdleten lägger till i substantiven i namnen på importerade modulmedlemmar.

Använd den här parametern för att undvika namnkonflikter som kan uppstå när olika medlemmar i sessionen har samma namn. Den här parametern ändrar inte modulen och påverkar inte filer som modulen importerar för eget bruk. Dessa kallas kapslade moduler. Den här cmdleten påverkar endast namnen på medlemmar i den aktuella sessionen.

Om du till exempel anger prefixet UTC och sedan importerar en Get-Date cmdlet är cmdleten känd i sessionen som Get-UTCDate, och den förväxlas inte med den ursprungliga Get-Date cmdleten.

Värdet för den här parametern har företräde framför egenskapen DefaultCommandPrefix för modulen, som anger standardprefixet.

Typ:String
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-PSSession

Anger en Användarhanterad PowerShell-session (PSSession) som den här cmdleten importerar moduler från till den aktuella sessionen. Ange en variabel som innehåller en PSSession eller ett kommando som hämtar en PSSession, till exempel ett Get-PSSession kommando.

När du importerar en modul från en annan session till den aktuella sessionen kan du använda cmdletarna från modulen i den aktuella sessionen, precis som du skulle använda cmdletar från en lokal modul. Kommandon som använder fjärr-cmdletar körs i fjärrsessionen, men fjärrkommunikationsinformationen hanteras i bakgrunden av PowerShell.

Den här parametern använder funktionen Implicit fjärrkommunikation i PowerShell. Det motsvarar att använda cmdleten Import-PSSession för att importera vissa moduler från en session.

Import-Module kan inte importera powershell-kärnmoduler från en annan session. PowerShell-kärnmodulerna har namn som börjar med Microsoft.PowerShell.

Den här parametern introducerades i Windows PowerShell 3.0.

Typ:PSSession
Position:Named
Standardvärde:None
Obligatorisk:True
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-RequiredVersion

Anger en version av modulen som den här cmdleten importerar. Om versionen inte är installerad Import-Module genererar ett fel.

Som standard Import-Module importerar modulen utan att kontrollera versionsnumret.

Om du vill ange en lägsta version använder du parametern MinimumVersion . Du kan också använda parametrarna Modul och Version för nyckelordet #Requires för att kräva en specifik version av en modul i ett skript.

Den här parametern introducerades i Windows PowerShell 3.0.

Skript som använder RequiredVersion för att importera moduler som ingår i befintliga versioner av Windows-operativsystemet körs inte automatiskt i framtida versioner av Windows-operativsystemet. Det beror på att versionsnumren för PowerShell-modulen i framtida versioner av Windows-operativsystemet är högre än modulversionsnummer i befintliga versioner av Windows-operativsystemet.

Typ:Version
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-Scope

Anger ett omfång som modulen ska importeras i.

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

  • Global. Tillgänglig för alla kommandon i sessionen. Motsvarar parametern Global .
  • Lokal. Endast tillgängligt i det aktuella omfånget.

När cmdleten anropas från kommandotolken, skriptfilen eller skriptblocket importeras som standard Import-Module alla kommandon till det globala sessionstillståndet. Du kan använda parametern -Scope Local för att importera modulinnehåll till skript- eller skriptblockeringsomfånget.

När cmdleten anropas från en annan modul Import-Module importeras kommandona i en modul, inklusive kommandon från kapslade moduler, till anroparens sessionstillstånd. -Scope Global Anger eller -Global anger att den här cmdleten importerar moduler till det globala sessionstillståndet så att de är tillgängliga för alla kommandon i sessionen.

Parametern Global motsvarar parametern Omfång med värdet Global.

Den här parametern introducerades i Windows PowerShell 3.0.

Typ:String
Godkända värden:Local, Global
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-SkipEditionCheck

Hoppar över kontrollen på fältet CompatiblePSEditions .

Tillåter inläsning av en modul från modulkatalogen "$($env:windir)\System32\WindowsPowerShell\v1.0\Modules" till PowerShell Core när modulen inte anges Core i CompatiblePSEditions manifestfältet.

När du importerar en modul från en annan sökväg gör den här växeln ingenting eftersom kontrollen inte utförs. På Linux och macOS gör den här växeln ingenting.

Mer information finns i about_PowerShell_Editions.

Varning

Import-Module -SkipEditionCheck kan fortfarande misslyckas med att importera en modul. Även om det lyckas kan det misslyckas att anropa ett kommando från modulen senare när det försöker använda ett inkompatibelt API.

Typ:SwitchParameter
Position:Named
Standardvärde:False
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-UseWindowsPowerShell

Läser in modulen med windows PowerShell-kompatibilitetsfunktioner. Mer information finns i about_Windows_PowerShell_Compatibility .

Typ:SwitchParameter
Alias:UseWinPS
Position:Named
Standardvärde:False
Obligatorisk:True
Godkänn pipeline-indata:False
Godkänn jokertecken:False

-Variable

Anger en matris med variabler som den här cmdleten importerar från modulen till den aktuella sessionen. Ange en lista med variabler. Jokertecken tillåts.

Vissa moduler exporterar automatiskt valda variabler till sessionen när du importerar modulen. Med den här parametern kan du välja bland de exporterade variablerna.

Typ:String[]
Position:Named
Standardvärde:None
Obligatorisk:False
Godkänn pipeline-indata:False
Godkänn jokertecken:True

Indata

String

Du kan skicka ett modulnamn till den här cmdleten.

PSModuleInfo

Du kan skicka ett modulobjekt till den här cmdleten.

Assembly

Du kan skicka ett sammansättningsobjekt till den här cmdleten.

Utdata

None

Som standard returnerar den här cmdleten inga utdata.

PSModuleInfo

Om du anger parametern PassThru genererar cmdleten ett System.Management.Automation.PSModuleInfo-objekt som representerar den importerade modulen.

PSCustomObject

Om du anger parametrarna AsCustomObject och PassThru tillsammans genererar cmdleten ett PSCustomObject-objekt som representerar modulen.

Kommentarer

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

  • Alla plattformar:

    • ipmo

  • Innan du kan importera en modul måste modulen vara tillgänglig för din lokala dator och ingå i PSModulePath miljövariabeln. Mer information finns i about_Modules.

    Du kan också använda parametrarna PSSession och CIMSession för att importera moduler som är installerade på fjärrdatorer. Kommandon som använder cmdletarna i dessa moduler körs dock i fjärrsessionen på fjärrdatorn.

  • Om du importerar medlemmar med samma namn och samma typ till din session använder PowerShell den medlem som importerades senast som standard. Variabler och alias ersätts och originalen är inte tillgängliga. Funktioner, cmdletar och leverantörer skuggas bara av de nya medlemmarna. De kan nås genom att kvalificera kommandonamnet med namnet på dess snapin-modul, modul eller funktionssökväg.

  • Om du vill uppdatera formateringsdata för kommandon som importerats från en modul använder du cmdleten Update-FormatData . Om formateringsfilen för en modul ändras använder du cmdleten Update-FormatData för att uppdatera formateringsdata för importerade kommandon. Du behöver inte importera modulen igen.

  • Från och med Windows PowerShell 3.0 paketeras kärnkommandona som installerats 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 nyare sessioner med kärnmoduler finns i metoden CreateDefault2.

  • I Windows PowerShell 2.0 har vissa egenskapsvärden för modulobjektet, till exempel egenskapsvärdena ExportedCmdlets och NestedModules , inte fyllts i förrän modulen importerades.

  • Om du försöker importera en modul som innehåller sammansättningar i blandat läge som inte är kompatibla med Windows PowerShell 3.0+ Import-Module returnerar ett felmeddelande som liknar följande.

    Import-Module: Sammansättning i blandat läge skapas mot version "v2.0.50727" av körningen och kan inte läsas in i 4.0-körningen utan ytterligare konfigurationsinformation.

    Det här felet uppstår när en modul som är utformad för Windows PowerShell 2.0 innehåller minst en sammansättning med blandade moduler. En sammansättning med blandade moduler som innehåller både hanterad och icke-hanterad kod, till exempel C++ och C#.

    Om du vill importera en modul som innehåller sammansättningar i blandat läge startar du Windows PowerShell 2.0 med hjälp av följande kommando och försöker sedan med Import-Module kommandot igen.

    PowerShell.exe -Version 2.0

  • 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 CIM-provider som har samma grundläggande funktioner.

    Du kan använda CIM-sessionsfunktionen på datorer som inte kör ett Windows-operativsystem 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, inklusive 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.

  • Som standard Import-Module importerar moduler i det globala omfånget även när de anropas från ett underordnat omfång. Omfånget på den översta nivån och alla underordnade omfång har åtkomst till modulens exporterade element.

    I ett underordnat omfång -Scope Local begränsar du importen till det omfånget och alla dess underordnade omfång. Överordnade omfång ser sedan inte de importerade medlemmarna.

    Kommentar

    Get-Module visar alla moduler som lästs in i den aktuella sessionen. Detta inkluderar moduler som läses in lokalt i ett underordnat omfång. Använd Get-Command -Module modulename för att se vilka medlemmar som läses in i det aktuella omfånget.

  • Import-Module läser inte in klass- och uppräkningsdefinitioner i modulen. Använd -instruktionen using module i början av skriptet. Detta importerar modulen, inklusive klass- och uppräkningsdefinitionerna. Mer information finns i about_Using.

  • Under utvecklingen av en skriptmodul är det vanligt att göra ändringar i koden och sedan läsa in den nya versionen av modulen med hjälp Import-Module av parametern Force . Detta fungerar endast för ändringar av funktioner i rotmodulen. Import-Module läser inte in några kapslade moduler igen. Det finns heller inget sätt att läsa in uppdaterade klasser eller uppräkningar.

    Om du vill hämta uppdaterade modulmedlemmar som definierats i kapslade moduler tar du bort modulen med Remove-Moduleoch importerar sedan modulen igen.

    Om modulen lästes in med en using instruktion måste du starta en ny session för att importera uppdaterade definitioner för klasserna och uppräkningar. Klasser och uppräkningar som definierats i PowerShell och importerats med en using instruktion kan inte tas bort.