ForEach-Object

Műveletet hajt végre a bemeneti objektumok gyűjteményének minden elemén.

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

A ForEach-Object parancsmag egy műveletet hajt végre a bemeneti objektumok gyűjteményének minden elemén. A bemeneti objektumok átirányíthatók a parancsmagba, vagy megadhatók az InputObject paraméterrel.

A Windows PowerShell 3.0-tól kezdve kétféleképpen hozhat létre parancsokatForEach-Object.

  • Szkriptblokk. A művelet megadásához szkriptblokkot használhat. A szkriptblokkon belül használja a változót $_ az aktuális objektum ábrázolásához. A szkriptblokk a Folyamat paraméter értéke. A szkriptblokk bármilyen PowerShell-szkriptet tartalmazhat.

    A következő parancs például lekéri a számítógépen lévő egyes folyamatok ProcessName tulajdonságának értékét.

    Get-Process | ForEach-Object {$_.ProcessName}

    ForEach-Object A támogatja a begin, processés end a blokkokat a about_functions.

    Megjegyzés

    A szkriptblokkok a hívó hatókörében futnak. Ezért a blokkok hozzáféréssel rendelkeznek az adott hatókörben lévő változókhoz, és új változókat hozhatnak létre, amelyek a parancsmag befejeződése után is megmaradnak a hatókörben.

  • Műveleti utasítás. Műveleti utasítást is írhat, amely sokkal inkább hasonlít a természetes nyelvhez. A műveleti utasítással megadhat egy tulajdonságértéket, vagy meghívhat egy metódust. A műveleti utasítások a Windows PowerShell 3.0-s kiadásban jelentek meg.

    Az alábbi parancs például lekéri a számítógépen lévő egyes folyamatok ProcessName tulajdonságának értékét is.

    Get-Process | ForEach-Object ProcessName

  • Párhuzamos futtatási szkriptblokk. A PowerShell 7.0-tól kezdve egy harmadik paraméterkészlet érhető el, amely az egyes szkriptblokkokat párhuzamosan futtatja. A ThrottleLimit paraméter korlátozza az egyszerre futó párhuzamos szkriptek számát. Mint korábban, a $_ változóval a szkriptblokk aktuális bemeneti objektumát ábrázolhatja. $using: A kulcsszóval változóhivatkozásokat adhat át a futó szkriptnek.

    A PowerShell 7-ben minden ciklus iterációjához létrejön egy új runspace, amely biztosítja a maximális elkülönítést. Ez nagy teljesítmény- és erőforrás-találat lehet, ha az elvégzett munka kicsi az új runspace-ekhez képest, vagy ha sok iteráció végez jelentős munkát. A PowerShell 7.1-től kezdve a rendszer alapértelmezés szerint újra felhasználja a runspace-készletből származó runspace-eket. A runspace pool méretét a ThrottleLimit paraméter határozza meg. A runspace-készlet alapértelmezett mérete 5. A UseNewRunspace kapcsolóval minden iterációhoz létrehozhat új futtatóteret.

    A párhuzamos szkriptblokkok alapértelmezés szerint annak a hívónak az aktuális munkakönyvtárát használják, amely elindította a párhuzamos feladatokat.

    További információt a cikk JEGYZETEK szakaszában talál.

Példák

1. példa: Egész számok osztása tömbben

Ez a példa három egész számból álló tömböt vesz fel, és 1024-sel osztja el őket.

30000, 56798, 12432 | ForEach-Object -Process {$_/1024}

29.296875
55.466796875
12.140625

2. példa: A könyvtárban lévő összes fájl hosszának lekérése

Ez a példa a PowerShell telepítési könyvtárában lévő fájlokat és könyvtárakat $PSHOMEdolgozza fel.

Get-ChildItem $PSHOME |
  ForEach-Object -Process {if (!$_.PSIsContainer) {$_.Name; $_.Length / 1024; " " }}

Ha az objektum nem könyvtár, a szkriptblokk lekéri a fájl nevét, 1024-tel osztja el a Length tulajdonság értékét, és hozzáad egy szóközt ("") a következő bejegyzéstől való elválasztásához. A parancsmag a PSISContainer tulajdonsággal határozza meg, hogy egy objektum könyvtár-e.

3. példa: A legutóbbi rendszeresemények kezelése

Ez a példa a rendszer eseménynaplójának 1000 legutóbbi eseményét írja egy szövegfájlba. Az aktuális idő az események feldolgozása előtt és után jelenik meg.

$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 lekéri az 1000 legutóbbi eseményt a rendszer eseménynaplójából, és tárolja őket a $Events változóban. $Events ezután a parancsmagra ForEach-Object lesz állítva. A Begin paraméter megjeleníti az aktuális dátumot és időpontot. Ezután a Process paraméter a Out-File parancsmag használatával létrehoz egy events.txt nevű szövegfájlt, és az adott fájlban lévő összes esemény üzenettulajdonságát tárolja. Végül a Vég paraméter a feldolgozás befejezését követő dátumot és időt jeleníti meg.

4. példa: Beállításkulcs értékének módosítása

Ez a példa a kulcs alatti HKCU:\Network alkulcsok RemotePath beállításjegyzék-bejegyzésének értékét nagybetűsre módosítja.

Get-ItemProperty -Path HKCU:\Network\* |
  ForEach-Object {Set-ItemProperty -Path $_.PSPath -Name RemotePath -Value $_.RemotePath.ToUpper();}

Ezzel a formátummal módosíthatja egy beállításjegyzék-bejegyzés értékének űrlapját vagy tartalmát.

A hálózati kulcs minden alkulcsa egy leképezett hálózati meghajtót jelöl, amely újracsatlakozik a bejelentkezéskor. A RemotePath bejegyzés tartalmazza a csatlakoztatott meghajtó UNC elérési útját. Ha például leképezi az E: meghajtót\\Server\Share, létrejön HKCU:\Network egy E alkulcs, amelyben a RemotePath beállításazonosítója a következőre \\Server\Sharevan állítva.

A parancs a Get-ItemProperty parancsmaggal lekéri a hálózati kulcs és a Set-ItemProperty parancsmag összes alkulcsát a RemotePath beállításjegyzék-bejegyzés értékének módosításához az egyes kulcsokban. A parancsban az Set-ItemProperty elérési út a beállításkulcs PSPath tulajdonságának értéke. Ez a Microsoft .NET-keretrendszer objektum olyan tulajdonsága, amely a beállításkulcsot jelöli, nem pedig egy beállításjegyzékbeli bejegyzést. A parancs a RemotePath érték ToUpper() metódusát használja, amely egy sztring (REG_SZ).

Mivel Set-ItemProperty az egyes kulcsok tulajdonságát módosítja, a ForEach-Object parancsmagnak hozzá kell férnie a tulajdonsághoz.

5. példa: Az $null automatikus változó használata

Ez a példa azt mutatja be, hogy az automatikus változó a parancsmagra ForEach-Object van-e állítva$null.

1, 2, $null, 4 | ForEach-Object {"Hello"}

Hello
Hello
Hello
Hello

Mivel a PowerShell explicit helyőrzőként kezeli $null , a ForEach-Object parancsmag olyan értéket $null hoz létre, mint más, rá irányuló objektumok esetében.

6. példa: Tulajdonságértékek lekérése

Ez a példa lekéri az összes telepített PowerShell-modul Path tulajdonságának értékét a ForEach-Object parancsmag MemberName paraméterével.

Get-Module -ListAvailable | ForEach-Object -MemberName Path
Get-Module -ListAvailable | Foreach Path

A második parancs egyenértékű az első paranccsal. A parancsmag aliasát ForEach-Object használjaForeach, és kihagyja a MemberName paraméter nevét, ami nem kötelező.

A ForEach-Object parancsmag tulajdonságértékek lekéréséhez hasznos, mert a típus módosítása nélkül kapja meg az értéket, ellentétben a Formátum parancsmagokkal vagy a Select-Object parancsmaggal, amelyek megváltoztatják a tulajdonság értéktípusát.

7. példa: Modulnevek felosztása összetevőnevekre

Ebben a példában háromféleképpen oszthat fel két pontból álló modulnevet az összetevők neveire. A parancsok a sztringek Split metódusát hívják meg. A három parancs különböző szintaxist használ, de egyenértékűek és felcserélhetők. A kimenet mindhárom esetben megegyezik.

"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
Host

Az első parancs a hagyományos szintaxist használja, amely egy szkriptblokkot és az aktuális objektumoperátort $_tartalmazza. A pontszintaxis használatával adja meg a metódust és a zárójeleket az elválasztó argumentum beágyazásához.

A második parancs a MemberName paramétert használja a Split metódus és az ArgumentList paraméter megadására a pont (.) felosztási elválasztóként való azonosításához.

A harmadik parancs a parancsmag Foreach aliasát ForEach-Object használja, és kihagyja a MemberName és az ArgumentList paraméterek nevét, amelyek nem kötelezőek.

8. példa: ForEach-Object használata két szkriptblokkdal

Ebben a példában két szkriptblokkot adunk át pozícióban. Az összes szkriptblokk a Process paraméterhez kötődik. A rendszer azonban úgy kezeli őket, mintha át lettek volna adva a Begin és a Process paramétereknek.

1..2 | ForEach-Object { 'begin' } { 'process' }

begin
process
process

9. példa: ForEach-Object használata kétnél több szkriptblokkdal

Ebben a példában két szkriptblokkot adunk át pozícióban. Az összes szkriptblokk a Process paraméterhez kötődik. A rendszer azonban úgy kezeli őket, mintha át lettek volna adva a Begin, Process és End paramétereknek.

1..2 | ForEach-Object { 'begin' } { 'process A' }  { 'process B' }  { 'end' }

begin
process A
process B
process A
process B
end

Megjegyzés

Az első szkriptblokk mindig a begin blokkra van leképezve, az utolsó blokk a end blokkra van leképezve, a kettő között lévő blokkok pedig mind a process blokkra vannak leképezve.

10. példa: Több szkriptblokk futtatása minden folyamatelemhez

Ahogy az előző példában is látható, a Folyamat paraméterrel átadott szkriptblokkok leképezhetők a Begin és a End paraméterekre. A leképezés elkerülése érdekében explicit értékeket kell megadnia a Kezdő és a Záró paraméterhez.

1..2 | ForEach-Object -Begin $null -Process { 'one' }, { 'two' }, { 'three' } -End $null

one
two
three
one
two
three

11. példa: Lassú szkript futtatása párhuzamos kötegekben

Ez a példa egy szkriptblokkot futtat, amely kiértékel egy sztringet, és egy másodpercig alvó állapotban van.

$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: 8

A ThrottleLimit paraméter értéke 4, így a bemenet négy kötegben lesz feldolgozva. A $using: kulcsszó a változó párhuzamos szkriptblokkokba való átadására $Message szolgál.

12. példa: Naplóbejegyzések lekérése párhuzamosan

Ez a példa 50 000 naplóbejegyzést kér le 5 rendszernaplóból egy helyi Windows-gépen.

$logNames = 'Security','Application','System','Windows PowerShell','Microsoft-Windows-Store/Operational'

$logEntries = $logNames | ForEach-Object -Parallel {
    Get-WinEvent -LogName $_ -MaxEvents 10000
} -ThrottleLimit 5

$logEntries.Count

50000

A Párhuzamos paraméter az egyes bemeneti naplók neveihez párhuzamosan futtatott szkriptblokkot adja meg. A ThrottleLimit paraméter biztosítja, hogy mind az öt szkriptblokk egyszerre fusson.

13. példa: Párhuzamos futtatás feladatként

Ez a példa egy olyan feladatot hoz létre, amely párhuzamosan futtat egy szkriptblokkot, egyszerre kettővel.

$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: 10

a $job változó megkapja a kimeneti adatokat gyűjtő feladatobjektumot, és figyeli a futó állapotot. A feladatobjektum a Wait kapcsoló paraméterrel van átirányítvaReceive-Job, amely úgy streameli a kimenetet a konzolra, mintha AsJob nélkül futtatták volna.ForEach-Object -Parallel

14. példa: Szálbiztos változóhivatkozások használata

Ez a példa szkriptblokkokat hív meg párhuzamosan az egyedileg elnevezett folyamatobjektumok gyűjtéséhez.

$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 pwsh

A concurrentDictionary objektum egyetlen példánya lesz átadva minden szkriptblokknak az objektumok gyűjtéséhez. Mivel a ConcurrentDictionary szálbiztos, minden párhuzamos szkript biztonságosan módosíthatja. Egy nem szálbiztos objektum, például a System.Collections.Generic.Dictionary nem biztonságos itt.

Megjegyzés

Ez a példa a Párhuzamos paraméter nagyon nem hatékony használatát szemlélteti. A szkript egyszerűen hozzáadja a bemeneti objektumot egy egyidejű szótárobjektumhoz. Ez triviális, és nem éri meg a terhelést invoking minden szkript egy külön szál. A párhuzamos kapcsoló nélküli normál működés ForEach-Object sokkal hatékonyabb és gyorsabb. Ez a példa csak a szálbiztos változók használatát mutatja be.

15. példa: Hibák írása párhuzamos végrehajtással

Ez a példa párhuzamosan ír a hibastreambe, ahol az írott hibák sorrendje véletlenszerű.

1..3 | ForEach-Object -Parallel {
    Write-Error "Error: $_"
}

Write-Error: Error: 1
Write-Error: Error: 3
Write-Error: Error: 2

16. példa: Hibák megszüntetése párhuzamos végrehajtáskor

Ez a példa egy megszakítási hibát mutat be egy párhuzamosan futó szkriptblokkban.

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: 5

Output: 3 A soha nem íródott, mert az iteráció párhuzamos szkriptblokkja leállt.

Megjegyzés

A PipelineVariable gyakori paraméterváltozók még a kulcsszóval sem támogatottak Foreach-Object -Parallel a $using: forgatókönyvekben.

17. példa: Változók átadása beágyazott párhuzamos szkriptben ScriptBlockSet

Létrehozhat egy változót egy Foreach-Object -Parallel hatókörrel rendelkező szkriptblokkon kívül, és használhatja azt a szkriptblokkban a $using kulcsszóval.

$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.

A beágyazott szkriptblokk nem tud hozzáférni a $test2 változóhoz, és hibaüzenet jelenik meg.

18. példa: Több, szkripteket párhuzamosan futtató feladat létrehozása

A ThrottleLimit paraméter korlátozza az egyes példányok ForEach-Object -Parallelsorán futó párhuzamos szkriptek számát. Nem korlátozza az AsJob paraméter használatakor létrehozható feladatok számát. Mivel maguk a feladatok párhuzamosan futnak, több párhuzamos feladat is létrehozható, amelyek mindegyike az egyidejű szkriptblokkok szabályozási korlátjának megfelelően fut.

$jobs = for ($i=0; $i -lt 10; $i++) {
    1..10 | ForEach-Object -Parallel {
        ./RunMyScript.ps1
    } -AsJob -ThrottleLimit 5
}

$jobs | Receive-Job -Wait

Ez a példa 10 futó feladatot hoz létre. Minden feladat nem futtat egyszerre több 5 szkriptet. Az egyidejűleg futó példányok teljes száma 50-re van korlátozva (10 feladat az 5 throttleLimit értékének 10-szerese).

Paraméterek

-ArgumentList

Egy metódushívás argumentumainak tömbje. Az Argumentumlista működésével kapcsolatos további információkért lásd: about_Splatting.

Ez a paraméter a Windows PowerShell 3.0-s kiadásban lett bevezetve.

Type:Object[]
Aliases:Args
Position:Named
Default value:None
Accept pipeline input:False
Accept wildcard characters:False

-AsJob

A párhuzamos hívás PowerShell-feladatként való futtatását okozza. A rendszer egyetlen feladatobjektumot ad vissza a futó szkriptblokkok kimenete helyett. A feladatobjektum gyermekfeladatokat tartalmaz minden futtatott párhuzamos szkriptblokkhoz. A feladatobjektumot minden PowerShell-feladatparancsmag használhatja a futó állapot figyeléséhez és az adatok lekéréséhez.

Ezt a paramétert a PowerShell 7.0-ban vezettük be.

Type:SwitchParameter
Position:Named
Default value:None
Accept pipeline input:False
Accept wildcard characters:False

-Begin

Olyan szkriptblokkot ad meg, amely azelőtt fut, hogy ez a parancsmag feldolgozza a bemeneti objektumokat. Ez a szkriptblokk csak egyszer fut a teljes folyamathoz. További információ a begin blokkról: about_Functions.

Type:ScriptBlock
Position:Named
Default value:None
Accept pipeline input:False
Accept wildcard characters:False

-Confirm

Jóváhagyást kér a parancsmag futtatása előtt.

Type:SwitchParameter
Aliases:cf
Position:Named
Default value:False
Accept pipeline input:False
Accept wildcard characters:False

-End

Egy szkriptblokkot ad meg, amely azután fut, hogy a parancsmag feldolgozza az összes bemeneti objektumot. Ez a szkriptblokk csak egyszer fut a teljes folyamathoz. További információ a end blokkról: about_Functions.

Type:ScriptBlock
Position:Named
Default value:None
Accept pipeline input:False
Accept wildcard characters:False

-InputObject

Megadja a bemeneti objektumokat. ForEach-Object A minden bemeneti objektumon futtatja a szkriptblokkot vagy a műveleti utasítást. Adjon meg egy változót, amely tartalmazza az objektumokat, vagy írjon be egy parancsot vagy kifejezést, amely lekéri az objektumokat.

Ha az InputObject paramétert ForEach-Objecthasználja a parancseredmények ForEach-Objectbeírása helyett, a rendszer egyetlen objektumként kezeli az InputObject értéket. Ez akkor is igaz, ha az érték olyan gyűjtemény, amely egy parancs, például -InputObject (Get-Process)a . Mivel az InputObject nem tud egyedi tulajdonságokat visszaadni egy tömbből vagy objektumgyűjteményből, azt javasoljuk, hogy ha olyan objektumok gyűjteményén hajt ForEach-Object végre műveleteket, amelyek meghatározott tulajdonságokkal rendelkeznek, akkor a folyamatban kell használnia ForEach-Object , ahogyan az ebben a témakörben látható példákban látható.

Type:PSObject
Position:Named
Default value:None
Accept pipeline input:True
Accept wildcard characters:False

-MemberName

Meghatározza a lekérendő tulajdonságot vagy a meghívandó metódust.

Helyettesítő karakterek használata engedélyezett, de csak akkor működik, ha az eredményül kapott sztring egyedi értékre van feloldva. Ha például futtatja Get-Process | ForEach -MemberName *Name, a helyettesítő karakterek mintája egynél több tagnak felel meg, ami a parancs sikertelenségéhez vezet.

Ez a paraméter a Windows PowerShell 3.0-s kiadásban lett bevezetve.

Type:String
Position:0
Default value:None
Accept pipeline input:False
Accept wildcard characters:True

-Parallel

Megadja a bemeneti objektumok párhuzamos feldolgozásához használandó szkriptblokkot. Adjon meg egy szkriptblokkot, amely leírja a műveletet.

Ez a paraméter a PowerShell 7.0-ban lett bevezetve.

Type:ScriptBlock
Position:Named
Default value:None
Accept pipeline input:False
Accept wildcard characters:False

-Process

Az egyes bemeneti objektumokon végrehajtott műveletet adja meg. Ez a szkriptblokk a folyamat összes objektumához fut. További információ a process blokkról: about_Functions.

Ha több szkriptblokkot ad meg a Process paraméternek, az első szkriptblokk mindig a begin blokkra lesz leképezve. Ha csak két szkriptblokk van, a második blokk lesz leképezve a process blokkra. Ha három vagy több szkriptblokk van, az első szkriptblokk mindig a begin blokkhoz van rendelve, az utolsó blokk a blokkhoz end van leképezve, a kettő között lévő blokkok pedig mind a process blokkhoz vannak leképezve.

Type:ScriptBlock[]
Position:0
Default value:None
Accept pipeline input:False
Accept wildcard characters:False

-RemainingScripts

Megadja az összes olyan szkriptblokkot, amelyet a Process paraméter nem vesz igénybe.

Ez a paraméter a Windows PowerShell 3.0-s verzióban lett bevezetve.

Type:ScriptBlock[]
Position:Named
Default value:None
Accept pipeline input:False
Accept wildcard characters:False

-ThrottleLimit

A párhuzamosan futó szkriptblokkok számát adja meg. A bemeneti objektumok le lesznek tiltva, amíg a futó szkriptblokkok száma nem esik a ThrottleLimit alá. Az alapértelmezett érték 5.

A ThrottleLimit paraméter korlátozza az egyes példányok ForEach-Object -Parallelsorán futó párhuzamos szkriptek számát. Nem korlátozza az AsJob paraméter használatakor létrehozható feladatok számát. Mivel maguk a feladatok párhuzamosan futnak, több párhuzamos feladat is létrehozható, amelyek mindegyike az egyidejű szkriptblokkok szabályozási korlátjának megfelelően fut.

Ez a paraméter a PowerShell 7.0-ban lett bevezetve.

Type:Int32
Position:Named
Default value:5
Accept pipeline input:False
Accept wildcard characters:False

-TimeoutSeconds

Megadja, hogy hány másodpercig várjon, amíg az összes bemenet feldolgozása párhuzamosan történik. A megadott időtúllépési idő után az összes futó szkript le lesz állítva. A többi feldolgozandó bemeneti objektumot a rendszer figyelmen kívül hagyja. Az alapértelmezett érték 0 letiltja az időtúllépést, és ForEach-Object -Parallel határozatlan ideig futhat. A Ctrl+C parancssorba való beírása leállítja a futó ForEach-Object -Parallel parancsokat. Ez a paraméter nem használható az AsJob paraméterrel együtt.

Ez a paraméter a PowerShell 7.0-ban lett bevezetve.

Type:Int32
Position:Named
Default value:0
Accept pipeline input:False
Accept wildcard characters:False

-UseNewRunspace

A párhuzamos hívás új runspace-t hoz létre minden hurok iterációhoz ahelyett, hogy újra használna runspace-eket a runspace készletből.

Ez a paraméter a PowerShell 7.1-ben lett bevezetve

Type:SwitchParameter
Position:Named
Default value:False
Accept pipeline input:False
Accept wildcard characters:False

-WhatIf

Bemutatja, mi történne a parancsmag futtatásakor. A parancsmag nem fut.

Type:SwitchParameter
Aliases:wi
Position:Named
Default value:False
Accept pipeline input:False
Accept wildcard characters:False

Bevitelek

PSObject

Bármilyen objektumot átirányíthat erre a parancsmagra.

Kimenetek

PSObject

Ez a parancsmag a bemenet által meghatározott objektumokat adja vissza.

Jegyzetek

A ForEach-Object parancsmag a Foreach utasításhoz hasonlóan működik, azzal a kivétellel, hogy a Foreach-utasításba nem lehet bemenő adatokat beszűkíteni. A Foreach utasítással kapcsolatos további információkért lásd about_Foreach.

A PowerShell 4.0-tól WhereForEach kezdve a metódusok gyűjteményekkel való használatra lettek hozzáadva. Ezekről az új módszerekről itt olvashat bővebben about_arrays

A következő használata ForEach-Object -Parallel:

  • A ForEach-Object -Parallel paraméterkészlet a PowerShell belső API-ját használja az egyes szkriptblokkok új futtatókörnyezetben való futtatásához. Ez jelentősen nagyobb többletterhelést jelent, mint ForEach-Object a szokásos szekvenciális feldolgozás. Fontos a Parallel használata, ahol a párhuzamos futtatás többletterhelése kicsi a szkriptblokk által végzett munkához képest. Például:

    • Számítási igényű szkriptek többmagos gépeken
    • Az eredményekre való várakozást vagy fájlműveleteket végző szkriptek

    A Párhuzamos paraméter használata esetén a szkriptek a normálnál sokkal lassabban futnak. Különösen akkor, ha a párhuzamos szkriptek triviálisak. Kísérletezzen a Parallelnel , és fedezze fel, hol lehet hasznos.

  • Párhuzamos futtatás esetén a ScriptProperties vagy a ScriptMethods funkcióval díszített objektumok nem garantálhatók a megfelelő működésre, ha azok más futtatókörnyezetben futnak, mint a szkriptek eredetileg hozzájuk lettek csatolva.

    A scriptblock-hívás mindig a saját futtatókörnyezetében kísérel meg futni, függetlenül attól, hogy hol hívja meg a rendszer. Azonban ideiglenes runspace-eket hoz létre, ForEach-Object -Parallel amelyek használat után törlődnek, így a szkriptek már nem futtathatók.

    Ez a viselkedés mindaddig működhet, amíg az otthoni futtatókörnyezet még létezik. Előfordulhat azonban, hogy nem kapja meg a kívánt eredményt, ha a szkript olyan külső változóktól függ, amelyek csak a hívó futtatóterében vannak jelen, a kezdő futtatókörnyezetben nem.

  • A nem megszakító hibák a parancsmag hibastreamjében lesznek megírva, amikor párhuzamosan futó szkriptblokkokban fordulnak elő. Mivel a párhuzamos szkriptblokk végrehajtási sorrendje nem determinisztikus, a hibák a hibastreamben való megjelenésének sorrendje véletlenszerű. Hasonlóképpen, a más adatfolyamokra írt üzenetek, például a figyelmeztetés, a részletes vagy az információk határozatlan sorrendben lesznek megírva ezekre az adatfolyamokra.

    A megszakítási hibák( például kivételek) megszakítják azoknak a szkriptblokkoknak az egyéni párhuzamos példányát, amelyekben előfordulnak. Előfordulhat, hogy egy szkriptblokk leállítása nem okozza a Foreach-Object parancsmag leállítását. A többi, párhuzamosan futó szkriptblokk továbbra is fut, hacsak nem tapasztalnak megszakítási hibát. A megszakítási hiba a hibaadat-adatfolyamba hibarekordként van megírva, amelynek a teljes jelölőjePSTaskExceptiona következő: . A megszakítási hibák PowerShell vagy try/catchtrap blokkok használatával átalakíthatók nem megszakítható hibákká.

  • A PipelineVariable gyakori paraméterváltozók nem támogatottak a párhuzamos forgatókönyvekben még a $using: kulcsszóval sem.

    Fontos

    A ForEach-Object -Parallel paraméterkészlet párhuzamosan futtatja a szkriptblokkokat külön folyamatszálakon. A $using: kulcsszó lehetővé teszi változóhivatkozások továbbítását a parancsmag hívási száláról az egyes futó szkriptblokkszálakra. Mivel a szkriptblokkok különböző szálakban futnak, a hivatkozás által átadott objektumváltozókat biztonságosan kell használni. Általában biztonságos az olyan hivatkozott objektumokból olvasni, amelyek nem változnak. Ha azonban az objektum állapota módosul, akkor szálbiztos objektumokat kell használnia, például .NET System.Collection.Concurrent típusokat (lásd a 11. példát).