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 importeras 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 precis som med 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 du 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-PSSessionlä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ändiga 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 $SDet 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-TestDessa 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 parametern Test noun och 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 FullDet 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 $batchDet 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 du 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 till $S den aktuella sessionen.
Det tredje kommandot använder parametern AsJob 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 TestManagementDet 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 modulparametern Import-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 hur Import-PSSession du skapar en modul i en temporär 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 PMDet 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 Julian-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å snapin-modulen för Windows PowerShell som lade till den ursprungliga Get-Date cmdleten i den aktuella sessionen.
Det femte kommandot använder det snapin-in-qualified namnet på cmdleten Get-Date för att köra ett Get-Date kommando.
Mer information om kommandopriorence 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** -AllowClobberDet 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 bara 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-BitsTransferDet 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 på 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 är resultatet av 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 $Sskriver 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 använder cmdleten Get-ChildItem 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 angivna namn eller namnmönster. 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 variabeln Sökvägsmiljö ($env:path) i fjärrsessionen, inklusive .txt, .exe och .dll filer.Cmdlet: Cmdletarna i fjärrsessionen. "Cmdlet" är standardvärdet.ExternalScript: .ps1-filerna i sökvägarna som anges i variabeln Sökvägsmiljö ($env:path) i fjärrsessionen.FilterochFunction: Windows PowerShell-funktionerna 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 av 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 även använda tab-completion på 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 meddelandet som varnar dig när du importerar en cmdlet eller funktion vars namn innehåller ett icke godkänt verb eller ett förbjudet tecken.
När en modul som du importerar exporterar cmdletar eller funktioner som inte har godkända verb i sina namn visas följande varningsmeddelande i Windows PowerShell:
"VARNING: Vissa importerade kommandonamn innehåller verb som inte har godkänts, vilket 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."
Detta meddelande ä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 sessionen 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 instruktionen using.
När värdet är ett namn eller en modulspecifikation söker PowerShell i PSModulePath efter den angivna modulen.
En modulspecifikation är en hashtable som har följande nycklar.
ModuleName- Obligatoriskt Anger modulnamnet.GUID- Valfritt 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 maximala godkända versionen av modulen.RequiredVersion– Anger en exakt, nödvändig version av modulen. Detta kan inte användas med de andra versionsnycklarna.
Du kan inte ange parametern FullyQualifiedModule i samma kommando som en modulparameter . De två parametrarna är ömsesidigt uteslutande.
| Type: | ModuleSpecification[] |
| Position: | Named |
| Default value: | None |
| Required: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
-Module
Anger och matris med kommandon i Snapin-modulerna och modulerna i Windows PowerShell. Ange snapin-modulnamnen och modulnamnen. Jokertecken är inte tillåtna.
Import-PSSession kan inte importera providers 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 är cmdleten känd i sessionen som 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 eller Get-PSSession ett New-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-PSSessionfö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-PSSessionimporterar inte variabler eller PowerShell-leverantörer.- 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. Om du vill förhindra namnkonflikter använder du parametern Prefix . Mer information finns i about_Command_Precedence.
Import-PSSessionkonverterar 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 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-PSSessionanvänder cmdletenWrite-Progressför att visa förloppet för kommandot. Du kan se förloppsindikatorn medan kommandot körs.- Om du vill hitta de kommandon som ska importeras
Import-PSSessionanvänder du cmdletenInvoke-Commandför att köra ettGet-Commandkommando 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-PSSessionkommando.Import-PSSessionDet går inte heller att importera kommandon från en PSSession som inte innehållerGet-Commandcmdletarna ,Get-FormatData,Select-ObjectochGet-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 kommandona 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-Commandkommando för att köra profilen i PSSession manuellt innan du importerar kommandon. - Den temporära modulen som
Import-PSSessionskapar 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-PSSessionkan körningsprincipen i den aktuella sessionen inte vara Begränsad eller AllSigned, eftersom den tillfälliga modulen somImport-PSSessionskapar innehåller osignerade skriptfiler som är förbjudna av dessa principer. Om du vill användaImport-PSSessionutan att ändra körningsprincipen för den lokala datorn använder du parameternSet-ExecutionPolicyOmfå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 prefixet som du tilldelar med hjälp av prefixparametern . Om du vill få hjälp med ett importerat kommando i Windows PowerShell 2.0 använder du det ursprungliga (icke-prefixerade) kommandonamnet.
Relaterade länkar
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för