Import-PSSession
Importa i comandi da un'altra sessione nella sessione corrente.
Sintassi
Import-PSSession
[-Prefix <String>]
[-DisableNameChecking]
[[-CommandName] <String[]>]
[-AllowClobber]
[-ArgumentList <Object[]>]
[-CommandType <CommandTypes>]
[-Module <String[]>]
[-FullyQualifiedModule <ModuleSpecification[]>]
[[-FormatTypeName] <String[]>]
[-Certificate <X509Certificate2>]
[-Session] <PSSession>
[<CommonParameters>]Descrizione
Il cmdlet Import-PSSession importa i comandi , ad esempio cmdlet, funzioni e alias, da una sessione PSSession in un computer locale o remoto nella sessione corrente. È possibile importare qualsiasi comando che il cmdlet Get-Command possa trovare nella sessione PSSession.
Usare un comando Import-PSSession per importare comandi da una shell personalizzata, ad esempio una shell di Microsoft Exchange Server o da una sessione che include moduli di Windows PowerShell e snap-in o altri elementi non presenti nella sessione corrente.
Per importare i comandi, usare prima di tutto il cmdlet New-PSSession per creare una sessione PSSession. Usare quindi il cmdlet Import-PSSession per importare i comandi. Per impostazione predefinita, Import-PSSession importa tutti i comandi ad eccezione dei comandi con gli stessi nomi dei comandi nella sessione corrente. Per importare tutti i comandi, usare il parametro AllowClobber.
È possibile usare i comandi importati esattamente come si userebbe qualsiasi comando nella sessione. Quando si usa un comando importato, la parte importata del comando viene eseguita in modo implicito nella sessione da cui è stata importata. Tuttavia, le operazioni remote vengono gestite interamente da Windows PowerShell. Non è necessario neanche essere a conoscenza di essi, ad eccezione del fatto che è necessario mantenere aperta la connessione all'altra sessione (PSSession). Se lo si chiude, i comandi importati non sono più disponibili.
Poiché i comandi importati potrebbero richiedere più tempo rispetto ai comandi locali, Import-PSSession aggiunge un parametro AsJob a ogni comando importato. Questo parametro consente di eseguire il comando come processo in background di Windows PowerShell. Per altre informazioni, vedere about_Jobs.
Quando si usa Import-PSSession, Windows PowerShell aggiunge i comandi importati a un modulo temporaneo esistente solo nella sessione e restituisce un oggetto che rappresenta il modulo. Per creare un modulo permanente che è possibile usare nelle sessioni future, usare il cmdlet Export-PSSession.
Il cmdlet Import-PSSession usa la funzionalità di comunicazione remota implicita di Windows PowerShell. Quando si importano comandi nella sessione corrente, vengono eseguiti in modo implicito nella sessione originale o in una sessione simile nel computer di origine.
A partire da Windows PowerShell 3.0, è possibile usare il cmdlet Import-Module per importare moduli da una sessione remota nella sessione corrente. Questa funzionalità usa la comunicazione remota implicita. Equivale all'uso di Import-PSSession per importare i moduli selezionati da una sessione remota nella sessione corrente.
Esempio
Esempio 1: Importare tutti i comandi da una sessione PSSession
$S = New-PSSession -ComputerName Server01
Import-PSSession -Session $SQuesto comando importa tutti i comandi da una sessione PSSession nel computer Server01 nella sessione corrente, ad eccezione dei comandi con gli stessi nomi dei comandi nella sessione corrente.
Poiché questo comando non usa il parametro CommandName, importa anche tutti i dati di formattazione necessari per i comandi importati.
Esempio 2: Importare comandi che terminano con una stringa specifica
$S = New-PSSession https://ps.testlabs.com/powershell
Import-PSSession -Session $S -CommandName *-test -FormatTypeName *
New-Test -Name Test1
Get-Test test1 | Run-TestQuesti comandi importano i comandi con nomi che terminano in "-test" da una sessione PSSession nella sessione locale e quindi mostrano come usare un cmdlet importato.
Il primo comando usa il cmdlet New-PSSession per creare una sessione PSSession. Salva la sessione PSSession nella variabile $S.
Il secondo comando usa il cmdlet Import-PSSession per importare i comandi dalla sessione PSSession in $S nella sessione corrente. Usa il parametro CommandName per specificare i comandi con il sostantivo Test e il parametro FormatTypeName per importare i dati di formattazione per i comandi Test.
Il terzo e il quarto comando usano i comandi importati nella sessione corrente. Poiché i comandi importati vengono effettivamente aggiunti alla sessione corrente, è possibile usare la sintassi locale per eseguirli. Non è necessario usare il cmdlet Invoke-Command per eseguire un comando importato.
Esempio 3: Importare i cmdlet da una sessione PSSession
$S1 = New-PSSession -ComputerName s1
$S2 = New-PSSession -ComputerName s2
Import-PSSession -Session s1 -Type cmdlet -Name New-Test, Get-Test -FormatTypeName *
Import-PSSession -Session s2 -Type Cmdlet -Name Set-Test -FormatTypeName *
New-Test Test1 | Set-Test -RunType FullQuesto esempio mostra che è possibile usare i cmdlet importati esattamente come si userebbero i cmdlet locali.
Questi comandi importano i cmdlet New-Test e Get-Test da una sessione PSSession nel computer Server01 e il cmdlet Set-Test da una sessione PSSession nel computer Server02.
Anche se i cmdlet sono stati importati da diverse sessioni PSSession, è possibile inviare tramite pipe un oggetto da un cmdlet a un altro senza errori.
Esempio 4: Eseguire un comando importato come processo in background
$S = New-PSSession -ComputerName Server01
Import-PSSession -Session $S -CommandName *-test* -FormatTypeName *
$batch = New-Test -Name Batch -AsJob
Receive-Job $batchQuesto esempio illustra come eseguire un comando importato come processo in background.
Poiché i comandi importati potrebbero richiedere più tempo rispetto ai comandi locali, Import-PSSession aggiunge un parametro AsJob a ogni comando importato. Il parametro AsJob consente di eseguire il comando come processo in background.
Il primo comando crea una sessione PSSession nel computer Server01 e salva l'oggetto PSSession nella variabile $S.
Il secondo comando usa Import-PSSession per importare i cmdlet test dalla sessione PSSession in $S nella sessione corrente.
Il terzo comando usa il parametro AsJob del cmdlet New-Test importato per eseguire un comando New-Test come processo in background. Il comando salva l'oggetto processo che New-Test restituisce nella variabile $batch.
Il quarto comando usa il cmdlet Receive-Job per ottenere i risultati del processo nella variabile $batch.
Esempio 5: Importare cmdlet e funzioni da un modulo di Windows PowerShell
$S = New-PSSession -ComputerName Server01
Invoke-Command -Session $S {Import-Module TestManagement}
Import-PSSession -Session $S -Module TestManagementQuesto esempio illustra come importare i cmdlet e le funzioni da un modulo di Windows PowerShell in un computer remoto nella sessione corrente.
Il primo comando crea una sessione PSSession nel computer Server01 e la salva nella variabile $S.
Il secondo comando usa il cmdlet Invoke-Command per eseguire un comando Import-Module nella sessione PSSession in $S.
In genere, il modulo viene aggiunto a tutte le sessioni da un comando Import-Module in un profilo di Windows PowerShell, ma i profili non vengono eseguiti nelle sessioni PSSession.
Il terzo comando usa il parametro Module di Import-PSSession per importare i cmdlet e le funzioni nel modulo nella sessione corrente.
Esempio 6: Creare un modulo in un file temporaneo
PS C:\> Import-PSSession $S -CommandName Get-Date, SearchHelp -FormatTypeName * -AllowClobber
Name : tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1zunz.ttf
Path : C:\Users\User01\AppData\Local\Temp\tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1
zunz.ttf\tmp_79468106-4e1d-4d90-af97-1154f9317239_
tcw1zunz.ttf.psm1
Description : Implicit remoting for http://server01.corp.fabrikam.com/wsman
Guid : 79468106-4e1d-4d90-af97-1154f9317239
Version : 1.0
ModuleBase : C:\Users\User01\AppData\Local\Temp\tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1
zunz.ttf
ModuleType : Script
PrivateData : {ImplicitRemoting}
AccessMode : ReadWrite
ExportedAliases : {}
ExportedCmdlets : {}
ExportedFunctions : {[Get-Date, Get-Date], [SearchHelp, SearchHelp]}
ExportedVariables : {}
NestedModules : {}Questo esempio mostra che Import-PSSession crea un modulo in un file temporaneo su disco. Mostra anche che tutti i comandi vengono convertiti in funzioni prima che vengano importati nella sessione corrente.
Il comando usa il cmdlet Import-PSSession per importare un cmdlet Get-Date e una funzione SearchHelp nella sessione corrente.
Il cmdlet Import-PSSession restituisce un oggetto PSModuleInfo che rappresenta il modulo temporaneo. Il valore della proprietà Path indica che Import-PSSession creato un file di modulo script (con estensione psm1) in un percorso temporaneo. La proprietà ExportedFunctions mostra che il cmdlet Get-Date e la funzione SearchHelp sono stati entrambi importati come funzioni.
Esempio 7: Eseguire un comando nascosto da un comando importato
PS C:\> Import-PSSession $S -CommandName Get-Date -FormatTypeName * -AllowClobber
PS C:\> Get-Command Get-Date -All
CommandType Name Definition
----------- ---- ----------
Function Get-Date ...
Cmdlet Get-Date Get-Date [[-Date] <DateTime>] [-Year <Int32>] [-Month <Int32>]
PS C:\> Get-Date
09074
PS C:\> (Get-Command -Type Cmdlet -Name Get-Date).PSSnapin.Name
Microsoft.PowerShell.Utility
PS C:\> Microsoft.PowerShell.Utility\Get-Date
Sunday, March 15, 2009 2:08:26 PMIn questo esempio viene illustrato come eseguire un comando nascosto da un comando importato.
Il primo comando importa un cmdlet Get-Date dalla sessione PSSession nella variabile $S. Poiché la sessione corrente include un cmdlet Get-Date, nel comando è necessario il parametro AllowClobber.
Il secondo comando usa il parametro All del cmdlet Get-Command per ottenere tutti i comandi Get-Date nella sessione corrente. L'output mostra che la sessione include il cmdlet Get-Date originale e una funzione Get-Date. La funzione Get-Date esegue il cmdlet Get-Date importato in PSSession in $S.
Il terzo comando esegue un comando Get-Date. Poiché le funzioni hanno la precedenza sui cmdlet, Windows PowerShell esegue la funzione Get-Date importata, che restituisce una data julian.
Il quarto e il quinto comando mostrano come usare un nome completo per eseguire un comando nascosto da un comando importato.
Il quarto comando ottiene il nome dello snap-in di Windows PowerShell che ha aggiunto il cmdlet Get-Date originale alla sessione corrente.
Il quinto comando usa il nome completo snap-in del cmdlet Get-Date per eseguire un comando Get-Date.
Per altre informazioni sulla precedenza dei comandi e sui comandi nascosti, vedere about_Command_Precedence.
Esempio 8: Importare comandi con una stringa specifica nei nomi
PS C:\> Import-PSSession -Session $S -CommandName **Item** -AllowClobberQuesto comando importa i comandi i cui nomi includono Item dalla sessione PSSession in $S. Poiché il comando include il parametro CommandName ma non il parametro FormatTypeData, viene importato solo il comando.
Usare questo comando quando si usa Import-PSSession per eseguire un comando in un computer remoto e si dispone già dei dati di formattazione per il comando nella sessione corrente.
Esempio 9: Usare il parametro Module per individuare i comandi importati nella sessione
PS C:\> $M = Import-PSSession -Session $S -CommandName *bits* -FormatTypeName *bits*
PS C:\> Get-Command -Module $M
CommandType Name
----------- ----
Function Add-BitsFile
Function Complete-BitsTransfer
Function Get-BitsTransfer
Function Remove-BitsTransfer
Function Resume-BitsTransfer
Function Set-BitsTransfer
Function Start-BitsTransfer
Function Suspend-BitsTransferQuesto comando illustra come usare il parametro Module di di Get-Command per scoprire quali comandi sono stati importati nella sessione da un comando Import-PSSession.
Il primo comando usa il cmdlet Import-PSSession per importare i comandi i cui nomi includono "bit" dalla sessione PSSession nella variabile $S. Il comando Import-PSSession restituisce un modulo temporaneo e il comando salva il modulo nella variabile $m.
Il secondo comando usa il cmdlet Get-Command per ottenere i comandi esportati dal modulo nella variabile $M.
Il parametro module accetta un valore stringa, progettato per il nome del modulo. Tuttavia, quando si invia un oggetto modulo, Windows PowerShell usa il metodo ToString sull'oggetto modulo, che restituisce il nome del modulo.
Il comando Get-Command è equivalente a Get-Command $M.Name".
Parametri
-AllowClobber
Indica che questo cmdlet importa i comandi specificati, anche se hanno gli stessi nomi dei comandi nella sessione corrente.
Se si importa un comando con lo stesso nome di un comando nella sessione corrente, il comando importato nasconde o sostituisce i comandi originali. Per altre informazioni, vedere about_Command_Precedence.
Per impostazione predefinita, Import-PSSession non importa comandi con lo stesso nome dei comandi nella sessione corrente.
| Tipo: | SwitchParameter |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-ArgumentList
Specifica una matrice di comandi risultanti dall'uso degli argomenti specificati (valori dei parametri).
Ad esempio, per importare la variante del comando Get-Item nell'unità del certificato (Cert:) nella sessione PSSession in $S, digitare Import-PSSession -Session $S -Command Get-Item -ArgumentList cert:.
| Tipo: | Object[] |
| Alias: | Args |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-Certificate
Specifica il certificato client utilizzato per firmare i file di formato (*. Format.ps1xml) o file di modulo script (psm1) nel modulo temporaneo creato Import-PSSession.
Immettere una variabile contenente un certificato o un comando o un'espressione che ottiene il certificato.
Per trovare un certificato, usare il cmdlet Get-PfxCertificate o usare il cmdlet Get-ChildItem nell'unità Certificato (Cert:). Se il certificato non è valido o non dispone di un'autorità sufficiente, il comando non riesce.
| Tipo: | X509Certificate2 |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-CommandName
Specifica i comandi con i nomi o i modelli di nome specificati. Sono consentiti caratteri jolly. Usare CommandName o il relativo alias Nome.
Per impostazione predefinita, Import-PSSession importa tutti i comandi dalla sessione, ad eccezione dei comandi con gli stessi nomi dei comandi nella sessione corrente. Ciò impedisce ai comandi importati di nascondere o sostituire i comandi nella sessione. Per importare tutti i comandi, anche quelli che nascondono o sostituiscono altri comandi, usare il parametro AllowClobber.
Se si usa il parametro CommandName, i file di formattazione per i comandi non vengono importati a meno che non si usi il parametro FormatTypeName. Analogamente, se si usa il parametro FormatTypeName, non vengono importati comandi a meno che non si usi il parametro CommandName.
| Tipo: | String[] |
| Alias: | Name |
| Posizione: | 2 |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-CommandType
Specifica il tipo di oggetti comando. Il valore predefinito è Cmdlet. Usare CommandType o il relativo alias Type. I valori accettabili per questo parametro sono:
-
Alias: alias di Windows PowerShell nella sessione remota. -
All: cmdlet e funzioni nella sessione remota. -
Application: tutti i file diversi da Windows-PowerShell nei percorsi elencati nella variabile di ambiente Path ($env:path) nella sessione remota, inclusi i file .txt, .exee .dll. -
Cmdlet: cmdlet nella sessione remota. "Cmdlet" è l'impostazione predefinita. -
ExternalScript: i file di .ps1 nei percorsi elencati nella variabile di ambiente Path ($env:path) nella sessione remota. -
FiltereFunction: le funzioni di Windows PowerShell nella sessione remota. -
Script: lo script si blocca nella sessione remota.
Questi valori sono definiti come enumerazione basata su flag. È possibile combinare più valori per impostare più flag usando questo parametro. I valori possono essere passati al parametro CommandType come matrice di valori o come stringa delimitata da virgole di tali valori. Il cmdlet combina i valori usando un'operazione binary-OR. Il passaggio di valori come matrice è l'opzione più semplice e consente anche di usare il completamento tramite tabulazione sui valori.
| Tipo: | CommandTypes |
| Alias: | Type |
| Valori accettati: | Alias, Function, Filter, Cmdlet, ExternalScript, Application, Script, Workflow, Configuration, All |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-DisableNameChecking
Indica che questo cmdlet elimina il messaggio che avvisa quando si importa un cmdlet o una funzione il cui nome include un verbo non approvato o un carattere non consentito.
Per impostazione predefinita, quando un modulo che si importa esporta cmdlet o funzioni con verbi non approvati nei nomi, Windows PowerShell visualizza il messaggio di avviso seguente:
"AVVISO: alcuni nomi di comando importati includono verbi non approvati che potrebbero renderli meno individuabili. Usare il parametro Verbose per altri dettagli o tipo Get-Verb per visualizzare l'elenco dei verbi approvati."
Questo messaggio è solo un avviso. Il modulo completo viene ancora importato, inclusi i comandi non conformi. Anche se il messaggio viene visualizzato agli utenti del modulo, il problema di denominazione deve essere risolto dall'autore del modulo.
| Tipo: | SwitchParameter |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-FormatTypeName
Specifica le istruzioni di formattazione per i tipi di Microsoft .NET Framework specificati. Immettere i nomi dei tipi. Sono consentiti caratteri jolly.
Il valore di questo parametro deve essere il nome di un tipo restituito da un comando Get-FormatData nella sessione da cui vengono importati i comandi. Per ottenere tutti i dati di formattazione nella sessione remota, digitare *.
Se il comando non include il parametro CommandName o FormatTypeName, Import-PSSession importa istruzioni di formattazione per tutti i tipi .NET Framework restituiti da un comando Get-FormatData nella sessione remota.
Se si usa il parametro FormatTypeName, non vengono importati comandi a meno che non si usi il parametro CommandName.
Analogamente, se si usa il parametro CommandName, i file di formattazione per i comandi non vengono importati a meno che non si usi il parametro FormatTypeName.
| Tipo: | String[] |
| Posizione: | 3 |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-FullyQualifiedModule
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 FullyQualifiedModule nello stesso comando di un parametro Module. I due parametri si escludono a vicenda.
| Tipo: | ModuleSpecification[] |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-Module
Specifica e matrice di comandi negli snap-in e nei moduli di Windows PowerShell. Immettere gli snap-in e i nomi dei moduli. I caratteri jolly non sono consentiti.
Import-PSSession non è possibile importare provider da uno snap-in.
Per altre informazioni, vedere about_PSSnapins e about_Modules.
| Tipo: | String[] |
| Alias: | PSSnapin |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-Prefix
Specifica un prefisso per i sostantivi nei nomi dei comandi importati.
Usare questo parametro per evitare conflitti di nomi che possono verificarsi quando comandi diversi nella sessione hanno lo stesso nome.
Ad esempio, se si specifica il prefisso Remote e quindi si importa un cmdlet Get-Date, il cmdlet è noto nella sessione come Get-RemoteDatee non viene confuso con il cmdlet Get-Date originale.
| Tipo: | String |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-Session
Specifica il PSSession da cui vengono importati i cmdlet. Immettere una variabile contenente un oggetto sessione o un comando che ottiene un oggetto sessione, ad esempio un comando New-PSSession o Get-PSSession. È possibile specificare una sola sessione. Questo parametro è obbligatorio.
| Tipo: | PSSession |
| Posizione: | 0 |
| Valore predefinito: | None |
| Necessario: | True |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
Input
None
Non è possibile inviare tramite pipe oggetti a questo cmdlet.
Output
Questo cmdlet restituisce lo stesso oggetto modulo restituito New-Module e Get-Module cmdlet.
Tuttavia, il modulo importato è temporaneo ed esiste solo nella sessione corrente. Per creare un modulo permanente su disco, usare il cmdlet Export-PSSession.
Note
-
Import-PSSessionsi basa sull'infrastruttura remota di PowerShell. Per usare questo cmdlet, è necessario configurare il computer per la comunicazione remota WS-Management. Per altre informazioni, vedere about_Remote e about_Remote_Requirements. -
Import-PSSessionnon importa variabili o provider di PowerShell. - Quando si importano comandi con gli stessi nomi dei comandi nella sessione corrente, i comandi importati possono nascondere alias, funzioni e cmdlet nella sessione e possono sostituire funzioni e variabili nella sessione. Per evitare conflitti di nomi, usare il parametro prefisso. Per altre informazioni, vedere about_Command_Precedence.
-
Import-PSSessionconverte tutti i comandi in funzioni prima di importarli. Di conseguenza, i comandi importati si comportano in modo leggermente diverso da quello che avrebbero mantenuto il tipo di comando originale. Ad esempio, se si importa un cmdlet da una sessione PSSession e quindi si importa un cmdlet con lo stesso nome da un modulo o da uno snap-in, il cmdlet importato dalla sessione PSSession viene sempre eseguito per impostazione predefinita perché le funzioni hanno la precedenza sui cmdlet. Viceversa, se si importa un alias in una sessione con un alias con lo stesso nome, viene sempre usato l'alias originale, perché gli alias hanno la precedenza sulle funzioni. Per altre informazioni, vedere about_Command_Precedence. -
Import-PSSessionusa il cmdletWrite-Progressper visualizzare lo stato di avanzamento del comando. È possibile che venga visualizzata la barra di stato durante l'esecuzione del comando. - Per trovare i comandi da importare,
Import-PSSessionusa il cmdletInvoke-Commandper eseguire un comandoGet-Commandnella sessione PSSession. Per ottenere i dati di formattazione per i comandi, usa il cmdletGet-FormatData. È possibile che vengano visualizzati messaggi di errore da questi cmdlet quando si esegue un comandoImport-PSSession. Inoltre,Import-PSSessionnon è in grado di importare comandi da una sessione PSSession che non include i cmdletGet-Command,Get-FormatData,Select-ObjecteGet-Help. - I comandi importati hanno le stesse limitazioni di altri comandi remoti, inclusa l'impossibilità di avviare un programma con un'interfaccia utente, ad esempio Blocco note.
- Poiché i profili di Windows PowerShell non vengono eseguiti in PSSessions, i comandi aggiunti da un profilo a una sessione non sono disponibili per
Import-PSSession. Per importare comandi da un profilo, usare un comandoInvoke-Commandper eseguire manualmente il profilo nella sessione PSSession prima di importare i comandi. - Il modulo temporaneo creato
Import-PSSessionpotrebbe includere un file di formattazione, anche se il comando non importa i dati di formattazione. Se il comando non importa i dati di formattazione, i file di formattazione creati non conterranno dati di formattazione. - Per usare
Import-PSSession, i criteri di esecuzione nella sessione corrente non possono essere limitati o AllSigned, perché il modulo temporaneo cheImport-PSSessioncrea contiene file di script non firmati non consentiti da questi criteri. Per usareImport-PSSessionsenza modificare i criteri di esecuzione per il computer locale, usare il parametro scope diSet-ExecutionPolicyper impostare un criterio di esecuzione meno restrittivo per un singolo processo. - In Windows PowerShell 2.0, gli argomenti della Guida per i comandi importati da un'altra sessione non includono il prefisso assegnato usando il parametro prefisso. Per ottenere assistenza per un comando importato in Windows PowerShell 2.0, usare il nome del comando originale (non preceduto).
