Condividi tramite

Get-Module

  • Riferimento
Modulo:
Microsoft.PowerShell.Core

Elencare i moduli importati nella sessione corrente o che possono essere importati da PSModulePath.

Sintassi

Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-All]
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-All]
   [-ListAvailable]
   [-PSEdition <String>]
   [-SkipEditionCheck]
   [-Refresh]
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-ListAvailable]
   [-PSEdition <String>]
   [-SkipEditionCheck]
   [-Refresh]
   -PSSession <PSSession>
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-ListAvailable]
   [-SkipEditionCheck]
   [-Refresh]
   -CimSession <CimSession>
   [-CimResourceUri <Uri>]
   [-CimNamespace <String>]
   [<CommonParameters>]

Descrizione

Il Get-Module cmdlet elenca i moduli di PowerShell importati o che possono essere importati in una sessione di PowerShell. Senza parametri, Get-Module ottiene i moduli importati nella sessione corrente. Il parametro ListAvailable viene usato per elencare i moduli disponibili per l'importazione dai percorsi specificati nella variabile di ambiente PSModulePath ($env:PSModulePath).

L'oggetto modulo che Get-Module restituisce contiene informazioni utili sul modulo. È anche possibile inviare tramite pipe gli oggetti modulo ad altri cmdlet, ad esempio i Import-Module cmdlet e Remove-Module .

Get-Module elenca i moduli, ma non li importa. A partire da Windows PowerShell 3.0, i moduli vengono importati automaticamente quando si usa un comando nel modulo, ma un Get-Module comando non attiva un'importazione automatica. È anche possibile importare i moduli nella sessione usando il Import-Module cmdlet .

A partire da Windows PowerShell 3.0, è possibile ottenere e quindi importare moduli da sessioni remote nella sessione locale. Questa strategia usa la funzionalità di comunicazione remota implicita di PowerShell ed è equivalente all'uso del Import-PSSession cmdlet . Quando si usano i comandi nei moduli importati da un'altra sessione, i comandi vengono eseguiti in modo implicito nella sessione remota. Questa funzionalità consente di gestire il computer remoto dalla sessione locale.

Inoltre, a partire da Windows PowerShell 3.0, è possibile usare Get-Module e Import-Module per ottenere e 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++.

La comunicazione remota implicita può essere usata per gestire i computer remoti in cui è abilitata la comunicazione remota di PowerShell. Creare una sessione PSSession nel computer remoto e quindi usare il parametro PSSession di per Get-Module ottenere i moduli di PowerShell nella sessione remota. Quando si importa un modulo dalla sessione remota, i comandi importati vengono eseguiti nella sessione nel computer remoto.

È possibile usare una strategia simile per gestire i computer in cui la comunicazione remota di PowerShell non è abilitata. Tra questi sono inclusi i computer che non eseguono il sistema operativo Windows e i computer che dispongono di PowerShell ma che non dispongono della comunicazione remota di PowerShell abilitata.

Per iniziare, creare una sessione CIM nel computer remoto. Una sessione CIM è una connessione a Strumentazione gestione Windows (WMI) nel computer remoto. Usare quindi il parametro CIMSession di Get-Module per ottenere moduli CIM dalla sessione CIM. Quando si importa un modulo CIM usando il Import-Module cmdlet e quindi si eseguono i comandi importati, i comandi vengono eseguiti in modo implicito nel computer remoto. È possibile usare questa strategia WMI e CIM per gestire il computer remoto.

Esempio

Esempio 1: Ottenere i moduli importati nella sessione corrente

Get-Module

Questo comando ottiene i moduli che sono stati importati nella sessione corrente.

Esempio 2: Ottenere moduli installati e moduli disponibili

Get-Module -ListAvailable

Questo comando ottiene i moduli installati nel computer che possono essere importati nella sessione corrente.

Get-Module cerca i moduli disponibili nel percorso specificato dalla variabile di ambiente $env:PSModulePath . Per altre informazioni su PSModulePath, vedere about_Modules e about_Environment_Variables.

Esempio 3: Ottenere tutti i file esportati

Get-Module -ListAvailable -All

Questo comando ottiene tutti i file esportati per tutti i moduli disponibili.

Esempio 4: Ottenere un modulo in base al nome completo

$FullyQualifiedName = @{ModuleName="Microsoft.PowerShell.Management";ModuleVersion="3.1.0.0"}
Get-Module -FullyQualifiedName $FullyQualifiedName | Format-Table -Property Name,Version

Name                             Version
----                             -------
Microsoft.PowerShell.Management  3.1.0.0

Questo esempio ottiene il modulo Microsoft.PowerShell.Management specificando il nome completo del modulo usando il parametro FullyQualifiedName . Il comando invia quindi tramite pipe i risultati nel Format-Table cmdlet per formattare i risultati come tabella con Nome e Versione come intestazioni di colonna.

In un nome completo per un modulo, il valore ModuleVersion funge da versione minima. Pertanto, per questo esempio corrisponde a qualsiasi modulo Microsoft.PowerShell.Management versione 3.1.0.0 o successiva.

Esempio 5: Ottenere le proprietà di un modulo

Get-Module | Get-Member -MemberType Property | Format-Table Name

Name
----
AccessMode
Author
ClrVersion
CompanyName
Copyright
Definition
Description
DotNetFrameworkVersion
ExportedAliases
ExportedCmdlets
ExportedCommands
ExportedFormatFiles
ExportedFunctions
ExportedTypeFiles
ExportedVariables
ExportedWorkflows
FileList
Guid
HelpInfoUri
LogPipelineExecutionDetails
ModuleBase
ModuleList
ModuleType
Name
NestedModules
OnRemove
Path
PowerShellHostName
PowerShellHostVersion
PowerShellVersion
PrivateData
ProcessorArchitecture
RequiredAssemblies
RequiredModules
RootModule
Scripts
SessionState
Version

Questo comando ottiene le proprietà dell'oggetto PSModuleInfo che Get-Module restituisce. Esiste un oggetto per ogni file di modulo.

È possibile usare le proprietà per formattare e filtrare gli oggetti del modulo. Per altre informazioni sulle proprietà, vedere Proprietà PSModuleInfo.

L'output include le nuove proprietà, ad esempio Author e CompanyName, introdotte in Windows PowerShell 3.0.

Esempio 6: Raggruppare tutti i moduli in base al nome

Get-Module -ListAvailable -All | Format-Table -Property Name, Moduletype, Path -Groupby Name

Name: AppLocker

Name      ModuleType Path
----      ---------- ----
AppLocker   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\AppLocker\AppLocker.psd1


   Name: Appx

Name ModuleType Path
---- ---------- ----
Appx   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\en-US\Appx.psd1
Appx   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\Appx.psd1
Appx     Script C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\Appx.psm1


   Name: BestPractices

Name          ModuleType Path
----          ---------- ----
BestPractices   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\BestPractices\BestPractices.psd1


   Name: BitsTransfer

Name         ModuleType Path
----         ---------- ----
BitsTransfer   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\BitsTransfer\BitsTransfer.psd1

Questo comando ottiene tutti i file di modulo, sia importati che disponibili e quindi li raggruppa in base al nome del modulo. In questo modo è possibile visualizzare i file di modulo esportati da ogni script.

Esempio 7: Visualizzare il contenuto di un manifesto del modulo

Questi comandi visualizzano il contenuto del manifesto del modulo per il modulo BitsTransfer di Windows PowerShell.

I moduli non devono avere file manifesto. Quando hanno un file manifesto, il file manifesto è necessario solo per includere un numero di versione. Tuttavia, i file manifesto forniscono spesso informazioni utili su un modulo, i requisiti e il relativo contenuto.

# First command
$m = Get-Module -list -Name BitsTransfer

# Second command
Get-Content $m.Path

@ {
    GUID               = "{8FA5064B-8479-4c5c-86EA-0D311FE48875}"
    Author             = "Microsoft Corporation"
    CompanyName        = "Microsoft Corporation"
    Copyright          = "Microsoft Corporation. All rights reserved."
    ModuleVersion      = "1.0.0.0"
    Description        = "Windows PowerShell File Transfer Module"
    PowerShellVersion  = "2.0"
    CLRVersion         = "2.0"
    NestedModules      = "Microsoft.BackgroundIntelligentTransfer.Management"
    FormatsToProcess   = "FileTransfer.Format.ps1xml"
    RequiredAssemblies = Join-Path $psScriptRoot "Microsoft.BackgroundIntelligentTransfer.Management.Interop.dll"
}

Il primo comando ottiene l'oggetto PSModuleInfo che rappresenta il modulo BitsTransfer. Salva l'oggetto nella $m variabile .

Il secondo comando usa il Get-Content cmdlet per ottenere il contenuto del file manifesto nel percorso specificato. Usa la notazione punto per ottenere il percorso del file manifesto, archiviato nella proprietà Path dell'oggetto . L'output mostra il contenuto del manifesto del modulo.

Esempio 8: Elencare i file nella directory del modulo

dir (Get-Module -ListAvailable FileTransfer).ModuleBase

Directory: C:\Windows\system32\WindowsPowerShell\v1.0\Modules\FileTransfer
Mode                LastWriteTime     Length Name
----                -------------     ------ ----
d----        12/16/2008  12:36 PM            en-US
-a---        11/19/2008  11:30 PM      16184 FileTransfer.Format.ps1xml
-a---        11/20/2008  11:30 PM       1044 FileTransfer.psd1
-a---        12/16/2008  12:20 AM     108544 Microsoft.BackgroundIntelligentTransfer.Management.Interop.dll

Questo comando elenca i file nella directory del modulo. Si tratta di un altro modo per determinare il contenuto di un modulo prima di importarlo. Alcuni moduli potrebbero contenere file della Guida o file Leggimi che descrivono il modulo.

Esempio 9: Ottenere moduli installati in un computer

$s = New-PSSession -ComputerName Server01

Get-Module -PSSession $s -ListAvailable

Questi comandi ottengono i moduli installati nel computer Server01.

Il primo comando usa il New-PSSession cmdlet per creare una sessione PSSession nel computer Server01. Il comando salva la sessione PSSession nella $s variabile .

Il secondo comando usa i parametri PSSession e ListAvailable di Get-Module per ottenere i moduli nella sessione PSSession nella $s variabile .

Se si inviano tramite pipe i moduli da altre sessioni al Import-Module cmdlet, Import-Module importa il modulo nella sessione corrente usando la funzionalità di comunicazione remota implicita. Equivale a usare il Import-PSSession cmdlet . È possibile usare i cmdlet del modulo nella sessione corrente, tuttavia i comandi che usano questi cmdlet vengono eseguiti effettivamente nella sessione remota. Per altre informazioni, vedere Import-Module e Import-PSSession.

Esempio 10: Gestire un computer che non esegue il sistema operativo Windows

I comandi in questo esempio consentono di gestire i sistemi di archiviazione di un computer remoto che non esegue il sistema operativo Windows. In questo esempio, poiché l'amministratore del computer ha installato il provider WMI di individuazione del modulo, i comandi CIM possono usare i valori predefiniti progettati per il provider.

$cs = New-CimSession -ComputerName RSDGF03
Get-Module -CimSession $cs -Name Storage | Import-Module
Get-Command Get-Disk

CommandType     Name                  ModuleName
-----------     ----                  ----------
Function        Get-Disk              Storage

Get-Disk

Number Friendly Name              OperationalStatus          Total Size Partition Style
------ -------------              -----------------          ---------- ---------------
0      Virtual HD ATA Device      Online                          40 GB MBR

Il primo comando usa il New-CimSession cmdlet per creare una sessione nel RSDGF03 computer remoto. La sessione si connette a WMI nel computer remoto. Il comando salva la sessione CIM nella $cs variabile .

Il secondo comando usa la sessione CIM nella $cs variabile per eseguire un Get-Module comando nel computer RSDGF03. Il comando usa il parametro Name per specificare il modulo Di archiviazione. Il comando usa un operatore pipeline (|) per inviare il modulo Storage al Import-Module cmdlet , che lo importa nella sessione locale.

Il terzo comando esegue il Get-Command cmdlet sul Get-Disk comando nel modulo Archiviazione. Quando si importa un modulo CIM nella sessione locale, PowerShell converte i file CDXML che rappresentano il modulo CIM in script di PowerShell, che vengono visualizzati come funzioni nella sessione locale.

Il quarto comando esegue il Get-Disk comando . Anche se il comando viene digitato nella sessione locale, viene eseguito in modo implicito nel computer remoto da cui è stato importato. Il comando ottiene oggetti dal computer remoto e li restituisce alla sessione locale.

Parametri

-All

Indica che questo cmdlet ottiene tutti i moduli in ogni cartella del modulo, inclusi moduli annidati, file manifesto (.psd1), file del modulo di script (.psm1) e file di modulo binario (.dll). Senza questo parametro, Get-Module ottiene solo il modulo predefinito in ogni cartella del modulo.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
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 ottenere moduli CIM da computer e dispositivi che non eseguono il 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 ottenere moduli CIM da computer e dispositivi che non eseguono il 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 .

Get-Module usa la connessione di sessione CIM per ottenere moduli dal computer remoto. Quando si importa il modulo usando il Import-Module cmdlet e si usano i comandi del modulo importato nella sessione corrente, i comandi vengono effettivamente eseguiti nel computer remoto.

È possibile usare questo parametro per ottenere moduli da computer e dispositivi che non eseguono il sistema operativo Windows e i computer che dispongono di PowerShell, ma che non dispongono della comunicazione remota di PowerShell abilitata.

Il parametro CimSession ottiene tutti i moduli in CIMSession. Tuttavia, è possibile importare solo moduli basati su CIM e su CDXML.

Tipo:CimSession
Posizione:Named
Valore predefinito:None
Necessario:True
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.

Non è possibile specificare il parametro FullyQualifiedName nello stesso comando di un parametro Name .

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

-ListAvailable

Indica che questo cmdlet ottiene tutti i moduli installati. Get-Module ottiene i moduli nei percorsi elencati nella variabile di ambiente PSModulePath . Senza questo parametro, Get-Module ottiene solo i moduli elencati nella variabile di ambiente PSModulePath e caricati nella sessione corrente. ListAvailable non restituisce informazioni sui moduli non trovati nella variabile di ambiente PSModulePath , anche se tali moduli vengono caricati nella sessione corrente.

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

-Name

Specifica i nomi o i modelli di nomi dei moduli che ottiene questo cmdlet. I caratteri jolly sono consentiti. È anche possibile inviare tramite pipe i nomi a Get-Module. Non è possibile specificare il parametro FullyQualifiedName nello stesso comando di un parametro Name .

Il nome non può accettare un GUID del modulo come valore. Per restituire i moduli specificando un GUID, usare invece FullyQualifiedName .

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

-PSEdition

Ottiene i moduli che supportano l'edizione specificata di PowerShell.

I valori validi per questo parametro sono:

  • Desktop
  • Core

Il Get-Module cmdlet controlla la proprietà CompatiblePSEditions dell'oggetto PSModuleInfo per il valore specificato e restituisce solo i moduli in cui è impostato.

Nota

  • Desktop Edition: basata su .NET Framework, fornisce la compatibilità con script e moduli destinati a versioni di PowerShell che eseguono edizioni a impatto completo di Windows, ad esempio Server Core e Windows Desktop.
  • Core Edition: basata su .NET Core, fornisce la compatibilità con script e moduli destinati a versioni di PowerShell che eseguono edizioni a impatto ridotto di Windows, ad esempio Nano Server e Windows IoT.
Tipo:String
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-PSSession

Ottiene i moduli nella sessione di PowerShell gestita dall'utente specificata (PSSession). Immettere una variabile contenente la sessione, un comando che ottiene la sessione, ad esempio un Get-PSSession comando o un comando che crea la sessione, ad esempio un New-PSSession comando.

Quando la sessione è connessa a un computer remoto, è necessario specificare il parametro ListAvailable .

Un Get-Module comando che usa il parametro PSSession equivale all'uso del Invoke-Command cmdlet per eseguire un Get-Module -ListAvailable comando in una sessione PSSession.

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

-Refresh

Indica che questo cmdlet aggiorna la cache dei comandi installati. La cache dei comandi viene creata all'avvio della sessione. Consente al Get-Command cmdlet di ottenere comandi da moduli non importati nella sessione.

Questo parametro è progettato per scenari di sviluppo e testing in cui il contenuto dei moduli è stato modificato dopo l'avvio della sessione.

Quando si specifica il parametro Refresh in un comando, è necessario specificare ListAvailable.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

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

-SkipEditionCheck

Ignora il controllo del campo CompatiblePSEditions .

Per impostazione predefinita, Get-Module omette i moduli nella %windir%\System32\WindowsPowerShell\v1.0\Modules directory che non specificano Core nel campo CompatiblePSEditions . Quando questa opzione è impostata, i moduli senza Core sono inclusi, in modo che vengano restituiti i moduli nel percorso del modulo di Windows PowerShell non compatibili con PowerShell v6 e versioni successive.

In macOS e Linux questo parametro non esegue alcuna operazione.

Per altre informazioni, vedere about_PowerShell_Editions .

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

Input

String

È possibile inviare tramite pipe i nomi dei moduli a questo cmdlet.

Output

PSModuleInfo

Questo cmdlet restituisce oggetti che rappresentano i moduli. Quando si specifica il parametro ListAvailable , Get-Module restituisce un oggetto ModuleInfoGrouping , ovvero un tipo di oggetto PSModuleInfo con le stesse proprietà e metodi.

Note

PowerShell include gli alias seguenti per Get-Module:

  • Tutte le piattaforme:

    • gmo

  • A partire da Windows PowerShell 3.0, i comandi principali inclusi in PowerShell sono inclusi nei moduli. L'eccezione è Microsoft.PowerShell.Core, ovvero uno snap-in (PSSnapin). Per impostazione predefinita, alla sessione viene aggiunto solo lo snap-in Microsoft.PowerShell.Core . I moduli vengono importati automaticamente al primo utilizzo ed è possibile usare il Import-Module cmdlet per importarli.

  • 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 principali, vedere Metodo CreateDefault2.

  • Get-Module ottiene solo i moduli in posizioni archiviate nel valore della variabile di ambiente PSModulePath ($env:PSModulePath). Il Import-Module cmdlet può importare moduli in altre posizioni, ma non è possibile usare il Get-Module cmdlet per ottenerli.

  • Inoltre, a partire da PowerShell 3.0, sono state aggiunte nuove proprietà all'oggetto che restituisce che Get-Module semplificano l'apprendimento dei moduli anche prima dell'importazione. Tutte le proprietà vengono popolate prima dell'importazione. Tra cui le proprietà ExportedCommands, ExportedCmdlets e ExportedFunctions che elencano i comandi esportati dal modulo.

  • Il parametro ListAvailable ottiene solo moduli ben formati, ovvero cartelle che contengono almeno un file il cui nome di base è uguale al nome della cartella del modulo. Il nome di base è il nome senza l'estensione del nome file. Le cartelle che contengono file con nomi diversi vengono considerate contenitori, ma non moduli.

    Per ottenere i moduli implementati come file DLL, ma non sono racchiusi in una cartella del modulo, specificare sia i parametri ListAvailable che Tutti .

  • 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 WMI alternativo con le stesse funzionalità di base.

    È possibile usare la funzionalità di sessione CIM nei computer che non eseguono il sistema operativo Windows e nei computer Windows che dispongono di PowerShell, ma che non dispongono della comunicazione remota di PowerShell abilitata.

    È anche possibile usare i parametri CIM per ottenere moduli CIM dai computer in cui è abilitata la comunicazione remota di PowerShell. Ciò include il computer locale. Quando si crea una sessione CIM nel computer locale, PowerShell usa DCOM, anziché WMI, per creare la sessione.