Condividi tramite

ForEach-Object

  • Riferimento
Modulo:
Microsoft.PowerShell.Core

Esegue un'operazione su ogni elemento in una raccolta di oggetti di input.

Sintassi

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
            -Parallel <scriptblock>
            [-InputObject <psobject>]
            [-ThrottleLimit <int>]
            [-TimeoutSeconds <int>]
            [-AsJob]
            [-UseNewRunspace]
            [-WhatIf]
            [-Confirm]
            [<CommonParameters>]

Descrizione

Il cmdlet ForEach-Object esegue un'operazione su ogni elemento in una raccolta di oggetti di input. Gli oggetti di input possono essere inviati tramite pipe al cmdlet o specificati usando il parametro InputObject.

A partire da Windows PowerShell 3.0, esistono due modi diversi per costruire un comando ForEach-Object.

  • blocco script. È possibile usare un blocco di script per specificare l'operazione. All'interno del blocco di script usare la variabile $_ per rappresentare l'oggetto corrente. Il blocco di script è il valore del parametro processo di. Il blocco di script può contenere qualsiasi script di PowerShell.

    Ad esempio, il comando seguente ottiene il valore della proprietà ProcessName di ogni processo nel computer.

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

    ForEach-Object supporta i blocchi begin, processe end come descritto in about_Functions.

    Nota

    I blocchi di script vengono eseguiti nell'ambito del chiamante. Pertanto, i blocchi hanno accesso alle variabili in tale ambito e possono creare nuove variabili che persistono in tale ambito al termine del cmdlet.

  • 'istruzione Operation. È anche possibile scrivere un'istruzione di operazione, molto più simile al linguaggio naturale. È possibile utilizzare l'istruzione operation per specificare un valore della proprietà o chiamare un metodo. Le istruzioni operation sono state introdotte in Windows PowerShell 3.0.

    Ad esempio, il comando seguente ottiene anche il valore della proprietà ProcessName di ogni processo nel computer.

    Get-Process | ForEach-Object ProcessName

  • Blocco di script in esecuzione parallela. A partire da PowerShell 7.0, è disponibile un terzo set di parametri che esegue ogni blocco di script in parallelo. Il parametro ThrottleLimit limita il numero di script paralleli in esecuzione alla volta. Come in precedenza, usare la variabile $_ per rappresentare l'oggetto di input corrente nel blocco di script. Usare il modificatore di ambito Using: per passare riferimenti a variabili allo script in esecuzione.

    In PowerShell 7 viene creato un nuovo spazio di esecuzione per ogni iterazione del ciclo per garantire il massimo isolamento. Può trattarsi di un impatto elevato sulle prestazioni e sulle risorse se il lavoro che si sta eseguendo è ridotto rispetto alla creazione di nuovi spazi di esecuzione o se sono presenti molte iterazioni che eseguono un lavoro significativo. A partire da PowerShell 7.1, gli spazi di esecuzione di un pool di spazi di esecuzione vengono riutilizzati per impostazione predefinita. Il parametro ThrottleLimit imposta le dimensioni del pool di spazi di esecuzione. La dimensione predefinita del pool di spazi di esecuzione è 5. È comunque possibile creare un nuovo spazio di esecuzione per ogni iterazione usando l'opzione UseNewRunspace.

    Per impostazione predefinita, gli scriptblock paralleli usano la directory di lavoro corrente del chiamante che ha avviato le attività parallele.

    Per altre informazioni, vedere la sezione NOTES di questo articolo.

Esempio

Esempio 1: Dividere numeri interi in una matrice

Questo esempio accetta una matrice di tre interi e li divide per 1024.

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

29.296875
55.466796875
12.140625

Esempio 2: Ottenere la lunghezza di tutti i file in una directory

In questo esempio vengono elaborati i file e le directory nella directory di installazione di PowerShell $PSHOME.

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

Se l'oggetto non è una directory, il blocco di script ottiene il nome del file, divide il valore della relativa proprietà length Length per 1024 e aggiunge uno spazio (" ") per separarlo dalla voce successiva. Il cmdlet usa la proprietà PSIsContainer per determinare se un oggetto è una directory.

Esempio 3: Operare sugli eventi di sistema più recenti

In questo esempio vengono scritti i 1000 eventi più recenti dal registro eventi di sistema in un file di testo. L'ora corrente viene visualizzata prima e dopo l'elaborazione degli eventi.

Get-EventLog -LogName System -Newest 1000 |
    ForEach-Object -Begin {Get-Date} -Process {
        Out-File -FilePath Events.txt -Append -InputObject $_.Message
    } -End {Get-Date}

Get-EventLog ottiene i 1000 eventi più recenti dal registro eventi di sistema e li invia tramite pipe al cmdlet ForEach-Object. Il parametro Begin visualizza la data e l'ora correnti. Il parametro processo di usa quindi il cmdlet Out-File per creare un file di testo denominato events.txt e archivia la proprietà del messaggio di ogni evento in tale file. Infine, il parametro End viene usato per visualizzare la data e l'ora dopo il completamento dell'elaborazione.

Esempio 4: Modificare il valore di una chiave del Registro di sistema

In questo esempio viene modificato il valore della voce del Registro di sistema RemotePath in tutte le sottochiavi nella chiave HKCU:\Network in testo maiuscolo.

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

È possibile utilizzare questo formato per modificare il formato o il contenuto di un valore di voce del Registro di sistema.

Ogni sottochiave nella chiave di rete rappresenta un'unità di rete mappata che si riconnette all'accesso. La voce remotePath contiene il percorso UNC dell'unità connessa. Ad esempio, se si esegue il mapping dell'unità E: a \\Server\Share, viene creata una sottochiave E in HKCU:\Network con il valore del Registro di sistema RemotePath impostato su \\Server\Share.

Il comando usa il cmdlet Get-ItemProperty per ottenere tutte le sottochiavi della chiave network e il cmdlet Set-ItemProperty per modificare il valore della voce del Registro di sistema RemotePath in ogni chiave. Nel comando Set-ItemProperty il percorso è il valore della proprietà PSPath della chiave del Registro di sistema. Si tratta di una proprietà dell'oggetto Microsoft .NET Framework che rappresenta la chiave del Registro di sistema, non una voce del Registro di sistema. Il comando usa il metodo ToUpper() del valore RemotePath, ovvero una stringa REG_SZ.

Poiché Set-ItemProperty modifica la proprietà di ogni chiave, per accedere alla proprietà è necessario il cmdlet ForEach-Object.

Esempio 5: Usare la variabile automatica $null

In questo esempio viene illustrato l'effetto del piping della variabile automatica $null al cmdlet ForEach-Object.

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

Hello
Hello
Hello
Hello

Poiché PowerShell considera $null come segnaposto esplicito, il cmdlet ForEach-Object genera un valore per $null come avviene per altri oggetti inviati tramite pipe.

Esempio 6: Ottenere i valori delle proprietà

Questo esempio ottiene il valore della proprietà Path di tutti i moduli di PowerShell installati usando il parametro MemberName del cmdlet ForEach-Object.

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

Il secondo comando equivale al primo. Usa l'alias Foreach del cmdlet ForEach-Object e omette il nome del parametro MemberName, facoltativo.

Il cmdlet ForEach-Object è utile per ottenere i valori delle proprietà, perché ottiene il valore senza modificare il tipo, a differenza dei cmdlet Format o del cmdlet Select-Object, che modificano il tipo di valore della proprietà.

Esempio 7: Suddividere i nomi dei moduli in nomi di componenti

In questo esempio vengono illustrati tre modi per suddividere due nomi di modulo separati da punti nei nomi dei componenti. I comandi chiamano il metodo Split di stringhe. I tre comandi usano una sintassi diversa, ma sono equivalenti e intercambiabili. L'output è lo stesso per tutti e tre i casi.

"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

Il primo comando usa la sintassi tradizionale, che include un blocco di script e l'operatore oggetto corrente $_. Usa la sintassi del punto per specificare il metodo e le parentesi per racchiudere l'argomento delimitatore.

Il secondo comando usa il parametro MemberName per specificare il metodo split e il parametro ArgumentList per identificare il punto (.) come delimitatore di divisione.

Il terzo comando usa l'alias foreach del cmdlet ForEach-Object e omette i nomi dei parametri MemberName e ArgumentList, che sono facoltativi.

Esempio 8: Uso di ForEach-Object con due blocchi di script

In questo esempio vengono passati due blocchi di script in modo posizionale. Tutti i blocchi di script vengono associati al parametro processo di. Tuttavia, vengono considerati come se fossero stati passati ai parametri Begin e Process.

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

begin
process
process

Esempio 9: Uso di ForEach-Object con più di due blocchi di script

In questo esempio vengono passati quattro blocchi di script in modo posizionale. Tutti i blocchi di script vengono associati al parametro processo di. Tuttavia, vengono considerati come se fossero stati passati ai parametri Begin, Processe End.

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

begin
process A
process B
process A
process B
end

Nota

Il primo blocco di script viene sempre mappato al blocco begin, l'ultimo blocco viene mappato al blocco di end e i due blocchi intermedi vengono mappati al blocco process.

Esempio 10: Eseguire più blocchi di script per ogni elemento della pipeline

Come illustrato nell'esempio precedente, vengono mappati più blocchi di script passati usando il parametro Processo di viene eseguito il mapping ai parametri Begin e End. Per evitare questo mapping, è necessario specificare valori espliciti per i parametri Begin e End.

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

one
two
three
one
two
three

Esempio 11: Eseguire script lenti in batch paralleli

Questo esempio esegue un blocco di script che valuta una stringa e dorme per un secondo.

$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

Il valore del parametro ThrottleLimit è impostato su 4 in modo che l'input venga elaborato in batch di quattro. Il modificatore di ambito Using: viene usato per passare la variabile $Message in ogni blocco di script parallelo.

Esempio 12: Recuperare le voci di log in parallelo

In questo esempio vengono recuperate 50.000 voci di log da 5 log di sistema in un computer Windows locale.

$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

Il parametro Parallel specifica il blocco di script eseguito in parallelo per ogni nome del log di input. Il parametro ThrottleLimit garantisce che tutti e cinque i blocchi di script vengano eseguiti contemporaneamente.

Esempio 13: Esecuzione in parallelo come processo

In questo esempio viene creato un processo che esegue un blocco di script in parallelo, due alla volta.

PS> $job = 1..10 | ForEach-Object -Parallel {
    "Output: $_"
    Start-Sleep 1
} -ThrottleLimit 2 -AsJob

PS> $job

Id     Name            PSJobTypeName   State         HasMoreData     Location      Command
--     ----            -------------   -----         -----------     --------      -------
23     Job23           PSTaskJob       Running       True            PowerShell    …

PS> $job.ChildJobs

Id     Name            PSJobTypeName   State         HasMoreData     Location      Command
--     ----            -------------   -----         -----------     --------      -------
24     Job24           PSTaskChildJob  Completed     True            PowerShell    …
25     Job25           PSTaskChildJob  Completed     True            PowerShell    …
26     Job26           PSTaskChildJob  Running       True            PowerShell    …
27     Job27           PSTaskChildJob  Running       True            PowerShell    …
28     Job28           PSTaskChildJob  NotStarted    False           PowerShell    …
29     Job29           PSTaskChildJob  NotStarted    False           PowerShell    …
30     Job30           PSTaskChildJob  NotStarted    False           PowerShell    …
31     Job31           PSTaskChildJob  NotStarted    False           PowerShell    …
32     Job32           PSTaskChildJob  NotStarted    False           PowerShell    …
33     Job33           PSTaskChildJob  NotStarted    False           PowerShell    …

Il parametro ThrottleLimit limita il numero di blocchi di script paralleli in esecuzione alla volta. Il parametro asjob fa sì che il cmdlet ForEach-Object restituisca un oggetto processo anziché trasmettere l'output alla console. La variabile $job riceve l'oggetto processo che raccoglie i dati di output e monitora lo stato di esecuzione. La proprietà $job.ChildJobs contiene i processi figlio che eseguono i blocchi di script paralleli.

Esempio 14: Uso di riferimenti a variabili thread-safe

In questo esempio vengono richiamati blocchi di script in parallelo per raccogliere oggetti Process denominati in modo univoco.

$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

Una singola istanza di un oggetto ConcurrentDictionary viene passata a ogni blocco di script per raccogliere gli oggetti. Poiché l'concurrentDictionary è thread-safe, è sicuro essere modificato da ogni script parallelo. Un oggetto non thread-safe, ad esempio System.Collections.Generic.Dictionary, non sarebbe sicuro da usare qui.

Nota

Questo esempio è un uso inefficiente di parametro Parallel. Lo script aggiunge l'oggetto di input a un oggetto dizionario simultaneo. È semplice e non vale la pena di richiamare ogni script in un thread separato. L'esecuzione di ForEach-Object senza l'opzione parallela di è più efficiente e veloce. Questo esempio è destinato solo a illustrare come usare le variabili thread-safe.

Esempio 15: Scrittura di errori con esecuzione parallela

Questo esempio scrive nel flusso di errori in parallelo, in cui l'ordine degli errori scritti è casuale.

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

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

Esempio 16: Terminazione degli errori nell'esecuzione parallela

In questo esempio viene illustrato un errore irreversibile in un blocco di script in esecuzione parallelo.

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 non viene mai scritto perché lo scriptblock parallelo per tale iterazione è stato terminato.

Nota

PipelineVariable variabili di parametro comuni non sono supportate negli scenari di ForEach-Object -Parallel anche con il modificatore di ambito Using:.

Esempio 17: Passaggio di variabili nello script parallelo annidato ScriptBlockSet

È possibile creare una variabile all'esterno di un ForEach-Object -Parallel scriptblock con ambito e usarla all'interno del blocco script con il modificatore di ambito 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' can't be retrieved because it has
     | not been set in the local session.

Lo scriptblock annidato non può accedere alla variabile $test2 e viene generato un errore.

Esempio 18: Creazione di più processi che eseguono script in parallelo

Il parametro ThrottleLimit limita il numero di script paralleli in esecuzione durante ogni istanza di ForEach-Object -Parallel. Non limita il numero di processi che è possibile creare quando si usa il parametro AsJob. Poiché i processi stessi vengono eseguiti simultaneamente, è possibile creare più processi paralleli, ognuno dei quali viene eseguito fino al limite massimo di blocchi di script simultanei.

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

$jobs | Receive-Job -Wait

In questo esempio vengono creati 10 processi in esecuzione. Ogni processo non viene eseguito più di 5 script contemporaneamente. Il numero totale di istanze in esecuzione contemporaneamente è limitato a 50 (10 processi volte il ThrottleLimit di 5).

Parametri

-ArgumentList

Specifica una matrice di argomenti per una chiamata al metodo. Per altre informazioni sul comportamento di ArgumentList, vedere about_Splatting.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Tipo:Object[]
Alias:Args
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-AsJob

Fa sì che la chiamata parallela sia eseguita come processo di PowerShell. Viene restituito un singolo oggetto processo anziché l'output dai blocchi di script in esecuzione. L'oggetto processo contiene processi figlio per ogni blocco di script parallelo eseguito. È possibile usare l'oggetto processo con uno dei cmdlet del processo di PowerShell per visualizzare lo stato di esecuzione e recuperare i dati.

Questo parametro è stato introdotto in PowerShell 7.0.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Begin

Specifica un blocco di script eseguito prima dell'elaborazione di qualsiasi oggetto di input da parte di questo cmdlet. Questo blocco di script viene eseguito una sola volta per l'intera pipeline. Per altre informazioni sul blocco begin, vedere about_Functions.

Tipo:ScriptBlock
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Confirm

Richiede conferma prima di eseguire il cmdlet.

Tipo:SwitchParameter
Alias:cf
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-End

Specifica un blocco di script eseguito dopo che questo cmdlet elabora tutti gli oggetti di input. Questo blocco di script viene eseguito una sola volta per l'intera pipeline. Per altre informazioni sul blocco end, vedere about_Functions.

Tipo:ScriptBlock
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-InputObject

Specifica gli oggetti di input. ForEach-Object esegue l'istruzione del blocco di script o dell'operazione su ogni oggetto di input. Immettere una variabile contenente gli oggetti oppure digitare un comando o un'espressione che ottiene gli oggetti .

Quando si usa il parametro InputObject con ForEach-Object, anziché i risultati del comando piping per ForEach-Object, il valore InputObject viene considerato come un singolo oggetto. Questo vale anche se il valore è una raccolta che rappresenta il risultato di un comando, ad esempio -InputObject (Get-Process). Poiché InputObject non può restituire singole proprietà da una matrice o da una raccolta di oggetti, è consigliabile usare ForEach-Object per eseguire operazioni su una raccolta di oggetti per gli oggetti con valori specifici nelle proprietà definite, è possibile usare ForEach-Object nella pipeline, come illustrato negli esempi di questo argomento.

Tipo:PSObject
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-MemberName

Specifica il nome della proprietà del membro da ottenere o il metodo membro da chiamare. I membri devono essere membri dell'istanza, non membri statici.

I caratteri jolly sono consentiti, ma funzionano solo se la stringa risultante viene risolta in un valore univoco. Ad esempio, se si esegue Get-Process | foreach -MemberName *Name, il criterio con caratteri jolly corrisponde a più membri, causando l'esito negativo del comando.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Tipo:String
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:False
Accettare caratteri jolly:True

-Parallel

Specifica il blocco di script da utilizzare per l'elaborazione parallela degli oggetti di input. Immettere un blocco di script che descrive l'operazione.

Questo parametro è stato introdotto in PowerShell 7.0.

Tipo:ScriptBlock
Posizione:Named
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Process

Specifica l'operazione eseguita su ogni oggetto di input. Questo blocco di script viene eseguito per ogni oggetto nella pipeline. Per altre informazioni sul blocco process, vedere about_Functions.

Quando si forniscono più blocchi di script al parametro processo, il primo blocco di script viene sempre mappato al blocco begin. Se sono presenti solo due blocchi di script, il secondo blocco viene mappato al blocco process. Se sono presenti tre o più blocchi di script, il primo blocco di script viene sempre mappato al blocco begin, l'ultimo blocco viene mappato al blocco end e i blocchi intermedi vengono mappati al blocco process.

Tipo:ScriptBlock[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-RemainingScripts

Specifica tutti i blocchi di script non acquisiti dal parametro process.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Tipo:ScriptBlock[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-ThrottleLimit

Specifica il numero di blocchi di script eseguiti in parallelo. Gli oggetti di input vengono bloccati fino a quando il numero di blocchi di script in esecuzione non scende al di sotto del ThrottleLimit. Il valore predefinito è 5.

Il parametro ThrottleLimit limita il numero di script paralleli in esecuzione durante ogni istanza di ForEach-Object -Parallel. Non limita il numero di processi che è possibile creare quando si usa il parametro AsJob. Poiché i processi stessi vengono eseguiti simultaneamente, è possibile creare un numero di processi paralleli, ognuno in esecuzione fino al numero limitato di blocchi di script simultanei.

Questo parametro è stato introdotto in PowerShell 7.0.

Tipo:Int32
Posizione:Named
Valore predefinito:5
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-TimeoutSeconds

Specifica il numero di secondi di attesa per l'elaborazione di tutti gli input in parallelo. Dopo il timeout specificato, tutti gli script in esecuzione vengono arrestati. E tutti gli oggetti di input rimanenti da elaborare vengono ignorati. Il valore predefinito di 0 disabilita il timeout e ForEach-Object -Parallel può essere eseguito a tempo indeterminato. Digitando ctrl+C nella riga di comando viene arrestato un comando ForEach-Object -Parallel in esecuzione. Questo parametro non può essere usato insieme al parametro AsJob.

Questo parametro è stato introdotto in PowerShell 7.0.

Tipo:Int32
Posizione:Named
Valore predefinito:0
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-UseNewRunspace

Fa sì che la chiamata parallela crei un nuovo spazio di esecuzione per ogni iterazione del ciclo anziché riutilizzare gli spazi di esecuzione dal pool di spazi di esecuzione.

Questo parametro è stato introdotto in PowerShell 7.1

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-WhatIf

Mostra cosa accadrebbe se il cmdlet viene eseguito. Il cmdlet non viene eseguito.

Tipo:SwitchParameter
Alias:wi
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

Input

PSObject

È possibile inviare tramite pipe qualsiasi oggetto a questo cmdlet.

Output

PSObject

Questo cmdlet restituisce oggetti determinati dall'input.

Note

PowerShell include gli alias seguenti per ForEach-Object:

  • Tutte le piattaforme:
    • %
    • foreach

Il cmdlet ForEach-Object funziona in modo analogo all'istruzione foreach, ad eccezione del fatto che non è possibile inviare tramite pipe l'input a un'istruzione foreach. Per altre informazioni sull'istruzione foreach, vedere about_Foreach.

A partire da PowerShell 4.0, sono stati aggiunti metodi Where e ForEach per l'uso con le raccolte. Altre informazioni su questi nuovi metodi sono disponibili qui about_Arrays

Uso di ForEach-Object -Parallel:

  • ForEach-Object -Parallel esegue ogni blocco di script in un nuovo spazio di esecuzione. I nuovi spazi di esecuzione creano un sovraccarico notevolmente maggiore rispetto all'esecuzione di ForEach-Object con l'elaborazione sequenziale. È importante usare Parallel in cui il sovraccarico dell'esecuzione in parallelo è ridotto rispetto al lavoro eseguito dal blocco di script. Per esempio:

    • Script a elevato utilizzo di calcolo in computer multi-core
    • Script che impiegano tempo in attesa dei risultati o che eseguono operazioni di file

    L'uso del parametro Parallel può causare l'esecuzione degli script molto più lenta del normale. Soprattutto se gli script paralleli sono semplici. Sperimentare Parallel per scoprire dove può essere utile.

  • Durante l'esecuzione in parallelo, gli oggetti decorati con ScriptProperties o ScriptMethods non possono funzionare correttamente se vengono eseguiti in uno spazio di esecuzione diverso rispetto agli script originariamente associati.

    La chiamata di Scriptblock tenta sempre di essere eseguita nella propria home spazio di esecuzione, indipendentemente dalla posizione in cui viene effettivamente richiamata. Tuttavia, ForEach-Object -Parallel crea spazi di esecuzione temporanei che vengono eliminati dopo l'uso, quindi non esiste più spazio di esecuzione per gli script da eseguire in.

    Questo comportamento può funzionare finché il home spazio di esecuzione esiste ancora. Tuttavia, è possibile che non si ottenga il risultato desiderato se lo script dipende da variabili esterne presenti solo nello spazio di esecuzione del chiamante e non dal home spazio di esecuzione.

  • Gli errori non irreversibili vengono scritti nel flusso di errore del cmdlet man mano che si verificano in blocchi di script in esecuzione paralleli. Poiché l'ordine di esecuzione di scriptblock parallelo non è deterministico, l'ordine in cui gli errori vengono visualizzati nel flusso di errori è casuale. Analogamente, i messaggi scritti in altri flussi di dati, ad esempio avvisi, verbose o informazioni vengono scritti in tali flussi di dati in un ordine indeterminato.

    Gli errori di terminazione, ad esempio le eccezioni, terminano la singola istanza parallela dei blocchi di script in cui si verificano. Un errore irreversibile in uno scriptblock potrebbe non causare la chiusura del cmdlet ForEach-Object. Gli altri scriptblock, in esecuzione in parallelo, continuano a essere eseguiti a meno che non si verifichino anche un errore irreversibile. L'errore irreversibile viene scritto nel flusso dei dati di errore come ErrorRecord con un FullyQualifiedErrorId di PSTaskException. Gli errori di terminazione possono essere convertiti in errori non irreversibili usando i blocchi di powerShell try/catch o trap.

  • PipelineVariable variabili di parametro comuni non sono supportate in scenari paralleli anche con il modificatore di ambito Using:.

    Importante

    Il set di parametri ForEach-Object -Parallel esegue blocchi di script in parallelo su thread di processo separati. Il modificatore Using: consente di passare riferimenti a variabili dal thread di chiamata del cmdlet a ogni thread di blocco di script in esecuzione. Poiché i blocchi di script vengono eseguiti in thread diversi, le variabili oggetto passate per riferimento devono essere usate in modo sicuro. In genere è possibile leggere da oggetti a cui si fa riferimento che non cambiano. Se è necessario modificare lo stato dell'oggetto, è necessario usare oggetti thread-safe, ad esempio .NET tipi system.Collection.Concurrent (vedere l'esempio 14).