Feedback

ForEach-Object

  • Referentie
Module:
Microsoft.PowerShell.Core

Hiermee voert u een bewerking uit op elk item in een verzameling invoerobjecten.

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

De ForEach-Object cmdlet voert een bewerking uit op elk item in een verzameling invoerobjecten. De invoerobjecten kunnen worden doorgesluisd naar de cmdlet of worden opgegeven met behulp van de parameter InputObject .

Vanaf Windows PowerShell 3.0 zijn er twee verschillende manieren om een ForEach-Object opdracht te maken.

  • Scriptblok. U kunt een scriptblok gebruiken om de bewerking op te geven. Gebruik in het scriptblok de $_ variabele om het huidige object weer te geven. Het scriptblok is de waarde van de procesparameter . Het scriptblok kan elk PowerShell-script bevatten.

    Met de volgende opdracht wordt bijvoorbeeld de waarde opgehaald van de eigenschap ProcessName van elk proces op de computer.

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

    ForEach-Object ondersteunt de begin, processen end blokken zoals beschreven in about_functions.

    Notitie

    De scriptblokken worden uitgevoerd in het bereik van de aanroeper. Daarom hebben de blokken toegang tot variabelen in dat bereik en kunnen ze nieuwe variabelen maken die in dat bereik blijven bestaan nadat de cmdlet is voltooid.

  • Bewerkingsinstructie. U kunt ook een bewerkingsinstructie schrijven, die veel meer lijkt op natuurlijke taal. U kunt de bewerkingsinstructie gebruiken om een eigenschapswaarde op te geven of een methode aan te roepen. Bewerkingsinstructies zijn geïntroduceerd in Windows PowerShell 3.0.

    Met de volgende opdracht wordt bijvoorbeeld ook de waarde opgehaald van de eigenschap ProcessName van elk proces op de computer.

    Get-Process | ForEach-Object ProcessName

  • Parallel uitvoeren van scriptblok. Vanaf PowerShell 7.0 is er een derde parameterset beschikbaar waarmee elk scriptblok parallel wordt uitgevoerd. De parameter ThrottleLimit beperkt het aantal parallelle scripts dat tegelijk wordt uitgevoerd. Net als voorheen gebruikt u de $_ variabele om het huidige invoerobject in het scriptblok weer te geven. Gebruik het $using: trefwoord om variabele verwijzingen door te geven naar het actieve script.

    In PowerShell 7 wordt voor elke lus-iteratie een nieuwe runspace gemaakt om maximale isolatie te garanderen. Dit kan een grote prestaties zijn en resources worden bereikt als het werk dat u doet klein is in vergelijking met het maken van nieuwe runspaces of als er veel iteraties zijn die aanzienlijk werk uitvoeren. Vanaf PowerShell 7.1 worden runspaces uit een runspace-pool standaard opnieuw gebruikt. De grootte van de runspace-pool wordt opgegeven door de parameter ThrottleLimit . De standaardgrootte van de runspace-pool is 5. U kunt nog steeds een nieuwe runspace maken voor elke iteratie met behulp van de UseNewRunspace-switch .

    Standaard gebruiken de parallelle scriptblokkeringen de huidige werkmap van de aanroeper die de parallelle taken heeft gestart.

    Zie de sectie NOTES van dit artikel voor meer informatie.

Voorbeelden

Voorbeeld 1: Gehele getallen in een matrix verdelen

In dit voorbeeld wordt een matrix van drie gehele getallen gebruikt en worden ze allemaal door 1024 gedeeld.

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

29.296875
55.466796875
12.140625

Voorbeeld 2: De lengte van alle bestanden in een map ophalen

In dit voorbeeld worden de bestanden en mappen in de Installatiemap $PSHOMEvan PowerShell verwerkt.

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

Als het object geen map is, krijgt het scriptblok de naam van het bestand, deelt u de waarde van de eigenschap Length door 1024 en voegt u een spatie (" ") toe om het te scheiden van de volgende vermelding. De cmdlet gebruikt de eigenschap PSISContainer om te bepalen of een object een map is.

Voorbeeld 3: Werken met de meest recente systeemevenementen

In dit voorbeeld worden de 1000 meest recente gebeurtenissen uit het gebeurtenislogboek van het systeem naar een tekstbestand geschreven. De huidige tijd wordt weergegeven voor en na het verwerken van de gebeurtenissen.

$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 haalt de 1000 meest recente gebeurtenissen op uit het gebeurtenislogboek van het systeem en slaat deze op in de $Events variabele. $Events wordt vervolgens doorgesluisd naar de ForEach-Object cmdlet. De parameter Begin geeft de huidige datum en tijd weer. Vervolgens gebruikt de parameter Proces de Out-File cmdlet om een tekstbestand met de naam events.txt te maken en de berichteigenschap van elk van de gebeurtenissen in dat bestand op te slaan. Ten slotte wordt de parameter End gebruikt om de datum en tijd weer te geven nadat alle verwerkingen zijn voltooid.

Voorbeeld 4: De waarde van een registersleutel wijzigen

In dit voorbeeld wordt de waarde van de RemotePath-registervermelding gewijzigd in alle subsleutels onder de HKCU:\Network sleutel in hoofdletters.

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

U kunt deze indeling gebruiken om het formulier of de inhoud van een registervermeldingswaarde te wijzigen.

Elke subsleutel in de netwerksleutel vertegenwoordigt een toegewezen netwerkstation dat opnieuw verbinding maakt bij aanmelding. De RemotePath-vermelding bevat het UNC-pad van het verbonden station. Als u bijvoorbeeld het station E: toe \\Server\Sharewijst, wordt er een E-subsleutel gemaakt HKCU:\Network waarin de remotePath-registerwaarde is ingesteld op \\Server\Share.

De opdracht gebruikt de Get-ItemProperty cmdlet om alle subsleutels van de netwerksleutel en de Set-ItemProperty cmdlet op te halen om de waarde van de RemotePath-registervermelding in elke sleutel te wijzigen. In de Set-ItemProperty opdracht is het pad de waarde van de PSPath-eigenschap van de registersleutel. Dit is een eigenschap van het Microsoft .NET Framework-object dat de registersleutel vertegenwoordigt, niet een registervermelding. De opdracht maakt gebruik van de methode ToUpper() van de RemotePath-waarde , een tekenreeks (REG_SZ).

Omdat Set-ItemProperty de eigenschap van elke sleutel wordt gewijzigd, is de ForEach-Object cmdlet vereist voor toegang tot de eigenschap.

Voorbeeld 5: De automatische variabele $null gebruiken

In dit voorbeeld ziet u het effect van het doorsluisen van de $null automatische variabele naar de ForEach-Object cmdlet.

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

Hello
Hello
Hello
Hello

Omdat PowerShell wordt behandeld als een expliciete tijdelijke aanduiding, genereert $null de ForEach-Object cmdlet een waarde voor $null net als voor andere objecten die ernaar worden doorgesluisd.

Voorbeeld 6: Eigenschapswaarden ophalen

In dit voorbeeld wordt de waarde opgehaald van de eigenschap Path van alle geïnstalleerde PowerShell-modules met behulp van de parameter MemberName van de ForEach-Object cmdlet.

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

De tweede opdracht is gelijk aan de eerste. Hierbij wordt de Foreach alias van de ForEach-Object cmdlet gebruikt en wordt de naam van de parameter MemberName weggelaten. Dit is optioneel.

De ForEach-Object cmdlet is handig voor het ophalen van eigenschapswaarden, omdat deze de waarde krijgt zonder het type te wijzigen, in tegenstelling tot de format-cmdlets of de Select-Object cmdlet, die het eigenschapswaardetype wijzigen.

Voorbeeld 7: Modulenamen splitsen in onderdeelnamen

In dit voorbeeld ziet u drie manieren om twee door puntjes gescheiden modulenamen te splitsen in hun onderdeelnamen. Met de opdrachten wordt de splitsmethode van tekenreeksen aangeroepen. De drie opdrachten gebruiken verschillende syntaxis, maar ze zijn gelijkwaardig en uitwisselbaar. De uitvoer is hetzelfde voor alle drie de gevallen.

"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

De eerste opdracht maakt gebruik van de traditionele syntaxis, die een scriptblok en de huidige objectoperator $_bevat. Hierbij wordt de syntaxis van de punt gebruikt om de methode en haakjes op te geven om het argument scheidingsteken tussen te sluiten.

De tweede opdracht gebruikt de parameter MemberName om de Split-methode en de parameter ArgumentList op te geven om de punt (.) te identificeren als het scheidingsteken voor splitsen.

De derde opdracht maakt gebruik van de Foreach-alias van de ForEach-Object cmdlet en laat de namen van de parameters MemberName en ArgumentList weg, die optioneel zijn.

Voorbeeld 8: ForEach-Object gebruiken met twee scriptblokken

In dit voorbeeld geven we twee scriptblokken positioneel door. Alle scriptblokken binden aan de procesparameter . Ze worden echter behandeld alsof ze zijn doorgegeven aan de parameters Begin en Proces .

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

begin
process
process

Voorbeeld 9: ForEach-Object gebruiken met meer dan twee scriptblokken

In dit voorbeeld geven we twee scriptblokken positioneel door. Alle scriptblokken binden aan de procesparameter . Ze worden echter behandeld alsof ze zijn doorgegeven aan de parameters Begin, Proces en Eind .

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

begin
process A
process B
process A
process B
end

Notitie

Het eerste scriptblok wordt altijd toegewezen aan het begin blok, het laatste blok wordt toegewezen aan het end blok en de blokken ertussen zijn allemaal toegewezen aan het process blok.

Voorbeeld 10: Meerdere scriptblokken uitvoeren voor elk pijplijnitem

Zoals in het vorige voorbeeld wordt weergegeven, worden meerdere scriptblokken doorgegeven met behulp van de parameter Proces , toegewezen aan de parameters Begin en Einde . Om deze toewijzing te voorkomen, moet u expliciete waarden opgeven voor de begin - en eindparameters .

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

one
two
three
one
two
three

Voorbeeld 11: Traag script uitvoeren in parallelle batches

In dit voorbeeld wordt een scriptblok uitgevoerd waarmee een tekenreeks en slaapstand voor één seconde worden geëvalueerd.

$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

De parameterwaarde ThrottleLimit is ingesteld op 4, zodat de invoer wordt verwerkt in batches van vier. Het $using: trefwoord wordt gebruikt om de $Message variabele door te geven aan elk parallel scriptblok.

Voorbeeld 12: logboekvermeldingen parallel ophalen

In dit voorbeeld worden 50.000 logboekvermeldingen opgehaald uit 5 systeemlogboeken op een lokale Windows-computer.

$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

De parameter Parallel geeft het scriptblok op dat parallel wordt uitgevoerd voor elke naam van het invoerlogboek. De parameter ThrottleLimit zorgt ervoor dat alle vijf scriptblokken tegelijkertijd worden uitgevoerd.

Voorbeeld 13: Parallel als taak uitvoeren

In dit voorbeeld wordt een taak gemaakt waarmee een scriptblok parallel, twee tegelijk, wordt uitgevoerd.

$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

de $job variabele ontvangt het taakobject dat uitvoergegevens verzamelt en de status van de uitvoering bewaakt. Het taakobject wordt doorgesluisd naar Receive-Job de parameter Wait Switch, die uitvoer naar de console streamt alsof ForEach-Object -Parallel deze zonder AsJob werd uitgevoerd.

Voorbeeld 14: Thread Safe-variabeleverwijzingen gebruiken

In dit voorbeeld worden scriptblokken parallel aangeroepen om unieke procesobjecten te verzamelen.

$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

Eén exemplaar van een ConcurrentDictionary-object wordt doorgegeven aan elk scriptblok om de objecten te verzamelen. Omdat de ConcurrentDictionary thread veilig is, is het veilig om te worden gewijzigd door elk parallel script. Een niet-thread-veilig object, zoals System.Collections.Generic.Dictionary, is hier niet veilig te gebruiken.

Notitie

Dit voorbeeld is een zeer inefficiënt gebruik van de parameter Parallel . Het script voegt het invoerobject gewoon toe aan een gelijktijdig woordenlijstobject. Het is triviaal en is de overhead van het aanroepen van elk script in een afzonderlijke thread niet waard. Normaal uitgevoerd ForEach-Object zonder de Parallelle switch is veel efficiënter en sneller. Dit voorbeeld is alleen bedoeld om te laten zien hoe u threadveilige variabelen gebruikt.

Voorbeeld 15: Schrijffouten met parallelle uitvoering

In dit voorbeeld wordt parallel naar de foutstroom geschreven, waarbij de volgorde van geschreven fouten willekeurig is.

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

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

Voorbeeld 16: Afsluitfouten bij parallelle uitvoering

In dit voorbeeld ziet u een afsluitfout in één parallel actieve scriptblock.

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 wordt nooit geschreven omdat de parallelle scriptblokkering voor die iteratie is beëindigd.

Notitie

PipelineVariable common parameter variables worden niet ondersteund in Foreach-Object -Parallel scenario's, zelfs niet met het $using: trefwoord.

Voorbeeld 17: Variabelen doorgeven in geneste parallelle script ScriptBlockSet

U kunt een variabele buiten een Foreach-Object -Parallel scoped scriptblock maken en deze gebruiken in de scriptblock met het $using trefwoord.

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

De geneste scriptblock heeft geen toegang tot de $test2 variabele en er wordt een fout gegenereerd.

Voorbeeld 18: Meerdere taken maken die scripts parallel uitvoeren

De parameter ThrottleLimit beperkt het aantal parallelle scripts dat wordt uitgevoerd tijdens elk exemplaar van ForEach-Object -Parallel. Het aantal taken dat kan worden gemaakt, wordt niet beperkt wanneer u de parameter AsJob gebruikt. Aangezien taken zelf gelijktijdig worden uitgevoerd, is het mogelijk om een aantal parallelle taken te maken, elk dat wordt uitgevoerd tot het beperkingslimietaantal gelijktijdige scriptblokkeringen.

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

$jobs | Receive-Job -Wait

In dit voorbeeld worden 10 actieve taken gemaakt. Elke taak voert niet meer die vijf scripts gelijktijdig uit. Het totale aantal exemplaren dat gelijktijdig wordt uitgevoerd, is beperkt tot 50 (10 taken keer het ThrottleLimit van 5).

Parameters

-ArgumentList

Hiermee geeft u een matrix van argumenten voor een methodeaanroep. Zie about_Splatting voor meer informatie over het gedrag van ArgumentList.

Deze parameter is geïntroduceerd in Windows PowerShell 3.0.

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

Zorgt ervoor dat de parallelle aanroep wordt uitgevoerd als een PowerShell-taak. Er wordt één taakobject geretourneerd in plaats van uitvoer van de actieve scriptblokken. Het taakobject bevat onderliggende taken voor elk parallel scriptblok dat wordt uitgevoerd. Het taakobject kan worden gebruikt door alle PowerShell-taak-cmdlets om de actieve status te bewaken en gegevens op te halen.

Deze parameter is geïntroduceerd in PowerShell 7.0.

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

Hiermee geeft u een scriptblok op dat wordt uitgevoerd voordat deze cmdlet invoerobjecten verwerkt. Dit scriptblok wordt slechts één keer uitgevoerd voor de hele pijplijn. Zie about_Functions voor meer informatie over het begin blok.

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

Hiermee wordt u gevraagd om bevestiging voordat u de cmdlet uitvoert.

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

Hiermee geeft u een scriptblok op dat wordt uitgevoerd nadat deze cmdlet alle invoerobjecten verwerkt. Dit scriptblok wordt slechts één keer uitgevoerd voor de hele pijplijn. Zie about_Functions voor meer informatie over het end blok.

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

Hiermee geeft u de invoerobjecten op. ForEach-Object voert het scriptblok of de bewerkingsinstructie uit op elk invoerobject. Voer een variabele in die de objecten bevat of typ een opdracht of expressie waarmee de objecten worden opgehaald.

Wanneer u de parameter InputObject gebruikt met ForEach-Object, in plaats van piping-opdrachtresultaten ForEach-Object, wordt de InputObject-waarde behandeld als één object. Dit geldt zelfs als de waarde een verzameling is die het resultaat is van een opdracht, zoals -InputObject (Get-Process). Omdat InputObject geen afzonderlijke eigenschappen kan retourneren uit een matrix of verzameling objecten, raden we u ForEach-Object aan om bewerkingen uit te voeren voor een verzameling objecten voor objecten die specifieke waarden in gedefinieerde eigenschappen hebben, gebruikt ForEach-Object u in de pijplijn, zoals wordt weergegeven in de voorbeelden in dit onderwerp.

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

Hiermee geeft u de eigenschap op die moet worden get of de methode die moet worden aangeroepen.

Jokertekens zijn toegestaan, maar werken alleen als de resulterende tekenreeks wordt omgezet in een unieke waarde. Als u bijvoorbeeld uitvoert Get-Process | ForEach -MemberName *Name, komt het jokertekenpatroon overeen met meer dan één lid waardoor de opdracht mislukt.

Deze parameter is geïntroduceerd in Windows PowerShell 3.0.

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

Hiermee geeft u het scriptblok op dat moet worden gebruikt voor parallelle verwerking van invoerobjecten. Voer een scriptblok in dat de bewerking beschrijft.

Deze parameter is geïntroduceerd in PowerShell 7.0.

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

Hiermee geeft u de bewerking op die wordt uitgevoerd op elk invoerobject. Dit scriptblok wordt uitgevoerd voor elk object in de pijplijn. Zie about_Functions voor meer informatie over het process blok.

Wanneer u meerdere scriptblokken aan de parameter Proces opgeeft, wordt het eerste scriptblok altijd toegewezen aan het begin blok. Als er slechts twee scriptblokken zijn, wordt het tweede blok toegewezen aan het process blok. Als er drie of meer scriptblokken zijn, wordt het eerste scriptblok altijd toegewezen aan het begin blok, wordt het laatste blok toegewezen aan het end blok en worden de blokken tussendoor allemaal toegewezen aan het process blok.

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

Hiermee geeft u alle scriptblokken op die niet door de parameter Proces worden genomen.

Deze parameter is geïntroduceerd in Windows PowerShell 3.0.

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

Hiermee geeft u het aantal scriptblokken op dat parallel wordt uitgevoerd. Invoerobjecten worden geblokkeerd totdat het actieve aantal scriptblokken onder het ThrottleLimit valt. De standaardwaarde is 5.

De parameter ThrottleLimit beperkt het aantal parallelle scripts dat wordt uitgevoerd tijdens elk exemplaar van ForEach-Object -Parallel. Het aantal taken dat kan worden gemaakt, wordt niet beperkt wanneer u de parameter AsJob gebruikt. Aangezien taken zelf gelijktijdig worden uitgevoerd, is het mogelijk om een aantal parallelle taken te maken, elk dat wordt uitgevoerd tot het beperkingslimietaantal gelijktijdige scriptblokkeringen.

Deze parameter is geïntroduceerd in PowerShell 7.0.

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

Hiermee geeft u het aantal seconden op dat moet worden gewacht totdat alle invoer parallel wordt verwerkt. Na de opgegeven time-outtijd worden alle actieve scripts gestopt. En alle resterende invoerobjecten die moeten worden verwerkt, worden genegeerd. De standaardwaarde voor het uitschakelen van 0 de time-out en ForEach-Object -Parallel kan voor onbepaalde tijd worden uitgevoerd. Als u Ctrl+C op de opdrachtregel typt, wordt een actieve ForEach-Object -Parallel opdracht gestopt. Deze parameter kan niet samen met de AsJob-parameter worden gebruikt.

Deze parameter is geïntroduceerd in PowerShell 7.0.

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

Hiermee wordt weergegeven wat er zou gebeuren als u de cmdlet uitvoert. De cmdlet wordt niet uitgevoerd.

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

Invoerwaarden

PSObject

U kunt elk object doorsluisen naar deze cmdlet.

Uitvoerwaarden

PSObject

Deze cmdlet retourneert objecten die worden bepaald door de invoer.

Notities

De ForEach-Object cmdlet werkt net als de Foreach-instructie , behalve dat u geen invoer kunt doorsluisen naar een Foreach-instructie . Zie about_Foreach voor meer informatie over de Foreach-instructie.

Vanaf PowerShell 4.0 Where zijn ForEach methoden toegevoegd voor gebruik met verzamelingen. Meer informatie over deze nieuwe methoden vindt u hier about_arrays

Met behulp van ForEach-Object -Parallel:

  • De ForEach-Object -Parallel parameterset maakt gebruik van de interne API van PowerShell om elk scriptblok in een nieuwe runspace uit te voeren. Dit is aanzienlijk meer overhead dan normaal wordt uitgevoerd ForEach-Object met sequentiële verwerking. Het is belangrijk om Parallel te gebruiken wanneer de overhead van parallel uitvoeren klein is in vergelijking met het werk dat het scriptblok uitvoert. Bijvoorbeeld:

    • Rekenintensieve scripts op machines met meerdere kernen
    • Scripts die tijd besteden aan het wachten op resultaten of het uitvoeren van bestandsbewerkingen

    Het gebruik van de parameter Parallel kan ertoe leiden dat scripts veel langzamer worden uitgevoerd dan normaal. Vooral als de parallelle scripts triviaal zijn. Experimenteer met Parallel om te ontdekken waar het nuttig kan zijn.

  • Wanneer objecten parallel worden uitgevoerd, kunnen objecten die zijn ingericht met ScriptProperties of ScriptMethods , niet worden gegarandeerd correct functioneren als ze worden uitgevoerd in een andere runspace dan de scripts die er oorspronkelijk aan zijn gekoppeld.

    Scriptblock-aanroep probeert altijd uit te voeren in de thuis-runspace, ongeacht waar deze daadwerkelijk wordt aangeroepen. ForEach-Object -Parallel Maakt echter tijdelijke runspaces die na gebruik worden verwijderd, dus er is geen runspace meer voor de scripts die moeten worden uitgevoerd.

    Dit gedrag kan werken zolang de startrunspace nog bestaat. Het is echter mogelijk dat u het gewenste resultaat niet krijgt als het script afhankelijk is van externe variabelen die alleen aanwezig zijn in de runspace van de aanroeper en niet de startrunspace .

  • Niet-afsluitfouten worden naar de cmdlet-foutstroom geschreven zodra deze zich voordoen in parallelle actieve scriptblokkeringen. Omdat de uitvoeringsvolgorde voor parallelle scriptblokkering niet-deterministisch is, is de volgorde waarin fouten in de foutstroom willekeurig worden weergegeven. Op dezelfde manier worden berichten die naar andere gegevensstromen worden geschreven, zoals waarschuwing, uitgebreid of informatie naar die gegevensstromen geschreven in een onbepaalde volgorde.

    Afsluitfouten, zoals uitzonderingen, beëindigen de afzonderlijke parallelle instantie van de scriptblokkeringen waarin ze optreden. Een afsluitfout in één scriptblokkering kan de beëindiging van de Foreach-Object cmdlet niet veroorzaken. De andere scriptblokkeringen, die parallel worden uitgevoerd, blijven worden uitgevoerd, tenzij er ook een afsluitfout optreedt. De afsluitfout wordt naar de foutgegevensstroom geschreven als een ErrorRecord met een FullyQualifiedErrorId van PSTaskException. Afsluitfouten kunnen worden geconverteerd naar niet-afsluitfouten met behulp van PowerShell try/catch of trap blokken.

  • Algemene parametervariabelen pipelineVariable worden niet ondersteund in parallelle scenario's, zelfs niet met het $using: trefwoord.

    Belangrijk

    De ForEach-Object -Parallel parameterset voert scriptblokken parallel uit op afzonderlijke procesthreads. Met $using: het trefwoord kunnen variabele verwijzingen van de cmdlet-aanroepthread worden doorgegeven aan elke actieve scriptblokthread. Omdat de scriptblokken in verschillende threads worden uitgevoerd, moeten de objectvariabelen die worden doorgegeven door verwijzing veilig worden gebruikt. Over het algemeen is het veilig om te lezen van objecten waarnaar wordt verwezen, die niet veranderen. Maar als de objectstatus wordt gewijzigd, moet u threadveilige objecten, zoals .NET System.Collection.Concurrent-typen (zie voorbeeld 11) gebruiken.