Import-Module

Sintaxe

Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>] 
      [<CommonParameters>]

Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -PSSession <PSSession> 
      [<CommonParameters>]

Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -CimSession <CimSession>
      [-CimResourceUri <Uri>]
      [-CimNamespace <String>]
      [<CommonParameters>]

Import-Module
      [-Name] <string[]>
      -UseWindowsPowerShell
      [-Global]
      [-Prefix <string>]
      [-Function <string[]>]
      [-Cmdlet <string[]>]
      [-Variable <string[]>]
      [-Alias <string[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <version>]
      [-MaximumVersion <string>]
      [-RequiredVersion <version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <string>]
      [<CommonParameters>]

Import-Module
      [-Global]
      [-Prefix <String>]
      [-FullyQualifiedName] <ModuleSpecification[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>] 
      [<CommonParameters>]

Import-Module
      [-Global]
      [-Prefix <String>]
      [-FullyQualifiedName] <ModuleSpecification[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -PSSession <PSSession> 
      [<CommonParameters>]

Import-Module
      [-FullyQualifiedName] <ModuleSpecification[]>
      -UseWindowsPowerShell
      [-Global]
      [-Prefix <string>]
      [-Function <string[]>]
      [-Cmdlet <string[]>]
      [-Variable <string[]>]
      [-Alias <string[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <string>]
      [<CommonParameters>]

Import-Module
      [-Global]
      [-Prefix <String>]
      [-Assembly] <Assembly[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>] 
      [<CommonParameters>]

Import-Module
      [-Global]
      [-Prefix <String>]
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-SkipEditionCheck]
      [-PassThru]
      [-AsCustomObject]
      [-ModuleInfo] <PSModuleInfo[]>
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>] 
      [<CommonParameters>]

Description

O cmdlet Import-Module adiciona um ou mais módulos à sessão atual. A partir do PowerShell 3.0, os módulos instalados são automaticamente importados para a sessão quando você usa comandos ou provedores no módulo. No entanto, você ainda pode usar o comando Import-Module para importar um módulo. Você pode desabilitar a importação automática de módulo usando a variável de preferência $PSModuleAutoloadingPreference. Para obter mais informações sobre a variável $PSModuleAutoloadingPreference, consulte about_Preference_Variables.

Um módulo é um pacote que contém membros que podem ser usados no PowerShell. Os membros incluem cmdlets, provedores, scripts, funções, variáveis e outras ferramentas e arquivos. Depois que um módulo é importado, você pode usar os membros do módulo em sua sessão. Para obter mais informações sobre módulos, consulte about_Modules.

Por padrão, Import-Module importa todos os membros exportados pelo módulo, mas você pode usar os parâmetros Alias, Function, Cmdlete Variable para restringir quais membros são importados. O parâmetro NoClobber impede que Import-Module importem membros que tenham os mesmos nomes que os membros na sessão atual.

Import-Module importa um módulo apenas para a sessão atual. Para importar o módulo para cada nova sessão, adicione um comando Import-Module ao seu perfil do PowerShell. Para obter mais informações sobre perfis, consulte about_Profiles.

Você pode gerenciar computadores Windows remotos que têm a comunicação remota do PowerShell habilitada criando um PSSession no computador remoto. Em seguida, use o parâmetro PSSession de Import-Module para importar os módulos instalados no computador remoto. Quando você usa os comandos importados na sessão atual, os comandos são executados implicitamente no computador remoto.

A partir do Windows PowerShell 3.0, você pode usar Import-Module para importar módulos do CIM (Common Information Model). Os módulos CIM definem cmdlets em arquivos CDXML (Cmdlet Definition XML). Esse recurso permite que você use cmdlets que são implementados em assemblies de código não gerenciados, como aqueles escritos em C++.

Para computadores remotos que não têm a comunicação remota do PowerShell habilitada, incluindo computadores que não executam o sistema operacional Windows, você pode usar o parâmetro CIMSession de Import-Module para importar módulos CIM do computador remoto. Os comandos importados são executados implicitamente no computador remoto. Um CIMSession é uma conexão com a WMI (Instrumentação de Gerenciamento do Windows) no computador remoto.

Exemplos

Exemplo 1: importar os membros de um módulo para a sessão atual

Este exemplo importa os membros do módulo PSDiagnostics para a sessão atual.

Import-Module -Name PSDiagnostics

Exemplo 2: importar todos os módulos especificados pelo caminho do módulo

Este exemplo importa todos os módulos disponíveis no caminho especificado pela variável de ambiente $env:PSModulePath para a sessão atual.

Get-Module -ListAvailable | Import-Module

Exemplo 3: Importar os membros de vários módulos para a sessão atual

Este exemplo importa os membros dos módulos PSDiagnostics e Dism para a sessão atual.

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

O cmdlet obtém os módulos PSDiagnostics e Dism e salva os objetos na variável . O parâmetro ListAvailable é necessário quando você está recebendo módulos que ainda não foram importados para a sessão.

O parâmetro ModuleInfo de Import-Module é usado para importar os módulos para a sessão atual.

Exemplo 4: Importar todos os módulos especificados por um caminho

Este exemplo usa um caminho explícito para identificar o módulo a ser importado.

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

Usar o parâmetro Verbose faz com que Import-Module relate o progresso à medida que carrega o módulo. Sem odetalhado , PassThru ou parâmetro AsCustomObject, não gera nenhuma saída quando importa um módulo.

Exemplo 5: restringir os membros do módulo importados para uma sessão

Este exemplo mostra como restringir quais membros do módulo são importados para a sessão e o efeito desse comando na sessão. O parâmetro da Função limita os membros importados do módulo. Você também pode usar os parâmetros Alias, Variablee Cmdlet para restringir outros membros importados por um módulo.

O cmdlet obtém o objeto que representa o módulo PSDiagnostics . A propriedade ExportedCmdlets lista todos os cmdlets exportados pelo módulo, embora nem todos tenham sido importados.

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

O uso do parâmetro Module do cmdlet mostra os comandos importados do módulo PSDiagnostics . Os resultados confirmam que somente os cmdlets Disable-PSTrace e Enable-PSTrace foram importados.

Exemplo 6: importar os membros de um módulo e adicionar um prefixo

Este exemplo importa o módulo PSDiagnostics para a sessão atual, adiciona um prefixo aos nomes de membro e exibe os nomes de membro prefixados. O parâmetro prefixo de adiciona o prefixo a todos os membros importados do módulo. O prefixo se aplica somente aos membros na sessão atual. Ele não altera o módulo. O parâmetro PassThru retorna um objeto de módulo que representa o módulo importado.

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 obtém os membros que foram importados do módulo. A saída mostra que os membros do módulo foram prefixados corretamente.

Exemplo 7: Obter e usar um objeto personalizado

Este exemplo demonstra como obter e usar o objeto personalizado retornado por Import-Module.

Os objetos personalizados incluem membros sintéticos que representam cada um dos membros do módulo importado. Por exemplo, os cmdlets e as funções em um módulo são convertidos em métodos de script do objeto personalizado.

Objetos personalizados são úteis no script. Eles também são úteis quando vários objetos importados têm os mesmos nomes. Usar o método de script de um objeto é equivalente a especificar o nome totalmente qualificado de um membro importado, incluindo o nome do módulo.

O parâmetro AsCustomObject só é utilizável ao importar um módulo de script. Use Get-Module para determinar qual dos módulos disponíveis é um módulo de 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"()

O módulo de script é importado usando o parâmetro AsCustomObject para solicitar um objeto personalizado e o parâmetro PassThru para retornar o objeto. O objeto personalizado resultante é salvo na variável $a.

A variável $a é canalizada para o cmdlet Get-Member para mostrar as propriedades e os métodos do objeto salvo. A saída mostra um método de script Show-Calendar.

Para chamar o método de script Show-Calendar, o nome do método deve estar entre aspas porque o nome inclui um hífen.

Exemplo 8: Reimportar um módulo na mesma sessão

Este exemplo mostra como usar o parâmetro Force de Import-Module ao reimportar um módulo para a mesma sessão. O parâmetro Force remove o módulo carregado e o importa novamente.

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

O primeiro comando importa o módulo PSDiagnostics . O segundo comando importa o módulo novamente, desta vez usando o parâmetro prefixo .

Sem o parâmetro Force, a sessão incluiria duas cópias de cada cmdlet PSDiagnostics, uma com o nome padrão e outra com o nome prefixado.

Exemplo 9: executar comandos que foram ocultos por comandos importados

Este exemplo mostra como executar comandos ocultos por comandos importados. O módulo TestModule inclui uma função chamada Get-Date que retorna o ano e o dia do ano.

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

O primeiro cmdlet Get-Date retorna um objeto DateTime com a data atual. Depois de importar o módulo TestModule, retorna o ano e o dia do ano.

Usando o parâmetro Todos os de Get-Command mostrar todos os comandos Get-Date na sessão. Os resultados mostram que há dois comandos Get-Date na sessão, uma função do módulo TestModule e um cmdlet do módulo Microsoft.PowerShell.Utility.

Como as funções têm precedência sobre cmdlets, a função Get-Date do módulo TestModule é executada, em vez do cmdlet Get-Date. Para executar a versão original do Get-Date, você deve qualificar o nome do comando com o nome do módulo.

Para obter mais informações sobre a precedência de comando no PowerShell, consulte about_Command_Precedence.

Exemplo 10: Importar uma versão mínima de um módulo

Este exemplo importa o módulo PowerShellGet. Ele usa o parâmetro MinimumVersion de Import-Module para importar apenas 2.0.0 de versão ou superior do módulo.

Import-Module -Name PowerShellGet -MinimumVersion 2.0.0

Você também pode usar o parâmetro RequiredVersion para importar uma versão específica de um módulo ou usar os parâmetros do módulo e versão da palavra-chave para exigir uma versão específica de um módulo em um script.

Exemplo 11: Importar usando um nome totalmente qualificado

Este exemplo importa uma versão específica de um módulo usando o 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' }

Exemplo 12: Importar usando um caminho totalmente qualificado

Este exemplo importa uma versão específica de um módulo usando o caminho totalmente qualificado.

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'

Exemplo 13: Importar um módulo de um computador remoto

Este exemplo mostra como usar o cmdlet Import-Module para importar um módulo de um computador remoto. Esse comando usa o recurso de Comunicação Remota Implícita do PowerShell.

Ao importar módulos de outra sessão, você pode usar os cmdlets na sessão atual. No entanto, os comandos que usam os cmdlets são executados na sessão 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 cria uma sessão remota (PSSession ) para o computador Server01. O de PSSession é salvo na variável .

Executar com o parâmetro PSSession mostra que o módulo NetSecurity está instalado e disponível no computador remoto. Esse comando é equivalente a usar o cmdlet Invoke-Command para executar Get-Module comando na sessão remota. Por exemplo:

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

Executar com o parâmetro PSSession importa o módulo NetSecurity do computador remoto para a sessão atual. O cmdlet recupera comandos que começam com e incluem do módulo NetSecurity. A saída confirma que o módulo e seus cmdlets foram importados para a sessão atual.

Em seguida, o cmdlet Get-NetFirewallRule obtém regras de firewall de Gerenciamento Remoto do Windows no computador Server01. Isso equivale a usar o cmdlet Invoke-Command para executar Get-NetFirewallRule na sessão remota.

Exemplo 14: Gerenciar o armazenamento em um computador remoto sem o sistema operacional Windows

Neste exemplo, o administrador do computador instalou o provedor WMI de Descoberta de Módulo, que permite usar comandos CIM projetados para o provedor.

O cmdlet New-CimSession cria uma sessão no computador remoto chamado RSDGF03. A sessão se conecta ao serviço WMI no computador remoto. A sessão CIM é salva na variável $cs. usa o cimSession em para importar o módulo CIM de Armazenamento do computador .

O cmdlet mostra o comando no módulo de Armazenamento do . Quando você importa um módulo CIM para a sessão local, o PowerShell converte os arquivos CDXML para cada comando em scripts do PowerShell, que aparecem como funções na sessão local.

Embora Get-Disk seja digitado na sessão local, o cmdlet é executado implicitamente no computador remoto do qual foi importado. O comando retorna objetos do computador remoto para a sessão local.

$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

Parâmetros

-Alias

-ArgumentList

-AsCustomObject

-Assembly

-CimNamespace

-CimResourceUri

-CimSession

-Cmdlet

-DisableNameChecking

-Force

-FullyQualifiedName

-Function

-Global

-MaximumVersion

-MinimumVersion

-ModuleInfo

-Name

-NoClobber

-PassThru

-Prefix

-PSSession

-RequiredVersion

-Scope

-SkipEditionCheck

-UseWindowsPowerShell

-Variable

Entradas

String

Você pode canalizar um nome de módulo para este cmdlet.

PSModuleInfo

Você pode canalizar um objeto de módulo para este cmdlet.

Assembly

Você pode canalizar um objeto de assembly para este cmdlet.

Saídas

None

Por padrão, esse cmdlet não retorna nenhuma saída.

PSModuleInfo

Se você especificar o parâmetro PassThru, o cmdlet gerará um objeto System.Management.Automation.PSModuleInfo que representa o módulo importado.

PSCustomObject

Se você especificar os parâmetros AsCustomObject e PassThru juntos, o cmdlet gerará um objeto PSCustomObject que representa o módulo.

Observações

O PowerShell inclui os seguintes aliases para Import-Module:

• Todas as plataformas:

  • ipmo

• Antes de importar um módulo, o módulo deve estar acessível ao computador local e incluído na variável de ambiente PSModulePath. Para obter mais informações, consulte about_Modules.

  Você também pode usar o de PSSession e parâmetros CIMSession para importar módulos instalados em computadores remotos. No entanto, os comandos que usam os cmdlets nesses módulos são executados na sessão remota no computador remoto.

• Se você importar membros com o mesmo nome e o mesmo tipo para sua sessão, o PowerShell usará o membro importado por último por padrão. Variáveis e aliases são substituídos e os originais não são acessíveis. Funções, cmdlets e provedores são meramente sombreados pelos novos membros. Eles podem ser acessados qualificando o nome do comando com o nome de seu snap-in, módulo ou caminho de função.

• Para atualizar os dados de formatação para comandos importados de um módulo, use o cmdlet Update-FormatData. Se o arquivo de formatação de um módulo for alterado, use o cmdlet Update-FormatData para atualizar os dados de formatação para comandos importados. Você não precisa importar o módulo novamente.

• A partir do Windows PowerShell 3.0, os comandos principais instalados com o PowerShell são empacotados em módulos. No Windows PowerShell 2.0 e em programas de host que criam sessões de estilo mais antigo em versões posteriores do PowerShell, os comandos principais são empacotados em snap-ins (PSSnapins). A exceção é Microsoft.PowerShell.Core, que é sempre um snap-in. Além disso, sessões remotas, como as iniciadas pelo cmdlet New-PSSession, são sessões de estilo mais antigo que incluem snap-ins principais.

  Para obter informações sobre o método CreateDefault2 que cria sessões de estilo mais recente com módulos principais, consulte o método CreateDefault2.

• No Windows PowerShell 2.0, alguns valores de propriedade do objeto do módulo, como os ExportedCmdlets e NestedModules valores de propriedade, não foram preenchidos até que o módulo fosse importado.

• Se você tentar importar um módulo que contém assemblies de modo misto que não são compatíveis com o Windows PowerShell 3.0+, Import-Module retornará uma mensagem de erro como a seguinte.

  Import-Module: o assembly de modo misto é criado com base na versão 'v2.0.50727' do runtime e não pode ser carregado no runtime 4.0 sem informações de configuração adicionais.

  Esse erro ocorre quando um módulo projetado para o Windows PowerShell 2.0 contém pelo menos um assembly de módulo misto. Um assembly de módulo misto que inclui código gerenciado e não gerenciado, como C++ e C#.

  Para importar um módulo que contém assemblies de modo misto, inicie o Windows PowerShell 2.0 usando o comando a seguir e tente o comando Import-Module novamente.

  PowerShell.exe -Version 2.0

• Para usar o recurso de sessão CIM, o computador remoto deve ter WS-Management comunicação remota e A WMI (Instrumentação de Gerenciamento do Windows), que é a implementação da Microsoft do padrão CIM (Common Information Model). O computador também deve ter o provedor WMI de Descoberta de Módulo ou um provedor DE CIM alternativo que tenha os mesmos recursos básicos.

  Você pode usar o recurso de sessão CIM em computadores que não estão executando um sistema operacional Windows e em computadores Windows que têm o PowerShell, mas não têm a comunicação remota do PowerShell habilitada.

  Você também pode usar os parâmetros CIM para obter módulos CIM de computadores que têm a comunicação remota do PowerShell habilitada, incluindo o computador local. Quando você cria uma sessão CIM no computador local, o PowerShell usa o DCOM, em vez do WMI, para criar a sessão.

• Por padrão, Import-Module importa módulos no escopo global mesmo quando chamados de um escopo descendente. O escopo de nível superior e todos os escopos descendentes têm acesso aos elementos exportados do módulo.

  Em um escopo descendente, -Scope Local limita a importação para esse escopo e todos os seus escopos descendentes. Em seguida, os escopos pai não veem os membros importados.

  Nota

  Get-Module mostra todos os módulos carregados na sessão atual. Isso inclui módulos carregados localmente em um escopo descendente. Use Get-Command -Module modulename para ver quais membros são carregados no escopo atual.

• Import-Module não carrega definições de classe e enumeração no módulo. Use a instrução using module no início do script. Isso importa o módulo, incluindo as definições de classe e enumeração. Para obter mais informações, consulte about_Using.

• Durante o desenvolvimento de um módulo de script, é comum fazer alterações no código e carregar a nova versão do módulo usando Import-Module com o parâmetro Force. Isso funciona apenas para alterações em funções no módulo raiz. Import-Module não recarrega nenhum módulo aninhado. Além disso, não há como carregar classes ou enumerações atualizadas.

  Para obter os membros do módulo atualizados definidos em módulos aninhados, remova o módulo com Remove-Modulee importe o módulo novamente.

  Se o módulo tiver sido carregado com uma instrução using, você deverá iniciar uma nova sessão para importar definições atualizadas para as classes e enumerações. Classes e enumerações definidas no PowerShell e importadas com uma instrução using não podem ser descarregadas.

Links Relacionados

• about_Modules
• Export-ModuleMember
• Get-Module
• New-Module
• Remove-Module
• about_PowerShell_Editions