Import-Module
Aggiunge moduli alla sessione corrente.
Sintassi
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>]Descrizione
Il Import-Module cmdlet aggiunge uno o più moduli alla sessione corrente. A partire da PowerShell 3.0, i moduli installati vengono importati automaticamente nella sessione quando si usano comandi o provider nel modulo. Tuttavia, è comunque possibile usare il Import-Module comando per importare un modulo.
È possibile disabilitare l'importazione automatica dei moduli usando la $PSModuleAutoloadingPreference variabile di preferenza. Per altre informazioni sulla $PSModuleAutoloadingPreference variabile, vedere about_Preference_Variables.
Un modulo è un pacchetto che contiene membri che possono essere usati in PowerShell. I membri includono cmdlet, provider, script, funzioni, variabili e altri strumenti e file. Dopo l'importazione di un modulo, è possibile usare i membri del modulo nella sessione. Per altre informazioni sui moduli, vedere about_Modules.
Per impostazione predefinita, Import-Module importa tutti i membri che il modulo esporta, ma è possibile usare i parametri Alias, Function, Cmdlet e Variable per limitare i membri importati. Il parametro NoClobber impedisce Import-Module l'importazione di membri con gli stessi nomi dei membri della sessione corrente.
Import-Module importa un modulo solo nella sessione corrente. Per importare il modulo in ogni nuova sessione, aggiungere un Import-Module comando al profilo di PowerShell. Per altre informazioni sui profili, vedere about_Profiles.
È possibile gestire computer Windows remoti in cui è abilitata la comunicazione remota di PowerShell creando una sessione PSSession nel computer remoto. Usare quindi il parametro PSSession di per Import-Module importare i moduli installati nel computer remoto. Quando si usano i comandi importati nella sessione corrente, i comandi vengono eseguiti in modo implicito nel computer remoto.
A partire da Windows PowerShell 3.0, è possibile usare Import-Module per importare moduli CIM (Common Information Model). I moduli CIM definiscono i cmdlet nei file CDXML (Cmdlet Definition XML). Questa funzionalità consente di usare i cmdlet implementati in assembly di codice non gestiti, ad esempio quelli scritti in C++.
Per i computer remoti che non hanno la comunicazione remota di PowerShell abilitata, inclusi i computer che non eseguono il sistema operativo Windows, è possibile usare il parametro CIMSession di Import-Module per importare moduli CIM dal computer remoto. I comandi importati vengono eseguiti in modo implicito nel computer remoto. Una CIMSession è una connessione a Strumentazione gestione Windows (WMI) nel computer remoto.
Esempio
Esempio 1: Importare i membri di un modulo nella sessione corrente
In questo esempio vengono importati i membri del modulo PSDiagnostics nella sessione corrente.
Import-Module -Name PSDiagnosticsEsempio 2: Importare tutti i moduli specificati dal percorso del modulo
In questo esempio vengono importati tutti i moduli disponibili nel percorso specificato dalla $env:PSModulePath variabile di ambiente nella sessione corrente.
Get-Module -ListAvailable | Import-ModuleEsempio 3: Importare i membri di diversi moduli nella sessione corrente
In questo esempio vengono importati i membri dei moduli PSDiagnostics e Dism nella sessione corrente.
$m = Get-Module -ListAvailable PSDiagnostics, Dism
Import-Module -ModuleInfo $mIl Get-Module cmdlet ottiene i moduli PSDiagnostics e Dism e salva gli oggetti nella $m variabile. Il parametro ListAvailable è obbligatorio quando si ottengono moduli non ancora importati nella sessione.
Il parametro ModuleInfo di Import-Module viene usato per importare i moduli nella sessione corrente.
Esempio 4: Importare tutti i moduli specificati da un percorso
In questo esempio viene usato un percorso esplicito per identificare il modulo da importare.
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'.L'uso del parametro Verbose determina Import-Module la segnalazione dello stato di avanzamento durante il caricamento del modulo.
Senza il parametro Verbose, PassThru o AsCustomObject , Import-Module non genera alcun output quando importa un modulo.
Esempio 5: Limitare i membri del modulo importati in una sessione
Questo esempio illustra come limitare i membri del modulo importati nella sessione e l'effetto di questo comando nella sessione. Il parametro Function limita i membri importati dal modulo. È anche possibile usare i parametri Alias, Variable e Cmdlet per limitare altri membri importati da un modulo.
Il Get-Module cmdlet ottiene l'oggetto che rappresenta il modulo PSDiagnostics . La proprietà ExportedCmdlets elenca tutti i cmdlet che il modulo esporta, anche se non sono stati tutti importati.
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 PSDiagnosticsUsando il parametro Module del Get-Command cmdlet vengono visualizzati i comandi importati dal modulo PSDiagnostics . I risultati confermano che sono stati importati solo i Disable-PSTrace cmdlet e Enable-PSTrace .
Esempio 6: Importare i membri di un modulo e aggiungere un prefisso
In questo esempio viene importato il modulo PSDiagnostics nella sessione corrente, viene aggiunto un prefisso ai nomi dei membri e quindi vengono visualizzati i nomi dei membri con prefisso. Il parametro Prefix di Import-Module aggiunge il x prefisso a tutti i membri importati dal modulo. Il prefisso si applica solo ai membri della sessione corrente. Non modifica il modulo. Il parametro PassThru restituisce un oggetto modulo che rappresenta il modulo importato.
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 PSDiagnosticsGet-Command ottiene i membri importati dal modulo. L'output mostra che i membri del modulo sono correttamente preceduti da un prefisso.
Esempio 7: Ottenere e usare un oggetto personalizzato
In questo esempio viene illustrato come ottenere e usare l'oggetto personalizzato restituito da Import-Module.
Gli oggetti personalizzati includono membri sintetici che rappresentano ogni membro dei moduli importati. Ad esempio, i cmdlet e le funzioni in un modulo vengono convertiti in metodi di script dell'oggetto personalizzato.
Gli oggetti personalizzati sono utili per la creazione di script. Sono utili anche quando diversi oggetti importati hanno gli stessi nomi. L'uso del metodo di script di un oggetto equivale alla definizione del nome completo di un membro importato, incluso il relativo nome di modulo.
Il parametro AsCustomObject è utilizzabile solo quando si importa un modulo script. Usare Get-Module per determinare quale dei moduli disponibili è un modulo script.
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"()Il Show-Calendar modulo script viene importato usando il parametro AsCustomObject per richiedere un oggetto personalizzato e il parametro PassThru per restituire l'oggetto. L'oggetto personalizzato risultante viene salvato nella $a variabile .
La $a variabile viene inviata tramite pipe al Get-Member cmdlet per visualizzare le proprietà e i metodi dell'oggetto salvato. L'output mostra un Show-Calendar metodo di script.
Per chiamare il Show-Calendar metodo script, il nome del metodo deve essere racchiuso tra virgolette perché il nome include un trattino.
Esempio 8: Reimportare un modulo nella stessa sessione
Questo esempio illustra come usare il parametro Force di Import-Module quando si importa un modulo nella stessa sessione. Il parametro Force rimuove il modulo caricato e quindi lo importa nuovamente.
Import-Module PSDiagnostics
Import-Module PSDiagnostics -Force -Prefix PSIl primo comando importa il modulo PSDiagnostics . Il secondo comando importa nuovamente il modulo, questa volta usando il parametro Prefix .
Senza il parametro Force , la sessione includerà due copie di ogni cmdlet PSDiagnostics , una con il nome standard e una con il nome con prefisso.
Esempio 9: Eseguire comandi nascosti dai comandi importati
Questo esempio illustra come eseguire comandi che sono stati nascosti dai comandi importati. Il modulo TestModule include una funzione denominata Get-Date che restituisce l'anno e il giorno dell'anno.
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 PMIl primo Get-Date cmdlet restituisce un oggetto DateTime con la data corrente. Dopo l'importazione del modulo TestModule, Get-Date restituisce l'anno e il giorno dell'anno.
Usando il parametro All di Get-Command mostra tutti i Get-Date comandi nella sessione. I risultati mostrano che nella sessione sono presenti due Get-Date comandi, una funzione del modulo TestModule e un cmdlet del modulo Microsoft.PowerShell.Utility .
Poiché le funzioni hanno la precedenza sui cmdlet, la Get-Date funzione del modulo TestModule viene eseguita, anziché il Get-Date cmdlet . Per eseguire la versione originale di Get-Date, è necessario qualificare il nome del comando con il nome del modulo.
Per altre informazioni sulla precedenza dei comandi in PowerShell, vedere about_Command_Precedence.
Esempio 10: Importare una versione minima di un modulo
In questo esempio viene importato il modulo PowerShellGet . Usa il parametro MinimumVersion di Import-Module per importare solo la versione o una versione 2.0.0 successiva del modulo.
Import-Module -Name PowerShellGet -MinimumVersion 2.0.0È anche possibile usare il parametro RequiredVersion per importare una versione specifica di un modulo oppure usare i parametri Module e Version della #Requires parola chiave per richiedere una versione specifica di un modulo in uno script.
Esempio 11: Importare usando un nome completo
In questo esempio viene importata una versione specifica di un modulo usando 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' }Esempio 12: Importare usando un percorso completo
In questo esempio viene importata una versione specifica di un modulo usando il percorso completo.
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'Esempio 13: Importare un modulo da un computer remoto
Questo esempio illustra come usare il Import-Module cmdlet per importare un modulo da un computer remoto.
Questo comando usa la funzionalità di comunicazione remota implicita di PowerShell.
Quando si importano moduli da un'altra sessione, è possibile usare i cmdlet nella sessione corrente. Tuttavia, i comandi che usano i cmdlet vengono eseguiti nella sessione remota.
$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-TCPNew-PSSession crea una sessione remota (PSSession) nel Server01 computer. La sessione PSSession viene salvata nella $s variabile .
L'esecuzione Get-Module con il parametro PSSession indica che il modulo NetSecurity è installato e disponibile nel computer remoto. Questo comando equivale all'uso del cmdlet per eseguire Get-Module il Invoke-Command comando nella sessione remota. Ad esempio:
Invoke-Command $s {Get-Module -ListAvailable -Name NetSecurity
L'esecuzione Import-Module con il parametro PSSession importa il modulo NetSecurity dal computer remoto nella sessione corrente. Il Get-Command cmdlet recupera i comandi che iniziano con Get e includono Firewall dal modulo NetSecurity . L'output conferma che il modulo e i relativi cmdlet sono stati importati nella sessione corrente.
Get-NetFirewallRule Il cmdlet ottiene quindi le regole del firewall di Gestione remota Windows nel Server01 computer. Equivale a usare il cmdlet per l'esecuzione Invoke-CommandGet-NetFirewallRule nella sessione remota.
Esempio 14: Gestire l'archiviazione in un computer remoto senza il sistema operativo Windows
In questo esempio, l'amministratore del computer ha installato il provider WMI di individuazione moduli, che consente di usare i comandi CIM progettati per il provider.
Il New-CimSession cmdlet crea una sessione nel computer remoto denominato RSDGF03. La sessione si connette al servizio WMI nel computer remoto. La sessione CIM viene salvata nella $cs variabile .
Import-Moduleusa CimSession in $cs per importare il modulo CIM Archiviazione dal RSDGF03 computer.
Il Get-Command cmdlet mostra il Get-Disk comando nel modulo Archiviazione. Quando si importa un modulo CIM nella sessione locale, PowerShell converte i file CDXML per ogni comando in script di PowerShell, che vengono visualizzati come funzioni nella sessione locale.
Sebbene Get-Disk sia tipizzato nella sessione locale, il cmdlet viene eseguito in modo implicito nel computer remoto da cui è stato importato. Il comando restituisce oggetti dal computer remoto alla sessione locale.
$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 MBRParametri
-Alias
Specifica gli alias importati da questo cmdlet dal modulo nella sessione corrente. Immettere un elenco di alias delimitato da virgole. I caratteri jolly sono consentiti.
Alcuni moduli esportano automaticamente gli alias selezionati nella sessione quando si importa il modulo. Questo parametro consente di scegliere tra gli alias esportati.
| Type: | String[] |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | True |
-ArgumentList
Specifica una matrice di argomenti o valori di parametro passati a un modulo script durante il Import-Module comando. Questo parametro è valido solo quando si importa un modulo script.
È anche possibile fare riferimento al parametro ArgumentList in base al relativo alias, args. Per altre informazioni sul comportamento di ArgumentList, vedere about_Splatting.
| Type: | Object[] |
| Aliases: | Args |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-AsCustomObject
Indica che questo cmdlet restituisce un oggetto personalizzato con membri che rappresentano i membri del modulo importati. Questo parametro è valido solo per i moduli di script.
Quando si utilizza il parametro AsCustomObject , Import-Module importa i membri del modulo nella sessione e quindi restituisce un oggetto PSCustomObject anziché un oggetto PSModuleInfo . È possibile salvare l'oggetto personalizzato in una variabile e usare l'enumerazione di accesso ai membri per richiamare i membri.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | False |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Assembly
Specifica una matrice di oggetti assembly. Questo cmdlet importa i cmdlet e i provider implementati negli oggetti assembly specificati. Immettere una variabile che contiene oggetti assembly o un comando che crea oggetti assembly. È anche possibile inviare tramite pipe un oggetto assembly a Import-Module.
Quando si usa questo parametro, vengono importati solo i cmdlet e i provider implementati dagli assembly specificati. Se il modulo contiene altri file, non vengono importati e potrebbero mancare membri importanti del modulo. Usare questo parametro per il debug e il test del modulo oppure quando viene richiesto di usarlo dall'autore del modulo.
| Type: | Assembly[] |
| Position: | 0 |
| Default value: | None |
| Required: | True |
| Accept pipeline input: | True |
| Accept wildcard characters: | False |
-CimNamespace
Specifica lo spazio dei nomi di un provider CIM alternativo che espone i moduli CIM. Il valore predefinito è lo spazio dei nomi del provider WMI di individuazione del modulo.
Usare questo parametro per importare moduli CIM da computer e dispositivi che non eseguono un sistema operativo Windows.
Questo parametro è stato introdotto in Windows PowerShell 3.0.
| Type: | String |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-CimResourceUri
Specifica un percorso alternativo per i moduli CIM. Il valore predefinito è l'URI di risorsa del provider WMI di individuazione del modulo nel computer remoto.
Usare questo parametro per importare moduli CIM da computer e dispositivi che non eseguono un sistema operativo Windows.
Questo parametro è stato introdotto in Windows PowerShell 3.0.
| Type: | Uri |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-CimSession
Specifica una sessione CIM nel computer remoto. Immettere una variabile contenente la sessione CIM o un comando che ottiene la sessione CIM, ad esempio un comando Get-CimSession .
Import-Module usa la connessione di sessione CIM per importare moduli dal computer remoto nella sessione corrente. Quando si usano i comandi del modulo importato nella sessione corrente, i comandi vengono eseguiti nel computer remoto.
È possibile usare questo parametro per importare moduli da computer e dispositivi che non eseguono il sistema operativo Windows e i computer Windows che dispongono di PowerShell, ma che non hanno la comunicazione remota di PowerShell abilitata.
Questo parametro è stato introdotto in Windows PowerShell 3.0.
| Type: | CimSession |
| Position: | Named |
| Default value: | None |
| Required: | True |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Cmdlet
Specifica una matrice di cmdlet che questo cmdlet importa dal modulo nella sessione corrente. I caratteri jolly sono consentiti.
Alcuni moduli esportano automaticamente i cmdlet selezionati nella sessione quando si importa il modulo. Questo parametro consente di scegliere tra i cmdlet esportati.
| Type: | String[] |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | True |
-DisableNameChecking
Indica che questo cmdlet elimina il messaggio che avvisa quando si importa un cmdlet o una funzione il cui nome include un verbo non approvato o un carattere non consentito.
Per impostazione predefinita, quando un modulo che si importa esporta cmdlet o funzioni con verbi non approvati nei nomi, PowerShell visualizza il messaggio di avviso seguente:
AVVISO: alcuni nomi di comando importati includono verbi non approvati che potrebbero renderli meno individuabili. Usare il parametro Verbose per altri dettagli o digitare Get-Verb per visualizzare l'elenco dei verbi approvati.
Si tratta semplicemente di un avviso. Il modulo completo viene comunque importato, inclusi i comandi non conformi. Il messaggio viene visualizzato dagli utenti del modulo, tuttavia il problema di denominazione deve essere corretto dall'autore del modulo.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | False |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Force
Questo parametro fa sì che un modulo venga caricato o ricaricato sopra quello corrente.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | False |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-FullyQualifiedName
Il valore può essere un nome di modulo, una specifica completa del modulo o un percorso di un file di modulo.
Quando il valore è un percorso, il percorso può essere completo o relativo. Un percorso relativo viene risolto rispetto allo script che contiene l'istruzione using.
Quando il valore è un nome o una specifica del modulo, PowerShell cerca il modulo specificato in PSModulePath .
Una specifica del modulo è una tabella hash con le chiavi seguenti.
ModuleName- Obbligatorio Specifica il nome del modulo.GUID- Facoltativo Specifica il GUID del modulo.- È anche obbligatorio specificare almeno una delle tre chiavi seguenti.
ModuleVersion- Specifica una versione minima accettabile del modulo.MaximumVersion- Specifica la versione massima accettabile del modulo.RequiredVersion- Specifica una versione esatta e obbligatoria del modulo. Non è possibile usare questa opzione con le altre chiavi di versione.
| Type: | ModuleSpecification[] |
| Position: | 0 |
| Default value: | None |
| Required: | True |
| Accept pipeline input: | True |
| Accept wildcard characters: | False |
-Function
Specifica una matrice di funzioni importate dal modulo nella sessione corrente. I caratteri jolly sono consentiti. Alcuni moduli esportano automaticamente le funzioni selezionate nella sessione quando si importa il modulo. Questo parametro consente di scegliere tra le funzioni esportate.
| Type: | String[] |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | True |
-Global
Indica che questo cmdlet importa i moduli nello stato della sessione globale in modo che siano disponibili per tutti i comandi nella sessione.
Per impostazione predefinita, quando Import-Module il cmdlet viene chiamato dal prompt dei comandi, dal file di script o da scriptblock, tutti i comandi vengono importati nello stato della sessione globale.
Quando viene richiamato da un altro modulo, Import-Module il cmdlet importa i comandi in un modulo, inclusi i comandi dai moduli annidati, nello stato della sessione del modulo chiamante.
Suggerimento
È consigliabile evitare di chiamare Import-Module dall'interno di un modulo. Dichiarare invece il modulo di destinazione come modulo annidato nel manifesto del modulo padre. La dichiarazione di moduli annidati migliora l'individuabilità delle dipendenze.
Il parametro Global equivale al parametro Scope con un valore Global.
Per limitare i comandi esportati da un modulo, usare un Export-ModuleMember comando nel modulo script.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | False |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-MaximumVersion
Specifica una versione massima. Questo cmdlet importa solo una versione del modulo minore o uguale al valore specificato. Se nessuna versione è idonea, Import-Module restituisce un errore.
| Type: | String |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-MinimumVersion
Specifica una versione minima. Questo cmdlet importa solo una versione del modulo maggiore o uguale al valore specificato. Usare il nome del parametro MinimumVersion o il relativo alias, Version. Se nessuna versione è idonea, Import-Module genera un errore.
Per specificare una versione esatta, usare il parametro RequiredVersion . È anche possibile usare i parametri Module e Version della parola chiave #Requires per richiedere una versione specifica di un modulo in uno script.
Questo parametro è stato introdotto in Windows PowerShell 3.0.
| Type: | Version |
| Aliases: | Version |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-ModuleInfo
Specifica una matrice di oggetti modulo da importare. Immettere una variabile contenente gli oggetti modulo o un comando che ottiene gli oggetti modulo, ad esempio il comando seguente: Get-Module -ListAvailable. È anche possibile inviare tramite pipe gli oggetti modulo a Import-Module.
| Type: | PSModuleInfo[] |
| Position: | 0 |
| Default value: | None |
| Required: | True |
| Accept pipeline input: | True |
| Accept wildcard characters: | False |
-Name
Specifica i nomi dei moduli da importare. Immettere il nome del modulo o il nome di un file nel modulo, ad esempio un .psd1file , .psm1, .dllo .ps1 . I percorsi dei file sono facoltativi. I caratteri jolly non sono consentiti. È anche possibile inviare tramite pipe nomi di modulo e nomi file a Import-Module.
Se si omette un percorso, Import-Module cerca il modulo nei percorsi salvati nella $env:PSModulePath variabile di ambiente.
Specificare solo il nome del modulo, quando possibile. Quando si specifica un nome file, vengono importati solo i membri implementati in tale file. Se il modulo contiene altri file, non vengono importati e potrebbero mancare membri importanti del modulo.
Nota
Sebbene sia possibile importare un file script (.ps1) come modulo, i file di script in genere non sono strutturati come file di moduli script (.psm1). L'importazione di un file di script non garantisce che sia utilizzabile come modulo. Per altre informazioni, vedere about_Modules.
| Type: | String[] |
| Position: | 0 |
| Default value: | None |
| Required: | True |
| Accept pipeline input: | True |
| Accept wildcard characters: | True |
-NoClobber
Impedisce l'importazione di comandi con gli stessi nomi dei comandi esistenti nella sessione corrente. Per impostazione predefinita, Import-Module importa tutti i comandi del modulo esportati.
I comandi con gli stessi nomi possono nascondere o sostituire i comandi nella sessione. Per evitare conflitti di nomi di comando in una sessione, usare i parametri Prefix o NoClobber . Per altre informazioni sui conflitti di nomi e sulla precedenza dei comandi, vedere "Conflitti di moduli e nomi" in about_Modules e about_Command_Precedence.
Questo parametro è stato introdotto in Windows PowerShell 3.0.
| Type: | SwitchParameter |
| Aliases: | NoOverwrite |
| Position: | Named |
| Default value: | False |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-PassThru
Restituisce un oggetto che rappresenta il modulo importato. Per impostazione predefinita, questo cmdlet non genera alcun output.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | False |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Prefix
Specifica un prefisso aggiunto da questo cmdlet ai sostantivi nei nomi dei membri del modulo importati.
Usare questo parametro per evitare conflitti di nomi che potrebbero verificarsi quando più membri nella sessione hanno lo stesso nome. Questo parametro non modifica il modulo e non influisce sui file importati dal modulo per il proprio uso. Questi moduli sono noti come moduli annidati. Questo cmdlet influisce solo sui nomi dei membri nella sessione corrente.
Ad esempio, se si specifica il prefisso UTC e quindi si importa un Get-Date cmdlet, il cmdlet è noto nella sessione come Get-UTCDatee non viene confuso con il cmdlet originale Get-Date .
Il valore di questo parametro ha la precedenza sulla proprietà DefaultCommandPrefix del modulo, che specifica il prefisso predefinito.
| Type: | String |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-PSSession
Specifica una sessione gestita dall'utente di PowerShell (PSSession) da cui questo cmdlet importa i moduli nella sessione corrente. Immettere una variabile che contiene una sessione PSSession o un comando che ottiene una sessione PSSession, ad esempio un Get-PSSession comando.
Quando si importa un modulo da un'altra sessione nella sessione corrente, è possibile usare i cmdlet del modulo nella sessione corrente, così come si userebbero i cmdlet da un modulo locale. I comandi che usano i cmdlet remoti vengono eseguiti nella sessione remota, ma i dettagli della comunicazione remota vengono gestiti in background da PowerShell.
Questo parametro usa la funzionalità di comunicazione remota implicita di PowerShell. Equivale a usare il Import-PSSession cmdlet per importare moduli specifici da una sessione.
Import-Module non può importare i moduli di PowerShell di base da un'altra sessione. I moduli di PowerShell principali hanno nomi che iniziano con Microsoft.PowerShell.
Questo parametro è stato introdotto in Windows PowerShell 3.0.
| Type: | PSSession |
| Position: | Named |
| Default value: | None |
| Required: | True |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-RequiredVersion
Specifica una versione del modulo importata da questo cmdlet. Se la versione non è installata, Import-Module genera un errore.
Per impostazione predefinita, Import-Module importa il modulo senza controllare il numero di versione.
Per specificare una versione minima, usare il parametro MinimumVersion . È anche possibile usare i parametri Module e Version della parola chiave #Requires per richiedere una versione specifica di un modulo in uno script.
Questo parametro è stato introdotto in Windows PowerShell 3.0.
Gli script che usano RequiredVersion per importare i moduli inclusi nelle versioni esistenti del sistema operativo Windows non vengono eseguiti automaticamente nelle versioni future del sistema operativo Windows. Ciò è dovuto al fatto che i numeri di versione del modulo di PowerShell nelle versioni future del sistema operativo Windows sono superiori ai numeri di versione del modulo nelle versioni esistenti del sistema operativo Windows.
| Type: | Version |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Scope
Specifica un ambito in cui importare il modulo.
I valori validi per questo parametro sono:
- Globale. disponibile per tutti i comandi nella sessione. Equivalente al parametro Global .
- Locale. disponibile solo nell'ambito corrente.
Per impostazione predefinita, quando Import-Module il cmdlet viene chiamato dal prompt dei comandi, dal file di script o da scriptblock, tutti i comandi vengono importati nello stato della sessione globale. È possibile usare il -Scope Local parametro per importare il contenuto del modulo nell'ambito script o scriptblock.
Quando viene richiamato da un altro modulo, Import-Module il cmdlet importa i comandi in un modulo, inclusi i comandi dai moduli annidati, nello stato della sessione del chiamante. Specificando -Scope Global o -Global indica che questo cmdlet importa i moduli nello stato della sessione globale in modo che siano disponibili per tutti i comandi nella sessione.
Il parametro Global equivale al parametro Scope con un valore Global.
Questo parametro è stato introdotto in Windows PowerShell 3.0.
| Type: | String |
| Accepted values: | Local, Global |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-SkipEditionCheck
Ignora il controllo nel CompatiblePSEditions campo.
Consente il caricamento di un modulo dalla directory del "$($env:windir)\System32\WindowsPowerShell\v1.0\Modules" modulo in PowerShell Core quando tale modulo non specifica Core nel campo manifesto CompatiblePSEditions .
Quando si importa un modulo da un altro percorso, questa opzione non esegue alcuna operazione, perché il controllo non viene eseguito. In Linux e macOS questa opzione non esegue alcuna operazione.
Per altre informazioni, vedere about_PowerShell_Editions.
Avviso
Import-Module -SkipEditionCheck è comunque probabile che l'importazione di un modulo non riesca. Anche se ha esito positivo, richiamare un comando dal modulo potrebbe avere esito negativo in un secondo momento quando tenta di usare un'API incompatibile.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | False |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-UseWindowsPowerShell
Carica il modulo usando la funzionalità di compatibilità di Windows PowerShell. Per altre informazioni, vedere about_Windows_PowerShell_Compatibility .
| Type: | SwitchParameter |
| Aliases: | UseWinPS |
| Position: | Named |
| Default value: | False |
| Required: | True |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Variable
Specifica una matrice di variabili importate dal modulo nella sessione corrente. Immettere un elenco di variabili. I caratteri jolly sono consentiti.
Alcuni moduli esportano automaticamente le variabili selezionate nella sessione quando si importa il modulo. Questo parametro consente di scegliere tra le variabili esportate.
| Type: | String[] |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | True |
Input
È possibile inviare tramite pipe un nome di modulo a questo cmdlet.
È possibile inviare tramite pipe un oggetto modulo a questo cmdlet.
È possibile inviare tramite pipe un oggetto assembly a questo cmdlet.
Output
None
Per impostazione predefinita, questo cmdlet non restituisce alcun output.
Se si specifica il parametro PassThru , il cmdlet genera un oggetto System.Management.Automation.PSModuleInfo che rappresenta il modulo importato.
Se si specificano insieme i parametri AsCustomObject e PassThru , il cmdlet genera un oggetto PSCustomObject che rappresenta il modulo.
Note
PowerShell include gli alias seguenti per Import-Module:
Tutte le piattaforme:
ipmo
Prima di poter importare un modulo, il modulo deve essere accessibile al computer locale e incluso nella
PSModulePathvariabile ambientale. Per altre informazioni, vedere about_Modules.È anche possibile usare i parametri PSSession e CIMSession per importare moduli installati nei computer remoti. Tuttavia, i comandi che usano i cmdlet in questi moduli vengono eseguiti nella sessione remota nel computer remoto.
Se si importano membri con lo stesso nome e lo stesso tipo nella sessione, PowerShell usa il membro importato per ultimo per impostazione predefinita. Le variabili e gli alias vengono sostituiti e gli originali non sono accessibili. Le funzioni, i cmdlet e i provider sono semplicemente ombreggiati dai nuovi membri. È possibile accedervi qualificando il nome del comando con il nome dello snap-in, del modulo o del percorso della funzione.
Per aggiornare i dati di formattazione per i comandi importati da un modulo, usare il
Update-FormatDatacmdlet . Se il file di formattazione per un modulo cambia, usare ilUpdate-FormatDatacmdlet per aggiornare i dati di formattazione per i comandi importati. Non è necessario importare di nuovo il modulo.A partire da Windows PowerShell 3.0, i comandi di base installati con PowerShell sono inclusi nei moduli. In Windows PowerShell 2.0 e nei programmi host che creano sessioni di tipo precedente nelle versioni successive di PowerShell, i comandi principali vengono inseriti in pacchetti in snap-in (PSSnapins). L'eccezione è Microsoft.PowerShell.Core, che è sempre uno snap-in. Inoltre, le sessioni remote, ad esempio quelle avviate dal
New-PSSessioncmdlet, sono sessioni di tipo precedente che includono snap-in di base.Per informazioni sul metodo CreateDefault2 che crea sessioni in stile più recente con moduli di base, vedere il metodo CreateDefault2.
In Windows PowerShell 2.0 alcuni valori delle proprietà dell'oggetto modulo, ad esempio i valori della proprietà ExportedCmdlets e NestedModules , non venivano popolati fino all'importazione del modulo.
Se si tenta di importare un modulo che contiene assembly in modalità mista non compatibili con Windows PowerShell 3.0+,
Import-Modulerestituisce un messaggio di errore simile al seguente.Import-Module: l'assembly in modalità mista viene compilato in base alla versione 'v2.0.50727' del runtime e non può essere caricato nel runtime 4.0 senza informazioni aggiuntive sulla configurazione.
Questo errore si verifica quando un modulo progettato per Windows PowerShell 2.0 contiene almeno un assembly di moduli misti. Assembly di moduli misti che include codice gestito e non gestito, ad esempio C++ e C#.
Per importare un modulo contenente assembly in modalità mista, avviare Windows PowerShell 2.0 usando il comando seguente e quindi riprovare.
Import-ModulePowerShell.exe -Version 2.0Per usare la funzionalità di sessione CIM, nel computer remoto deve essere abilitata la comunicazione remotadi WS-Management e deve essere installato Strumentazione gestione Windows (WMI), che è l'implementazione Microsoft dello standard Common Information Model (CIM). Il computer deve inoltre disporre del provider WMI di individuazione del modulo o di un provider CIM alternativo con le stesse funzionalità di base.
È possibile usare la funzionalità di sessione CIM nei computer che non eseguono un sistema operativo Windows e nei computer Windows con PowerShell, ma non è abilitata la comunicazione remota di PowerShell.
È anche possibile usare i parametri CIM per ottenere moduli CIM dai computer in cui è abilitata la comunicazione remota di PowerShell, incluso il computer locale. Quando si crea una sessione CIM nel computer locale, PowerShell usa DCOM, anziché WMI, per creare la sessione.
Per impostazione predefinita,
Import-Moduleimporta i moduli nell'ambito globale anche quando viene chiamato da un ambito discendente. L'ambito di primo livello e tutti gli ambiti discendenti hanno accesso agli elementi esportati del modulo.In un ambito discendente limita
-Scope Locall'importazione a tale ambito e a tutti i relativi ambiti discendenti. Gli ambiti padre non visualizzano quindi i membri importati.Nota
Get-Modulemostra tutti i moduli caricati nella sessione corrente. Sono inclusi i moduli caricati localmente in un ambito discendente. UsareGet-Command -Module modulenameper visualizzare i membri caricati nell'ambito corrente.Import-Modulenon carica le definizioni di classe ed enumerazione nel modulo. Usare l'istruzioneusing moduleall'inizio dello script. Questo importa il modulo, incluse le definizioni di classe ed enumerazione. Per altre informazioni, vedere about_Using.Durante lo sviluppo di un modulo di script, è comune apportare modifiche al codice e quindi caricare la nuova versione del modulo usando
Import-Modulecon il parametro Force . Questa operazione funziona solo per le modifiche apportate alle funzioni nel modulo radice.Import-Modulenon ricarica i moduli annidati. Inoltre, non è possibile caricare classi o enumerazioni aggiornate.Per ottenere i membri del modulo aggiornati definiti nei moduli annidati, rimuovere il modulo con
Remove-Module, quindi importare nuovamente il modulo.Se il modulo è stato caricato con un'istruzione
using, è necessario avviare una nuova sessione per importare definizioni aggiornate per le classi e le enumerazioni. Le classi e le enumerazioni definite in PowerShell e importate con un'istruzioneusingnon possono essere scaricate.
Collegamenti correlati
Commenti e suggerimenti
Presto disponibile: nel corso del 2024 verranno dismessi i problemi di GitHub come meccanismo di feedback per il contenuto e verranno sostituiti con un nuovo sistema di feedback. Per altre informazioni, vedere: https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per