Condividi tramite

Import-Module

  • Riferimento
Modulo:
Microsoft.PowerShell.Core

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 PSDiagnostics

Esempio 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-Module

Esempio 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 $m

Il 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    PSDiagnostics

Usando 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    PSDiagnostics

Get-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 PS

Il 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 PM

Il 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-TCP

New-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-Command Get-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 di 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 MBR

Parametri

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

Tipo:String[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:Object[]
Alias:Args
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:Assembly[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly: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.

Tipo:String
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:Uri
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:CimSession
Posizione:Named
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:String[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Force

Questo parametro fa sì che un modulo venga caricato o ricaricato sopra quello corrente. Alcuni moduli caricano assembly esterni. L'importazione non riesce se si importa un modulo che carica una versione più recente di un assembly. Il parametro Force non può eseguire l'override dell'errore. Per caricare la nuova versione, è necessario avviare una nuova sessione.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.
Tipo:ModuleSpecification[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly: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.

Tipo:String[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:String
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:Version
Alias:Version
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:PSModuleInfo[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly: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.

Tipo:String[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly: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.

Tipo:SwitchParameter
Alias:NoOverwrite
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-PassThru

Restituisce un oggetto che rappresenta il modulo importato. Per impostazione predefinita, questo cmdlet non genera alcun output.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:String
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:PSSession
Posizione:Named
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:Version
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:String
Valori accettati:Local, Global
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-UseWindowsPowerShell

Carica il modulo usando la funzionalità di compatibilità di Windows PowerShell. Per altre informazioni, vedere about_Windows_PowerShell_Compatibility .

Tipo:SwitchParameter
Alias:UseWinPS
Posizione:Named
Valore predefinito:False
Necessario:True
Accettare l'input della pipeline:False
Accettare caratteri jolly: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.

Tipo:String[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:True

Input

String

È possibile inviare tramite pipe un nome di modulo a questo cmdlet.

PSModuleInfo

È possibile inviare tramite pipe un oggetto modulo a questo cmdlet.

Assembly

È possibile inviare tramite pipe un oggetto assembly a questo cmdlet.

Output

None

Per impostazione predefinita, questo cmdlet non restituisce alcun output.

PSModuleInfo

Se si specifica il parametro PassThru , il cmdlet genera un oggetto System.Management.Automation.PSModuleInfo che rappresenta il modulo importato.

PSCustomObject

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 PSModulePath variabile 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-FormatData cmdlet . Se il file di formattazione per un modulo cambia, usare il Update-FormatData cmdlet 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-PSSession cmdlet, 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-Module restituisce 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-Module

    PowerShell.exe -Version 2.0

  • Per 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-Module importa 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 Local l'importazione a tale ambito e a tutti i relativi ambiti discendenti. Gli ambiti padre non visualizzano quindi i membri importati.

    Nota

    Get-Module mostra tutti i moduli caricati nella sessione corrente. Sono inclusi i moduli caricati localmente in un ambito discendente. Usare Get-Command -Module modulename per visualizzare i membri caricati nell'ambito corrente.

  • Import-Module non carica le definizioni di classe ed enumerazione nel modulo. Usare l'istruzione using module all'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-Module con il parametro Force . Questa operazione funziona solo per le modifiche apportate alle funzioni nel modulo radice. Import-Module non 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'istruzione using non possono essere scaricate.