ForEach-Object
Utför en åtgärd mot varje objekt i en samling indataobjekt.
Syntax
ForEach-Object
[-InputObject <PSObject>]
[-Begin <ScriptBlock>]
[-Process] <ScriptBlock[]>
[-End <ScriptBlock>]
[-RemainingScripts <ScriptBlock[]>]
[-WhatIf]
[-Confirm]
[<CommonParameters>] ForEach-Object
[-InputObject <PSObject>]
[-MemberName] <String>
[-ArgumentList <Object[]>]
[-WhatIf]
[-Confirm]
[<CommonParameters>] ForEach-Object
[-InputObject <PSObject>]
-Parallel <ScriptBlock>
[-ThrottleLimit <Int32>]
[-TimeoutSeconds <Int32>]
[-AsJob]
[-WhatIf]
[-Confirm]
[<CommonParameters>] Description
Cmdleten ForEach-Object utför en åtgärd på varje objekt i en samling indataobjekt. Indataobjekten kan skickas till cmdleten eller anges med hjälp av parametern InputObject .
Från och med Windows PowerShell 3.0 finns det två olika sätt att skapa ett ForEach-Object kommando.
Skriptblock. Du kan använda ett skriptblock för att ange åtgärden. Använd variabeln i skriptblocket
$_för att representera det aktuella objektet. Skriptblocket är värdet för parametern Process . Skriptblocket kan innehålla alla PowerShell-skript.Följande kommando hämtar till exempel värdet för egenskapen ProcessName för varje process på datorn.
Get-Process | ForEach-Object {$_.ProcessName}ForEach-Objectstöder blockenbegin,processochendenligt beskrivningen i about_functions.Anteckning
Skriptblocken körs i anroparens omfång. Därför har blocken åtkomst till variabler i det omfånget och kan skapa nya variabler som finns kvar i omfånget när cmdleten har slutförts.
Åtgärdsinstrukering. Du kan också skriva en åtgärdsinstrukering, som liknar det naturliga språket. Du kan använda åtgärdssatsen för att ange ett egenskapsvärde eller anropa en metod. Åtgärdsinstruktioner introducerades i Windows PowerShell 3.0.
Följande kommando hämtar till exempel även värdet för egenskapen ProcessName för varje process på datorn.
Get-Process | ForEach-Object ProcessNameSkriptblock som körs parallellt. Från och med PowerShell 7.0 är en tredje parameteruppsättning tillgänglig som kör varje skriptblock parallellt. Parametern ThrottleLimit begränsar antalet parallella skript som körs åt gången. Precis som tidigare använder du variabeln
$_för att representera det aktuella indataobjektet i skriptblocket. Använd nyckelordet$using:för att skicka variabelreferenser till skriptet som körs.I PowerShell 7 skapas ett nytt runspace för varje loopiteration för att säkerställa maximal isolering. Detta kan vara en stor prestanda- och resursträff om det arbete du utför är litet jämfört med att skapa nya runspaces eller om det finns många iterationer som utför betydande arbete. Från och med PowerShell 7.1 återanvänds runspaces från en runspace-pool som standard. Storleken på runspace-poolen anges av parametern ThrottleLimit . Standardstorleken för runspace-poolen är 5. Du kan fortfarande skapa ett nytt runspace för varje iteration med hjälp av växeln UseNewRunspace .
Som standard använder parallella skriptblock den aktuella arbetskatalogen för anroparen som startade de parallella aktiviteterna.
Mer information finns i avsnittet ANTECKNINGAR i den här artikeln.
Exempel
Exempel 1: Dividera heltal i en matris
Det här exemplet tar en matris med tre heltal och delar var och en av dem med 1024.
30000, 56798, 12432 | ForEach-Object -Process {$_/1024}
29.296875
55.466796875
12.140625Exempel 2: Hämta längden på alla filer i en katalog
Det här exemplet bearbetar filerna och katalogerna i PowerShell-installationskatalogen $PSHOME.
Get-ChildItem $PSHOME |
ForEach-Object -Process {if (!$_.PSIsContainer) {$_.Name; $_.Length / 1024; " " }}Om objektet inte är en katalog hämtar skriptblocket namnet på filen, dividerar värdet för egenskapen Length med 1024 och lägger till ett blanksteg (" ") för att separera det från nästa post. Cmdleten använder egenskapen PSISContainer för att avgöra om ett objekt är en katalog.
Exempel 3: Arbeta med de senaste systemhändelserna
I det här exemplet skrivs de 1 000 senaste händelserna från systemhändelseloggen till en textfil. Den aktuella tiden visas före och efter bearbetning av händelserna.
$Events = Get-EventLog -LogName System -Newest 1000
$events | ForEach-Object -Begin {Get-Date} -Process {Out-File -FilePath Events.txt -Append -InputObject $_.Message} -End {Get-Date}Get-EventLog hämtar de 1 000 senaste händelserna från systemhändelseloggen och lagrar dem i variabeln $Events . $Events skickas sedan till cmdleten ForEach-Object . Parametern Begin visar aktuellt datum och tid. Sedan använder parametern Process cmdleten Out-File för att skapa en textfil med namnet events.txt och lagrar meddelandeegenskapen för var och en av händelserna i filen. Slutligen används parametern End för att visa datum och tid när all bearbetning har slutförts.
Exempel 4: Ändra värdet för en registernyckel
I det här exemplet ändras värdet för RemotePath-registerposten i alla undernycklar under HKCU:\Network nyckeln till versaler.
Get-ItemProperty -Path HKCU:\Network\* |
ForEach-Object {Set-ItemProperty -Path $_.PSPath -Name RemotePath -Value $_.RemotePath.ToUpper();}Du kan använda det här formatet för att ändra formuläret eller innehållet i ett registerpostvärde.
Varje undernyckel i nätverksnyckeln representerar en mappad nätverksenhet som återansluter vid inloggning. RemotePath-posten innehåller UNC-sökvägen för den anslutna enheten. Om du till exempel mappar enheten E: till \\Server\Shareskapas en E-undernyckel i HKCU:\Network med registervärdet RemotePath inställt på \\Server\Share.
Kommandot använder cmdleten Get-ItemProperty för att hämta alla undernycklar till nätverksnyckeln och cmdleten Set-ItemProperty för att ändra värdet för RemotePath-registerposten i varje nyckel. Set-ItemProperty I kommandot är sökvägen värdet för egenskapen PSPath för registernyckeln. Det här är en egenskap för Objektet Microsoft .NET Framework som representerar registernyckeln, inte en registerpost. Kommandot använder metoden ToUpper() för RemotePath-värdet , som är en sträng (REG_SZ).
Eftersom Set-ItemProperty ändrar egenskapen för varje nyckel krävs cmdleten ForEach-Object för att få åtkomst till egenskapen.
Exempel 5: Använd den automatiska variabeln $null
Det här exemplet visar effekten av att skicka den $null automatiska variabeln till cmdleten ForEach-Object .
1, 2, $null, 4 | ForEach-Object {"Hello"}
Hello
Hello
Hello
HelloEftersom PowerShell behandlar $null som en explicit platshållare genererar cmdleten ForEach-Object ett värde för $null som det gör för andra objekt som skickas till den.
Exempel 6: Hämta egenskapsvärden
Det här exemplet hämtar värdet för egenskapen Path för alla installerade PowerShell-moduler med hjälp av parametern MemberName för cmdleten ForEach-Object .
Get-Module -ListAvailable | ForEach-Object -MemberName Path
Get-Module -ListAvailable | Foreach PathDet andra kommandot motsvarar det första. Den använder aliaset Foreach för cmdleten ForEach-Object och utelämnar namnet på parametern MemberName , vilket är valfritt.
Cmdleten ForEach-Object är användbar för att hämta egenskapsvärden, eftersom den hämtar värdet utan att ändra typen, till skillnad från format-cmdletar eller cmdleten Select-Object, som ändrar egenskapsvärdetypen.
Exempel 7: Dela upp modulnamn i komponentnamn
Det här exemplet visar tre sätt att dela upp två punktavgränsade modulnamn i sina komponentnamn. Kommandona anropar metoden Split för strängar. De tre kommandona använder olika syntax, men de är likvärdiga och utbytbara. Utdata är desamma för alla tre fallen.
"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" | ForEach-Object {$_.Split(".")}
"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" | ForEach-Object -MemberName Split -ArgumentList "."
"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" | Foreach Split "."
Microsoft
PowerShell
Core
Microsoft
PowerShell
HostDet första kommandot använder den traditionella syntaxen, som innehåller ett skriptblock och den aktuella objektoperatorn $_. Den använder punktsyntaxen för att ange metoden och parenteserna för att omsluta avgränsarargumentet.
Det andra kommandot använder parametern MemberName för att ange split-metoden och parametern ArgumentList för att identifiera punkten (.) som avgränsare.
Det tredje kommandot använder Foreach-aliaset för cmdleten ForEach-Object och utelämnar namnen på parametrarna MemberName och ArgumentList , som är valfria.
Exempel 8: Använda ForEach-Object med två skriptblock
I det här exemplet skickar vi två skriptblock positionligt. Alla skriptblock binder till parametern Process . De behandlas dock som om de hade skickats till parametrarna Begin och Process .
1..2 | ForEach-Object { 'begin' } { 'process' }
begin
process
processExempel 9: Använda ForEach-Object med fler än två skriptblock
I det här exemplet skickar vi två skriptblock positionligt. Alla skriptblock binder till parametern Process . De behandlas dock som om de hade skickats till parametrarna Begin, Process och End .
1..2 | ForEach-Object { 'begin' } { 'process A' } { 'process B' } { 'end' }
begin
process A
process B
process A
process B
endAnteckning
Det första skriptblocket begin mappas alltid till blocket, det sista blocket mappas till end blocket och blocken däremellan mappas till process blocket.
Exempel 10: Kör flera skriptblock för varje pipelineobjekt
Som du ser i föregående exempel mappas flera skriptblock som skickas med hjälp av processparametern till parametrarna Begin och End . För att undvika den här mappningen måste du ange explicita värden för parametrarna Begin och End .
1..2 | ForEach-Object -Begin $null -Process { 'one' }, { 'two' }, { 'three' } -End $null
one
two
three
one
two
threeExempel 11: Kör långsamt skript i parallella batchar
Det här exemplet kör ett skriptblock som utvärderar en sträng och viloläge i en sekund.
$Message = "Output:"
1..8 | ForEach-Object -Parallel {
"$using:Message $_"
Start-Sleep 1
} -ThrottleLimit 4
Output: 1
Output: 2
Output: 3
Output: 4
Output: 5
Output: 6
Output: 7
Output: 8Parametervärdet ThrottleLimit är inställt på 4 så att indata bearbetas i batchar om fyra.
Nyckelordet $using: används för att skicka variabeln $Message till varje parallellt skriptblock.
Exempel 12: Hämta loggposter parallellt
Det här exemplet hämtar 50 000 loggposter från 5 systemloggar på en lokal Windows-dator.
$logNames = 'Security','Application','System','Windows PowerShell','Microsoft-Windows-Store/Operational'
$logEntries = $logNames | ForEach-Object -Parallel {
Get-WinEvent -LogName $_ -MaxEvents 10000
} -ThrottleLimit 5
$logEntries.Count
50000Parametern Parallel anger skriptblocket som körs parallellt för varje indataloggnamn. Parametern ThrottleLimit säkerställer att alla fem skriptblocken körs samtidigt.
Exempel 13: Kör parallellt som ett jobb
Det här exemplet skapar ett jobb som kör ett skriptblock parallellt, två i taget.
$job = 1..10 | ForEach-Object -Parallel {
"Output: $_"
Start-Sleep 1
} -ThrottleLimit 2 -AsJob
$job | Receive-Job -Wait
Output: 1
Output: 2
Output: 3
Output: 4
Output: 5
Output: 6
Output: 7
Output: 8
Output: 9
Output: 10variabeln $job tar emot jobbobjektet som samlar in utdata och övervakar körningstillståndet.
Jobbobjektet skickas till Receive-Job med växelparametern Wait , som strömmar utdata till konsolen som om ForEach-Object -Parallel det kördes utan AsJob.
Exempel 14: Använda trådsäkra variabelreferenser
Det här exemplet anropar skriptblock parallellt för att samla in unikt namngivna processobjekt.
$threadSafeDictionary = [System.Collections.Concurrent.ConcurrentDictionary[string,object]]::new()
Get-Process | ForEach-Object -Parallel {
$dict = $using:threadSafeDictionary
$dict.TryAdd($_.ProcessName, $_)
}
$threadSafeDictionary["pwsh"]
NPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName
------ ----- ----- ------ -- -- -----------
82 82.87 130.85 15.55 2808 2 pwshEn enda instans av ett ConcurrentDictionary-objekt skickas till varje skriptblock för att samla in objekten. Eftersom ConcurrentDictionary är trådsäkert är det säkert att ändras av varje parallellt skript. Ett icke-trådsäkert objekt, till exempel System.Collections.Generic.Dictionary, skulle inte vara säkert att använda här.
Anteckning
Det här exemplet är en mycket ineffektiv användning av parametern Parallel . Skriptet lägger helt enkelt till indataobjektet i ett samtidigt ordlisteobjekt. Det är trivialt och inte värt att anropa varje skript i en separat tråd. Att köra ForEach-Object normalt utan parallellbrytare är mycket effektivare och snabbare. Det här exemplet är endast avsett att demonstrera hur du använder trådsäkra variabler.
Exempel 15: Skriva fel med parallell körning
Det här exemplet skriver till felströmmen parallellt, där ordningen på skrivna fel är slumpmässig.
1..3 | ForEach-Object -Parallel {
Write-Error "Error: $_"
}
Write-Error: Error: 1
Write-Error: Error: 3
Write-Error: Error: 2Exempel 16: Avslutande av fel vid parallell körning
Det här exemplet visar ett avslutande fel i ett skriptblock som körs parallellt.
1..5 | ForEach-Object -Parallel {
if ($_ -eq 3)
{
throw "Terminating Error: $_"
}
Write-Output "Output: $_"
}
Exception: Terminating Error: 3
Output: 1
Output: 4
Output: 2
Output: 5Output: 3 skrivs aldrig eftersom den parallella scriptblock för iterationen avslutades.
Anteckning
PipelineVariable vanliga parametervariabler stöds inte i Foreach-Object -Parallel scenarier även med nyckelordet $using: .
Exempel 17: Skicka variabler i det kapslade parallella skriptet ScriptBlockSet
Du kan skapa en variabel utanför en Foreach-Object -Parallel begränsad scriptblock och använda den i scriptblock med nyckelordet $using .
$test1 = 'TestA'
1..2 | Foreach-Object -Parallel {
$using:test1
}
TestA
TestA
# You CANNOT create a variable inside a scoped scriptblock
# to be used in a nested foreach parallel scriptblock.
$test1 = 'TestA'
1..2 | Foreach-Object -Parallel {
$using:test1
$test2 = 'TestB'
1..2 | Foreach-Object -Parallel {
$using:test2
}
}
Line |
2 | 1..2 | Foreach-Object -Parallel {
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
| The value of the using variable '$using:test2' cannot be retrieved because it has not been set in the local session.Det kapslade skriptblocket kan inte komma åt variabeln $test2 och ett fel utlöses.
Exempel 18: Skapa flera jobb som kör skript parallellt
Parametern ThrottleLimit begränsar antalet parallella skript som körs under varje instans av ForEach-Object -Parallel. Det begränsar inte antalet jobb som kan skapas när du använder asjob-parametern . Eftersom själva jobben körs samtidigt är det möjligt att skapa ett antal parallella jobb, var och en körs upp till begränsningsgränsen för antalet samtidiga skriptblock.
$jobs = for ($i=0; $i -lt 10; $i++) {
1..10 | ForEach-Object -Parallel {
./RunMyScript.ps1
} -AsJob -ThrottleLimit 5
}
$jobs | Receive-Job -WaitI det här exemplet skapas 10 jobb som körs. Varje jobb kör inte fler än 5 skript samtidigt. Det totala antalet instanser som körs samtidigt är begränsat till 50 (10 jobb gånger begränsningsbegränsningen på 5).
Parametrar
Anger en matris med argument till ett metodanrop. Mer information om beteendet för ArgumentList finns i about_Splatting.
Den här parametern introducerades i Windows PowerShell 3.0.
| Type: | Object[] |
| Aliases: | Args |
| Position: | Named |
| Default value: | None |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Gör att det parallella anropet körs som ett PowerShell-jobb. Ett enskilt jobbobjekt returneras i stället för utdata från de skriptblock som körs. Jobbobjektet innehåller underordnade jobb för varje parallellt skriptblock som körs. Jobbobjektet kan användas av alla PowerShell-jobb-cmdletar för att övervaka körningstillstånd och hämta data.
Den här parametern introducerades i PowerShell 7.0.
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | None |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Anger ett skriptblock som körs innan den här cmdleten bearbetar indataobjekt. Det här skriptblocket körs bara en gång för hela pipelinen. Mer information om blocket finns i beginabout_Functions.
| Type: | ScriptBlock |
| Position: | Named |
| Default value: | None |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Uppmanar dig att bekräfta innan du kör cmdleten.
| Type: | SwitchParameter |
| Aliases: | cf |
| Position: | Named |
| Default value: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Anger ett skriptblock som körs efter att denna cmdlet bearbetar alla indataobjekt. Det här skriptblocket körs bara en gång för hela pipelinen. Mer information om blocket finns i endabout_Functions.
| Type: | ScriptBlock |
| Position: | Named |
| Default value: | None |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Anger indataobjekten. ForEach-Object kör skriptblocket eller åtgärdsinstrukeringen för varje indataobjekt. Ange en variabel som innehåller objekten eller skriv ett kommando eller uttryck som hämtar objekten.
När du använder parametern InputObject med ForEach-Object, i stället för att skicka kommandoresultat till ForEach-Object, behandlas InputObject-värdet som ett enda objekt. Detta gäller även om värdet är en samling som är resultatet av ett kommando, till exempel -InputObject (Get-Process).
Eftersom InputObject inte kan returnera enskilda egenskaper från en matris eller en samling objekt rekommenderar vi att om du använder ForEach-Object för att utföra åtgärder på en samling objekt för de objekt som har specifika värden i definierade egenskaper, använder ForEach-Object du i pipelinen, som du ser i exemplen i det här avsnittet.
| Type: | PSObject |
| Position: | Named |
| Default value: | None |
| Accept pipeline input: | True |
| Accept wildcard characters: | False |
Anger den egenskap som ska hämtas eller vilken -metod som ska anropas.
Jokertecken tillåts, men fungerar bara om den resulterande strängen matchas till ett unikt värde.
Om du till exempel kör Get-Process | ForEach -MemberName *Namematchar jokertecknet fler än en medlem, vilket gör att kommandot misslyckas.
Den här parametern introducerades i Windows PowerShell 3.0.
| Type: | String |
| Position: | 0 |
| Default value: | None |
| Accept pipeline input: | False |
| Accept wildcard characters: | True |
Anger det skriptblock som ska användas för parallell bearbetning av indataobjekt. Ange ett skriptblock som beskriver åtgärden.
Den här parametern introducerades i PowerShell 7.0.
| Type: | ScriptBlock |
| Position: | Named |
| Default value: | None |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Anger den åtgärd som utförs på varje indataobjekt. Det här skriptblocket körs för varje objekt i pipelinen. Mer information om blocket finns i processabout_Functions.
När du anger flera skriptblock till parametern Process mappas alltid det första skriptblocket begin till blocket. Om det bara finns två skriptblock mappas det andra blocket till process blocket. Om det finns tre eller flera skriptblock mappas alltid det första skriptblocket begin till blocket, det sista blocket mappas till end blocket och blocken däremellan mappas till process blocket.
| Type: | ScriptBlock[] |
| Position: | 0 |
| Default value: | None |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Anger alla skriptblock som inte tas av parametern Process .
Den här parametern introducerades i Windows PowerShell 3.0.
| Type: | ScriptBlock[] |
| Position: | Named |
| Default value: | None |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Anger antalet skriptblock som är parallella. Indataobjekt blockeras tills antalet skriptblock som körs understiger ThrottleLimit. Standardvärdet är 5.
Parametern ThrottleLimit begränsar antalet parallella skript som körs under varje instans av ForEach-Object -Parallel. Det begränsar inte antalet jobb som kan skapas när du använder asjob-parametern . Eftersom jobben körs samtidigt är det möjligt att skapa ett antal parallella jobb, var och en körs upp till begränsningsgränsen för antalet samtidiga skriptblock.
Den här parametern introducerades i PowerShell 7.0.
| Type: | Int32 |
| Position: | Named |
| Default value: | 5 |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Anger hur många sekunder som ska vänta tills alla indata bearbetas parallellt. Efter den angivna tidsgränsen stoppas alla skript som körs. Och eventuella återstående indataobjekt som ska bearbetas ignoreras. Standardvärdet 0 för inaktiverar tidsgränsen och ForEach-Object -Parallel kan köras på obestämd tid. Om du skriver Ctrl+C på kommandoraden stoppas ett kommando som körs ForEach-Object -Parallel . Den här parametern kan inte användas tillsammans med asjob-parametern .
Den här parametern introducerades i PowerShell 7.0.
| Type: | Int32 |
| Position: | Named |
| Default value: | 0 |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Gör att det parallella anropet skapar ett nytt runspace för varje loop-iteration i stället för att återanvända runspaces från runspace-poolen.
Den här parametern introducerades i PowerShell 7.1
| Type: | SwitchParameter |
| Position: | Named |
| Default value: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Visar vad som skulle hända om cmdleten kördes. Cmdleten körs inte.
| Type: | SwitchParameter |
| Aliases: | wi |
| Position: | Named |
| Default value: | False |
| Accept pipeline input: | False |
| Accept wildcard characters: | False |
Indata
Du kan skicka valfritt objekt till den här cmdleten.
Utdata
Den här cmdleten returnerar objekt som bestäms av indata.
Kommentarer
Cmdleten ForEach-Object fungerar ungefär som Foreach-instruktionen , förutom att du inte kan skicka indata till en Foreach-instruktion . Mer information om Foreach-instruktionen finns i about_Foreach.
Från och med PowerShell 4.0 WhereForEach har metoder lagts till för användning med samlingar. Du kan läsa mer om dessa nya metoder här about_arrays
Använda ForEach-Object -Parallel:
Parameteruppsättningen
ForEach-Object -Parallelanvänder PowerShells interna API för att köra varje skriptblock i ett nytt körningsutrymme. Detta är betydligt mer omkostnader än att köraForEach-Objectnormalt med sekventiell bearbetning. Det är viktigt att använda Parallel där arbetet med att köra parallellt är litet jämfört med det arbete som skriptblocket utför. Exempel:- Beräkningsintensiva skript på datorer med flera kärnor
- Skript som ägnar tid åt att vänta på resultat eller utföra filåtgärder
Om du använder parametern Parallel kan skript köras mycket långsammare än normalt. Särskilt om de parallella skripten är triviala. Experimentera med Parallel för att upptäcka var det kan vara fördelaktigt.
När de körs parallellt kan objekt som är dekorerade med ScriptProperties eller ScriptMethods inte garanteras fungera korrekt om de körs i ett annat körningsutrymme än skripten som ursprungligen var kopplade till dem.
Scriptblock-anrop försöker alltid köras i dess hemkörningsutrymme , oavsett var det faktiskt anropas. Skapar dock
ForEach-Object -Paralleltillfälliga runspaces som tas bort efter användning, så det finns inget körningsutrymme för skripten att köra i längre.Det här beteendet kan fungera så länge home runspace fortfarande finns. Du kanske dock inte får önskat resultat om skriptet är beroende av externa variabler som bara finns i anroparens runspace och inte start-runspace .
Icke-avslutande fel skrivs till cmdlet-felströmmen när de inträffar parallellt med skriptblockering. Eftersom körningsordningen för parallell scriptblock är icke-deterministisk är ordningen där fel visas i felströmmen slumpmässig. På samma sätt skrivs meddelanden som skrivs till andra dataströmmar, t.ex. varning, utförlig eller information, till dessa dataströmmar i obestämd ordning.
Avslutande fel, till exempel undantag, avslutar den enskilda parallella instansen av skriptblocken där de inträffar. Ett avslutande fel i ett skriptblock kan inte orsaka att cmdleten
Foreach-Objectavslutas. De andra skriptblocken, som körs parallellt, fortsätter att köras om de inte också påträffar ett avslutande fel. Det avslutande felet skrivs till feldataströmmen som en ErrorRecord med FullyQualifiedErrorId förPSTaskException. Avslutande fel kan konverteras till icke-avslutande fel med hjälp av PowerShelltry/catchellertrapblock.PipelineVariable vanliga parametervariabler stöds inte i parallella scenarier även med nyckelordet
$using:.Viktigt
Parameteruppsättningen
ForEach-Object -Parallelkör skriptblock parallellt på separata processtrådar. Med nyckelordet$using:kan du skicka variabelreferenser från cmdletens anropstråd till varje skriptblockstråd som körs. Eftersom skriptblocken körs i olika trådar måste objektvariablerna som skickas med referens användas på ett säkert sätt. I allmänhet är det säkert att läsa från refererade objekt som inte ändras. Men om objekttillståndet ändras måste du använda trådsäkra objekt, till exempel .NET System.Collection.Concurrent-typer (se exempel 11).
Relaterade länkar
Feedback
Skicka och visa feedback för