Import-Module
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]
[-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]
[-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]
[-PassThru]
[-AsCustomObject]
[-MinimumVersion <Version>]
[-MaximumVersion <String>]
[-RequiredVersion <Version>]
[-ArgumentList <Object[]>]
[-DisableNameChecking]
[-NoClobber]
[-Scope <String>]
-CimSession <CimSession>
[-CimResourceUri <Uri>]
[-CimNamespace <String>]
[<CommonParameters>]
Import-Module
[-Global]
[-Prefix <String>]
[-FullyQualifiedName] <ModuleSpecification[]>
[-Function <String[]>]
[-Cmdlet <String[]>]
[-Variable <String[]>]
[-Alias <String[]>]
[-Force]
[-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]
[-PassThru]
[-AsCustomObject]
[-ArgumentList <Object[]>]
[-DisableNameChecking]
[-NoClobber]
[-Scope <String>]
-PSSession <PSSession>
[<CommonParameters>]
Import-Module
[-Global]
[-Prefix <String>]
[-Assembly] <Assembly[]>
[-Function <String[]>]
[-Cmdlet <String[]>]
[-Variable <String[]>]
[-Alias <String[]>]
[-Force]
[-PassThru]
[-AsCustomObject]
[-ArgumentList <Object[]>]
[-DisableNameChecking]
[-NoClobber]
[-Scope <String>]
[<CommonParameters>]
Import-Module
[-Global]
[-Prefix <String>]
[-Function <String[]>]
[-Cmdlet <String[]>]
[-Variable <String[]>]
[-Alias <String[]>]
[-Force]
[-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. De moduler som du importerar måste vara installerade på den lokala datorn eller en fjärrdator.
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 och du kan aktivera och inaktivera automatisk modulimport med hjälp $PSModuleAutoloadingPreference
av inställningsvariabeln. Mer information om moduler finns i about_Modules. 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, providers, skript, funktioner, variabler och andra verktyg och filer. När en modul har importerats kan du använda modulmedlemmarna i sessionen.
Om du vill importera en modul använder du parametrarna Name, Assembly, ModuleInfo, MinimumVersion och RequiredVersion för att identifiera modulen som ska importeras. 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 de medlemmar som importeras. Du kan också använda parametern NoClobber för att förhindra Import-Module
att medlemmar som har samma namn som medlemmar i den aktuella sessionen importeras.
Import-Module
importerar endast en modul till den aktuella sessionen. Om du vill importera modulen till alla sessioner lägger du till ett Import-Module
kommando i PowerShell-profilen. Mer information om profiler finns i about_Profiles.
Från och med Windows PowerShell 3.0 kan du använda Import-Module
för att 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 Import-Module
blir cmdleten ett primärt 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 med 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, inklusive datorer som inte kör Windows-operativsystemet och Windows-datorer som har PowerShell, men som inte har PowerShell-fjärrkommunikation aktiverat.
Börja med att skapa en CIM-session på fjärrdatorn, som är en anslutning till Windows Management Instrumentation (WMI) på fjärrdatorn. Använd sedan CIMSession-parameternImport-Module
för för att importera CIM-moduler från fjärrdatorn. När du importerar en CIM-modul 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: Importera medlemmarna i en modul till den aktuella sessionen
Det här exemplet importerar medlemmarna i PSDiagnostics-modulen till den aktuella sessionen. Namnparameternamnet är valfritt och kan utelämnas.
Import-Module -Name PSDiagnostics
Som standard Import-Module
genererar inte några utdata när den importerar en modul. Om du vill begära utdata använder du parametern PassThru eller AsCustomObject eller den utförliga gemensamma parametern.
Exempel 2: Importera alla moduler som anges av modulsökvägen
Det här exemplet importerar 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
I det här exemplet importeras 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 för används för att importera modulerna till den aktuella sessionen.
Dessa kommandon motsvarar att använda en pipelineoperator (|
) för att skicka utdata från ett Get-Module
kommando till Import-Module
.
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 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.
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
Det första kommandot importerar endast Disable-PSTrace
cmdletarna och Enable-PSTrace
från PSDiagnostics-modulen . Parametern Funktion begränsar de medlemmar som importeras från modulen. Du kan också använda parametrarna Alias, Variable 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.
I det tredje kommandot hämtar modulparametern för Get-Command
cmdleten de kommandon som importerades från PSDiagnostics-modulen . Resultatet bekräftar att endast Disable-PSTrace
cmdletarna och Enable-PSTrace
har importerats.
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 till medlemsnamnen och visar sedan prefixet medlemsnamn. Prefixet gäller endast för medlemmarna i den aktuella sessionen. Modulen ändras inte.
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
Den använder prefixparameternImport-Module
för lägger till x-prefixet till alla medlemmar som importeras från modulen och Parametern PassThru för att returnera ett modulobjekt som representerar den importerade modulen.
Cmdleten Get-Command
för att hämta de medlemmar som har importerats från modulen. Utdata visar att modulmedlemmarna har prefixet korrekt.
Exempel 7: Hämta och använda ett anpassat objekt
Dessa kommandon visar hur du hämtar och använder det anpassade objekt som Import-Module returnerar.
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 mycket 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 endast användas när du importerar en skriptmodul, så den första uppgiften ä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"()
Det första kommandot använder cmdleten Get-Module
för att hämta tillgängliga moduler. Kommandot använder en pipelineoperator för att skicka modulobjekten till cmdleten Format-Table
, som listar Namn och ModuleType för varje modul i en tabell.
Det andra kommandot använder cmdleten Import-Module
för att importera skriptmodulen Show-Calendar .
Kommandot använder parametern AsCustomObject för att begära ett anpassat objekt och parametern PassThru för att returnera objektet. Kommandot sparar det resulterande anpassade objektet i variabeln $a
.
Det tredje kommandot använder en pipelineoperator för att skicka variabeln $a
till cmdleten Get-Member
, som hämtar egenskaperna och metoderna för PSCustomObject i $a
. Utdata visar en Show-Calendar()- skriptmetod.
Det sista kommandot använder skriptmetoden Show-Calendar . Metodnamnet måste omges av citattecken, eftersom det 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.
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 prefixparametern .
Med hjälp av parametern Import-Module
Force tar du bort modulen och importerar den sedan igen. Utan den här parametern skulle sessionen innehålla två kopior av varje PSDiagnostics-cmdlet , en med standardnamnet och en med prefixet namn.
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. Modulen TestModule. 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:26:12 PM
Det första Get-Datecmdlet returns a **DateTime** object with the current date. After importing the **TestModule** module,
Get-Date" returnerar året och dagen på året.
Med parametern Get-Command
Alla i får vi alla Get-Date
kommandon i sessionen. Resultatet 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 körs Get-Date
funktionen från TestModule-modulen i stället för cmdleten Get-Date
. Om du vill köra den ursprungliga versionen av Get-Date
må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
Import-Module -Name PSWorkflow -MinimumVersion 3.0.0.0
Det här kommandot importerar PSWorkflow-modulen . Den använder parametern Import-Module
MinimumVersion för för att importera endast version 3.0.0.0 eller senare av modulen.
Du kan också använda parametern RequiredVersion för att importera en viss version av en modul eller använda parametrarna Module och Version för nyckelordet #Requires
för att kräva en viss version av en modul i ett skript.
Exempel 11: 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
Det första kommandot använder cmdleten New-PSSession
för att skapa en fjärrsession (PSSession) till Server01-datorn. Kommandot sparar PSSession i variabeln $s
.
Det andra kommandot använder PSSession-parametern för cmdleten Get-Module
för att hämta NetSecurity-modulen i sessionen i variabeln $s
. Det här kommandot motsvarar att använda cmdleten Invoke-Command
för att köra ett Get-Module
kommando i sessionen i $s
(Invoke-Command $s {Get-Module -ListAvailable -Name NetSecurity
). Utdata visar att NetSecurity-modulen är installerad på datorn och är tillgänglig för sessionen i variabeln $s
.
Det tredje kommandot använder PSSession-parametern för cmdleten Import-Module
för att importera NetSecurity-modulen från sessionen i variabeln $s
till den aktuella sessionen.
Det fjärde kommandot använder cmdleten Get-Command
för att hämta kommandon som börjar med Get och include Firewall från NetSecurity-modulen . Utdata hämtar kommandona och bekräftar att modulen och dess cmdletar har importerats till den aktuella sessionen.
Det femte kommandot använder cmdleten Get-NetFirewallRule
för att hämta brandväggsregler för Windows Remote Management på Server01-datorn. Det här kommandot motsvarar att använda cmdleten Invoke-Command
för att köra ett Get-NetFirewallRule
kommando i sessionen i variabeln $s
.
Exempel 12: Hantera lagring på en fjärrdator utan 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.
Med kommandona i det här exemplet kan du hantera lagringssystemen på en fjärrdator som inte kör Windows-operativsystemet.
Det första kommandot använder cmdleten New-CimSession
för att skapa en session på RSDGF03 fjärrdator. 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 Import-Module
kommando på den RSDGF03 datorn. Kommandot använder parametern Namn för att ange CIM-modulen för lagring .
Det tredje kommandot kör Get-Command
kommandot på Get-Disk
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.
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.
$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 denna cmdlet importerar från modulen till den aktuella sessionen. Ange en kommaavgränsad lista över 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.
Type: | String[] |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | 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 finns i about_Aliases.
Type: | Object[] |
Aliases: | Args |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-AsCustomObject
Anger att denna cmdlet 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 punktnotation för att anropa medlemmarna.
Type: | SwitchParameter |
Position: | Named |
Default value: | False |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Assembly
Anger en matris med sammansättningsobjekt. Den här cmdleten importerar de cmdletar och providrar som implementeras 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 providrar 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.
Type: | Assembly[] |
Position: | 0 |
Default value: | None |
Required: | True |
Accept pipeline input: | True |
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 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.
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 WMI-providern för modulidentifiering 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.
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 .
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 faktiskt 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.
Type: | CimSession |
Position: | Named |
Default value: | None |
Required: | True |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Cmdlet
Anger en matris med cmdletar som denna cmdlet 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.
Type: | String[] |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | True |
-DisableNameChecking
Anger att denna cmdlet undertrycker det meddelande som varnar dig när du importerar en cmdlet eller funktion vars namn innehåller ett verb som inte är godkänt eller ett otillåtet 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 är godkända, 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.
Det här meddelandet ä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.
Type: | SwitchParameter |
Position: | Named |
Default value: | False |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Force
Den här parametern gör att en modul läses in eller läses in igen utöver den aktuella
Type: | SwitchParameter |
Position: | Named |
Default value: | False |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-FullyQualifiedName
Anger det fullständigt kvalificerade namnet på modulspecifikationen.
Type: | ModuleSpecification[] |
Position: | 0 |
Default value: | None |
Required: | True |
Accept pipeline input: | True |
Accept wildcard characters: | False |
-Function
Anger en matris med funktioner som denna cmdlet 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.
Type: | String[] |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | True |
-Global
Anger att denna cmdlet 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 scriptblock 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 anroparens sessionstillstånd.
Tips
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. Att deklarera kapslade moduler förbättrar identifieringen av beroenden.
Parametern Global motsvarar parametern Scope med värdet Global.
Om du vill begränsa de kommandon som en modul exporterar använder du ett Export-ModuleMember
kommando i skriptmodulen.
Type: | SwitchParameter |
Position: | Named |
Default value: | False |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-MaximumVersion
Anger en maximal version. Denna cmdlet importerar endast en version av modulen som är mindre än eller lika med det angivna värdet. Om ingen version kvalificerar Import-Module
sig genererar ett fel.
Type: | String |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-MinimumVersion
Anger en lägsta version. Denna cmdlet importerar endast en version av modulen som är större än eller lika med det angivna värdet. Om ingen version kvalificerar Import-Module
sig genererar ett fel.
Som standard Import-Module
importerar modulen utan att kontrollera versionsnumret.
Använd parameternamnet MinimumVersion eller dess alias Version.
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.
Type: | Version |
Aliases: | Version |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | 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
.
Type: | PSModuleInfo[] |
Position: | 0 |
Default value: | None |
Required: | True |
Accept pipeline input: | True |
Accept wildcard characters: | 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-, .dll- eller 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
söker 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.
Type: | String[] |
Position: | 0 |
Default value: | None |
Required: | True |
Accept pipeline input: | True |
Accept wildcard characters: | True |
-NoClobber
Anger att denna cmdlet inte importerar kommandon som har samma namn som befintliga kommandon i den aktuella sessionen. Som standard Import-Module
importeras 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 kommandoprioriteten finns i "Moduler och namnkonflikter" i about_Modules och about_Command_Precedence.
Den här parametern introducerades i Windows PowerShell 3.0.
Type: | SwitchParameter |
Aliases: | NoOverwrite |
Position: | Named |
Default value: | False |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-PassThru
Returnerar ett objekt som representerar det objekt som du arbetar med. Som standard genererar denna cmdlet inga utdata.
Type: | SwitchParameter |
Position: | Named |
Default value: | False |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Prefix
Anger ett prefix som denna cmdlet 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 den påverkar inte filer som modulen importerar för eget bruk. Dessa kallas kapslade moduler. Denna cmdlet påverkar endast namnen på medlemmar i den aktuella sessionen.
Om du till exempel anger prefixet UTC och sedan importerar en Get-Date
cmdlet kallas cmdleten i sessionen för 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.
Type: | String |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-PSSession
Anger en användarhanterad PowerShell-session (PSSession) från vilken denna cmdlet importerar moduler 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 faktiskt 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 Core-moduler från en annan session. PowerShell Core-modulerna har namn som börjar med Microsoft.PowerShell.
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 |
-RequiredVersion
Anger en version av modulen som denna cmdlet 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 Versionsnummer för PowerShell-modulen i framtida versioner av Windows-operativsystemet är högre än modulversionsnummer i befintliga versioner av Windows-operativsystemet.
Type: | Version |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Scope
Anger ett omfång som den här cmdleten importerar modulen till.
De acceptabla värdena för den här parametern är:
- Global. Tillgänglig för alla kommandon i sessionen. Motsvarar parametern Global .
- Lokalt. Endast tillgängligt i det aktuella omfånget.
När cmdleten anropas från kommandotolken, skriptfilen eller scriptblock importeras som standard Import-Module
alla kommandon till det globala sessionstillståndet. Du kan använda parametern -Scope med värdet Lokal för att importera modulinnehåll till skript- eller scriptblock-omfå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 denna cmdlet importerar moduler till det globala sessionstillståndet så att de är tillgängliga för alla kommandon i sessionen.
Parametern Global motsvarar parametern Scope med värdet Global.
Den här parametern introducerades i Windows PowerShell 3.0.
Type: | String |
Accepted values: | Local, Global |
Position: | Named |
Default value: | Current scope |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Variable
Anger en matris med variabler som denna cmdlet 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.
Type: | String[] |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | True |
Indata
System.String, System.Management.Automation.PSModuleInfo, System.Reflection.Assembly
Du kan skicka ett modulnamn, modulobjekt eller sammansättningsobjekt till den här cmdleten.
Utdata
None, System.Management.Automation.PSModuleInfo, or System.Management.Automation.PSCustomObject
Den här cmdleten returnerar en PSModuleInfo eller PSCustomObject. Som standard Import-Module
genererar inte några utdata. Om du anger parametern PassThru genererar cmdleten ett System.Management.Automation.PSModuleInfo-objekt som representerar modulen. Om du anger parametern AsCustomObject genereras ett PSCustomObject-objekt .
Kommentarer
Innan du kan importera en modul måste modulen installeras på den lokala datorn. Modulkatalogen måste alltså kopieras till en katalog som är tillgänglig för den lokala datorn. 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 providrar 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 har importerats från en modul använder du cmdleten
Update-FormatData
.Update-FormatData
uppdaterar också formateringsdata för kommandon i sessionen som importerades från moduler. Om formateringsfilen för en modul ändras kan du köra ettUpdate-FormatData
kommando 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 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 Metoden CreateDefault2.
Import-Module
kan inte importera PowerShell Core-moduler från en annan session. PowerShell Core-modulerna har namn som börjar med Microsoft.PowerShell.I Windows PowerShell 2.0 fylldes inte några av egenskapsvärdena för modulobjektet, till exempel egenskapsvärdena ExportedCmdlets och NestedModules, i förrän modulen importerades och var inte tillgängliga för modulobjektet som parametern PassThru returnerar. I Windows PowerShell 3.0 fylls alla egenskapsvärden för modulen i.
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 returneras
Import-Module
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, dvs. en sammansättning 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 Microsofts implementering av CIM-standarden (Common Information Model). Datorn måste också ha WMI-providern för Modulidentifiering 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.