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 cmdlet Get-Module 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 importanti sul modulo. È anche possibile inviare tramite pipe gli oggetti modulo ad altri cmdlet, ad esempio i cmdlet Import-Module 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 comando Get-Module non attiva un'importazione automatica. È anche possibile importare i moduli nella sessione usando il cmdlet Import-Module.

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 cmdlet Import-PSSession. 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 un PSSession nel computer remoto e quindi usare il parametro PSSession di Get-Module per 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 cmdlet Import-Module 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 importati nella sessione corrente.

Esempio 2: Ottenere moduli installati e moduli disponibili

Get-Module -ListAvailable

Questo comando ottiene i moduli installati nel computer e può essere importato 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 cmdlet Format-Table per formattare i risultati come tabella con Name e Version 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 di 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 restituito Get-Module. Esiste un oggetto per ogni file di modulo.

È possibile usare le proprietà per formattare e filtrare gli oggetti 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 che ogni script sta esportando.

Esempio 7: Visualizzare il contenuto di un manifesto del modulo

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

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 spesso forniscono informazioni utili su un modulo, i relativi 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 variabile $m.

Il secondo comando usa il cmdlet Get-Content 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. Questo è un altro modo per determinare cosa si trova in un modulo prima di importarlo. Alcuni moduli possono avere file della Guida o file ReadMe 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 cmdlet New-PSSession per creare un PSSession nel computer Server01. Il comando salva il PSSession nella variabile $s.

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

Se si inviano tramite pipe i moduli da altre sessioni al cmdlet Import-Module, Import-Module importa il modulo nella sessione corrente usando la funzionalità di comunicazione remota implicita. Equivale a usare il cmdlet Import-PSSession. È possibile usare i cmdlet del modulo nella sessione corrente, ma i comandi che usano questi cmdlet eseguono effettivamente la 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 moduli, 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 cmdlet New-CimSession per creare una sessione nel computer remoto RSDGF03. La sessione si connette a WMI nel computer remoto. Il comando salva la sessione CIM nella variabile $cs.

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

Il terzo comando esegue il cmdlet Get-Command nel comando Get-Disk 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 comando Get-Disk. 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 i file nested modules, manifest (.psd1) , i file del modulo script (.psm1) e i file binary module (.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 moduli.

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 della risorsa del provider WMI individuazione moduli 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 cmdlet Import-Module 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 nella CIMSession. Tuttavia, è possibile importare solo moduli basati su CIM e XML di definizione dei cmdlet (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 PSModulePath per il modulo specificato.

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. Sono consentiti caratteri jolly. È anche possibile inviare tramite pipe i nomi a Get-Module. Non è possibile specificare il parametro FullyQualifiedName nello stesso comando di un parametro Name.

nome non può accettare un GUID del modulo come valore. Per restituire i moduli specificando un GUID, usare 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 accettabili per questo parametro sono:

  • Desktop
  • Core

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

Nota

  • Desktop Edition: basata su .NET Framework e offre compatibilità con script e moduli destinati alle versioni di PowerShell in esecuzione su edizioni con footprint completo di Windows, ad esempio Server Core e Windows Desktop.
  • Core Edition: basata su .NET Core e offre compatibilità con script e moduli destinati a versioni di PowerShell in esecuzione su edizioni con footprint 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 comando Get-PSSession o un comando che crea la sessione, ad esempio un comando New-PSSession.

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

Un comando Get-Module che usa il parametro PSSession equivale all'uso del cmdlet Invoke-Command per eseguire un comando Get-Module -ListAvailable in un 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 cmdlet Get-Command di ottenere comandi da moduli non importati nella sessione.

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

Quando si specifica il parametro Aggiorna 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 directory %windir%\System32\WindowsPowerShell\v1.0\Modules che non specificano Core nel campo CompatiblePSEditions. Quando questa opzione è impostata, vengono restituiti i moduli senza Core, 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 cmdlet Import-Module per importarli.

  • In Windows PowerShell 2.0 e nei programmi host che creano sessioni di tipo precedente in 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 cmdlet New-PSSession, sono sessioni di tipo precedente che includono snap-in di base.

    Per informazioni sul metodo CreateDefault2 che crea sessioni più recenti con moduli di base, vedere Metodo CreateDefault2.

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

  • Inoltre, a partire da PowerShell 3.0, sono state aggiunte nuove proprietà all'oggetto che Get-Module restituisce che semplificano l'apprendimento dei moduli anche prima dell'importazione. Tutte le proprietà vengono popolate prima dell'importazione. Sono inclusi i ExportedCommands, ExportedCmdlets e le proprietà 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 corrisponde 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 il listAvailable che Tutti i parametri.

  • Per usare la funzionalità di sessione CIM, il computer remoto deve avere WS-Management comunicazione remota e Strumentazione gestione Windows (WMI), che è l'implementazione Microsoft dello standard COMMON Information Model (CIM). Il computer deve inoltre disporre del provider WMI di individuazione moduli 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.