Import-Module

Import-Module
    [-Name] <String[]>
    [-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
    [-Name] <String[]>
    -PSSession <PSSession>
    [-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
    [-Name] <String[]>
    -CimSession <CimSession>
    [-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>]
    [-CimResourceUri <Uri>]
    [-CimNamespace <String>]
    [<CommonParameters>]

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

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

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

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

El cmdlet Import-Module agrega uno o varios módulos a la sesión actual. Los módulos que importe deben estar instalados en el equipo local o en un equipo remoto.

A partir de PowerShell 3.0, los módulos instalados se importan automáticamente a la sesión cuando se usan comandos o proveedores en el módulo. Sin embargo, todavía puede usar el comando Import-Module para importar un módulo y puede habilitar y deshabilitar la importación automática de módulos mediante la variable de preferencia $PSModuleAutoloadingPreference. Para obtener más información sobre los módulos, consulte about_Modules. Para obtener más información sobre la variable de $PSModuleAutoloadingPreference, vea about_Preference_Variables.

Un módulo es un paquete que contiene miembros que se pueden usar en PowerShell. Los miembros incluyen cmdlets, proveedores, scripts, funciones, variables y otros archivos y herramientas. Una vez importado un módulo, puede usar los miembros del módulo en la sesión.

Para importar un módulo, use elName , Assembly, ModuleInfo, MinimumVersion y los parámetros requiredVersion para identificar el módulo que se va a importar. De forma predeterminada, importa todos los miembros que exporta el módulo, pero puede usar los parámetrosalias de , Function, Cmdlety Variable para restringir los miembros que se importan. También puede usar el parámetro noClobber para evitar que Import-Module importe miembros que tengan los mismos nombres que los miembros de la sesión actual.

Import-Module importa un módulo solo en la sesión actual. Para importar el módulo en todas las sesiones, agregue un comando Import-Module al perfil de PowerShell. Para obtener más información sobre los perfiles, vea about_Profiles.

A partir de Windows PowerShell 3.0, puede usar Import-Module para importar módulos de Common Information Model (CIM), en los que los cmdlets se definen en archivos XML de definición de cmdlet (CDXML). Esta característica permite usar cmdlets que se implementan en ensamblados de código no administrados, como los escritos en C++.

Con estas nuevas características, Import-Module cmdlet se convierte en una herramienta principal para administrar empresas heterogéneas que incluyen equipos que ejecutan el sistema operativo Windows y los equipos que ejecutan otros sistemas operativos.

Para administrar equipos remotos que ejecutan el sistema operativo Windows con PowerShell y la comunicación remota de PowerShell habilitado, cree una PSSession en el equipo remoto y, a continuación, use el parámetro PSSession de Get-Module para obtener los módulos de PowerShell en la PSSession. Al importar los módulos y, a continuación, usar los comandos importados en la sesión actual, los comandos se ejecutan implícitamente en el PSSession de en el equipo remoto. Puede usar esta estrategia para administrar el equipo remoto.

Puede usar una estrategia similar para administrar equipos que no tienen habilitada la comunicación remota de PowerShell, incluidos los equipos que no ejecutan el sistema operativo Windows y los equipos Windows que tienen PowerShell, pero que no tienen habilitada la comunicación remota de PowerShell.

Empiece por crear una sesión CIM en el equipo remoto, que es una conexión a Instrumental de administración de Windows (WMI) en el equipo remoto. A continuación, use el parámetro CIMSession de para importar módulos CIM desde el equipo remoto. Al importar un módulo CIM y, a continuación, ejecutar los comandos importados, los comandos se ejecutan implícitamente en el equipo remoto. Puede usar esta estrategia WMI y CIM para administrar el equipo remoto.

En este ejemplo se importan los miembros del módulo de PSDiagnostics en la sesión actual. El Nombre nombre de parámetro es opcional y se puede omitir.

Import-Module -Name PSDiagnostics

De forma predeterminada, Import-Module no genera ningún resultado cuando importa un módulo. Para solicitar la salida, use el parámetro PassThru o AsCustomObject, o el parámetro Verbose common.

En este ejemplo se importan todos los módulos disponibles en la ruta de acceso especificada por la variable de entorno $env:PSModulePath en la sesión actual.

Get-Module -ListAvailable | Import-Module

En este ejemplo se importan los miembros de los módulos de PSDiagnostics y Dism en la sesión actual.

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

El cmdlet Get-Module obtiene los módulos de PSDiagnostics y Dism y guarda los objetos en la variable $m. El parámetro ListAvailable es necesario cuando se obtienen módulos que aún no se importan en la sesión.

El parámetro ModuleInfo de Import-Module se usa para importar los módulos en la sesión actual.

Estos comandos son equivalentes al uso de un operador de canalización (|) para enviar la salida de un comando de Get-Module a Import-Module.

En este ejemplo se usa una ruta de acceso explícita para identificar el módulo que se va a importar.

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

El uso del parámetro verbose hace que Import-Module notificar el progreso a medida que carga el módulo. Sin eldetallado de , PassThru o parámetro asCustomObject, no genera ninguna salida cuando importa un módulo.

En este ejemplo se muestra cómo restringir qué miembros del módulo se importan en la sesión y el efecto de este comando en la sesión.

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

El primer comando importa solo los cmdlets Disable-PSTrace y Enable-PSTrace del módulo de PSDiagnostics. El parámetro Function limita los miembros que se importan desde el módulo. También puede usar los parámetros de Alias, Variabley Cmdlet para restringir otros miembros que importa un módulo.

El cmdlet Get-Module obtiene el objeto que representa el módulo de PSDiagnostics. La propiedad ExportedCmdlets enumera todos los cmdlets que exporta el módulo, aunque no se importaron todos.

En el tercer comando, el parámetro Module del cmdlet obtiene los comandos que se importaron desde el módulo de PSDiagnostics. Los resultados confirman que solo se importaron los cmdlets Disable-PSTrace y Enable-PSTrace.

En este ejemplo se importa el módulo de PSDiagnostics en la sesión actual, se agrega un prefijo a los nombres de miembro y, a continuación, se muestran los nombres de miembro con prefijo. El prefijo solo se aplica a los miembros de la sesión actual. No cambia el módulo.

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

Usa el parámetro Prefix de Import-Module agrega el prefijo x a todos los miembros que se importan desde el módulo y el parámetro PassThru para devolver un objeto de módulo que representa el módulo importado.

El cmdlet Get-Command para obtener los miembros que se han importado desde el módulo. La salida muestra que los miembros del módulo tenían el prefijo correcto.

Estos comandos muestran cómo obtener y usar el objeto personalizado que import-Module devuelve.

Los objetos personalizados incluyen miembros sintéticos que representan cada uno de los miembros del módulo importado. Por ejemplo, los cmdlets y funciones de un módulo se convierten en métodos de script del objeto personalizado.

Los objetos personalizados son muy útiles en el scripting. También son útiles cuando varios objetos importados tienen los mismos nombres. El uso del método de script de un objeto es equivalente a especificar el nombre completo de un miembro importado, incluido su nombre de módulo.

El parámetro AsCustomObject solo se puede usar al importar un módulo de script, por lo que la primera tarea es determinar cuál de los módulos disponibles es un 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"()

El primer comando usa el cmdlet Get-Module para obtener los módulos disponibles. El comando usa un operador de canalización para pasar los objetos de módulo al cmdlet , que enumera el name y ModuleType de cada módulo de una tabla.

El segundo comando usa el cmdlet para importar el módulo de script show-calendar . El comando usa el parámetro AsCustomObject para solicitar un objeto personalizado y el parámetro PassThru para devolver el objeto. El comando guarda el objeto personalizado resultante en la variable $a.

El tercer comando usa un operador de canalización para enviar la variable $a al cmdlet Get-Member, que obtiene las propiedades y los métodos del PSCustomObject en $a. La salida muestra un método de script Show-Calendar().

El último comando usa el método de script Show-Calendar. El nombre del método debe incluirse entre comillas, ya que incluye un guión.

En este ejemplo se muestra cómo usar el parámetro Force de Import-Module cuando se vuelve a importar un módulo en la misma sesión.

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

El primer comando importa el módulo PSDiagnostics. El segundo comando vuelve a importar el módulo, esta vez con el parámetro prefijo .

Con el parámetro Force, Import-Module quita el módulo y, a continuación, lo importa de nuevo. Sin este parámetro, la sesión incluiría dos copias de cada cmdlet psDiagnostics, uno con el nombre estándar y otro con el nombre prefijo.

En este ejemplo se muestra cómo ejecutar comandos ocultos por comandos importados. El módulo TestModule. incluye una función denominada Get-Date que devuelve el año y el día del año.

Get-Date

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

Import-Module TestModule
Get-Date

19227

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

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

Microsoft.PowerShell.Utility\Get-Date

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

La primera fecha get-datecmdlet returns a **DateTime** object with the current date. After importing the **TestModule** module,Get-Date devuelve el año y el día del año.

Con el parámetro All del Get-Command obtenemos todos los comandos Get-Date de la sesión. Los resultados muestran que hay dos comandos Get-Date en la sesión, una función del módulo TestModule y un cmdlet del módulo Microsoft.PowerShell.Utility.

Dado que las funciones tienen prioridad sobre los cmdlets, se ejecuta la función Get-Date de módulo testModule, en lugar del cmdlet Get-Date. Para ejecutar la versión original de Get-Date debe calificar el nombre del comando con el nombre del módulo.

Para obtener más información sobre la precedencia de comandos en PowerShell, consulte about_Command_Precedence.

Import-Module -Name PSWorkflow -MinimumVersion 3.0.0.0

Este comando importa el módulo PSWorkflow. Usa el parámetro MinimumVersion de Import-Module para importar solo la versión 3.0.0.0 o posterior del módulo.

También puede usar el parámetro RequiredVersion para importar una versión determinada de un módulo o usar los parámetros module y Version de la palabra clave para requerir una versión determinada de un módulo en un script.

En este ejemplo se muestra cómo usar el cmdlet Import-Module para importar un módulo desde un equipo remoto. Este comando usa la característica comunicación remota implícita de PowerShell.

Al importar módulos desde otra sesión, puede usar los cmdlets de la sesión actual. Sin embargo, los comandos que usan los cmdlets se ejecutan realmente en la sesión 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

El primer comando usa el cmdlet New-PSSession para crear una sesión remota (PSSession) en el equipo Server01. El comando guarda el psSession de en la variable $s.

El segundo comando usa el parámetro PSSession del cmdlet para obtener el módulo de NetSecurity en la sesión de la variable . Este comando equivale a usar el cmdlet Invoke-Command para ejecutar un comando Get-Module en la sesión de $s (Invoke-Command $s {Get-Module -ListAvailable -Name NetSecurity). La salida muestra que el módulo NetSecurity está instalado en el equipo y está disponible para la sesión en la variable $s.

El tercer comando usa el parámetro PSSession del cmdlet para importar el módulo netSecurity de desde la sesión de la variable en la sesión actual.

El cuarto comando usa el cmdlet Get-Command para obtener comandos que comienzan con Get e incluyen Firewall desde el módulo de NetSecurity. La salida obtiene los comandos y confirma que el módulo y sus cmdlets se importaron en la sesión actual.

El quinto comando usa el cmdlet Get-NetFirewallRule para obtener reglas de firewall de administración remota de Windows en el equipo Server01. Este comando equivale a usar el cmdlet Invoke-Command para ejecutar un comando Get-NetFirewallRule en la sesión de la variable $s.

En este ejemplo, dado que el administrador del equipo ha instalado el proveedor WMI de detección de módulos, los comandos CIM pueden usar los valores predeterminados, que están diseñados para el proveedor.

Los comandos de este ejemplo permiten administrar los sistemas de almacenamiento de un equipo remoto que no ejecuta el sistema operativo Windows.

El primer comando usa el cmdlet New-CimSession para crear una sesión en el equipo remoto RSDGF03. La sesión se conecta a WMI en el equipo remoto. El comando guarda la sesión CIM en la variable $cs.

El segundo comando usa la sesión CIM en la variable $cs para ejecutar un comando Import-Module en el equipo RSDGF03. El comando usa el parámetro Name de para especificar el módulo CIM de Storage.

El tercer comando ejecuta el comando en el comando del módulo storage de . Al importar un módulo CIM en la sesión local, PowerShell convierte los archivos CDXML para cada comando en scripts de PowerShell, que aparecen como funciones en la sesión local.

El cuarto comando ejecuta el comando Get-Disk. Aunque el comando se escribe en la sesión local, se ejecuta implícitamente en el equipo remoto desde el que se importó. El comando obtiene objetos del equipo remoto y los devuelve a la sesión 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

Este cmdlet admite los parámetros comunes: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction y -WarningVariable. Para obtener más información, vea about_CommonParameters.

Puede canalizar un nombre de módulo, un objeto de módulo o un objeto de ensamblado a este cmdlet.

Este cmdlet devuelve un PSModuleInfo de o PSCustomObject. De forma predeterminada, Import-Module no genera ninguna salida. Si especifica el parámetro PassThru, el cmdlet genera un objeto System.Management.Automation.PSModuleInfo que representa el módulo. Si especifica el parámetro AsCustomObject, genera un objeto PSCustomObject.

• Para poder importar un módulo, el módulo debe instalarse en el equipo local. Es decir, el directorio del módulo debe copiarse en un directorio al que se pueda acceder al equipo local. Para obtener más información, vea about_Modules.

  También puede usar los parámetros PSSession y CIMSession para importar módulos instalados en equipos remotos. Sin embargo, los comandos que usan los cmdlets de estos módulos se ejecutan realmente en la sesión remota en el equipo remoto.

• Si importa miembros con el mismo nombre y el mismo tipo en la sesión, PowerShell usa el miembro importado por última vez de forma predeterminada. Las variables y alias se reemplazan y los originales no son accesibles. Las funciones, los cmdlets y los proveedores son simplemente sombreados por los nuevos miembros. Se puede acceder a ellos si califica el nombre del comando con el nombre de su complemento, módulo o ruta de acceso de la función.

• Para actualizar los datos de formato de los comandos que se han importado desde un módulo, use el cmdlet Update-FormatData. Update-FormatData también actualiza los datos de formato de los comandos de la sesión que se importaron desde módulos. Si cambia el archivo de formato de un módulo, puede ejecutar un comando Update-FormatData para actualizar los datos de formato de los comandos importados. No es necesario volver a importar el módulo.

• A partir de Windows PowerShell 3.0, los comandos principales que se instalan con PowerShell se empaquetan en módulos. En Windows PowerShell 2.0 y en programas host que crean sesiones de estilo anterior en versiones posteriores de PowerShell, los comandos principales se empaquetan en complementos (PSSnapins). La excepción es Microsoft.PowerShell.Core, que siempre es un complemento. Además, las sesiones remotas, como las iniciadas por el cmdlet New-PSSession, son sesiones de estilo anterior que incluyen complementos principales.

  Para obtener información sobre el método createDefault2 de que crea sesiones de estilo más reciente con módulos principales, consulte el Método CreateDefault2.

• Import-Module no puede importar módulos de PowerShell Core desde otra sesión. Los módulos de PowerShell Core tienen nombres que comienzan por Microsoft.PowerShell.

• En Windows PowerShell 2.0, algunos de los valores de propiedad del objeto module, como los ExportedCmdlets y nestedModules valores de propiedad, no se rellenaron hasta que se importó el módulo y no estaban disponibles en el objeto de módulo que devuelve el parámetro passThru . En Windows PowerShell 3.0, se rellenan todos los valores de propiedad del módulo.

• Si intenta importar un módulo que contiene ensamblados en modo mixto que no son compatibles con Windows PowerShell 3.0, Import-Module devuelve un mensaje de error similar al siguiente.

  Import-Module : el ensamblado de modo mixto se compila con la versión "v2.0.50727" del tiempo de ejecución y no se puede cargar en el entorno de ejecución 4.0 sin información de configuración adicional.

  Este error se produce cuando un módulo diseñado para Windows PowerShell 2.0 contiene al menos un ensamblado de módulo mixto, es decir, un ensamblado que incluye código administrado y no administrado, como C++ y C#.

  Para importar un módulo que contiene ensamblados en modo mixto, inicie Windows PowerShell 2.0 mediante el comando siguiente y vuelva a intentar el comando Import-Module.

  PowerShell.exe -Version 2.0

• Para usar la característica de sesión CIM, el equipo remoto debe tener WS-Management comunicación remota e Instrumental de administración de Windows (WMI), que es la implementación de Microsoft del estándar Common Information Model (CIM). El equipo también debe tener el proveedor WMI de detección de módulos o un proveedor CIM alternativo que tenga las mismas características básicas.

  Puede usar la característica de sesión CIM en equipos que no ejecutan un sistema operativo Windows y en equipos Windows con PowerShell, pero que no tienen habilitada la comunicación remota de PowerShell.

  También puede usar los parámetros CIM para obtener módulos CIM de equipos que tengan habilitada la comunicación remota de PowerShell, incluido el equipo local. Al crear una sesión CIM en el equipo local, PowerShell usa DCOM, en lugar de WMI, para crear la sesión.