Import-PSSession

Referens

Modul:: Microsoft.PowerShell.Utility

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-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ä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 $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 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.
Filteroch Function: 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-PSSessionCommandName 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

PSModuleInfo

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 cmdleten Write-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 cmdleten Invoke-Command för att köra ett Get-Command kommando i PSSession. För att hämta formateringsdata för kommandona använder den cmdleten Get-FormatData . Du kan se felmeddelanden från dessa cmdletar när du kör ett Import-PSSession kommando. Import-PSSession Det går inte heller att importera kommandon från en PSSession som inte innehåller Get-Commandcmdletarna , Get-FormatDataSelect-Object, och Get-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 ett Invoke-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-PSSessionkan körningsprincipen i den aktuella sessionen inte vara Begränsad eller AllSigned, eftersom den tillfälliga modulen som Import-PSSession skapar innehåller osignerade skriptfiler som är förbjudna av dessa principer. Om du vill använda Import-PSSession utan att ändra körningsprincipen för den lokala datorn använder du parametern Set-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 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).

Export-PSSession