Import-PSSession
Importerar kommandon från en annan session till den aktuella sessionen.
Syntax
Import-PSSession
[-Prefix <String>]
[-DisableNameChecking]
[[-CommandName] <String[]>]
[-AllowClobber]
[-ArgumentList <Object[]>]
[-CommandType <CommandTypes>]
[-Module <String[]>]
[-FullyQualifiedModule <ModuleSpecification[]>]
[[-FormatTypeName] <String[]>]
[-Certificate <X509Certificate2>]
[-Session] <PSSession>
[<CommonParameters>]
Description
Cmdleten Import-PSSession
importerar kommandon, till exempel cmdletar, funktioner och alias, från en PSSession på en lokal dator eller fjärrdator till den aktuella sessionen. Du kan importera alla kommandon som cmdleten Get-Command
kan hitta i PSSession.
Använd ett Import-PSSession
kommando för att importera kommandon från ett anpassat gränssnitt, till exempel ett Microsoft Exchange Server-gränssnitt, eller från en session som innehåller Windows PowerShell moduler och snapin-moduler eller andra element som inte finns i den aktuella sessionen.
Om du vill importera kommandon använder du först cmdleten New-PSSession
för att skapa en PSSession. Använd sedan cmdleten Import-PSSession
för att importera kommandona. Som standard Import-PSSession
importerar alla kommandon förutom kommandon som har samma namn som kommandon i den aktuella sessionen. Om du vill importera alla kommandon använder du parametern AllowClobber .
Du kan använda importerade kommandon på samma sätt som du skulle använda alla kommandon i sessionen. När du använder ett importerat kommando körs den importerade delen av kommandot implicit i sessionen som den importerades från. Fjärråtgärderna hanteras dock helt av Windows PowerShell. Du behöver inte ens vara medveten om dem, förutom att du måste hålla anslutningen till den andra sessionen (PSSession) öppen. Om du stänger den är de importerade kommandona inte längre tillgängliga.
Eftersom importerade kommandon kan ta längre tid att köra än lokala kommandon lägger Import-PSSession
till en AsJob-parameter i varje importerat kommando. Med den här parametern kan du köra kommandot som ett Windows PowerShell bakgrundsjobb. Mer information finns i artikeln om jobb.
När du använder Import-PSSession
lägger Windows PowerShell till de importerade kommandona i en tillfällig modul som bara finns i sessionen och returnerar ett objekt som representerar modulen. Om du vill skapa en beständig modul som du kan använda i framtida sessioner använder du cmdleten Export-PSSession
.
Cmdleten Import-PSSession
använder den implicita fjärrkommunikationsfunktionen i Windows PowerShell. När du importerar kommandon till den aktuella sessionen körs de implicit i den ursprungliga sessionen eller i en liknande session på den ursprungliga datorn.
Från och med Windows PowerShell 3.0 kan du använda cmdleten Import-Module
för att importera moduler från en fjärrsession till den aktuella sessionen. Den här funktionen använder implicit fjärrkommunikation. Det motsvarar att använda Import-PSSession
för att importera valda moduler från en fjärrsession till den aktuella sessionen.
Exempel
Exempel 1: Importera alla kommandon från en PSSession
$S = New-PSSession -ComputerName Server01
Import-PSSession -Session $S
Det här kommandot importerar alla kommandon från en PSSession på Server01-datorn till den aktuella sessionen, förutom kommandon som har samma namn som kommandon i den aktuella sessionen.
Eftersom det här kommandot inte använder parametern CommandName importeras även alla formateringsdata som krävs för de importerade kommandona.
Exempel 2: Importera kommandon som slutar med en specifik sträng
$S = New-PSSession https://ps.testlabs.com/powershell
Import-PSSession -Session $S -CommandName *-test -FormatTypeName *
New-Test -Name Test1
Get-Test test1 | Run-Test
Dessa kommandon importerar kommandona med namn som slutar med "-test" från en PSSession till den lokala sessionen och visar sedan hur du använder en importerad cmdlet.
Det första kommandot använder cmdleten New-PSSession
för att skapa en PSSession. PsSession sparas i variabeln $S
.
Det andra kommandot använder cmdleten Import-PSSession
för att importera kommandon från PSSession in $S
till den aktuella sessionen. Den använder parametern CommandName för att ange kommandon med test-substantiv och parametern FormatTypeName för att importera formateringsdata för testkommandona.
De tredje och fjärde kommandona använder de importerade kommandona i den aktuella sessionen. Eftersom importerade kommandon faktiskt läggs till i den aktuella sessionen använder du den lokala syntaxen för att köra dem. Du behöver inte använda cmdleten Invoke-Command
för att köra ett importerat kommando.
Exempel 3: Importera cmdletar från en 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 Full
Det här exemplet visar att du kan använda importerade cmdletar precis som du skulle använda lokala cmdletar.
Dessa kommandon importerar New-Test
cmdletarna och Get-Test
från en PSSession på Server01-datorn och cmdleten Set-Test
från en PSSession på Server02-datorn.
Även om cmdletarna importerades från olika PSSessioner kan du skicka ett objekt från en cmdlet till en annan utan fel.
Exempel 4: Kör ett importerat kommando som ett bakgrundsjobb
$S = New-PSSession -ComputerName Server01
Import-PSSession -Session $S -CommandName *-test* -FormatTypeName *
$batch = New-Test -Name Batch -AsJob
Receive-Job $batch
Det här exemplet visar hur du kör ett importerat kommando som ett bakgrundsjobb.
Eftersom importerade kommandon kan ta längre tid att köra än lokala kommandon lägger Import-PSSession
till en AsJob-parameter i varje importerat kommando. Med parametern AsJob kan du köra kommandot som ett bakgrundsjobb.
Det första kommandot skapar en PSSession på Server01-datorn och sparar PSSession-objektet i variabeln $S
.
Det andra kommandot använder Import-PSSession
för att importera test-cmdletar från PSSession in $S
till den aktuella sessionen.
Det tredje kommandot använder asjob-parametern för den importerade New-Test
cmdleten för att köra ett New-Test
kommando som ett bakgrundsjobb. Kommandot sparar jobbobjektet som New-Test
returneras i variabeln $batch
.
Det fjärde kommandot använder cmdleten Receive-Job
för att hämta resultatet av jobbet i variabeln $batch
.
Exempel 5: Importera cmdletar och funktioner från en Windows PowerShell modul
$S = New-PSSession -ComputerName Server01
Invoke-Command -Session $S {Import-Module TestManagement}
Import-PSSession -Session $S -Module TestManagement
Det här exemplet visar hur du importerar cmdletar och funktioner från en Windows PowerShell-modul på en fjärrdator till den aktuella sessionen.
Det första kommandot skapar en PSSession på Server01-datorn och sparar den i variabeln $S
.
Det andra kommandot använder cmdleten Invoke-Command
för att köra ett Import-Module
kommando i PSSession i $S
.
Vanligtvis läggs modulen till i alla sessioner med ett Import-Module
kommando i en Windows PowerShell profil, men profiler körs inte i PSSessioner.
Det tredje kommandot använder modulparameternImport-PSSession
för för att importera cmdletar och funktioner i modulen till den aktuella sessionen.
Exempel 6: Skapa en modul i en temporär fil
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 : {}
Det här exemplet visar att Import-PSSession
skapar en modul i en tillfällig fil på disken. Det visar också att alla kommandon konverteras till funktioner innan de importeras till den aktuella sessionen.
Kommandot använder cmdleten Import-PSSession
för att importera en Get-Date
cmdlet och en SearchHelp-funktion till den aktuella sessionen.
Cmdleten Import-PSSession
returnerar ett PSModuleInfo-objekt som representerar den tillfälliga modulen. Värdet för egenskapen Path visar att Import-PSSession
en skriptmodulfil (.psm1) har skapats på en tillfällig plats. Egenskapen ExportedFunctions visar att både cmdleten Get-Date
och SearchHelp-funktionen importerades som funktioner.
Exempel 7: Kör ett kommando som är dolt av ett importerat kommando
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 PM
Det här exemplet visar hur du kör ett kommando som är dolt av ett importerat kommando.
Det första kommandot importerar en Get-Date
cmdlet från PSSession i variabeln $S
. Eftersom den aktuella sessionen innehåller en Get-Date
cmdlet krävs parametern AllowClobber i kommandot .
Det andra kommandot använder parametern Alla i cmdleten Get-Command
för att hämta alla Get-Date
kommandon i den aktuella sessionen. Utdata visar att sessionen innehåller den ursprungliga Get-Date
cmdleten och en Get-Date
funktion. Funktionen Get-Date
kör den importerade Get-Date
cmdleten i PSSession i $S
.
Det tredje kommandot kör ett Get-Date
kommando. Eftersom funktioner har företräde framför cmdletar kör Windows PowerShell den importerade Get-Date
funktionen, som returnerar ett julianskt datum.
De fjärde och femte kommandona visar hur du använder ett kvalificerat namn för att köra ett kommando som är dolt av ett importerat kommando.
Det fjärde kommandot hämtar namnet på Windows PowerShell snapin-modul som lade till den ursprungliga Get-Date
cmdleten i den aktuella sessionen.
Det femte kommandot använder det snapin-in-kvalificerade namnet på cmdleten Get-Date
för att köra ett Get-Date
kommando.
Mer information om kommandoprioritet och dolda kommandon finns i about_Command_Precedence.
Exempel 8: Importera kommandon som har en specifik sträng i sina namn
PS C:\> Import-PSSession -Session $S -CommandName **Item** -AllowClobber
Det här kommandot importerar kommandon vars namn inkluderar Objekt från PSSession i $S
. Eftersom kommandot innehåller parametern CommandName men inte parametern FormatTypeData importeras endast kommandot.
Använd det här kommandot när du använder Import-PSSession
för att köra ett kommando på en fjärrdator och du redan har formateringsdata för kommandot i den aktuella sessionen.
Exempel 9: Använd modulparametern för att identifiera vilka kommandon som importerades till sessionen
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-BitsTransfer
Det här kommandot visar hur du använder modulparameternGet-Command
för för att ta reda på vilka kommandon som importerades till sessionen med ett Import-PSSession
kommando.
Det första kommandot använder cmdleten Import-PSSession
för att importera kommandon vars namn innehåller "bitar" från PSSession i variabeln $S
. Kommandot Import-PSSession
returnerar en tillfällig modul och kommandot sparar modulen i variabeln $m
.
Det andra kommandot använder cmdleten Get-Command
för att hämta de kommandon som exporteras av modulen i variabeln $M
.
Modulparametern tar ett strängvärde som är utformat för modulnamnet. Men när du skickar ett modulobjekt använder Windows PowerShell metoden ToString för modulobjektet, som returnerar modulnamnet.
Kommandot Get-Command
motsvarar Get-Command $M.Name
".
Parametrar
-AllowClobber
Anger att denna cmdlet importerar de angivna kommandona, även om de har samma namn som kommandon i den aktuella sessionen.
Om du importerar ett kommando med samma namn som ett kommando i den aktuella sessionen döljer eller ersätter det importerade kommandot de ursprungliga kommandona. Mer information finns i about_Command_Precedence.
Som standard Import-PSSession
importerar inte kommandon som har samma namn som kommandon i den aktuella sessionen.
Type: | SwitchParameter |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-ArgumentList
Anger en matris med kommandon som resulterar från att använda de angivna argumenten (parametervärden).
Om du till exempel vill importera -varianten Get-Item
av kommandot i certifikatenheten (Cert:) i PSSession i $S
skriver du 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
Anger det klientcertifikat som används för att signera formatfilerna (*. Format.ps1xml) eller skriptmodulfiler (.psm1) i den temporära modul som Import-PSSession
skapas.
Ange en variabel som innehåller ett certifikat eller ett kommando eller uttryck som hämtar certifikatet.
Om du vill hitta ett certifikat använder du cmdleten Get-PfxCertificate
eller Get-ChildItem
cmdleten på certifikatenheten (Cert:). Om certifikatet inte är giltigt eller inte har tillräcklig behörighet misslyckas kommandot.
Type: | X509Certificate2 |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-CommandName
Anger kommandon med de angivna namnen eller namnmönstren. Jokertecken tillåts. Använd CommandName eller dess alias, Name.
Som standard Import-PSSession
importerar alla kommandon från sessionen, förutom kommandon som har samma namn som kommandon i den aktuella sessionen. Detta förhindrar att importerade kommandon döljer eller ersätter kommandon i sessionen. Om du vill importera alla kommandon, även de som döljer eller ersätter andra kommandon, använder du parametern AllowClobber .
Om du använder parametern CommandName importeras inte formateringsfilerna för kommandona om du inte använder parametern FormatTypeName . Om du använder parametern FormatTypeName importeras inga kommandon om du inte använder parametern CommandName .
Type: | String[] |
Aliases: | Name |
Position: | 2 |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-CommandType
Anger typen av kommandoobjekt. Standardvärdet är Cmdlet. Använd CommandType eller dess alias, Typ. De acceptabla värdena för den här parametern är:
Alias
: Windows PowerShell alias i fjärrsessionen.All
: Cmdletar och funktioner i fjärrsessionen.Application
: Alla andra filer än Windows-PowerShell filer i sökvägarna som visas i miljövariabeln Sökväg ($env:path
) i fjärrsessionen, inklusive .txt, .exe och .dll filer.Cmdlet
: Cmdletarna i fjärrsessionen. "Cmdlet" är standard.ExternalScript
: De .ps1 filerna i sökvägarna som anges i miljövariabeln Sökväg ($env:path
) i fjärrsessionen.Filter
ochFunction
: funktionerna Windows PowerShell i fjärrsessionen.Script
: Skriptet blockerar i fjärrsessionen.
Dessa värden definieras som en flaggbaserad uppräkning. Du kan kombinera flera värden för att ange flera flaggor med hjälp av den här parametern. Värdena kan skickas till parametern CommandType som en matris med värden eller som en kommaavgränsad sträng med dessa värden. Cmdleten kombinerar värdena med hjälp av en binär-OR-åtgärd. Att skicka värden som en matris är det enklaste alternativet och du kan också använda tabbifyllning för värdena.
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
Anger att denna cmdlet undertrycker det meddelande som varnar dig när du importerar en cmdlet eller funktion vars namn innehåller ett verb som inte är godkänt eller ett otillåtet tecken.
När en modul som du importerar exporterar cmdletar eller funktioner som inte har godkända verb i sina namn visas som standard följande varningsmeddelande i Windows PowerShell:
"VARNING! Vissa importerade kommandonamn innehåller icke godkända verb som kan göra dem mindre identifierbara. Använd parametern Verbose för mer information eller typ Get-Verb
för att se listan över godkända verb."
Det här meddelandet är bara en varning. Den fullständiga modulen importeras fortfarande, inklusive kommandon som inte överensstämmer. Även om meddelandet visas för modulanvändare bör namngivningsproblemet åtgärdas av modulförfattaren.
Type: | SwitchParameter |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-FormatTypeName
Anger formateringsinstruktioner för de angivna Microsoft .NET Framework-typerna. Ange typnamnen. Jokertecken tillåts.
Värdet för den här parametern måste vara namnet på en typ som returneras av ett Get-FormatData
kommando i den session som kommandona importeras från. Om du vill hämta alla formateringsdata i fjärrsessionen skriver du *
.
Om kommandot inte innehåller parametern Import-PSSession
CommandName eller FormatTypeName importeras formateringsinstruktioner för alla .NET Framework typer som returneras av ett Get-FormatData
kommando i fjärrsessionen.
Om du använder parametern FormatTypeName importeras inga kommandon om du inte använder parametern CommandName .
Om du använder parametern CommandName importeras inte formateringsfilerna för kommandona om du inte använder parametern FormatTypeName .
Type: | String[] |
Position: | 3 |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-FullyQualifiedModule
Värdet kan vara ett modulnamn, en fullständig modulspecifikation eller en sökväg till en modulfil.
När värdet är en sökväg kan sökvägen vara fullständigt kvalificerad eller relativ. En relativ sökväg matchas i förhållande till skriptet som innehåller using-instruktionen.
När värdet är ett namn eller en modulspecifikation söker PowerShell igenom PSModulePath efter den angivna modulen.
En modulspecifikation är en hash-tabell som har följande nycklar.
ModuleName
- Krävs Anger modulnamnet.GUID
- Valfri Anger GUID för modulen.- Det är också Obligatoriskt att ange minst en av de tre nycklarna nedan.
ModuleVersion
– Anger en lägsta godtagbar version av modulen.MaximumVersion
– Anger den högsta godkända versionen av modulen.RequiredVersion
– Anger en exakt version av modulen som krävs. Detta kan inte användas med de andra versionsnycklarna.
Du kan inte ange parametern FullyQualifiedModule i samma kommando som en modulparameter . De två parametrarna utesluter varandra.
Type: | ModuleSpecification[] |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Module
Anger och matris med kommandon i Windows PowerShell snapin-moduler och moduler. Ange namnen på snapin-modulen och modulen. Jokertecken tillåts inte.
Import-PSSession
kan inte importera leverantörer från en snapin-modul.
Mer information finns i about_PSSnapins och about_Modules.
Type: | String[] |
Aliases: | PSSnapin |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Prefix
Anger ett prefix till substantiven i namnen på importerade kommandon.
Använd den här parametern för att undvika namnkonflikter som kan uppstå när olika kommandon i sessionen har samma namn.
Om du till exempel anger prefixet Remote och sedan importerar en Get-Date
cmdlet, kallas cmdleten i sessionen för Get-RemoteDate
, och den förväxlas inte med den ursprungliga Get-Date
cmdleten.
Type: | String |
Position: | Named |
Default value: | None |
Required: | False |
Accept pipeline input: | False |
Accept wildcard characters: | False |
-Session
Anger PSSession som cmdletarna importeras från. Ange en variabel som innehåller ett sessionsobjekt eller ett kommando som hämtar ett sessionsobjekt, till exempel ett New-PSSession
- eller Get-PSSession
-kommando. Du kan bara ange en session. Den här parametern krävs.
Type: | PSSession |
Position: | 0 |
Default value: | None |
Required: | True |
Accept pipeline input: | False |
Accept wildcard characters: | False |
Indata
None
Du kan inte skicka objekt till den här cmdleten.
Utdata
Den här cmdleten returnerar samma modulobjekt som New-Module
och Get-Module
cmdletar returnerar.
Den importerade modulen är dock tillfällig och finns bara i den aktuella sessionen. Om du vill skapa en permanent modul på disken använder du cmdleten Export-PSSession
.
Kommentarer
Import-PSSession
förlitar sig på PowerShell-fjärrkommunikationsinfrastrukturen. Om du vill använda den här cmdleten måste datorn konfigureras för WS-Management fjärrkommunikation. Mer information finns i about_Remote och about_Remote_Requirements.Import-PSSession
importerar inte variabler eller PowerShell-providers.- När du importerar kommandon som har samma namn som kommandon i den aktuella sessionen kan de importerade kommandona dölja alias, funktioner och cmdletar i sessionen och de kan ersätta funktioner och variabler i sessionen. Använd prefixparametern för att förhindra namnkonflikter. Mer information finns i about_Command_Precedence.
Import-PSSession
konverterar alla kommandon till funktioner innan de importeras. Därför fungerar importerade kommandon lite annorlunda än de skulle göra om de behöll sin ursprungliga kommandotyp. Om du till exempel importerar en cmdlet från en PSSession och sedan importerar en cmdlet med samma namn från en modul eller snapin-modul, körs cmdleten som importeras från PSSession alltid som standard eftersom funktioner har företräde framför cmdletar. Om du däremot importerar ett alias till en session som har ett alias med samma namn används alltid det ursprungliga aliaset, eftersom alias har företräde framför funktioner. Mer information finns i about_Command_Precedence.Import-PSSession
använder cmdletenWrite-Progress
för att visa förloppet för kommandot. Du kan se förloppsindikatorn när kommandot körs.- För att hitta de kommandon som ska importeras
Import-PSSession
använder cmdletenInvoke-Command
för att köra ettGet-Command
kommando i PSSession. För att hämta formateringsdata för kommandona använder den cmdletenGet-FormatData
. Du kan se felmeddelanden från dessa cmdletar när du kör ettImport-PSSession
kommando.Import-PSSession
Det går inte heller att importera kommandon från en PSSession som inte innehållerGet-Command
cmdletarna ,Get-FormatData
Select-Object
, ochGet-Help
. - Importerade kommandon har samma begränsningar som andra fjärrkommandon, inklusive oförmåga att starta ett program med ett användargränssnitt, till exempel Anteckningar.
- Eftersom Windows PowerShell profiler inte körs i PSSessioner är de kommandon som en profil lägger till i en session inte tillgängliga för
Import-PSSession
. Om du vill importera kommandon från en profil använder du ettInvoke-Command
kommando för att köra profilen i PSSession manuellt innan du importerar kommandon. - Den temporära modulen som
Import-PSSession
skapar kan innehålla en formateringsfil, även om kommandot inte importerar formateringsdata. Om kommandot inte importerar formateringsdata innehåller formateringsfiler som skapas inte formateringsdata. - Om du vill använda
Import-PSSession
kan körningsprincipen i den aktuella sessionen inte vara Begränsad eller AllSigned, eftersom den tillfälliga modulen somImport-PSSession
skapar innehåller osignerade skriptfiler som är förbjudna av dessa principer. Om du vill användaImport-PSSession
utan att ändra körningsprincipen för den lokala datorn använder du parameternSet-ExecutionPolicy
Omfång för för att ange en mindre restriktiv körningsprincip för en enda process. - I Windows PowerShell 2.0 innehåller hjälpavsnitt för kommandon som importeras från en annan session inte det prefix som du tilldelar med hjälp av prefixparametern. Om du vill ha hjälp med ett importerat kommando i Windows PowerShell 2.0 använder du det ursprungliga kommandonamnet (utan prefix).