Import-PSSession
Importa i comandi da un'altra sessione alla 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 Import-PSSession cmdlet 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 Get-Command cmdlet possa trovare nella sessione PSSession.
Usare un Import-PSSession comando 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 New-PSSession cmdlet per creare una sessione PSSession. Usare quindi il Import-PSSession cmdlet 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 analogamente a qualsiasi comando della sessione. Quando si usa un comando importato, la parte importata del comando viene eseguita implicitamente nella sessione dalla quale è stata importata. Tuttavia, le operazioni remote vengono gestite interamente da Windows PowerShell. Non è necessario che l'utente sia a conoscenza della loro esecuzione, tuttavia deve ricordarsi di tenere aperta la connessione all'altra sessione (sessione PSSession). Se la si chiude, i comandi importati non saranno 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 (Informazioni sui processi).
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 Export-PSSession cmdlet .
Il Import-PSSession cmdlet usa la funzionalità di comunicazione remota implicita di Windows PowerShell. Quando si importano i comandi nella sessione corrente, vengono eseguiti implicitamente nella sessione originale o in una sessione simile nel computer di origine.
A partire da Windows PowerShell 3.0, è possibile usare il Import-Module cmdlet per importare moduli da una sessione remota nella sessione corrente. Questa funzionalità usa la comunicazione remota implicita. Equivale a usare 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 alla sessione corrente, ad eccezione dei comandi che hanno gli stessi nomi di quelli della 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 comandi con nomi che finiscono con "-test" da una sessione PSSession alla sessione locale, quindi visualizzano come usare un cmdlet importato.
Il primo comando usa il New-PSSession cmdlet per creare una sessione PSSession. Salva la sessione PSSession nella $S variabile .
Il secondo comando usa il Import-PSSession cmdlet 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, per eseguirli viene usata la sintassi locale. Non è necessario usare il Invoke-Command cmdlet 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 analogamente ai cmdlet locali.
Questi comandi importano i New-Test cmdlet e Get-Test da una sessione PSSession nel computer Server01 e il Set-Test cmdlet 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 all'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 mostra 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 $S variabile .
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 importato New-Test per eseguire un New-Test comando come processo in background. Il comando salva l'oggetto processo che New-Test restituisce nella $batch variabile .
Il quarto comando usa il Receive-Job cmdlet per ottenere i risultati del processo nella $batch variabile .
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 mostra 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 $S variabile .
Il secondo comando usa il Invoke-Command cmdlet per eseguire un Import-Module comando nella sessione PSSession in $S.
In genere, il modulo viene aggiunto a tutte le sessioni da un Import-Module comando 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 di essere importati nella sessione corrente.
Il comando usa il Import-PSSession cmdlet per importare un Get-Date cmdlet e una funzione SearchHelp nella sessione corrente.
Il Import-PSSession cmdlet restituisce un oggetto PSModuleInfo che rappresenta il modulo temporaneo. Il valore della proprietà Path mostra che Import-PSSession è stato creato un file di modulo script (psm1) in un percorso temporaneo. La proprietà ExportedFunctions mostra che il Get-Date cmdlet 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 PMQuesto esempio mostra come eseguire un comando nascosto da un comando importato.
Il primo comando importa un Get-Date cmdlet dalla sessione PSSession nella $S variabile . Poiché la sessione corrente include un Get-Date cmdlet, il parametro AllowClobber è obbligatorio nel comando .
Il secondo comando usa il parametro All del Get-Command cmdlet per ottenere tutti i Get-Date comandi nella sessione corrente. L'output mostra che la sessione include il cmdlet originale Get-Date e una Get-Date funzione. La Get-Date funzione esegue il cmdlet importato Get-Date in PSSession in $S.
Il terzo comando esegue un Get-Date comando. Poiché le funzioni hanno la precedenza sui cmdlet, Windows PowerShell esegue la funzione importata Get-Date , 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 originale Get-Date alla sessione corrente.
Il quinto comando usa il nome completo dello snap-in del Get-Date cmdlet per eseguire un Get-Date comando.
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 Get-Command per scoprire quali comandi sono stati importati nella sessione da un Import-PSSession comando.
Il primo comando usa il Import-PSSession cmdlet per importare i comandi i cui nomi includono "bit" dalla sessione PSSession nella $S variabile. Il Import-PSSession comando restituisce un modulo temporaneo e il comando salva il modulo nella $m variabile .
Il secondo comando usa il Get-Command cmdlet per ottenere i comandi esportati dal modulo nella $M variabile .
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 nell'oggetto modulo, che restituisce il nome del modulo.
Il Get-Command comando è l'equivalente di 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 del 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.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-ArgumentList
Specifica una matrice di comandi risultanti dall'uso degli argomenti specificati (valori dei parametri).
Ad esempio, per importare la variante del Get-Item comando nell'unità del certificato (Cert:) nella sessione PSSession in $S, digitare Import-PSSession -Session $S -Command Get-Item -ArgumentList cert:.
| Type: | Object[] |
| Aliases: | Args |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Certificate
Specifica il certificato client utilizzato per firmare i file di formato (*. Format.ps1xml) o file di modulo script (con estensione psm1) nel modulo temporaneo creato Import-PSSession .
Immettere una variabile che contiene un certificato oppure un comando o un'espressione che ottiene il certificato.
Per trovare un certificato, usare il Get-PfxCertificate cmdlet o usare il Get-ChildItem cmdlet nell'unità Certificato (Cert:). Se il certificato non è valido o non ha autorizzazioni sufficienti, il comando non riesce.
| Type: | X509Certificate2 |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-CommandName
Specifica i comandi con i nomi o i modelli di nome specificati. I caratteri jolly sono consentiti. Usare CommandName o il relativo alias, Name.
Per impostazione predefinita, Import-PSSession importa tutti i comandi dalla sessione, ad eccezione dei comandi con gli stessi nomi dei comandi nella sessione corrente. In questo modo si evita che i comandi importati nascondano o sostituiscano i comandi nella sessione. Per importare tutti i comandi, anche quelli che nascondono o sostituiscono altri comandi, usare il parametro AllowClobber .
Se si utilizza 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 .
| Type: | String[] |
| Aliases: | Name |
| Position: | 2 |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-CommandType
Specifica il tipo di oggetti comando. Il valore predefinito è Cmdlet. Usare CommandType o il relativo alias, Type. I valori validi per questo parametro sono:
Alias: alias di Windows PowerShell nella sessione remota.All: cmdlet e funzioni nella sessione remota.Application: tutti i file diversi dai file di Windows PowerShell nei percorsi elencati nella variabile di ambiente Path ($env:path) nella sessione remota, inclusi i file .txt, .exe e .dll.Cmdlet: cmdlet nella sessione remota. "Cmdlet" è il valore predefinito.ExternalScript: i file con estensione 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.
| Type: | CommandTypes |
| Aliases: | Type |
| Accepted values: | Alias, Function, Filter, Cmdlet, ExternalScript, Application, Script, Workflow, Configuration, All |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | 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 importato esporta cmdlet o funzioni i cui nomi contengono verbi non approvati, Windows PowerShell visualizza il seguente messaggio di avviso:
"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".
Si tratta semplicemente di un avviso. Il modulo completo viene comunque importato, inclusi i comandi non conformi. Il messaggio viene visualizzato dagli utenti del modulo, tuttavia il problema di denominazione deve essere corretto dall'autore del modulo.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-FormatTypeName
Specifica le istruzioni di formattazione per i tipi di Microsoft .NET Framework specificati. Immettere i nomi dei tipi. I caratteri jolly sono consentiti.
Il valore di questo parametro deve essere il nome di un tipo restituito da un Get-FormatData comando 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 Get-FormatData comando nella sessione remota.
Se si utilizza 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 .
| Type: | String[] |
| Position: | 3 |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | 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 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 FullyQualifiedModule nello stesso comando di un parametro Module . I due parametri si escludono a vicenda.
| Type: | ModuleSpecification[] |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Module
Specifica e matrice di comandi negli snap-in e nei moduli di Windows PowerShell. Immettere i nomi degli snap-in e dei moduli. I caratteri jolly non sono consentiti.
Import-PSSession non può importare provider da uno snap-in.
Per altre informazioni, vedere about_PSSnapins e about_Modules.
| Type: | String[] |
| Aliases: | PSSnapin |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Prefix
Specifica un prefisso per i sostantivi nei nomi dei comandi importati.
Usare questo parametro per evitare conflitti di nomi che potrebbero verificarsi quando più comandi nella sessione hanno lo stesso nome.
Ad esempio, se si specifica il prefisso Remote e quindi si importa un Get-Date cmdlet, il cmdlet è noto nella sessione come Get-RemoteDatee non viene confuso con il cmdlet originale Get-Date .
| Type: | String |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Session
Specifica la sessione 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 New-PSSession comando o Get-PSSession . È possibile specificare una sola sessione. Questo parametro è obbligatorio.
| Type: | PSSession |
| Position: | 0 |
| Default value: | None |
| Required: | True |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Input
None
Non è possibile inviare tramite pipe oggetti a questo cmdlet.
Output
Questo cmdlet restituisce lo stesso oggetto modulo restituito New-Module dai cmdlet e Get-Module .
Tuttavia, il modulo importato è temporaneo ed esiste solo nella sessione corrente. Per creare un modulo permanente su disco, usare il Export-PSSession cmdlet .
Note
Import-PSSessionsi basa sull'infrastruttura remota di PowerShell. Per usare questo cmdlet, il computer deve essere configurato 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 i comandi con lo stesso nome dei comandi della sessione corrente, i comandi importati possono nascondere alias, funzioni e cmdlet e sostituire funzioni e variabili nella sessione. Per evitare conflitti di nomi, usare il parametro Prefix . Per altre informazioni, vedere about_Command_Precedence.
Import-PSSessionconverte tutti i comandi in funzioni prima di importarli. Di conseguenza, i comandi importati hanno un comportamento leggermente diverso rispetto a quello che avrebbero avuto mantenendo il tipo di comando originale. Ad esempio, se si importa un cmdlet da una sessione PSSession e 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 rispetto ai cmdlet. Al contrario, se si importa un alias in una sessione in cui è presente un alias con lo stesso nome, viene sempre usato l'alias originale perché gli alias hanno la precedenza rispetto alle funzioni. Per altre informazioni, vedere about_Command_Precedence.Import-PSSessionusa ilWrite-Progresscmdlet per visualizzare lo stato di avanzamento del comando. È possibile che venga visualizzato l'indicatore di stato durante l'esecuzione del comando.- Per trovare i comandi da importare,
Import-PSSessionusa ilInvoke-Commandcmdlet per eseguire unGet-Commandcomando nella sessione PSSession. Per ottenere i dati di formattazione per i comandi, usa ilGet-FormatDatacmdlet . È possibile che vengano visualizzati messaggi di errore da questi cmdlet quando si esegue unImport-PSSessioncomando.Import-PSSessionNon è inoltre possibile importare comandi da una sessione PSSession che non include iGet-Commandcmdlet ,Get-FormatDataSelect-Object, eGet-Help. - I comandi importati hanno le stesse limitazioni degli altri comandi remoti, inclusa l'impossibilità di avviare un programma con un'interfaccia utente, ad esempio il 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 unInvoke-Commandcomando per eseguire manualmente il profilo nella sessione PSSession prima di importare i comandi. - Il modulo temporaneo che
Import-PSSessioncrea può includere un file di formattazione, anche se il comando non importa i dati di formattazione. I file di formattazione creati non conterranno dati di formattazione se il comando non li importa. - 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, utilizzare 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 su un comando importato in Windows PowerShell 2.0, usare il nome del comando originale (senza prefisso).
Collegamenti correlati
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per